id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequencelengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
sequencelengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
5,800 | arangodb/go-driver | meta.go | IDs | func (l DocumentMetaSlice) IDs() []DocumentID {
ids := make([]DocumentID, len(l))
for i, m := range l {
ids[i] = m.ID
}
return ids
} | go | func (l DocumentMetaSlice) IDs() []DocumentID {
ids := make([]DocumentID, len(l))
for i, m := range l {
ids[i] = m.ID
}
return ids
} | [
"func",
"(",
"l",
"DocumentMetaSlice",
")",
"IDs",
"(",
")",
"[",
"]",
"DocumentID",
"{",
"ids",
":=",
"make",
"(",
"[",
"]",
"DocumentID",
",",
"len",
"(",
"l",
")",
")",
"\n",
"for",
"i",
",",
"m",
":=",
"range",
"l",
"{",
"ids",
"[",
"i",
"]",
"=",
"m",
".",
"ID",
"\n",
"}",
"\n",
"return",
"ids",
"\n",
"}"
] | // IDs returns the ID's of all elements. | [
"IDs",
"returns",
"the",
"ID",
"s",
"of",
"all",
"elements",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/meta.go#L62-L68 |
5,801 | arangodb/go-driver | client_server_info_impl.go | Version | func (c *client) Version(ctx context.Context) (VersionInfo, error) {
req, err := c.conn.NewRequest("GET", "_api/version")
if err != nil {
return VersionInfo{}, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := c.conn.Do(ctx, req)
if err != nil {
return VersionInfo{}, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return VersionInfo{}, WithStack(err)
}
var data VersionInfo
if err := resp.ParseBody("", &data); err != nil {
return VersionInfo{}, WithStack(err)
}
return data, nil
} | go | func (c *client) Version(ctx context.Context) (VersionInfo, error) {
req, err := c.conn.NewRequest("GET", "_api/version")
if err != nil {
return VersionInfo{}, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := c.conn.Do(ctx, req)
if err != nil {
return VersionInfo{}, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return VersionInfo{}, WithStack(err)
}
var data VersionInfo
if err := resp.ParseBody("", &data); err != nil {
return VersionInfo{}, WithStack(err)
}
return data, nil
} | [
"func",
"(",
"c",
"*",
"client",
")",
"Version",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"VersionInfo",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"c",
".",
"conn",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"VersionInfo",
"{",
"}",
",",
"WithStack",
"(",
"err",
")",
"\n",
"}",
"\n",
"applyContextSettings",
"(",
"ctx",
",",
"req",
")",
"\n",
"resp",
",",
"err",
":=",
"c",
".",
"conn",
".",
"Do",
"(",
"ctx",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"VersionInfo",
"{",
"}",
",",
"WithStack",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"resp",
".",
"CheckStatus",
"(",
"200",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"VersionInfo",
"{",
"}",
",",
"WithStack",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"data",
"VersionInfo",
"\n",
"if",
"err",
":=",
"resp",
".",
"ParseBody",
"(",
"\"",
"\"",
",",
"&",
"data",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"VersionInfo",
"{",
"}",
",",
"WithStack",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"data",
",",
"nil",
"\n",
"}"
] | // Version returns version information from the connected database server. | [
"Version",
"returns",
"version",
"information",
"from",
"the",
"connected",
"database",
"server",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/client_server_info_impl.go#L30-L48 |
5,802 | arangodb/go-driver | client_server_info_impl.go | asServerRole | func (r roleResponse) asServerRole(ctx context.Context, c *client) (ServerRole, error) {
switch r.Role {
case "SINGLE":
switch r.Mode {
case "resilient":
if err := c.echo(ctx); IsNoLeader(err) {
return ServerRoleSinglePassive, nil
} else if err != nil {
return ServerRoleUndefined, WithStack(err)
}
return ServerRoleSingleActive, nil
default:
return ServerRoleSingle, nil
}
case "PRIMARY":
return ServerRoleDBServer, nil
case "COORDINATOR":
return ServerRoleCoordinator, nil
case "AGENT":
return ServerRoleAgent, nil
case "UNDEFINED":
return ServerRoleUndefined, nil
default:
return ServerRoleUndefined, nil
}
} | go | func (r roleResponse) asServerRole(ctx context.Context, c *client) (ServerRole, error) {
switch r.Role {
case "SINGLE":
switch r.Mode {
case "resilient":
if err := c.echo(ctx); IsNoLeader(err) {
return ServerRoleSinglePassive, nil
} else if err != nil {
return ServerRoleUndefined, WithStack(err)
}
return ServerRoleSingleActive, nil
default:
return ServerRoleSingle, nil
}
case "PRIMARY":
return ServerRoleDBServer, nil
case "COORDINATOR":
return ServerRoleCoordinator, nil
case "AGENT":
return ServerRoleAgent, nil
case "UNDEFINED":
return ServerRoleUndefined, nil
default:
return ServerRoleUndefined, nil
}
} | [
"func",
"(",
"r",
"roleResponse",
")",
"asServerRole",
"(",
"ctx",
"context",
".",
"Context",
",",
"c",
"*",
"client",
")",
"(",
"ServerRole",
",",
"error",
")",
"{",
"switch",
"r",
".",
"Role",
"{",
"case",
"\"",
"\"",
":",
"switch",
"r",
".",
"Mode",
"{",
"case",
"\"",
"\"",
":",
"if",
"err",
":=",
"c",
".",
"echo",
"(",
"ctx",
")",
";",
"IsNoLeader",
"(",
"err",
")",
"{",
"return",
"ServerRoleSinglePassive",
",",
"nil",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"ServerRoleUndefined",
",",
"WithStack",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"ServerRoleSingleActive",
",",
"nil",
"\n",
"default",
":",
"return",
"ServerRoleSingle",
",",
"nil",
"\n",
"}",
"\n",
"case",
"\"",
"\"",
":",
"return",
"ServerRoleDBServer",
",",
"nil",
"\n",
"case",
"\"",
"\"",
":",
"return",
"ServerRoleCoordinator",
",",
"nil",
"\n",
"case",
"\"",
"\"",
":",
"return",
"ServerRoleAgent",
",",
"nil",
"\n",
"case",
"\"",
"\"",
":",
"return",
"ServerRoleUndefined",
",",
"nil",
"\n",
"default",
":",
"return",
"ServerRoleUndefined",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // asServerRole converts the response into a ServerRole | [
"asServerRole",
"converts",
"the",
"response",
"into",
"a",
"ServerRole"
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/client_server_info_impl.go#L58-L83 |
5,803 | arangodb/go-driver | client_server_info_impl.go | ServerRole | func (c *client) ServerRole(ctx context.Context) (ServerRole, error) {
req, err := c.conn.NewRequest("GET", "_admin/server/role")
if err != nil {
return ServerRoleUndefined, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := c.conn.Do(ctx, req)
if err != nil {
return ServerRoleUndefined, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return ServerRoleUndefined, WithStack(err)
}
var data roleResponse
if err := resp.ParseBody("", &data); err != nil {
return ServerRoleUndefined, WithStack(err)
}
role, err := data.asServerRole(ctx, c)
if err != nil {
return ServerRoleUndefined, WithStack(err)
}
return role, nil
} | go | func (c *client) ServerRole(ctx context.Context) (ServerRole, error) {
req, err := c.conn.NewRequest("GET", "_admin/server/role")
if err != nil {
return ServerRoleUndefined, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := c.conn.Do(ctx, req)
if err != nil {
return ServerRoleUndefined, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return ServerRoleUndefined, WithStack(err)
}
var data roleResponse
if err := resp.ParseBody("", &data); err != nil {
return ServerRoleUndefined, WithStack(err)
}
role, err := data.asServerRole(ctx, c)
if err != nil {
return ServerRoleUndefined, WithStack(err)
}
return role, nil
} | [
"func",
"(",
"c",
"*",
"client",
")",
"ServerRole",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"ServerRole",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"c",
".",
"conn",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"ServerRoleUndefined",
",",
"WithStack",
"(",
"err",
")",
"\n",
"}",
"\n",
"applyContextSettings",
"(",
"ctx",
",",
"req",
")",
"\n",
"resp",
",",
"err",
":=",
"c",
".",
"conn",
".",
"Do",
"(",
"ctx",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"ServerRoleUndefined",
",",
"WithStack",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"resp",
".",
"CheckStatus",
"(",
"200",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"ServerRoleUndefined",
",",
"WithStack",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"data",
"roleResponse",
"\n",
"if",
"err",
":=",
"resp",
".",
"ParseBody",
"(",
"\"",
"\"",
",",
"&",
"data",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"ServerRoleUndefined",
",",
"WithStack",
"(",
"err",
")",
"\n",
"}",
"\n",
"role",
",",
"err",
":=",
"data",
".",
"asServerRole",
"(",
"ctx",
",",
"c",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"ServerRoleUndefined",
",",
"WithStack",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"role",
",",
"nil",
"\n",
"}"
] | // ServerRole returns the role of the server that answers the request. | [
"ServerRole",
"returns",
"the",
"role",
"of",
"the",
"server",
"that",
"answers",
"the",
"request",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/client_server_info_impl.go#L86-L108 |
5,804 | arangodb/go-driver | client_server_info_impl.go | ServerID | func (c *client) ServerID(ctx context.Context) (string, error) {
req, err := c.conn.NewRequest("GET", "_admin/server/id")
if err != nil {
return "", WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := c.conn.Do(ctx, req)
if err != nil {
return "", WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return "", WithStack(err)
}
var data idResponse
if err := resp.ParseBody("", &data); err != nil {
return "", WithStack(err)
}
return data.ID, nil
} | go | func (c *client) ServerID(ctx context.Context) (string, error) {
req, err := c.conn.NewRequest("GET", "_admin/server/id")
if err != nil {
return "", WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := c.conn.Do(ctx, req)
if err != nil {
return "", WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return "", WithStack(err)
}
var data idResponse
if err := resp.ParseBody("", &data); err != nil {
return "", WithStack(err)
}
return data.ID, nil
} | [
"func",
"(",
"c",
"*",
"client",
")",
"ServerID",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"string",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"c",
".",
"conn",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"WithStack",
"(",
"err",
")",
"\n",
"}",
"\n",
"applyContextSettings",
"(",
"ctx",
",",
"req",
")",
"\n",
"resp",
",",
"err",
":=",
"c",
".",
"conn",
".",
"Do",
"(",
"ctx",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"WithStack",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"resp",
".",
"CheckStatus",
"(",
"200",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"WithStack",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"data",
"idResponse",
"\n",
"if",
"err",
":=",
"resp",
".",
"ParseBody",
"(",
"\"",
"\"",
",",
"&",
"data",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"WithStack",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"data",
".",
"ID",
",",
"nil",
"\n",
"}"
] | // Gets the ID of this server in the cluster.
// An error is returned when calling this to a server that is not part of a cluster. | [
"Gets",
"the",
"ID",
"of",
"this",
"server",
"in",
"the",
"cluster",
".",
"An",
"error",
"is",
"returned",
"when",
"calling",
"this",
"to",
"a",
"server",
"that",
"is",
"not",
"part",
"of",
"a",
"cluster",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/client_server_info_impl.go#L116-L134 |
5,805 | arangodb/go-driver | id.go | Validate | func (id DocumentID) Validate() error {
if id == "" {
return WithStack(fmt.Errorf("DocumentID is empty"))
}
parts := strings.Split(string(id), "/")
if len(parts) != 2 {
return WithStack(fmt.Errorf("Expected 'collection/key', got '%s'", string(id)))
}
if parts[0] == "" {
return WithStack(fmt.Errorf("Collection part of '%s' is empty", string(id)))
}
if parts[1] == "" {
return WithStack(fmt.Errorf("Key part of '%s' is empty", string(id)))
}
return nil
} | go | func (id DocumentID) Validate() error {
if id == "" {
return WithStack(fmt.Errorf("DocumentID is empty"))
}
parts := strings.Split(string(id), "/")
if len(parts) != 2 {
return WithStack(fmt.Errorf("Expected 'collection/key', got '%s'", string(id)))
}
if parts[0] == "" {
return WithStack(fmt.Errorf("Collection part of '%s' is empty", string(id)))
}
if parts[1] == "" {
return WithStack(fmt.Errorf("Key part of '%s' is empty", string(id)))
}
return nil
} | [
"func",
"(",
"id",
"DocumentID",
")",
"Validate",
"(",
")",
"error",
"{",
"if",
"id",
"==",
"\"",
"\"",
"{",
"return",
"WithStack",
"(",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
")",
"\n",
"}",
"\n",
"parts",
":=",
"strings",
".",
"Split",
"(",
"string",
"(",
"id",
")",
",",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"parts",
")",
"!=",
"2",
"{",
"return",
"WithStack",
"(",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"string",
"(",
"id",
")",
")",
")",
"\n",
"}",
"\n",
"if",
"parts",
"[",
"0",
"]",
"==",
"\"",
"\"",
"{",
"return",
"WithStack",
"(",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"string",
"(",
"id",
")",
")",
")",
"\n",
"}",
"\n",
"if",
"parts",
"[",
"1",
"]",
"==",
"\"",
"\"",
"{",
"return",
"WithStack",
"(",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"string",
"(",
"id",
")",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Validate validates the given id. | [
"Validate",
"validates",
"the",
"given",
"id",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/id.go#L40-L55 |
5,806 | arangodb/go-driver | id.go | ValidateOrEmpty | func (id DocumentID) ValidateOrEmpty() error {
if id == "" {
return nil
}
if err := id.Validate(); err != nil {
return WithStack(err)
}
return nil
} | go | func (id DocumentID) ValidateOrEmpty() error {
if id == "" {
return nil
}
if err := id.Validate(); err != nil {
return WithStack(err)
}
return nil
} | [
"func",
"(",
"id",
"DocumentID",
")",
"ValidateOrEmpty",
"(",
")",
"error",
"{",
"if",
"id",
"==",
"\"",
"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"err",
":=",
"id",
".",
"Validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"WithStack",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // ValidateOrEmpty validates the given id unless it is empty.
// In case of empty, nil is returned. | [
"ValidateOrEmpty",
"validates",
"the",
"given",
"id",
"unless",
"it",
"is",
"empty",
".",
"In",
"case",
"of",
"empty",
"nil",
"is",
"returned",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/id.go#L59-L67 |
5,807 | arangodb/go-driver | id.go | Collection | func (id DocumentID) Collection() string {
parts := strings.Split(string(id), "/")
return pathUnescape(parts[0])
} | go | func (id DocumentID) Collection() string {
parts := strings.Split(string(id), "/")
return pathUnescape(parts[0])
} | [
"func",
"(",
"id",
"DocumentID",
")",
"Collection",
"(",
")",
"string",
"{",
"parts",
":=",
"strings",
".",
"Split",
"(",
"string",
"(",
"id",
")",
",",
"\"",
"\"",
")",
"\n",
"return",
"pathUnescape",
"(",
"parts",
"[",
"0",
"]",
")",
"\n",
"}"
] | // Collection returns the collection part of the ID. | [
"Collection",
"returns",
"the",
"collection",
"part",
"of",
"the",
"ID",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/id.go#L75-L78 |
5,808 | arangodb/go-driver | id.go | Key | func (id DocumentID) Key() string {
parts := strings.Split(string(id), "/")
if len(parts) == 2 {
return pathUnescape(parts[1])
}
return ""
} | go | func (id DocumentID) Key() string {
parts := strings.Split(string(id), "/")
if len(parts) == 2 {
return pathUnescape(parts[1])
}
return ""
} | [
"func",
"(",
"id",
"DocumentID",
")",
"Key",
"(",
")",
"string",
"{",
"parts",
":=",
"strings",
".",
"Split",
"(",
"string",
"(",
"id",
")",
",",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"parts",
")",
"==",
"2",
"{",
"return",
"pathUnescape",
"(",
"parts",
"[",
"1",
"]",
")",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}"
] | // Key returns the key part of the ID. | [
"Key",
"returns",
"the",
"key",
"part",
"of",
"the",
"ID",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/id.go#L81-L87 |
5,809 | arangodb/go-driver | id.go | NewDocumentID | func NewDocumentID(collection, key string) DocumentID {
return DocumentID(pathEscape(collection) + "/" + pathEscape(key))
} | go | func NewDocumentID(collection, key string) DocumentID {
return DocumentID(pathEscape(collection) + "/" + pathEscape(key))
} | [
"func",
"NewDocumentID",
"(",
"collection",
",",
"key",
"string",
")",
"DocumentID",
"{",
"return",
"DocumentID",
"(",
"pathEscape",
"(",
"collection",
")",
"+",
"\"",
"\"",
"+",
"pathEscape",
"(",
"key",
")",
")",
"\n",
"}"
] | // NewDocumentID creates a new document ID from the given collection, key pair. | [
"NewDocumentID",
"creates",
"a",
"new",
"document",
"ID",
"from",
"the",
"given",
"collection",
"key",
"pair",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/id.go#L90-L92 |
5,810 | arangodb/go-driver | context.go | WithRevision | func WithRevision(parent context.Context, revision string) context.Context {
return context.WithValue(contextOrBackground(parent), keyRevision, revision)
} | go | func WithRevision(parent context.Context, revision string) context.Context {
return context.WithValue(contextOrBackground(parent), keyRevision, revision)
} | [
"func",
"WithRevision",
"(",
"parent",
"context",
".",
"Context",
",",
"revision",
"string",
")",
"context",
".",
"Context",
"{",
"return",
"context",
".",
"WithValue",
"(",
"contextOrBackground",
"(",
"parent",
")",
",",
"keyRevision",
",",
"revision",
")",
"\n",
"}"
] | // WithRevision is used to configure a context to make document
// functions specify an explicit revision of the document using an `If-Match` condition. | [
"WithRevision",
"is",
"used",
"to",
"configure",
"a",
"context",
"to",
"make",
"document",
"functions",
"specify",
"an",
"explicit",
"revision",
"of",
"the",
"document",
"using",
"an",
"If",
"-",
"Match",
"condition",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/context.go#L65-L67 |
5,811 | arangodb/go-driver | context.go | WithRevisions | func WithRevisions(parent context.Context, revisions []string) context.Context {
return context.WithValue(contextOrBackground(parent), keyRevisions, revisions)
} | go | func WithRevisions(parent context.Context, revisions []string) context.Context {
return context.WithValue(contextOrBackground(parent), keyRevisions, revisions)
} | [
"func",
"WithRevisions",
"(",
"parent",
"context",
".",
"Context",
",",
"revisions",
"[",
"]",
"string",
")",
"context",
".",
"Context",
"{",
"return",
"context",
".",
"WithValue",
"(",
"contextOrBackground",
"(",
"parent",
")",
",",
"keyRevisions",
",",
"revisions",
")",
"\n",
"}"
] | // WithRevisions is used to configure a context to make multi-document
// functions specify explicit revisions of the documents. | [
"WithRevisions",
"is",
"used",
"to",
"configure",
"a",
"context",
"to",
"make",
"multi",
"-",
"document",
"functions",
"specify",
"explicit",
"revisions",
"of",
"the",
"documents",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/context.go#L71-L73 |
5,812 | arangodb/go-driver | context.go | WithReturnNew | func WithReturnNew(parent context.Context, result interface{}) context.Context {
return context.WithValue(contextOrBackground(parent), keyReturnNew, result)
} | go | func WithReturnNew(parent context.Context, result interface{}) context.Context {
return context.WithValue(contextOrBackground(parent), keyReturnNew, result)
} | [
"func",
"WithReturnNew",
"(",
"parent",
"context",
".",
"Context",
",",
"result",
"interface",
"{",
"}",
")",
"context",
".",
"Context",
"{",
"return",
"context",
".",
"WithValue",
"(",
"contextOrBackground",
"(",
"parent",
")",
",",
"keyReturnNew",
",",
"result",
")",
"\n",
"}"
] | // WithReturnNew is used to configure a context to make create, update & replace document
// functions return the new document into the given result. | [
"WithReturnNew",
"is",
"used",
"to",
"configure",
"a",
"context",
"to",
"make",
"create",
"update",
"&",
"replace",
"document",
"functions",
"return",
"the",
"new",
"document",
"into",
"the",
"given",
"result",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/context.go#L77-L79 |
5,813 | arangodb/go-driver | context.go | WithReturnOld | func WithReturnOld(parent context.Context, result interface{}) context.Context {
return context.WithValue(contextOrBackground(parent), keyReturnOld, result)
} | go | func WithReturnOld(parent context.Context, result interface{}) context.Context {
return context.WithValue(contextOrBackground(parent), keyReturnOld, result)
} | [
"func",
"WithReturnOld",
"(",
"parent",
"context",
".",
"Context",
",",
"result",
"interface",
"{",
"}",
")",
"context",
".",
"Context",
"{",
"return",
"context",
".",
"WithValue",
"(",
"contextOrBackground",
"(",
"parent",
")",
",",
"keyReturnOld",
",",
"result",
")",
"\n",
"}"
] | // WithReturnOld is used to configure a context to make update & replace document
// functions return the old document into the given result. | [
"WithReturnOld",
"is",
"used",
"to",
"configure",
"a",
"context",
"to",
"make",
"update",
"&",
"replace",
"document",
"functions",
"return",
"the",
"old",
"document",
"into",
"the",
"given",
"result",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/context.go#L83-L85 |
5,814 | arangodb/go-driver | context.go | WithEndpoint | func WithEndpoint(parent context.Context, endpoint string) context.Context {
endpoint = util.FixupEndpointURLScheme(endpoint)
return context.WithValue(contextOrBackground(parent), keyEndpoint, endpoint)
} | go | func WithEndpoint(parent context.Context, endpoint string) context.Context {
endpoint = util.FixupEndpointURLScheme(endpoint)
return context.WithValue(contextOrBackground(parent), keyEndpoint, endpoint)
} | [
"func",
"WithEndpoint",
"(",
"parent",
"context",
".",
"Context",
",",
"endpoint",
"string",
")",
"context",
".",
"Context",
"{",
"endpoint",
"=",
"util",
".",
"FixupEndpointURLScheme",
"(",
"endpoint",
")",
"\n",
"return",
"context",
".",
"WithValue",
"(",
"contextOrBackground",
"(",
"parent",
")",
",",
"keyEndpoint",
",",
"endpoint",
")",
"\n",
"}"
] | // WithEndpoint is used to configure a context that forces a request to be executed on a specific endpoint.
// If you specify an endpoint like this, failover is disabled.
// If you specify an unknown endpoint, an InvalidArgumentError is returned from requests. | [
"WithEndpoint",
"is",
"used",
"to",
"configure",
"a",
"context",
"that",
"forces",
"a",
"request",
"to",
"be",
"executed",
"on",
"a",
"specific",
"endpoint",
".",
"If",
"you",
"specify",
"an",
"endpoint",
"like",
"this",
"failover",
"is",
"disabled",
".",
"If",
"you",
"specify",
"an",
"unknown",
"endpoint",
"an",
"InvalidArgumentError",
"is",
"returned",
"from",
"requests",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/context.go#L100-L103 |
5,815 | arangodb/go-driver | context.go | WithAllowDirtyReads | func WithAllowDirtyReads(parent context.Context, wasDirtyRead *bool) context.Context {
return context.WithValue(contextOrBackground(parent), keyAllowDirtyReads, wasDirtyRead)
} | go | func WithAllowDirtyReads(parent context.Context, wasDirtyRead *bool) context.Context {
return context.WithValue(contextOrBackground(parent), keyAllowDirtyReads, wasDirtyRead)
} | [
"func",
"WithAllowDirtyReads",
"(",
"parent",
"context",
".",
"Context",
",",
"wasDirtyRead",
"*",
"bool",
")",
"context",
".",
"Context",
"{",
"return",
"context",
".",
"WithValue",
"(",
"contextOrBackground",
"(",
"parent",
")",
",",
"keyAllowDirtyReads",
",",
"wasDirtyRead",
")",
"\n",
"}"
] | // WithAllowDirtyReads is used in an active failover deployment to allow reads from the follower.
// You can pass a reference to a boolean that will set according to wether a potentially dirty read
// happened or not. nil is allowed.
// This is valid for document reads, aql queries, gharial vertex and edge reads. | [
"WithAllowDirtyReads",
"is",
"used",
"in",
"an",
"active",
"failover",
"deployment",
"to",
"allow",
"reads",
"from",
"the",
"follower",
".",
"You",
"can",
"pass",
"a",
"reference",
"to",
"a",
"boolean",
"that",
"will",
"set",
"according",
"to",
"wether",
"a",
"potentially",
"dirty",
"read",
"happened",
"or",
"not",
".",
"nil",
"is",
"allowed",
".",
"This",
"is",
"valid",
"for",
"document",
"reads",
"aql",
"queries",
"gharial",
"vertex",
"and",
"edge",
"reads",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/context.go#L145-L147 |
5,816 | arangodb/go-driver | context.go | WithRawResponse | func WithRawResponse(parent context.Context, value *[]byte) context.Context {
return context.WithValue(contextOrBackground(parent), keyRawResponse, value)
} | go | func WithRawResponse(parent context.Context, value *[]byte) context.Context {
return context.WithValue(contextOrBackground(parent), keyRawResponse, value)
} | [
"func",
"WithRawResponse",
"(",
"parent",
"context",
".",
"Context",
",",
"value",
"*",
"[",
"]",
"byte",
")",
"context",
".",
"Context",
"{",
"return",
"context",
".",
"WithValue",
"(",
"contextOrBackground",
"(",
"parent",
")",
",",
"keyRawResponse",
",",
"value",
")",
"\n",
"}"
] | // WithRawResponse is used to configure a context that will make all functions store the raw response into a
// buffer. | [
"WithRawResponse",
"is",
"used",
"to",
"configure",
"a",
"context",
"that",
"will",
"make",
"all",
"functions",
"store",
"the",
"raw",
"response",
"into",
"a",
"buffer",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/context.go#L151-L153 |
5,817 | arangodb/go-driver | context.go | WithResponse | func WithResponse(parent context.Context, value *Response) context.Context {
return context.WithValue(contextOrBackground(parent), keyResponse, value)
} | go | func WithResponse(parent context.Context, value *Response) context.Context {
return context.WithValue(contextOrBackground(parent), keyResponse, value)
} | [
"func",
"WithResponse",
"(",
"parent",
"context",
".",
"Context",
",",
"value",
"*",
"Response",
")",
"context",
".",
"Context",
"{",
"return",
"context",
".",
"WithValue",
"(",
"contextOrBackground",
"(",
"parent",
")",
",",
"keyResponse",
",",
"value",
")",
"\n",
"}"
] | // WithResponse is used to configure a context that will make all functions store the response into the given value. | [
"WithResponse",
"is",
"used",
"to",
"configure",
"a",
"context",
"that",
"will",
"make",
"all",
"functions",
"store",
"the",
"response",
"into",
"the",
"given",
"value",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/context.go#L156-L158 |
5,818 | arangodb/go-driver | context.go | WithImportDetails | func WithImportDetails(parent context.Context, value *[]string) context.Context {
return context.WithValue(contextOrBackground(parent), keyImportDetails, value)
} | go | func WithImportDetails(parent context.Context, value *[]string) context.Context {
return context.WithValue(contextOrBackground(parent), keyImportDetails, value)
} | [
"func",
"WithImportDetails",
"(",
"parent",
"context",
".",
"Context",
",",
"value",
"*",
"[",
"]",
"string",
")",
"context",
".",
"Context",
"{",
"return",
"context",
".",
"WithValue",
"(",
"contextOrBackground",
"(",
"parent",
")",
",",
"keyImportDetails",
",",
"value",
")",
"\n",
"}"
] | // WithImportDetails is used to configure a context that will make import document requests return
// details about documents that could not be imported. | [
"WithImportDetails",
"is",
"used",
"to",
"configure",
"a",
"context",
"that",
"will",
"make",
"import",
"document",
"requests",
"return",
"details",
"about",
"documents",
"that",
"could",
"not",
"be",
"imported",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/context.go#L162-L164 |
5,819 | arangodb/go-driver | context.go | WithIgnoreRevisions | func WithIgnoreRevisions(parent context.Context, value ...bool) context.Context {
v := true
if len(value) == 1 {
v = value[0]
}
return context.WithValue(contextOrBackground(parent), keyIgnoreRevs, v)
} | go | func WithIgnoreRevisions(parent context.Context, value ...bool) context.Context {
v := true
if len(value) == 1 {
v = value[0]
}
return context.WithValue(contextOrBackground(parent), keyIgnoreRevs, v)
} | [
"func",
"WithIgnoreRevisions",
"(",
"parent",
"context",
".",
"Context",
",",
"value",
"...",
"bool",
")",
"context",
".",
"Context",
"{",
"v",
":=",
"true",
"\n",
"if",
"len",
"(",
"value",
")",
"==",
"1",
"{",
"v",
"=",
"value",
"[",
"0",
"]",
"\n",
"}",
"\n",
"return",
"context",
".",
"WithValue",
"(",
"contextOrBackground",
"(",
"parent",
")",
",",
"keyIgnoreRevs",
",",
"v",
")",
"\n",
"}"
] | // WithIgnoreRevisions is used to configure a context to make modification
// functions ignore revisions in the update.
// Do not use in combination with WithRevision or WithRevisions. | [
"WithIgnoreRevisions",
"is",
"used",
"to",
"configure",
"a",
"context",
"to",
"make",
"modification",
"functions",
"ignore",
"revisions",
"in",
"the",
"update",
".",
"Do",
"not",
"use",
"in",
"combination",
"with",
"WithRevision",
"or",
"WithRevisions",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/context.go#L183-L189 |
5,820 | arangodb/go-driver | context.go | WithConfigured | func WithConfigured(parent context.Context, value ...bool) context.Context {
v := true
if len(value) == 1 {
v = value[0]
}
return context.WithValue(contextOrBackground(parent), keyConfigured, v)
} | go | func WithConfigured(parent context.Context, value ...bool) context.Context {
v := true
if len(value) == 1 {
v = value[0]
}
return context.WithValue(contextOrBackground(parent), keyConfigured, v)
} | [
"func",
"WithConfigured",
"(",
"parent",
"context",
".",
"Context",
",",
"value",
"...",
"bool",
")",
"context",
".",
"Context",
"{",
"v",
":=",
"true",
"\n",
"if",
"len",
"(",
"value",
")",
"==",
"1",
"{",
"v",
"=",
"value",
"[",
"0",
"]",
"\n",
"}",
"\n",
"return",
"context",
".",
"WithValue",
"(",
"contextOrBackground",
"(",
"parent",
")",
",",
"keyConfigured",
",",
"v",
")",
"\n",
"}"
] | // WithConfigured is used to configure a context to return the configured value of
// a user grant instead of the effective grant. | [
"WithConfigured",
"is",
"used",
"to",
"configure",
"a",
"context",
"to",
"return",
"the",
"configured",
"value",
"of",
"a",
"user",
"grant",
"instead",
"of",
"the",
"effective",
"grant",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/context.go#L200-L206 |
5,821 | arangodb/go-driver | context.go | WithDBServerID | func WithDBServerID(parent context.Context, id string) context.Context {
return context.WithValue(contextOrBackground(parent), keyDBServerID, id)
} | go | func WithDBServerID(parent context.Context, id string) context.Context {
return context.WithValue(contextOrBackground(parent), keyDBServerID, id)
} | [
"func",
"WithDBServerID",
"(",
"parent",
"context",
".",
"Context",
",",
"id",
"string",
")",
"context",
".",
"Context",
"{",
"return",
"context",
".",
"WithValue",
"(",
"contextOrBackground",
"(",
"parent",
")",
",",
"keyDBServerID",
",",
"id",
")",
"\n",
"}"
] | // WithDBServerID is used to configure a context that includes an ID of a specific DBServer. | [
"WithDBServerID",
"is",
"used",
"to",
"configure",
"a",
"context",
"that",
"includes",
"an",
"ID",
"of",
"a",
"specific",
"DBServer",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/context.go#L216-L218 |
5,822 | arangodb/go-driver | context.go | WithBatchID | func WithBatchID(parent context.Context, id string) context.Context {
return context.WithValue(contextOrBackground(parent), keyBatchID, id)
} | go | func WithBatchID(parent context.Context, id string) context.Context {
return context.WithValue(contextOrBackground(parent), keyBatchID, id)
} | [
"func",
"WithBatchID",
"(",
"parent",
"context",
".",
"Context",
",",
"id",
"string",
")",
"context",
".",
"Context",
"{",
"return",
"context",
".",
"WithValue",
"(",
"contextOrBackground",
"(",
"parent",
")",
",",
"keyBatchID",
",",
"id",
")",
"\n",
"}"
] | // WithBatchID is used to configure a context that includes an ID of a Batch.
// This is used in replication functions. | [
"WithBatchID",
"is",
"used",
"to",
"configure",
"a",
"context",
"that",
"includes",
"an",
"ID",
"of",
"a",
"Batch",
".",
"This",
"is",
"used",
"in",
"replication",
"functions",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/context.go#L222-L224 |
5,823 | arangodb/go-driver | context.go | WithJobIDResponse | func WithJobIDResponse(parent context.Context, jobID *string) context.Context {
return context.WithValue(contextOrBackground(parent), keyJobIDResponse, jobID)
} | go | func WithJobIDResponse(parent context.Context, jobID *string) context.Context {
return context.WithValue(contextOrBackground(parent), keyJobIDResponse, jobID)
} | [
"func",
"WithJobIDResponse",
"(",
"parent",
"context",
".",
"Context",
",",
"jobID",
"*",
"string",
")",
"context",
".",
"Context",
"{",
"return",
"context",
".",
"WithValue",
"(",
"contextOrBackground",
"(",
"parent",
")",
",",
"keyJobIDResponse",
",",
"jobID",
")",
"\n",
"}"
] | // WithJobIDResponse is used to configure a context that includes a reference to a JobID
// that is filled on a error-free response.
// This is used in cluster functions. | [
"WithJobIDResponse",
"is",
"used",
"to",
"configure",
"a",
"context",
"that",
"includes",
"a",
"reference",
"to",
"a",
"JobID",
"that",
"is",
"filled",
"on",
"a",
"error",
"-",
"free",
"response",
".",
"This",
"is",
"used",
"in",
"cluster",
"functions",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/context.go#L229-L231 |
5,824 | arangodb/go-driver | context.go | loadContextResponseValues | func loadContextResponseValues(cs contextSettings, resp Response) {
// Parse potential dirty read
if cs.DirtyReadFlag != nil {
if dirtyRead := resp.Header("X-Arango-Potential-Dirty-Read"); dirtyRead != "" {
*cs.DirtyReadFlag = true // The documentation does not say anything about the actual value (dirtyRead == "true")
} else {
*cs.DirtyReadFlag = false
}
}
} | go | func loadContextResponseValues(cs contextSettings, resp Response) {
// Parse potential dirty read
if cs.DirtyReadFlag != nil {
if dirtyRead := resp.Header("X-Arango-Potential-Dirty-Read"); dirtyRead != "" {
*cs.DirtyReadFlag = true // The documentation does not say anything about the actual value (dirtyRead == "true")
} else {
*cs.DirtyReadFlag = false
}
}
} | [
"func",
"loadContextResponseValues",
"(",
"cs",
"contextSettings",
",",
"resp",
"Response",
")",
"{",
"// Parse potential dirty read",
"if",
"cs",
".",
"DirtyReadFlag",
"!=",
"nil",
"{",
"if",
"dirtyRead",
":=",
"resp",
".",
"Header",
"(",
"\"",
"\"",
")",
";",
"dirtyRead",
"!=",
"\"",
"\"",
"{",
"*",
"cs",
".",
"DirtyReadFlag",
"=",
"true",
"// The documentation does not say anything about the actual value (dirtyRead == \"true\")",
"\n",
"}",
"else",
"{",
"*",
"cs",
".",
"DirtyReadFlag",
"=",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // loadContextResponseValue loads generic values from the response and puts it into variables specified
// via context values. | [
"loadContextResponseValue",
"loads",
"generic",
"values",
"from",
"the",
"response",
"and",
"puts",
"it",
"into",
"variables",
"specified",
"via",
"context",
"values",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/context.go#L256-L265 |
5,825 | arangodb/go-driver | context.go | setDirtyReadFlagIfRequired | func setDirtyReadFlagIfRequired(ctx context.Context, wasDirty bool) {
if v := ctx.Value(keyAllowDirtyReads); v != nil {
if ref, ok := v.(*bool); ok && ref != nil {
*ref = wasDirty
}
}
} | go | func setDirtyReadFlagIfRequired(ctx context.Context, wasDirty bool) {
if v := ctx.Value(keyAllowDirtyReads); v != nil {
if ref, ok := v.(*bool); ok && ref != nil {
*ref = wasDirty
}
}
} | [
"func",
"setDirtyReadFlagIfRequired",
"(",
"ctx",
"context",
".",
"Context",
",",
"wasDirty",
"bool",
")",
"{",
"if",
"v",
":=",
"ctx",
".",
"Value",
"(",
"keyAllowDirtyReads",
")",
";",
"v",
"!=",
"nil",
"{",
"if",
"ref",
",",
"ok",
":=",
"v",
".",
"(",
"*",
"bool",
")",
";",
"ok",
"&&",
"ref",
"!=",
"nil",
"{",
"*",
"ref",
"=",
"wasDirty",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // setDirtyReadFlagIfRequired is a helper function that sets the bool reference for allowDirtyReads to the
// specified value, if required and reference is not nil. | [
"setDirtyReadFlagIfRequired",
"is",
"a",
"helper",
"function",
"that",
"sets",
"the",
"bool",
"reference",
"for",
"allowDirtyReads",
"to",
"the",
"specified",
"value",
"if",
"required",
"and",
"reference",
"is",
"not",
"nil",
"."
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/context.go#L269-L275 |
5,826 | arangodb/go-driver | agency/error.go | Error | func (e KeyNotFoundError) Error() string {
return fmt.Sprintf("Key '%s' not found", strings.Join(e.Key, "/"))
} | go | func (e KeyNotFoundError) Error() string {
return fmt.Sprintf("Key '%s' not found", strings.Join(e.Key, "/"))
} | [
"func",
"(",
"e",
"KeyNotFoundError",
")",
"Error",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"strings",
".",
"Join",
"(",
"e",
".",
"Key",
",",
"\"",
"\"",
")",
")",
"\n",
"}"
] | // Error returns a human readable error string | [
"Error",
"returns",
"a",
"human",
"readable",
"error",
"string"
] | b14f41496c3dc1253a16c06bbc405605934b214a | https://github.com/arangodb/go-driver/blob/b14f41496c3dc1253a16c06bbc405605934b214a/agency/error.go#L47-L49 |
5,827 | ivpusic/grpool | grpool.go | NewPool | func NewPool(numWorkers int, jobQueueLen int) *Pool {
jobQueue := make(chan Job, jobQueueLen)
workerPool := make(chan *worker, numWorkers)
pool := &Pool{
JobQueue: jobQueue,
dispatcher: newDispatcher(workerPool, jobQueue),
}
return pool
} | go | func NewPool(numWorkers int, jobQueueLen int) *Pool {
jobQueue := make(chan Job, jobQueueLen)
workerPool := make(chan *worker, numWorkers)
pool := &Pool{
JobQueue: jobQueue,
dispatcher: newDispatcher(workerPool, jobQueue),
}
return pool
} | [
"func",
"NewPool",
"(",
"numWorkers",
"int",
",",
"jobQueueLen",
"int",
")",
"*",
"Pool",
"{",
"jobQueue",
":=",
"make",
"(",
"chan",
"Job",
",",
"jobQueueLen",
")",
"\n",
"workerPool",
":=",
"make",
"(",
"chan",
"*",
"worker",
",",
"numWorkers",
")",
"\n\n",
"pool",
":=",
"&",
"Pool",
"{",
"JobQueue",
":",
"jobQueue",
",",
"dispatcher",
":",
"newDispatcher",
"(",
"workerPool",
",",
"jobQueue",
")",
",",
"}",
"\n\n",
"return",
"pool",
"\n",
"}"
] | // Will make pool of gorouting workers.
// numWorkers - how many workers will be created for this pool
// queueLen - how many jobs can we accept until we block
//
// Returned object contains JobQueue reference, which you can use to send job to pool. | [
"Will",
"make",
"pool",
"of",
"gorouting",
"workers",
".",
"numWorkers",
"-",
"how",
"many",
"workers",
"will",
"be",
"created",
"for",
"this",
"pool",
"queueLen",
"-",
"how",
"many",
"jobs",
"can",
"we",
"accept",
"until",
"we",
"block",
"Returned",
"object",
"contains",
"JobQueue",
"reference",
"which",
"you",
"can",
"use",
"to",
"send",
"job",
"to",
"pool",
"."
] | 28957a27c9441f178d644aa598bac0aad4dd7bba | https://github.com/ivpusic/grpool/blob/28957a27c9441f178d644aa598bac0aad4dd7bba/grpool.go#L95-L105 |
5,828 | beeker1121/goque | queue.go | OpenQueue | func OpenQueue(dataDir string) (*Queue, error) {
var err error
// Create a new Queue.
q := &Queue{
DataDir: dataDir,
db: &leveldb.DB{},
head: 0,
tail: 0,
isOpen: false,
}
// Open database for the queue.
q.db, err = leveldb.OpenFile(dataDir, nil)
if err != nil {
return q, err
}
// Check if this Goque type can open the requested data directory.
ok, err := checkGoqueType(dataDir, goqueQueue)
if err != nil {
return q, err
}
if !ok {
return q, ErrIncompatibleType
}
// Set isOpen and return.
q.isOpen = true
return q, q.init()
} | go | func OpenQueue(dataDir string) (*Queue, error) {
var err error
// Create a new Queue.
q := &Queue{
DataDir: dataDir,
db: &leveldb.DB{},
head: 0,
tail: 0,
isOpen: false,
}
// Open database for the queue.
q.db, err = leveldb.OpenFile(dataDir, nil)
if err != nil {
return q, err
}
// Check if this Goque type can open the requested data directory.
ok, err := checkGoqueType(dataDir, goqueQueue)
if err != nil {
return q, err
}
if !ok {
return q, ErrIncompatibleType
}
// Set isOpen and return.
q.isOpen = true
return q, q.init()
} | [
"func",
"OpenQueue",
"(",
"dataDir",
"string",
")",
"(",
"*",
"Queue",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// Create a new Queue.",
"q",
":=",
"&",
"Queue",
"{",
"DataDir",
":",
"dataDir",
",",
"db",
":",
"&",
"leveldb",
".",
"DB",
"{",
"}",
",",
"head",
":",
"0",
",",
"tail",
":",
"0",
",",
"isOpen",
":",
"false",
",",
"}",
"\n\n",
"// Open database for the queue.",
"q",
".",
"db",
",",
"err",
"=",
"leveldb",
".",
"OpenFile",
"(",
"dataDir",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"q",
",",
"err",
"\n",
"}",
"\n\n",
"// Check if this Goque type can open the requested data directory.",
"ok",
",",
"err",
":=",
"checkGoqueType",
"(",
"dataDir",
",",
"goqueQueue",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"q",
",",
"err",
"\n",
"}",
"\n",
"if",
"!",
"ok",
"{",
"return",
"q",
",",
"ErrIncompatibleType",
"\n",
"}",
"\n\n",
"// Set isOpen and return.",
"q",
".",
"isOpen",
"=",
"true",
"\n",
"return",
"q",
",",
"q",
".",
"init",
"(",
")",
"\n",
"}"
] | // OpenQueue opens a queue if one exists at the given directory. If one
// does not already exist, a new queue is created. | [
"OpenQueue",
"opens",
"a",
"queue",
"if",
"one",
"exists",
"at",
"the",
"given",
"directory",
".",
"If",
"one",
"does",
"not",
"already",
"exist",
"a",
"new",
"queue",
"is",
"created",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/queue.go#L24-L54 |
5,829 | beeker1121/goque | queue.go | Dequeue | func (q *Queue) Dequeue() (*Item, error) {
q.Lock()
defer q.Unlock()
// Check if queue is closed.
if !q.isOpen {
return nil, ErrDBClosed
}
// Try to get the next item in the queue.
item, err := q.getItemByID(q.head + 1)
if err != nil {
return nil, err
}
// Remove this item from the queue.
if err := q.db.Delete(item.Key, nil); err != nil {
return nil, err
}
// Increment head position.
q.head++
return item, nil
} | go | func (q *Queue) Dequeue() (*Item, error) {
q.Lock()
defer q.Unlock()
// Check if queue is closed.
if !q.isOpen {
return nil, ErrDBClosed
}
// Try to get the next item in the queue.
item, err := q.getItemByID(q.head + 1)
if err != nil {
return nil, err
}
// Remove this item from the queue.
if err := q.db.Delete(item.Key, nil); err != nil {
return nil, err
}
// Increment head position.
q.head++
return item, nil
} | [
"func",
"(",
"q",
"*",
"Queue",
")",
"Dequeue",
"(",
")",
"(",
"*",
"Item",
",",
"error",
")",
"{",
"q",
".",
"Lock",
"(",
")",
"\n",
"defer",
"q",
".",
"Unlock",
"(",
")",
"\n\n",
"// Check if queue is closed.",
"if",
"!",
"q",
".",
"isOpen",
"{",
"return",
"nil",
",",
"ErrDBClosed",
"\n",
"}",
"\n\n",
"// Try to get the next item in the queue.",
"item",
",",
"err",
":=",
"q",
".",
"getItemByID",
"(",
"q",
".",
"head",
"+",
"1",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Remove this item from the queue.",
"if",
"err",
":=",
"q",
".",
"db",
".",
"Delete",
"(",
"item",
".",
"Key",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Increment head position.",
"q",
".",
"head",
"++",
"\n\n",
"return",
"item",
",",
"nil",
"\n",
"}"
] | // Dequeue removes the next item in the queue and returns it. | [
"Dequeue",
"removes",
"the",
"next",
"item",
"in",
"the",
"queue",
"and",
"returns",
"it",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/queue.go#L103-L127 |
5,830 | beeker1121/goque | queue.go | Peek | func (q *Queue) Peek() (*Item, error) {
q.RLock()
defer q.RUnlock()
// Check if queue is closed.
if !q.isOpen {
return nil, ErrDBClosed
}
return q.getItemByID(q.head + 1)
} | go | func (q *Queue) Peek() (*Item, error) {
q.RLock()
defer q.RUnlock()
// Check if queue is closed.
if !q.isOpen {
return nil, ErrDBClosed
}
return q.getItemByID(q.head + 1)
} | [
"func",
"(",
"q",
"*",
"Queue",
")",
"Peek",
"(",
")",
"(",
"*",
"Item",
",",
"error",
")",
"{",
"q",
".",
"RLock",
"(",
")",
"\n",
"defer",
"q",
".",
"RUnlock",
"(",
")",
"\n\n",
"// Check if queue is closed.",
"if",
"!",
"q",
".",
"isOpen",
"{",
"return",
"nil",
",",
"ErrDBClosed",
"\n",
"}",
"\n\n",
"return",
"q",
".",
"getItemByID",
"(",
"q",
".",
"head",
"+",
"1",
")",
"\n",
"}"
] | // Peek returns the next item in the queue without removing it. | [
"Peek",
"returns",
"the",
"next",
"item",
"in",
"the",
"queue",
"without",
"removing",
"it",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/queue.go#L130-L140 |
5,831 | beeker1121/goque | queue.go | Close | func (q *Queue) Close() error {
q.Lock()
defer q.Unlock()
// Check if queue is already closed.
if !q.isOpen {
return nil
}
// Close the LevelDB database.
if err := q.db.Close(); err != nil {
return err
}
// Reset queue head and tail and set
// isOpen to false.
q.head = 0
q.tail = 0
q.isOpen = false
return nil
} | go | func (q *Queue) Close() error {
q.Lock()
defer q.Unlock()
// Check if queue is already closed.
if !q.isOpen {
return nil
}
// Close the LevelDB database.
if err := q.db.Close(); err != nil {
return err
}
// Reset queue head and tail and set
// isOpen to false.
q.head = 0
q.tail = 0
q.isOpen = false
return nil
} | [
"func",
"(",
"q",
"*",
"Queue",
")",
"Close",
"(",
")",
"error",
"{",
"q",
".",
"Lock",
"(",
")",
"\n",
"defer",
"q",
".",
"Unlock",
"(",
")",
"\n\n",
"// Check if queue is already closed.",
"if",
"!",
"q",
".",
"isOpen",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// Close the LevelDB database.",
"if",
"err",
":=",
"q",
".",
"db",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Reset queue head and tail and set",
"// isOpen to false.",
"q",
".",
"head",
"=",
"0",
"\n",
"q",
".",
"tail",
"=",
"0",
"\n",
"q",
".",
"isOpen",
"=",
"false",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Close closes the LevelDB database of the queue. | [
"Close",
"closes",
"the",
"LevelDB",
"database",
"of",
"the",
"queue",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/queue.go#L223-L244 |
5,832 | beeker1121/goque | queue.go | Drop | func (q *Queue) Drop() error {
if err := q.Close(); err != nil {
return err
}
return os.RemoveAll(q.DataDir)
} | go | func (q *Queue) Drop() error {
if err := q.Close(); err != nil {
return err
}
return os.RemoveAll(q.DataDir)
} | [
"func",
"(",
"q",
"*",
"Queue",
")",
"Drop",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"q",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"os",
".",
"RemoveAll",
"(",
"q",
".",
"DataDir",
")",
"\n",
"}"
] | // Drop closes and deletes the LevelDB database of the queue. | [
"Drop",
"closes",
"and",
"deletes",
"the",
"LevelDB",
"database",
"of",
"the",
"queue",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/queue.go#L247-L253 |
5,833 | beeker1121/goque | queue.go | init | func (q *Queue) init() error {
// Create a new LevelDB Iterator.
iter := q.db.NewIterator(nil, nil)
defer iter.Release()
// Set queue head to the first item.
if iter.First() {
q.head = keyToID(iter.Key()) - 1
}
// Set queue tail to the last item.
if iter.Last() {
q.tail = keyToID(iter.Key())
}
return iter.Error()
} | go | func (q *Queue) init() error {
// Create a new LevelDB Iterator.
iter := q.db.NewIterator(nil, nil)
defer iter.Release()
// Set queue head to the first item.
if iter.First() {
q.head = keyToID(iter.Key()) - 1
}
// Set queue tail to the last item.
if iter.Last() {
q.tail = keyToID(iter.Key())
}
return iter.Error()
} | [
"func",
"(",
"q",
"*",
"Queue",
")",
"init",
"(",
")",
"error",
"{",
"// Create a new LevelDB Iterator.",
"iter",
":=",
"q",
".",
"db",
".",
"NewIterator",
"(",
"nil",
",",
"nil",
")",
"\n",
"defer",
"iter",
".",
"Release",
"(",
")",
"\n\n",
"// Set queue head to the first item.",
"if",
"iter",
".",
"First",
"(",
")",
"{",
"q",
".",
"head",
"=",
"keyToID",
"(",
"iter",
".",
"Key",
"(",
")",
")",
"-",
"1",
"\n",
"}",
"\n\n",
"// Set queue tail to the last item.",
"if",
"iter",
".",
"Last",
"(",
")",
"{",
"q",
".",
"tail",
"=",
"keyToID",
"(",
"iter",
".",
"Key",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"iter",
".",
"Error",
"(",
")",
"\n",
"}"
] | // init initializes the queue data. | [
"init",
"initializes",
"the",
"queue",
"data",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/queue.go#L275-L291 |
5,834 | beeker1121/goque | file.go | checkGoqueType | func checkGoqueType(dataDir string, gt goqueType) (bool, error) {
// Set the path to 'GOQUE' file.
path := filepath.Join(dataDir, "GOQUE")
// Read 'GOQUE' file for this directory.
f, err := os.OpenFile(path, os.O_RDONLY, 0)
if os.IsNotExist(err) {
f, err = os.OpenFile(path, os.O_RDWR|os.O_CREATE, 0644)
if err != nil {
return false, err
}
defer f.Close()
// Create byte slice of goqueType.
gtb := make([]byte, 1)
gtb[0] = byte(gt)
_, err = f.Write(gtb)
if err != nil {
return false, err
}
return true, nil
}
if err != nil {
return false, err
}
defer f.Close()
// Get the saved type from the file.
fb := make([]byte, 1)
_, err = f.Read(fb)
if err != nil {
return false, err
}
// Convert the file byte to its goqueType.
filegt := goqueType(fb[0])
// Compare the types.
if filegt == gt {
return true, nil
} else if filegt == goqueStack && gt == goqueQueue {
return true, nil
} else if filegt == goqueQueue && gt == goqueStack {
return true, nil
}
return false, nil
} | go | func checkGoqueType(dataDir string, gt goqueType) (bool, error) {
// Set the path to 'GOQUE' file.
path := filepath.Join(dataDir, "GOQUE")
// Read 'GOQUE' file for this directory.
f, err := os.OpenFile(path, os.O_RDONLY, 0)
if os.IsNotExist(err) {
f, err = os.OpenFile(path, os.O_RDWR|os.O_CREATE, 0644)
if err != nil {
return false, err
}
defer f.Close()
// Create byte slice of goqueType.
gtb := make([]byte, 1)
gtb[0] = byte(gt)
_, err = f.Write(gtb)
if err != nil {
return false, err
}
return true, nil
}
if err != nil {
return false, err
}
defer f.Close()
// Get the saved type from the file.
fb := make([]byte, 1)
_, err = f.Read(fb)
if err != nil {
return false, err
}
// Convert the file byte to its goqueType.
filegt := goqueType(fb[0])
// Compare the types.
if filegt == gt {
return true, nil
} else if filegt == goqueStack && gt == goqueQueue {
return true, nil
} else if filegt == goqueQueue && gt == goqueStack {
return true, nil
}
return false, nil
} | [
"func",
"checkGoqueType",
"(",
"dataDir",
"string",
",",
"gt",
"goqueType",
")",
"(",
"bool",
",",
"error",
")",
"{",
"// Set the path to 'GOQUE' file.",
"path",
":=",
"filepath",
".",
"Join",
"(",
"dataDir",
",",
"\"",
"\"",
")",
"\n\n",
"// Read 'GOQUE' file for this directory.",
"f",
",",
"err",
":=",
"os",
".",
"OpenFile",
"(",
"path",
",",
"os",
".",
"O_RDONLY",
",",
"0",
")",
"\n",
"if",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"f",
",",
"err",
"=",
"os",
".",
"OpenFile",
"(",
"path",
",",
"os",
".",
"O_RDWR",
"|",
"os",
".",
"O_CREATE",
",",
"0644",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"defer",
"f",
".",
"Close",
"(",
")",
"\n\n",
"// Create byte slice of goqueType.",
"gtb",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"1",
")",
"\n",
"gtb",
"[",
"0",
"]",
"=",
"byte",
"(",
"gt",
")",
"\n\n",
"_",
",",
"err",
"=",
"f",
".",
"Write",
"(",
"gtb",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"defer",
"f",
".",
"Close",
"(",
")",
"\n\n",
"// Get the saved type from the file.",
"fb",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"1",
")",
"\n",
"_",
",",
"err",
"=",
"f",
".",
"Read",
"(",
"fb",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n\n",
"// Convert the file byte to its goqueType.",
"filegt",
":=",
"goqueType",
"(",
"fb",
"[",
"0",
"]",
")",
"\n\n",
"// Compare the types.",
"if",
"filegt",
"==",
"gt",
"{",
"return",
"true",
",",
"nil",
"\n",
"}",
"else",
"if",
"filegt",
"==",
"goqueStack",
"&&",
"gt",
"==",
"goqueQueue",
"{",
"return",
"true",
",",
"nil",
"\n",
"}",
"else",
"if",
"filegt",
"==",
"goqueQueue",
"&&",
"gt",
"==",
"goqueStack",
"{",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"false",
",",
"nil",
"\n",
"}"
] | // checkGoqueType checks if the type of Goque data structure
// trying to be opened is compatible with the opener type.
//
// A file named 'GOQUE' within the data directory used by
// the structure stores the structure type, using the constants
// declared above.
//
// Stacks and Queues are 100% compatible with each other, while
// a PriorityQueue is incompatible with both.
//
// Returns true if types are compatible and false if incompatible. | [
"checkGoqueType",
"checks",
"if",
"the",
"type",
"of",
"Goque",
"data",
"structure",
"trying",
"to",
"be",
"opened",
"is",
"compatible",
"with",
"the",
"opener",
"type",
".",
"A",
"file",
"named",
"GOQUE",
"within",
"the",
"data",
"directory",
"used",
"by",
"the",
"structure",
"stores",
"the",
"structure",
"type",
"using",
"the",
"constants",
"declared",
"above",
".",
"Stacks",
"and",
"Queues",
"are",
"100%",
"compatible",
"with",
"each",
"other",
"while",
"a",
"PriorityQueue",
"is",
"incompatible",
"with",
"both",
".",
"Returns",
"true",
"if",
"types",
"are",
"compatible",
"and",
"false",
"if",
"incompatible",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/file.go#L31-L80 |
5,835 | beeker1121/goque | prefix_queue.go | OpenPrefixQueue | func OpenPrefixQueue(dataDir string) (*PrefixQueue, error) {
var err error
// Create a new Queue.
pq := &PrefixQueue{
DataDir: dataDir,
db: &leveldb.DB{},
isOpen: false,
}
// Open database for the prefix queue.
pq.db, err = leveldb.OpenFile(dataDir, nil)
if err != nil {
return nil, err
}
// Check if this Goque type can open the requested data directory.
ok, err := checkGoqueType(dataDir, goquePrefixQueue)
if err != nil {
return nil, err
}
if !ok {
return nil, ErrIncompatibleType
}
// Set isOpen and return.
pq.isOpen = true
return pq, pq.init()
} | go | func OpenPrefixQueue(dataDir string) (*PrefixQueue, error) {
var err error
// Create a new Queue.
pq := &PrefixQueue{
DataDir: dataDir,
db: &leveldb.DB{},
isOpen: false,
}
// Open database for the prefix queue.
pq.db, err = leveldb.OpenFile(dataDir, nil)
if err != nil {
return nil, err
}
// Check if this Goque type can open the requested data directory.
ok, err := checkGoqueType(dataDir, goquePrefixQueue)
if err != nil {
return nil, err
}
if !ok {
return nil, ErrIncompatibleType
}
// Set isOpen and return.
pq.isOpen = true
return pq, pq.init()
} | [
"func",
"OpenPrefixQueue",
"(",
"dataDir",
"string",
")",
"(",
"*",
"PrefixQueue",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// Create a new Queue.",
"pq",
":=",
"&",
"PrefixQueue",
"{",
"DataDir",
":",
"dataDir",
",",
"db",
":",
"&",
"leveldb",
".",
"DB",
"{",
"}",
",",
"isOpen",
":",
"false",
",",
"}",
"\n\n",
"// Open database for the prefix queue.",
"pq",
".",
"db",
",",
"err",
"=",
"leveldb",
".",
"OpenFile",
"(",
"dataDir",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Check if this Goque type can open the requested data directory.",
"ok",
",",
"err",
":=",
"checkGoqueType",
"(",
"dataDir",
",",
"goquePrefixQueue",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"ErrIncompatibleType",
"\n",
"}",
"\n\n",
"// Set isOpen and return.",
"pq",
".",
"isOpen",
"=",
"true",
"\n",
"return",
"pq",
",",
"pq",
".",
"init",
"(",
")",
"\n",
"}"
] | // OpenPrefixQueue opens a prefix queue if one exists at the given directory.
// If one does not already exist, a new prefix queue is created. | [
"OpenPrefixQueue",
"opens",
"a",
"prefix",
"queue",
"if",
"one",
"exists",
"at",
"the",
"given",
"directory",
".",
"If",
"one",
"does",
"not",
"already",
"exist",
"a",
"new",
"prefix",
"queue",
"is",
"created",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/prefix_queue.go#L42-L70 |
5,836 | beeker1121/goque | prefix_queue.go | EnqueueString | func (pq *PrefixQueue) EnqueueString(prefix, value string) (*Item, error) {
return pq.Enqueue([]byte(prefix), []byte(value))
} | go | func (pq *PrefixQueue) EnqueueString(prefix, value string) (*Item, error) {
return pq.Enqueue([]byte(prefix), []byte(value))
} | [
"func",
"(",
"pq",
"*",
"PrefixQueue",
")",
"EnqueueString",
"(",
"prefix",
",",
"value",
"string",
")",
"(",
"*",
"Item",
",",
"error",
")",
"{",
"return",
"pq",
".",
"Enqueue",
"(",
"[",
"]",
"byte",
"(",
"prefix",
")",
",",
"[",
"]",
"byte",
"(",
"value",
")",
")",
"\n",
"}"
] | // EnqueueString is a helper function for Enqueue that accepts the prefix and
// value as a string rather than a byte slice. | [
"EnqueueString",
"is",
"a",
"helper",
"function",
"for",
"Enqueue",
"that",
"accepts",
"the",
"prefix",
"and",
"value",
"as",
"a",
"string",
"rather",
"than",
"a",
"byte",
"slice",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/prefix_queue.go#L119-L121 |
5,837 | beeker1121/goque | prefix_queue.go | Dequeue | func (pq *PrefixQueue) Dequeue(prefix []byte) (*Item, error) {
pq.Lock()
defer pq.Unlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Get the queue for this prefix.
q, err := pq.getQueue(prefix)
if err != nil {
return nil, err
}
// Try to get the next item in the queue.
item, err := pq.getItemByPrefixID(prefix, q.Head+1)
if err != nil {
return nil, err
}
// Remove this item from the queue.
if err := pq.db.Delete(item.Key, nil); err != nil {
return nil, err
}
// Increment head position and decrement prefix queue size.
q.Head++
pq.size--
// Save the queue.
if err := pq.saveQueue(prefix, q); err != nil {
return nil, err
}
// Save main prefix queue data.
if err := pq.save(); err != nil {
return nil, err
}
return item, nil
} | go | func (pq *PrefixQueue) Dequeue(prefix []byte) (*Item, error) {
pq.Lock()
defer pq.Unlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Get the queue for this prefix.
q, err := pq.getQueue(prefix)
if err != nil {
return nil, err
}
// Try to get the next item in the queue.
item, err := pq.getItemByPrefixID(prefix, q.Head+1)
if err != nil {
return nil, err
}
// Remove this item from the queue.
if err := pq.db.Delete(item.Key, nil); err != nil {
return nil, err
}
// Increment head position and decrement prefix queue size.
q.Head++
pq.size--
// Save the queue.
if err := pq.saveQueue(prefix, q); err != nil {
return nil, err
}
// Save main prefix queue data.
if err := pq.save(); err != nil {
return nil, err
}
return item, nil
} | [
"func",
"(",
"pq",
"*",
"PrefixQueue",
")",
"Dequeue",
"(",
"prefix",
"[",
"]",
"byte",
")",
"(",
"*",
"Item",
",",
"error",
")",
"{",
"pq",
".",
"Lock",
"(",
")",
"\n",
"defer",
"pq",
".",
"Unlock",
"(",
")",
"\n\n",
"// Check if queue is closed.",
"if",
"!",
"pq",
".",
"isOpen",
"{",
"return",
"nil",
",",
"ErrDBClosed",
"\n",
"}",
"\n\n",
"// Get the queue for this prefix.",
"q",
",",
"err",
":=",
"pq",
".",
"getQueue",
"(",
"prefix",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Try to get the next item in the queue.",
"item",
",",
"err",
":=",
"pq",
".",
"getItemByPrefixID",
"(",
"prefix",
",",
"q",
".",
"Head",
"+",
"1",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Remove this item from the queue.",
"if",
"err",
":=",
"pq",
".",
"db",
".",
"Delete",
"(",
"item",
".",
"Key",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Increment head position and decrement prefix queue size.",
"q",
".",
"Head",
"++",
"\n",
"pq",
".",
"size",
"--",
"\n\n",
"// Save the queue.",
"if",
"err",
":=",
"pq",
".",
"saveQueue",
"(",
"prefix",
",",
"q",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Save main prefix queue data.",
"if",
"err",
":=",
"pq",
".",
"save",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"item",
",",
"nil",
"\n",
"}"
] | // Dequeue removes the next item in the prefix queue and returns it. | [
"Dequeue",
"removes",
"the",
"next",
"item",
"in",
"the",
"prefix",
"queue",
"and",
"returns",
"it",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/prefix_queue.go#L136-L177 |
5,838 | beeker1121/goque | prefix_queue.go | DequeueString | func (pq *PrefixQueue) DequeueString(prefix string) (*Item, error) {
return pq.Dequeue([]byte(prefix))
} | go | func (pq *PrefixQueue) DequeueString(prefix string) (*Item, error) {
return pq.Dequeue([]byte(prefix))
} | [
"func",
"(",
"pq",
"*",
"PrefixQueue",
")",
"DequeueString",
"(",
"prefix",
"string",
")",
"(",
"*",
"Item",
",",
"error",
")",
"{",
"return",
"pq",
".",
"Dequeue",
"(",
"[",
"]",
"byte",
"(",
"prefix",
")",
")",
"\n",
"}"
] | // DequeueString is a helper function for Dequeue that accepts the prefix as a
// string rather than a byte slice. | [
"DequeueString",
"is",
"a",
"helper",
"function",
"for",
"Dequeue",
"that",
"accepts",
"the",
"prefix",
"as",
"a",
"string",
"rather",
"than",
"a",
"byte",
"slice",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/prefix_queue.go#L181-L183 |
5,839 | beeker1121/goque | prefix_queue.go | Peek | func (pq *PrefixQueue) Peek(prefix []byte) (*Item, error) {
pq.RLock()
defer pq.RUnlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Get the queue for this prefix.
q, err := pq.getQueue(prefix)
if err != nil {
return nil, err
}
return pq.getItemByPrefixID(prefix, q.Head+1)
} | go | func (pq *PrefixQueue) Peek(prefix []byte) (*Item, error) {
pq.RLock()
defer pq.RUnlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Get the queue for this prefix.
q, err := pq.getQueue(prefix)
if err != nil {
return nil, err
}
return pq.getItemByPrefixID(prefix, q.Head+1)
} | [
"func",
"(",
"pq",
"*",
"PrefixQueue",
")",
"Peek",
"(",
"prefix",
"[",
"]",
"byte",
")",
"(",
"*",
"Item",
",",
"error",
")",
"{",
"pq",
".",
"RLock",
"(",
")",
"\n",
"defer",
"pq",
".",
"RUnlock",
"(",
")",
"\n\n",
"// Check if queue is closed.",
"if",
"!",
"pq",
".",
"isOpen",
"{",
"return",
"nil",
",",
"ErrDBClosed",
"\n",
"}",
"\n\n",
"// Get the queue for this prefix.",
"q",
",",
"err",
":=",
"pq",
".",
"getQueue",
"(",
"prefix",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"pq",
".",
"getItemByPrefixID",
"(",
"prefix",
",",
"q",
".",
"Head",
"+",
"1",
")",
"\n",
"}"
] | // Peek returns the next item in the given queue without removing it. | [
"Peek",
"returns",
"the",
"next",
"item",
"in",
"the",
"given",
"queue",
"without",
"removing",
"it",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/prefix_queue.go#L186-L202 |
5,840 | beeker1121/goque | prefix_queue.go | PeekString | func (pq *PrefixQueue) PeekString(prefix string) (*Item, error) {
return pq.Peek([]byte(prefix))
} | go | func (pq *PrefixQueue) PeekString(prefix string) (*Item, error) {
return pq.Peek([]byte(prefix))
} | [
"func",
"(",
"pq",
"*",
"PrefixQueue",
")",
"PeekString",
"(",
"prefix",
"string",
")",
"(",
"*",
"Item",
",",
"error",
")",
"{",
"return",
"pq",
".",
"Peek",
"(",
"[",
"]",
"byte",
"(",
"prefix",
")",
")",
"\n",
"}"
] | // PeekString is a helper function for Peek that accepts the prefix as a
// string rather than a byte slice. | [
"PeekString",
"is",
"a",
"helper",
"function",
"for",
"Peek",
"that",
"accepts",
"the",
"prefix",
"as",
"a",
"string",
"rather",
"than",
"a",
"byte",
"slice",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/prefix_queue.go#L206-L208 |
5,841 | beeker1121/goque | prefix_queue.go | PeekByIDString | func (pq *PrefixQueue) PeekByIDString(prefix string, id uint64) (*Item, error) {
return pq.PeekByID([]byte(prefix), id)
} | go | func (pq *PrefixQueue) PeekByIDString(prefix string, id uint64) (*Item, error) {
return pq.PeekByID([]byte(prefix), id)
} | [
"func",
"(",
"pq",
"*",
"PrefixQueue",
")",
"PeekByIDString",
"(",
"prefix",
"string",
",",
"id",
"uint64",
")",
"(",
"*",
"Item",
",",
"error",
")",
"{",
"return",
"pq",
".",
"PeekByID",
"(",
"[",
"]",
"byte",
"(",
"prefix",
")",
",",
"id",
")",
"\n",
"}"
] | // PeekByIDString is a helper function for Peek that accepts the prefix as a
// string rather than a byte slice. | [
"PeekByIDString",
"is",
"a",
"helper",
"function",
"for",
"Peek",
"that",
"accepts",
"the",
"prefix",
"as",
"a",
"string",
"rather",
"than",
"a",
"byte",
"slice",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/prefix_queue.go#L225-L227 |
5,842 | beeker1121/goque | prefix_queue.go | Update | func (pq *PrefixQueue) Update(prefix []byte, id uint64, newValue []byte) (*Item, error) {
pq.Lock()
defer pq.Unlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Get the queue for this prefix.
q, err := pq.getQueue(prefix)
if err != nil {
return nil, err
}
// Check if item exists in queue.
if id <= q.Head || id > q.Tail {
return nil, ErrOutOfBounds
}
// Create new Item.
item := &Item{
ID: id,
Key: generateKeyPrefixID(prefix, id),
Value: newValue,
}
// Update this item in the queue.
if err := pq.db.Put(item.Key, item.Value, nil); err != nil {
return nil, err
}
return item, nil
} | go | func (pq *PrefixQueue) Update(prefix []byte, id uint64, newValue []byte) (*Item, error) {
pq.Lock()
defer pq.Unlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Get the queue for this prefix.
q, err := pq.getQueue(prefix)
if err != nil {
return nil, err
}
// Check if item exists in queue.
if id <= q.Head || id > q.Tail {
return nil, ErrOutOfBounds
}
// Create new Item.
item := &Item{
ID: id,
Key: generateKeyPrefixID(prefix, id),
Value: newValue,
}
// Update this item in the queue.
if err := pq.db.Put(item.Key, item.Value, nil); err != nil {
return nil, err
}
return item, nil
} | [
"func",
"(",
"pq",
"*",
"PrefixQueue",
")",
"Update",
"(",
"prefix",
"[",
"]",
"byte",
",",
"id",
"uint64",
",",
"newValue",
"[",
"]",
"byte",
")",
"(",
"*",
"Item",
",",
"error",
")",
"{",
"pq",
".",
"Lock",
"(",
")",
"\n",
"defer",
"pq",
".",
"Unlock",
"(",
")",
"\n\n",
"// Check if queue is closed.",
"if",
"!",
"pq",
".",
"isOpen",
"{",
"return",
"nil",
",",
"ErrDBClosed",
"\n",
"}",
"\n\n",
"// Get the queue for this prefix.",
"q",
",",
"err",
":=",
"pq",
".",
"getQueue",
"(",
"prefix",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Check if item exists in queue.",
"if",
"id",
"<=",
"q",
".",
"Head",
"||",
"id",
">",
"q",
".",
"Tail",
"{",
"return",
"nil",
",",
"ErrOutOfBounds",
"\n",
"}",
"\n\n",
"// Create new Item.",
"item",
":=",
"&",
"Item",
"{",
"ID",
":",
"id",
",",
"Key",
":",
"generateKeyPrefixID",
"(",
"prefix",
",",
"id",
")",
",",
"Value",
":",
"newValue",
",",
"}",
"\n\n",
"// Update this item in the queue.",
"if",
"err",
":=",
"pq",
".",
"db",
".",
"Put",
"(",
"item",
".",
"Key",
",",
"item",
".",
"Value",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"item",
",",
"nil",
"\n",
"}"
] | // Update updates an item in the given queue without changing its position. | [
"Update",
"updates",
"an",
"item",
"in",
"the",
"given",
"queue",
"without",
"changing",
"its",
"position",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/prefix_queue.go#L230-L263 |
5,843 | beeker1121/goque | prefix_queue.go | UpdateString | func (pq *PrefixQueue) UpdateString(prefix string, id uint64, value string) (*Item, error) {
return pq.Update([]byte(prefix), id, []byte(value))
} | go | func (pq *PrefixQueue) UpdateString(prefix string, id uint64, value string) (*Item, error) {
return pq.Update([]byte(prefix), id, []byte(value))
} | [
"func",
"(",
"pq",
"*",
"PrefixQueue",
")",
"UpdateString",
"(",
"prefix",
"string",
",",
"id",
"uint64",
",",
"value",
"string",
")",
"(",
"*",
"Item",
",",
"error",
")",
"{",
"return",
"pq",
".",
"Update",
"(",
"[",
"]",
"byte",
"(",
"prefix",
")",
",",
"id",
",",
"[",
"]",
"byte",
"(",
"value",
")",
")",
"\n",
"}"
] | // UpdateString is a helper function for Update that accepts the prefix and
// value as a string rather than a byte slice. | [
"UpdateString",
"is",
"a",
"helper",
"function",
"for",
"Update",
"that",
"accepts",
"the",
"prefix",
"and",
"value",
"as",
"a",
"string",
"rather",
"than",
"a",
"byte",
"slice",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/prefix_queue.go#L267-L269 |
5,844 | beeker1121/goque | prefix_queue.go | Close | func (pq *PrefixQueue) Close() error {
pq.Lock()
defer pq.Unlock()
// Check if queue is already closed.
if !pq.isOpen {
return nil
}
// Close the LevelDB database.
if err := pq.db.Close(); err != nil {
return err
}
// Reset size and set isOpen to false.
pq.size = 0
pq.isOpen = false
return nil
} | go | func (pq *PrefixQueue) Close() error {
pq.Lock()
defer pq.Unlock()
// Check if queue is already closed.
if !pq.isOpen {
return nil
}
// Close the LevelDB database.
if err := pq.db.Close(); err != nil {
return err
}
// Reset size and set isOpen to false.
pq.size = 0
pq.isOpen = false
return nil
} | [
"func",
"(",
"pq",
"*",
"PrefixQueue",
")",
"Close",
"(",
")",
"error",
"{",
"pq",
".",
"Lock",
"(",
")",
"\n",
"defer",
"pq",
".",
"Unlock",
"(",
")",
"\n\n",
"// Check if queue is already closed.",
"if",
"!",
"pq",
".",
"isOpen",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// Close the LevelDB database.",
"if",
"err",
":=",
"pq",
".",
"db",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Reset size and set isOpen to false.",
"pq",
".",
"size",
"=",
"0",
"\n",
"pq",
".",
"isOpen",
"=",
"false",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Close closes the LevelDB database of the prefix queue. | [
"Close",
"closes",
"the",
"LevelDB",
"database",
"of",
"the",
"prefix",
"queue",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/prefix_queue.go#L289-L308 |
5,845 | beeker1121/goque | prefix_queue.go | Drop | func (pq *PrefixQueue) Drop() error {
if err := pq.Close(); err != nil {
return err
}
return os.RemoveAll(pq.DataDir)
} | go | func (pq *PrefixQueue) Drop() error {
if err := pq.Close(); err != nil {
return err
}
return os.RemoveAll(pq.DataDir)
} | [
"func",
"(",
"pq",
"*",
"PrefixQueue",
")",
"Drop",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"pq",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"os",
".",
"RemoveAll",
"(",
"pq",
".",
"DataDir",
")",
"\n",
"}"
] | // Drop closes and deletes the LevelDB database of the prefix queue. | [
"Drop",
"closes",
"and",
"deletes",
"the",
"LevelDB",
"database",
"of",
"the",
"prefix",
"queue",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/prefix_queue.go#L311-L317 |
5,846 | beeker1121/goque | prefix_queue.go | getQueue | func (pq *PrefixQueue) getQueue(prefix []byte) (*queue, error) {
// Try to get the queue gob value.
qval, err := pq.db.Get(generateKeyPrefixData(prefix), nil)
if err == errors.ErrNotFound {
return nil, ErrEmpty
} else if err != nil {
return nil, err
}
// Decode gob to our queue type.
q := &queue{}
buffer := bytes.NewBuffer(qval)
dec := gob.NewDecoder(buffer)
return q, dec.Decode(q)
} | go | func (pq *PrefixQueue) getQueue(prefix []byte) (*queue, error) {
// Try to get the queue gob value.
qval, err := pq.db.Get(generateKeyPrefixData(prefix), nil)
if err == errors.ErrNotFound {
return nil, ErrEmpty
} else if err != nil {
return nil, err
}
// Decode gob to our queue type.
q := &queue{}
buffer := bytes.NewBuffer(qval)
dec := gob.NewDecoder(buffer)
return q, dec.Decode(q)
} | [
"func",
"(",
"pq",
"*",
"PrefixQueue",
")",
"getQueue",
"(",
"prefix",
"[",
"]",
"byte",
")",
"(",
"*",
"queue",
",",
"error",
")",
"{",
"// Try to get the queue gob value.",
"qval",
",",
"err",
":=",
"pq",
".",
"db",
".",
"Get",
"(",
"generateKeyPrefixData",
"(",
"prefix",
")",
",",
"nil",
")",
"\n",
"if",
"err",
"==",
"errors",
".",
"ErrNotFound",
"{",
"return",
"nil",
",",
"ErrEmpty",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Decode gob to our queue type.",
"q",
":=",
"&",
"queue",
"{",
"}",
"\n",
"buffer",
":=",
"bytes",
".",
"NewBuffer",
"(",
"qval",
")",
"\n",
"dec",
":=",
"gob",
".",
"NewDecoder",
"(",
"buffer",
")",
"\n",
"return",
"q",
",",
"dec",
".",
"Decode",
"(",
"q",
")",
"\n",
"}"
] | // getQueue gets the unique queue for the given prefix. | [
"getQueue",
"gets",
"the",
"unique",
"queue",
"for",
"the",
"given",
"prefix",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/prefix_queue.go#L320-L334 |
5,847 | beeker1121/goque | prefix_queue.go | saveQueue | func (pq *PrefixQueue) saveQueue(prefix []byte, q *queue) error {
// Encode the queue using gob.
var buffer bytes.Buffer
enc := gob.NewEncoder(&buffer)
if err := enc.Encode(q); err != nil {
return err
}
// Save it to the database.
return pq.db.Put(generateKeyPrefixData(prefix), buffer.Bytes(), nil)
} | go | func (pq *PrefixQueue) saveQueue(prefix []byte, q *queue) error {
// Encode the queue using gob.
var buffer bytes.Buffer
enc := gob.NewEncoder(&buffer)
if err := enc.Encode(q); err != nil {
return err
}
// Save it to the database.
return pq.db.Put(generateKeyPrefixData(prefix), buffer.Bytes(), nil)
} | [
"func",
"(",
"pq",
"*",
"PrefixQueue",
")",
"saveQueue",
"(",
"prefix",
"[",
"]",
"byte",
",",
"q",
"*",
"queue",
")",
"error",
"{",
"// Encode the queue using gob.",
"var",
"buffer",
"bytes",
".",
"Buffer",
"\n",
"enc",
":=",
"gob",
".",
"NewEncoder",
"(",
"&",
"buffer",
")",
"\n",
"if",
"err",
":=",
"enc",
".",
"Encode",
"(",
"q",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Save it to the database.",
"return",
"pq",
".",
"db",
".",
"Put",
"(",
"generateKeyPrefixData",
"(",
"prefix",
")",
",",
"buffer",
".",
"Bytes",
"(",
")",
",",
"nil",
")",
"\n",
"}"
] | // savePrefixQueue saves the given queue for the given prefix. | [
"savePrefixQueue",
"saves",
"the",
"given",
"queue",
"for",
"the",
"given",
"prefix",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/prefix_queue.go#L355-L365 |
5,848 | beeker1121/goque | prefix_queue.go | save | func (pq *PrefixQueue) save() error {
val := make([]byte, 8)
binary.BigEndian.PutUint64(val, pq.size)
return pq.db.Put(pq.getDataKey(), val, nil)
} | go | func (pq *PrefixQueue) save() error {
val := make([]byte, 8)
binary.BigEndian.PutUint64(val, pq.size)
return pq.db.Put(pq.getDataKey(), val, nil)
} | [
"func",
"(",
"pq",
"*",
"PrefixQueue",
")",
"save",
"(",
")",
"error",
"{",
"val",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"8",
")",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint64",
"(",
"val",
",",
"pq",
".",
"size",
")",
"\n",
"return",
"pq",
".",
"db",
".",
"Put",
"(",
"pq",
".",
"getDataKey",
"(",
")",
",",
"val",
",",
"nil",
")",
"\n",
"}"
] | // save saves the main prefix queue data. | [
"save",
"saves",
"the",
"main",
"prefix",
"queue",
"data",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/prefix_queue.go#L368-L372 |
5,849 | beeker1121/goque | prefix_queue.go | getDataKey | func (pq *PrefixQueue) getDataKey() []byte {
var key []byte
key = append(key, prefixDelimiter)
return append(key, []byte(":main_data")...)
} | go | func (pq *PrefixQueue) getDataKey() []byte {
var key []byte
key = append(key, prefixDelimiter)
return append(key, []byte(":main_data")...)
} | [
"func",
"(",
"pq",
"*",
"PrefixQueue",
")",
"getDataKey",
"(",
")",
"[",
"]",
"byte",
"{",
"var",
"key",
"[",
"]",
"byte",
"\n",
"key",
"=",
"append",
"(",
"key",
",",
"prefixDelimiter",
")",
"\n",
"return",
"append",
"(",
"key",
",",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
"...",
")",
"\n",
"}"
] | // getDataKey generates the main prefix queue data key. | [
"getDataKey",
"generates",
"the",
"main",
"prefix",
"queue",
"data",
"key",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/prefix_queue.go#L375-L379 |
5,850 | beeker1121/goque | prefix_queue.go | getItemByPrefixID | func (pq *PrefixQueue) getItemByPrefixID(prefix []byte, id uint64) (*Item, error) {
// Check if empty.
if pq.size == 0 {
return nil, ErrEmpty
}
// Get the queue for this prefix.
q, err := pq.getQueue(prefix)
if err != nil {
return nil, err
}
// Check if out of bounds.
if id <= q.Head || id > q.Tail {
return nil, ErrOutOfBounds
}
// Get item from database.
item := &Item{
ID: id,
Key: generateKeyPrefixID(prefix, id),
}
if item.Value, err = pq.db.Get(item.Key, nil); err != nil {
return nil, err
}
return item, nil
} | go | func (pq *PrefixQueue) getItemByPrefixID(prefix []byte, id uint64) (*Item, error) {
// Check if empty.
if pq.size == 0 {
return nil, ErrEmpty
}
// Get the queue for this prefix.
q, err := pq.getQueue(prefix)
if err != nil {
return nil, err
}
// Check if out of bounds.
if id <= q.Head || id > q.Tail {
return nil, ErrOutOfBounds
}
// Get item from database.
item := &Item{
ID: id,
Key: generateKeyPrefixID(prefix, id),
}
if item.Value, err = pq.db.Get(item.Key, nil); err != nil {
return nil, err
}
return item, nil
} | [
"func",
"(",
"pq",
"*",
"PrefixQueue",
")",
"getItemByPrefixID",
"(",
"prefix",
"[",
"]",
"byte",
",",
"id",
"uint64",
")",
"(",
"*",
"Item",
",",
"error",
")",
"{",
"// Check if empty.",
"if",
"pq",
".",
"size",
"==",
"0",
"{",
"return",
"nil",
",",
"ErrEmpty",
"\n",
"}",
"\n\n",
"// Get the queue for this prefix.",
"q",
",",
"err",
":=",
"pq",
".",
"getQueue",
"(",
"prefix",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Check if out of bounds.",
"if",
"id",
"<=",
"q",
".",
"Head",
"||",
"id",
">",
"q",
".",
"Tail",
"{",
"return",
"nil",
",",
"ErrOutOfBounds",
"\n",
"}",
"\n\n",
"// Get item from database.",
"item",
":=",
"&",
"Item",
"{",
"ID",
":",
"id",
",",
"Key",
":",
"generateKeyPrefixID",
"(",
"prefix",
",",
"id",
")",
",",
"}",
"\n\n",
"if",
"item",
".",
"Value",
",",
"err",
"=",
"pq",
".",
"db",
".",
"Get",
"(",
"item",
".",
"Key",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"item",
",",
"nil",
"\n",
"}"
] | // getItemByPrefixID returns an item, if found, for the given prefix and ID. | [
"getItemByPrefixID",
"returns",
"an",
"item",
"if",
"found",
"for",
"the",
"given",
"prefix",
"and",
"ID",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/prefix_queue.go#L382-L410 |
5,851 | beeker1121/goque | prefix_queue.go | init | func (pq *PrefixQueue) init() error {
// Get the main prefix queue data.
val, err := pq.db.Get(pq.getDataKey(), nil)
if err == errors.ErrNotFound {
return nil
} else if err != nil {
return err
}
pq.size = binary.BigEndian.Uint64(val)
return nil
} | go | func (pq *PrefixQueue) init() error {
// Get the main prefix queue data.
val, err := pq.db.Get(pq.getDataKey(), nil)
if err == errors.ErrNotFound {
return nil
} else if err != nil {
return err
}
pq.size = binary.BigEndian.Uint64(val)
return nil
} | [
"func",
"(",
"pq",
"*",
"PrefixQueue",
")",
"init",
"(",
")",
"error",
"{",
"// Get the main prefix queue data.",
"val",
",",
"err",
":=",
"pq",
".",
"db",
".",
"Get",
"(",
"pq",
".",
"getDataKey",
"(",
")",
",",
"nil",
")",
"\n",
"if",
"err",
"==",
"errors",
".",
"ErrNotFound",
"{",
"return",
"nil",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"pq",
".",
"size",
"=",
"binary",
".",
"BigEndian",
".",
"Uint64",
"(",
"val",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // init initializes the prefix queue data. | [
"init",
"initializes",
"the",
"prefix",
"queue",
"data",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/prefix_queue.go#L413-L424 |
5,852 | beeker1121/goque | prefix_queue.go | generateKeyPrefixID | func generateKeyPrefixID(prefix []byte, id uint64) []byte {
// Handle the prefix.
key := append(prefix, prefixDelimiter)
// Handle the item ID.
key = append(key, idToKey(id)...)
return key
} | go | func generateKeyPrefixID(prefix []byte, id uint64) []byte {
// Handle the prefix.
key := append(prefix, prefixDelimiter)
// Handle the item ID.
key = append(key, idToKey(id)...)
return key
} | [
"func",
"generateKeyPrefixID",
"(",
"prefix",
"[",
"]",
"byte",
",",
"id",
"uint64",
")",
"[",
"]",
"byte",
"{",
"// Handle the prefix.",
"key",
":=",
"append",
"(",
"prefix",
",",
"prefixDelimiter",
")",
"\n\n",
"// Handle the item ID.",
"key",
"=",
"append",
"(",
"key",
",",
"idToKey",
"(",
"id",
")",
"...",
")",
"\n\n",
"return",
"key",
"\n",
"}"
] | // generateKeyPrefixID generates a key using the given prefix and ID. | [
"generateKeyPrefixID",
"generates",
"a",
"key",
"using",
"the",
"given",
"prefix",
"and",
"ID",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/prefix_queue.go#L433-L441 |
5,853 | beeker1121/goque | priority_queue.go | OpenPriorityQueue | func OpenPriorityQueue(dataDir string, order order) (*PriorityQueue, error) {
var err error
// Create a new PriorityQueue.
pq := &PriorityQueue{
DataDir: dataDir,
db: &leveldb.DB{},
order: order,
isOpen: false,
}
// Open database for the priority queue.
pq.db, err = leveldb.OpenFile(dataDir, nil)
if err != nil {
return pq, err
}
// Check if this Goque type can open the requested data directory.
ok, err := checkGoqueType(dataDir, goquePriorityQueue)
if err != nil {
return pq, err
}
if !ok {
return pq, ErrIncompatibleType
}
// Set isOpen and return.
pq.isOpen = true
return pq, pq.init()
} | go | func OpenPriorityQueue(dataDir string, order order) (*PriorityQueue, error) {
var err error
// Create a new PriorityQueue.
pq := &PriorityQueue{
DataDir: dataDir,
db: &leveldb.DB{},
order: order,
isOpen: false,
}
// Open database for the priority queue.
pq.db, err = leveldb.OpenFile(dataDir, nil)
if err != nil {
return pq, err
}
// Check if this Goque type can open the requested data directory.
ok, err := checkGoqueType(dataDir, goquePriorityQueue)
if err != nil {
return pq, err
}
if !ok {
return pq, ErrIncompatibleType
}
// Set isOpen and return.
pq.isOpen = true
return pq, pq.init()
} | [
"func",
"OpenPriorityQueue",
"(",
"dataDir",
"string",
",",
"order",
"order",
")",
"(",
"*",
"PriorityQueue",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// Create a new PriorityQueue.",
"pq",
":=",
"&",
"PriorityQueue",
"{",
"DataDir",
":",
"dataDir",
",",
"db",
":",
"&",
"leveldb",
".",
"DB",
"{",
"}",
",",
"order",
":",
"order",
",",
"isOpen",
":",
"false",
",",
"}",
"\n\n",
"// Open database for the priority queue.",
"pq",
".",
"db",
",",
"err",
"=",
"leveldb",
".",
"OpenFile",
"(",
"dataDir",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"pq",
",",
"err",
"\n",
"}",
"\n\n",
"// Check if this Goque type can open the requested data directory.",
"ok",
",",
"err",
":=",
"checkGoqueType",
"(",
"dataDir",
",",
"goquePriorityQueue",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"pq",
",",
"err",
"\n",
"}",
"\n",
"if",
"!",
"ok",
"{",
"return",
"pq",
",",
"ErrIncompatibleType",
"\n",
"}",
"\n\n",
"// Set isOpen and return.",
"pq",
".",
"isOpen",
"=",
"true",
"\n",
"return",
"pq",
",",
"pq",
".",
"init",
"(",
")",
"\n",
"}"
] | // OpenPriorityQueue opens a priority queue if one exists at the given
// directory. If one does not already exist, a new priority queue is
// created. | [
"OpenPriorityQueue",
"opens",
"a",
"priority",
"queue",
"if",
"one",
"exists",
"at",
"the",
"given",
"directory",
".",
"If",
"one",
"does",
"not",
"already",
"exist",
"a",
"new",
"priority",
"queue",
"is",
"created",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/priority_queue.go#L52-L81 |
5,854 | beeker1121/goque | priority_queue.go | Enqueue | func (pq *PriorityQueue) Enqueue(priority uint8, value []byte) (*PriorityItem, error) {
pq.Lock()
defer pq.Unlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Get the priorityLevel.
level := pq.levels[priority]
// Create new PriorityItem.
item := &PriorityItem{
ID: level.tail + 1,
Priority: priority,
Key: pq.generateKey(priority, level.tail+1),
Value: value,
}
// Add it to the priority queue.
if err := pq.db.Put(item.Key, item.Value, nil); err != nil {
return nil, err
}
// Increment tail position.
level.tail++
// If this priority level is more important than the curLevel.
if pq.cmpAsc(priority) || pq.cmpDesc(priority) {
pq.curLevel = priority
}
return item, nil
} | go | func (pq *PriorityQueue) Enqueue(priority uint8, value []byte) (*PriorityItem, error) {
pq.Lock()
defer pq.Unlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Get the priorityLevel.
level := pq.levels[priority]
// Create new PriorityItem.
item := &PriorityItem{
ID: level.tail + 1,
Priority: priority,
Key: pq.generateKey(priority, level.tail+1),
Value: value,
}
// Add it to the priority queue.
if err := pq.db.Put(item.Key, item.Value, nil); err != nil {
return nil, err
}
// Increment tail position.
level.tail++
// If this priority level is more important than the curLevel.
if pq.cmpAsc(priority) || pq.cmpDesc(priority) {
pq.curLevel = priority
}
return item, nil
} | [
"func",
"(",
"pq",
"*",
"PriorityQueue",
")",
"Enqueue",
"(",
"priority",
"uint8",
",",
"value",
"[",
"]",
"byte",
")",
"(",
"*",
"PriorityItem",
",",
"error",
")",
"{",
"pq",
".",
"Lock",
"(",
")",
"\n",
"defer",
"pq",
".",
"Unlock",
"(",
")",
"\n\n",
"// Check if queue is closed.",
"if",
"!",
"pq",
".",
"isOpen",
"{",
"return",
"nil",
",",
"ErrDBClosed",
"\n",
"}",
"\n\n",
"// Get the priorityLevel.",
"level",
":=",
"pq",
".",
"levels",
"[",
"priority",
"]",
"\n\n",
"// Create new PriorityItem.",
"item",
":=",
"&",
"PriorityItem",
"{",
"ID",
":",
"level",
".",
"tail",
"+",
"1",
",",
"Priority",
":",
"priority",
",",
"Key",
":",
"pq",
".",
"generateKey",
"(",
"priority",
",",
"level",
".",
"tail",
"+",
"1",
")",
",",
"Value",
":",
"value",
",",
"}",
"\n\n",
"// Add it to the priority queue.",
"if",
"err",
":=",
"pq",
".",
"db",
".",
"Put",
"(",
"item",
".",
"Key",
",",
"item",
".",
"Value",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Increment tail position.",
"level",
".",
"tail",
"++",
"\n\n",
"// If this priority level is more important than the curLevel.",
"if",
"pq",
".",
"cmpAsc",
"(",
"priority",
")",
"||",
"pq",
".",
"cmpDesc",
"(",
"priority",
")",
"{",
"pq",
".",
"curLevel",
"=",
"priority",
"\n",
"}",
"\n\n",
"return",
"item",
",",
"nil",
"\n",
"}"
] | // Enqueue adds an item to the priority queue. | [
"Enqueue",
"adds",
"an",
"item",
"to",
"the",
"priority",
"queue",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/priority_queue.go#L84-L118 |
5,855 | beeker1121/goque | priority_queue.go | Dequeue | func (pq *PriorityQueue) Dequeue() (*PriorityItem, error) {
pq.Lock()
defer pq.Unlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Try to get the next item.
item, err := pq.getNextItem()
if err != nil {
return nil, err
}
// Remove this item from the priority queue.
if err = pq.db.Delete(item.Key, nil); err != nil {
return nil, err
}
// Increment head position.
pq.levels[pq.curLevel].head++
return item, nil
} | go | func (pq *PriorityQueue) Dequeue() (*PriorityItem, error) {
pq.Lock()
defer pq.Unlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Try to get the next item.
item, err := pq.getNextItem()
if err != nil {
return nil, err
}
// Remove this item from the priority queue.
if err = pq.db.Delete(item.Key, nil); err != nil {
return nil, err
}
// Increment head position.
pq.levels[pq.curLevel].head++
return item, nil
} | [
"func",
"(",
"pq",
"*",
"PriorityQueue",
")",
"Dequeue",
"(",
")",
"(",
"*",
"PriorityItem",
",",
"error",
")",
"{",
"pq",
".",
"Lock",
"(",
")",
"\n",
"defer",
"pq",
".",
"Unlock",
"(",
")",
"\n\n",
"// Check if queue is closed.",
"if",
"!",
"pq",
".",
"isOpen",
"{",
"return",
"nil",
",",
"ErrDBClosed",
"\n",
"}",
"\n\n",
"// Try to get the next item.",
"item",
",",
"err",
":=",
"pq",
".",
"getNextItem",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Remove this item from the priority queue.",
"if",
"err",
"=",
"pq",
".",
"db",
".",
"Delete",
"(",
"item",
".",
"Key",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Increment head position.",
"pq",
".",
"levels",
"[",
"pq",
".",
"curLevel",
"]",
".",
"head",
"++",
"\n\n",
"return",
"item",
",",
"nil",
"\n",
"}"
] | // Dequeue removes the next item in the priority queue and returns it. | [
"Dequeue",
"removes",
"the",
"next",
"item",
"in",
"the",
"priority",
"queue",
"and",
"returns",
"it",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/priority_queue.go#L139-L163 |
5,856 | beeker1121/goque | priority_queue.go | DequeueByPriority | func (pq *PriorityQueue) DequeueByPriority(priority uint8) (*PriorityItem, error) {
pq.Lock()
defer pq.Unlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Try to get the next item in the given priority level.
item, err := pq.getItemByPriorityID(priority, pq.levels[priority].head+1)
if err != nil {
return nil, err
}
// Remove this item from the priority queue.
if err = pq.db.Delete(item.Key, nil); err != nil {
return nil, err
}
// Increment head position.
pq.levels[priority].head++
return item, nil
} | go | func (pq *PriorityQueue) DequeueByPriority(priority uint8) (*PriorityItem, error) {
pq.Lock()
defer pq.Unlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Try to get the next item in the given priority level.
item, err := pq.getItemByPriorityID(priority, pq.levels[priority].head+1)
if err != nil {
return nil, err
}
// Remove this item from the priority queue.
if err = pq.db.Delete(item.Key, nil); err != nil {
return nil, err
}
// Increment head position.
pq.levels[priority].head++
return item, nil
} | [
"func",
"(",
"pq",
"*",
"PriorityQueue",
")",
"DequeueByPriority",
"(",
"priority",
"uint8",
")",
"(",
"*",
"PriorityItem",
",",
"error",
")",
"{",
"pq",
".",
"Lock",
"(",
")",
"\n",
"defer",
"pq",
".",
"Unlock",
"(",
")",
"\n\n",
"// Check if queue is closed.",
"if",
"!",
"pq",
".",
"isOpen",
"{",
"return",
"nil",
",",
"ErrDBClosed",
"\n",
"}",
"\n\n",
"// Try to get the next item in the given priority level.",
"item",
",",
"err",
":=",
"pq",
".",
"getItemByPriorityID",
"(",
"priority",
",",
"pq",
".",
"levels",
"[",
"priority",
"]",
".",
"head",
"+",
"1",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Remove this item from the priority queue.",
"if",
"err",
"=",
"pq",
".",
"db",
".",
"Delete",
"(",
"item",
".",
"Key",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Increment head position.",
"pq",
".",
"levels",
"[",
"priority",
"]",
".",
"head",
"++",
"\n\n",
"return",
"item",
",",
"nil",
"\n",
"}"
] | // DequeueByPriority removes the next item in the given priority level
// and returns it. | [
"DequeueByPriority",
"removes",
"the",
"next",
"item",
"in",
"the",
"given",
"priority",
"level",
"and",
"returns",
"it",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/priority_queue.go#L167-L191 |
5,857 | beeker1121/goque | priority_queue.go | Peek | func (pq *PriorityQueue) Peek() (*PriorityItem, error) {
pq.RLock()
defer pq.RUnlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
return pq.getNextItem()
} | go | func (pq *PriorityQueue) Peek() (*PriorityItem, error) {
pq.RLock()
defer pq.RUnlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
return pq.getNextItem()
} | [
"func",
"(",
"pq",
"*",
"PriorityQueue",
")",
"Peek",
"(",
")",
"(",
"*",
"PriorityItem",
",",
"error",
")",
"{",
"pq",
".",
"RLock",
"(",
")",
"\n",
"defer",
"pq",
".",
"RUnlock",
"(",
")",
"\n\n",
"// Check if queue is closed.",
"if",
"!",
"pq",
".",
"isOpen",
"{",
"return",
"nil",
",",
"ErrDBClosed",
"\n",
"}",
"\n\n",
"return",
"pq",
".",
"getNextItem",
"(",
")",
"\n",
"}"
] | // Peek returns the next item in the priority queue without removing it. | [
"Peek",
"returns",
"the",
"next",
"item",
"in",
"the",
"priority",
"queue",
"without",
"removing",
"it",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/priority_queue.go#L194-L204 |
5,858 | beeker1121/goque | priority_queue.go | PeekByPriorityID | func (pq *PriorityQueue) PeekByPriorityID(priority uint8, id uint64) (*PriorityItem, error) {
pq.RLock()
defer pq.RUnlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
return pq.getItemByPriorityID(priority, id)
} | go | func (pq *PriorityQueue) PeekByPriorityID(priority uint8, id uint64) (*PriorityItem, error) {
pq.RLock()
defer pq.RUnlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
return pq.getItemByPriorityID(priority, id)
} | [
"func",
"(",
"pq",
"*",
"PriorityQueue",
")",
"PeekByPriorityID",
"(",
"priority",
"uint8",
",",
"id",
"uint64",
")",
"(",
"*",
"PriorityItem",
",",
"error",
")",
"{",
"pq",
".",
"RLock",
"(",
")",
"\n",
"defer",
"pq",
".",
"RUnlock",
"(",
")",
"\n\n",
"// Check if queue is closed.",
"if",
"!",
"pq",
".",
"isOpen",
"{",
"return",
"nil",
",",
"ErrDBClosed",
"\n",
"}",
"\n\n",
"return",
"pq",
".",
"getItemByPriorityID",
"(",
"priority",
",",
"id",
")",
"\n",
"}"
] | // PeekByPriorityID returns the item with the given ID and priority without
// removing it. | [
"PeekByPriorityID",
"returns",
"the",
"item",
"with",
"the",
"given",
"ID",
"and",
"priority",
"without",
"removing",
"it",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/priority_queue.go#L232-L242 |
5,859 | beeker1121/goque | priority_queue.go | Update | func (pq *PriorityQueue) Update(priority uint8, id uint64, newValue []byte) (*PriorityItem, error) {
pq.Lock()
defer pq.Unlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Check if item exists in queue.
if id <= pq.levels[priority].head || id > pq.levels[priority].tail {
return nil, ErrOutOfBounds
}
// Create new PriorityItem.
item := &PriorityItem{
ID: id,
Priority: priority,
Key: pq.generateKey(priority, id),
Value: newValue,
}
// Update this item in the queue.
if err := pq.db.Put(item.Key, item.Value, nil); err != nil {
return nil, err
}
return item, nil
} | go | func (pq *PriorityQueue) Update(priority uint8, id uint64, newValue []byte) (*PriorityItem, error) {
pq.Lock()
defer pq.Unlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Check if item exists in queue.
if id <= pq.levels[priority].head || id > pq.levels[priority].tail {
return nil, ErrOutOfBounds
}
// Create new PriorityItem.
item := &PriorityItem{
ID: id,
Priority: priority,
Key: pq.generateKey(priority, id),
Value: newValue,
}
// Update this item in the queue.
if err := pq.db.Put(item.Key, item.Value, nil); err != nil {
return nil, err
}
return item, nil
} | [
"func",
"(",
"pq",
"*",
"PriorityQueue",
")",
"Update",
"(",
"priority",
"uint8",
",",
"id",
"uint64",
",",
"newValue",
"[",
"]",
"byte",
")",
"(",
"*",
"PriorityItem",
",",
"error",
")",
"{",
"pq",
".",
"Lock",
"(",
")",
"\n",
"defer",
"pq",
".",
"Unlock",
"(",
")",
"\n\n",
"// Check if queue is closed.",
"if",
"!",
"pq",
".",
"isOpen",
"{",
"return",
"nil",
",",
"ErrDBClosed",
"\n",
"}",
"\n\n",
"// Check if item exists in queue.",
"if",
"id",
"<=",
"pq",
".",
"levels",
"[",
"priority",
"]",
".",
"head",
"||",
"id",
">",
"pq",
".",
"levels",
"[",
"priority",
"]",
".",
"tail",
"{",
"return",
"nil",
",",
"ErrOutOfBounds",
"\n",
"}",
"\n\n",
"// Create new PriorityItem.",
"item",
":=",
"&",
"PriorityItem",
"{",
"ID",
":",
"id",
",",
"Priority",
":",
"priority",
",",
"Key",
":",
"pq",
".",
"generateKey",
"(",
"priority",
",",
"id",
")",
",",
"Value",
":",
"newValue",
",",
"}",
"\n\n",
"// Update this item in the queue.",
"if",
"err",
":=",
"pq",
".",
"db",
".",
"Put",
"(",
"item",
".",
"Key",
",",
"item",
".",
"Value",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"item",
",",
"nil",
"\n",
"}"
] | // Update updates an item in the priority queue without changing its
// position. | [
"Update",
"updates",
"an",
"item",
"in",
"the",
"priority",
"queue",
"without",
"changing",
"its",
"position",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/priority_queue.go#L246-L274 |
5,860 | beeker1121/goque | priority_queue.go | Length | func (pq *PriorityQueue) Length() uint64 {
pq.RLock()
defer pq.RUnlock()
var length uint64
for _, v := range pq.levels {
length += v.length()
}
return length
} | go | func (pq *PriorityQueue) Length() uint64 {
pq.RLock()
defer pq.RUnlock()
var length uint64
for _, v := range pq.levels {
length += v.length()
}
return length
} | [
"func",
"(",
"pq",
"*",
"PriorityQueue",
")",
"Length",
"(",
")",
"uint64",
"{",
"pq",
".",
"RLock",
"(",
")",
"\n",
"defer",
"pq",
".",
"RUnlock",
"(",
")",
"\n\n",
"var",
"length",
"uint64",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"pq",
".",
"levels",
"{",
"length",
"+=",
"v",
".",
"length",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"length",
"\n",
"}"
] | // Length returns the total number of items in the priority queue. | [
"Length",
"returns",
"the",
"total",
"number",
"of",
"items",
"in",
"the",
"priority",
"queue",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/priority_queue.go#L295-L305 |
5,861 | beeker1121/goque | priority_queue.go | Close | func (pq *PriorityQueue) Close() error {
pq.Lock()
defer pq.Unlock()
// Check if queue is already closed.
if !pq.isOpen {
return nil
}
// Close the LevelDB database.
if err := pq.db.Close(); err != nil {
return err
}
// Reset head and tail of each priority level
// and set isOpen to false.
for i := 0; i <= 255; i++ {
pq.levels[uint8(i)].head = 0
pq.levels[uint8(i)].tail = 0
}
pq.isOpen = false
return nil
} | go | func (pq *PriorityQueue) Close() error {
pq.Lock()
defer pq.Unlock()
// Check if queue is already closed.
if !pq.isOpen {
return nil
}
// Close the LevelDB database.
if err := pq.db.Close(); err != nil {
return err
}
// Reset head and tail of each priority level
// and set isOpen to false.
for i := 0; i <= 255; i++ {
pq.levels[uint8(i)].head = 0
pq.levels[uint8(i)].tail = 0
}
pq.isOpen = false
return nil
} | [
"func",
"(",
"pq",
"*",
"PriorityQueue",
")",
"Close",
"(",
")",
"error",
"{",
"pq",
".",
"Lock",
"(",
")",
"\n",
"defer",
"pq",
".",
"Unlock",
"(",
")",
"\n\n",
"// Check if queue is already closed.",
"if",
"!",
"pq",
".",
"isOpen",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// Close the LevelDB database.",
"if",
"err",
":=",
"pq",
".",
"db",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Reset head and tail of each priority level",
"// and set isOpen to false.",
"for",
"i",
":=",
"0",
";",
"i",
"<=",
"255",
";",
"i",
"++",
"{",
"pq",
".",
"levels",
"[",
"uint8",
"(",
"i",
")",
"]",
".",
"head",
"=",
"0",
"\n",
"pq",
".",
"levels",
"[",
"uint8",
"(",
"i",
")",
"]",
".",
"tail",
"=",
"0",
"\n",
"}",
"\n",
"pq",
".",
"isOpen",
"=",
"false",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Close closes the LevelDB database of the priority queue. | [
"Close",
"closes",
"the",
"LevelDB",
"database",
"of",
"the",
"priority",
"queue",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/priority_queue.go#L308-L331 |
5,862 | beeker1121/goque | priority_queue.go | cmpAsc | func (pq *PriorityQueue) cmpAsc(priority uint8) bool {
return pq.order == ASC && priority < pq.curLevel
} | go | func (pq *PriorityQueue) cmpAsc(priority uint8) bool {
return pq.order == ASC && priority < pq.curLevel
} | [
"func",
"(",
"pq",
"*",
"PriorityQueue",
")",
"cmpAsc",
"(",
"priority",
"uint8",
")",
"bool",
"{",
"return",
"pq",
".",
"order",
"==",
"ASC",
"&&",
"priority",
"<",
"pq",
".",
"curLevel",
"\n",
"}"
] | // cmpAsc returns wehther the given priority level is higher than the
// current priority level based on ascending order. | [
"cmpAsc",
"returns",
"wehther",
"the",
"given",
"priority",
"level",
"is",
"higher",
"than",
"the",
"current",
"priority",
"level",
"based",
"on",
"ascending",
"order",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/priority_queue.go#L344-L346 |
5,863 | beeker1121/goque | priority_queue.go | cmpDesc | func (pq *PriorityQueue) cmpDesc(priority uint8) bool {
return pq.order == DESC && priority > pq.curLevel
} | go | func (pq *PriorityQueue) cmpDesc(priority uint8) bool {
return pq.order == DESC && priority > pq.curLevel
} | [
"func",
"(",
"pq",
"*",
"PriorityQueue",
")",
"cmpDesc",
"(",
"priority",
"uint8",
")",
"bool",
"{",
"return",
"pq",
".",
"order",
"==",
"DESC",
"&&",
"priority",
">",
"pq",
".",
"curLevel",
"\n",
"}"
] | // cmpAsc returns wehther the given priority level is higher than the
// current priority level based on descending order. | [
"cmpAsc",
"returns",
"wehther",
"the",
"given",
"priority",
"level",
"is",
"higher",
"than",
"the",
"current",
"priority",
"level",
"based",
"on",
"descending",
"order",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/priority_queue.go#L350-L352 |
5,864 | beeker1121/goque | priority_queue.go | resetCurrentLevel | func (pq *PriorityQueue) resetCurrentLevel() {
if pq.order == ASC {
pq.curLevel = 255
} else if pq.order == DESC {
pq.curLevel = 0
}
} | go | func (pq *PriorityQueue) resetCurrentLevel() {
if pq.order == ASC {
pq.curLevel = 255
} else if pq.order == DESC {
pq.curLevel = 0
}
} | [
"func",
"(",
"pq",
"*",
"PriorityQueue",
")",
"resetCurrentLevel",
"(",
")",
"{",
"if",
"pq",
".",
"order",
"==",
"ASC",
"{",
"pq",
".",
"curLevel",
"=",
"255",
"\n",
"}",
"else",
"if",
"pq",
".",
"order",
"==",
"DESC",
"{",
"pq",
".",
"curLevel",
"=",
"0",
"\n",
"}",
"\n",
"}"
] | // resetCurrentLevel resets the current priority level of the queue
// so the highest level can be found. | [
"resetCurrentLevel",
"resets",
"the",
"current",
"priority",
"level",
"of",
"the",
"queue",
"so",
"the",
"highest",
"level",
"can",
"be",
"found",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/priority_queue.go#L356-L362 |
5,865 | beeker1121/goque | priority_queue.go | findOffset | func (pq *PriorityQueue) findOffset(offset uint64) (*PriorityItem, error) {
var length uint64
var curLevel uint8 = pq.curLevel
var newLevel int
// Handle newLevel initialization for descending order.
if pq.order == DESC {
newLevel = 255
}
// For condition expression.
condExpr := func(level int) bool {
if pq.order == ASC {
return level <= 255
}
return level >= 0
}
// For loop expression.
loopExpr := func(level *int) {
if pq.order == ASC {
*level++
} else if pq.order == DESC {
*level--
}
}
// Level comparison.
cmpLevels := func(newLevel, curLevel uint8) bool {
if pq.order == ASC {
return newLevel >= curLevel
}
return newLevel <= curLevel
}
// Loop through the priority levels.
for ; condExpr(newLevel); loopExpr(&newLevel) {
// If this level is lower than the current level based on ordering and contains items.
if cmpLevels(uint8(newLevel), curLevel) && pq.levels[uint8(newLevel)].length() > 0 {
curLevel = uint8(newLevel)
newLength := pq.levels[curLevel].length()
// If the offset is within the current priority level.
if length+newLength >= offset+1 {
return pq.getItemByPriorityID(curLevel, offset-length+1)
}
length += newLength
}
}
return nil, ErrOutOfBounds
} | go | func (pq *PriorityQueue) findOffset(offset uint64) (*PriorityItem, error) {
var length uint64
var curLevel uint8 = pq.curLevel
var newLevel int
// Handle newLevel initialization for descending order.
if pq.order == DESC {
newLevel = 255
}
// For condition expression.
condExpr := func(level int) bool {
if pq.order == ASC {
return level <= 255
}
return level >= 0
}
// For loop expression.
loopExpr := func(level *int) {
if pq.order == ASC {
*level++
} else if pq.order == DESC {
*level--
}
}
// Level comparison.
cmpLevels := func(newLevel, curLevel uint8) bool {
if pq.order == ASC {
return newLevel >= curLevel
}
return newLevel <= curLevel
}
// Loop through the priority levels.
for ; condExpr(newLevel); loopExpr(&newLevel) {
// If this level is lower than the current level based on ordering and contains items.
if cmpLevels(uint8(newLevel), curLevel) && pq.levels[uint8(newLevel)].length() > 0 {
curLevel = uint8(newLevel)
newLength := pq.levels[curLevel].length()
// If the offset is within the current priority level.
if length+newLength >= offset+1 {
return pq.getItemByPriorityID(curLevel, offset-length+1)
}
length += newLength
}
}
return nil, ErrOutOfBounds
} | [
"func",
"(",
"pq",
"*",
"PriorityQueue",
")",
"findOffset",
"(",
"offset",
"uint64",
")",
"(",
"*",
"PriorityItem",
",",
"error",
")",
"{",
"var",
"length",
"uint64",
"\n",
"var",
"curLevel",
"uint8",
"=",
"pq",
".",
"curLevel",
"\n",
"var",
"newLevel",
"int",
"\n\n",
"// Handle newLevel initialization for descending order.",
"if",
"pq",
".",
"order",
"==",
"DESC",
"{",
"newLevel",
"=",
"255",
"\n",
"}",
"\n\n",
"// For condition expression.",
"condExpr",
":=",
"func",
"(",
"level",
"int",
")",
"bool",
"{",
"if",
"pq",
".",
"order",
"==",
"ASC",
"{",
"return",
"level",
"<=",
"255",
"\n",
"}",
"\n",
"return",
"level",
">=",
"0",
"\n",
"}",
"\n\n",
"// For loop expression.",
"loopExpr",
":=",
"func",
"(",
"level",
"*",
"int",
")",
"{",
"if",
"pq",
".",
"order",
"==",
"ASC",
"{",
"*",
"level",
"++",
"\n",
"}",
"else",
"if",
"pq",
".",
"order",
"==",
"DESC",
"{",
"*",
"level",
"--",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Level comparison.",
"cmpLevels",
":=",
"func",
"(",
"newLevel",
",",
"curLevel",
"uint8",
")",
"bool",
"{",
"if",
"pq",
".",
"order",
"==",
"ASC",
"{",
"return",
"newLevel",
">=",
"curLevel",
"\n",
"}",
"\n",
"return",
"newLevel",
"<=",
"curLevel",
"\n",
"}",
"\n\n",
"// Loop through the priority levels.",
"for",
";",
"condExpr",
"(",
"newLevel",
")",
";",
"loopExpr",
"(",
"&",
"newLevel",
")",
"{",
"// If this level is lower than the current level based on ordering and contains items.",
"if",
"cmpLevels",
"(",
"uint8",
"(",
"newLevel",
")",
",",
"curLevel",
")",
"&&",
"pq",
".",
"levels",
"[",
"uint8",
"(",
"newLevel",
")",
"]",
".",
"length",
"(",
")",
">",
"0",
"{",
"curLevel",
"=",
"uint8",
"(",
"newLevel",
")",
"\n",
"newLength",
":=",
"pq",
".",
"levels",
"[",
"curLevel",
"]",
".",
"length",
"(",
")",
"\n\n",
"// If the offset is within the current priority level.",
"if",
"length",
"+",
"newLength",
">=",
"offset",
"+",
"1",
"{",
"return",
"pq",
".",
"getItemByPriorityID",
"(",
"curLevel",
",",
"offset",
"-",
"length",
"+",
"1",
")",
"\n",
"}",
"\n\n",
"length",
"+=",
"newLength",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"ErrOutOfBounds",
"\n",
"}"
] | // findOffset finds the given offset from the current queue position
// based on priority order. | [
"findOffset",
"finds",
"the",
"given",
"offset",
"from",
"the",
"current",
"queue",
"position",
"based",
"on",
"priority",
"order",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/priority_queue.go#L366-L418 |
5,866 | beeker1121/goque | priority_queue.go | getNextItem | func (pq *PriorityQueue) getNextItem() (*PriorityItem, error) {
// If the current priority level is empty.
if pq.levels[pq.curLevel].length() == 0 {
// Set starting value for curLevel.
pq.resetCurrentLevel()
// Try to get the next priority level.
for i := 0; i <= 255; i++ {
if (pq.cmpAsc(uint8(i)) || pq.cmpDesc(uint8(i))) && pq.levels[uint8(i)].length() > 0 {
pq.curLevel = uint8(i)
}
}
// If still empty, return queue empty error.
if pq.levels[pq.curLevel].length() == 0 {
return nil, ErrEmpty
}
}
// Try to get the next item in the current priority level.
return pq.getItemByPriorityID(pq.curLevel, pq.levels[pq.curLevel].head+1)
} | go | func (pq *PriorityQueue) getNextItem() (*PriorityItem, error) {
// If the current priority level is empty.
if pq.levels[pq.curLevel].length() == 0 {
// Set starting value for curLevel.
pq.resetCurrentLevel()
// Try to get the next priority level.
for i := 0; i <= 255; i++ {
if (pq.cmpAsc(uint8(i)) || pq.cmpDesc(uint8(i))) && pq.levels[uint8(i)].length() > 0 {
pq.curLevel = uint8(i)
}
}
// If still empty, return queue empty error.
if pq.levels[pq.curLevel].length() == 0 {
return nil, ErrEmpty
}
}
// Try to get the next item in the current priority level.
return pq.getItemByPriorityID(pq.curLevel, pq.levels[pq.curLevel].head+1)
} | [
"func",
"(",
"pq",
"*",
"PriorityQueue",
")",
"getNextItem",
"(",
")",
"(",
"*",
"PriorityItem",
",",
"error",
")",
"{",
"// If the current priority level is empty.",
"if",
"pq",
".",
"levels",
"[",
"pq",
".",
"curLevel",
"]",
".",
"length",
"(",
")",
"==",
"0",
"{",
"// Set starting value for curLevel.",
"pq",
".",
"resetCurrentLevel",
"(",
")",
"\n\n",
"// Try to get the next priority level.",
"for",
"i",
":=",
"0",
";",
"i",
"<=",
"255",
";",
"i",
"++",
"{",
"if",
"(",
"pq",
".",
"cmpAsc",
"(",
"uint8",
"(",
"i",
")",
")",
"||",
"pq",
".",
"cmpDesc",
"(",
"uint8",
"(",
"i",
")",
")",
")",
"&&",
"pq",
".",
"levels",
"[",
"uint8",
"(",
"i",
")",
"]",
".",
"length",
"(",
")",
">",
"0",
"{",
"pq",
".",
"curLevel",
"=",
"uint8",
"(",
"i",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// If still empty, return queue empty error.",
"if",
"pq",
".",
"levels",
"[",
"pq",
".",
"curLevel",
"]",
".",
"length",
"(",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"ErrEmpty",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Try to get the next item in the current priority level.",
"return",
"pq",
".",
"getItemByPriorityID",
"(",
"pq",
".",
"curLevel",
",",
"pq",
".",
"levels",
"[",
"pq",
".",
"curLevel",
"]",
".",
"head",
"+",
"1",
")",
"\n",
"}"
] | // getNextItem returns the next item in the priority queue, updating
// the current priority level of the queue if necessary. | [
"getNextItem",
"returns",
"the",
"next",
"item",
"in",
"the",
"priority",
"queue",
"updating",
"the",
"current",
"priority",
"level",
"of",
"the",
"queue",
"if",
"necessary",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/priority_queue.go#L422-L443 |
5,867 | beeker1121/goque | priority_queue.go | generatePrefix | func (pq *PriorityQueue) generatePrefix(level uint8) []byte {
// priority + prefixSep = 1 + 1 = 2
prefix := make([]byte, 2)
prefix[0] = byte(level)
prefix[1] = prefixSep[0]
return prefix
} | go | func (pq *PriorityQueue) generatePrefix(level uint8) []byte {
// priority + prefixSep = 1 + 1 = 2
prefix := make([]byte, 2)
prefix[0] = byte(level)
prefix[1] = prefixSep[0]
return prefix
} | [
"func",
"(",
"pq",
"*",
"PriorityQueue",
")",
"generatePrefix",
"(",
"level",
"uint8",
")",
"[",
"]",
"byte",
"{",
"// priority + prefixSep = 1 + 1 = 2",
"prefix",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"2",
")",
"\n",
"prefix",
"[",
"0",
"]",
"=",
"byte",
"(",
"level",
")",
"\n",
"prefix",
"[",
"1",
"]",
"=",
"prefixSep",
"[",
"0",
"]",
"\n",
"return",
"prefix",
"\n",
"}"
] | // generatePrefix creates the key prefix for the given priority level. | [
"generatePrefix",
"creates",
"the",
"key",
"prefix",
"for",
"the",
"given",
"priority",
"level",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/priority_queue.go#L465-L471 |
5,868 | beeker1121/goque | priority_queue.go | generateKey | func (pq *PriorityQueue) generateKey(priority uint8, id uint64) []byte {
// prefix + key = 2 + 8 = 10
key := make([]byte, 10)
copy(key[0:2], pq.generatePrefix(priority))
copy(key[2:], idToKey(id))
return key
} | go | func (pq *PriorityQueue) generateKey(priority uint8, id uint64) []byte {
// prefix + key = 2 + 8 = 10
key := make([]byte, 10)
copy(key[0:2], pq.generatePrefix(priority))
copy(key[2:], idToKey(id))
return key
} | [
"func",
"(",
"pq",
"*",
"PriorityQueue",
")",
"generateKey",
"(",
"priority",
"uint8",
",",
"id",
"uint64",
")",
"[",
"]",
"byte",
"{",
"// prefix + key = 2 + 8 = 10",
"key",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"10",
")",
"\n",
"copy",
"(",
"key",
"[",
"0",
":",
"2",
"]",
",",
"pq",
".",
"generatePrefix",
"(",
"priority",
")",
")",
"\n",
"copy",
"(",
"key",
"[",
"2",
":",
"]",
",",
"idToKey",
"(",
"id",
")",
")",
"\n",
"return",
"key",
"\n",
"}"
] | // generateKey create a key to be used with LevelDB. | [
"generateKey",
"create",
"a",
"key",
"to",
"be",
"used",
"with",
"LevelDB",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/priority_queue.go#L474-L480 |
5,869 | beeker1121/goque | priority_queue.go | init | func (pq *PriorityQueue) init() error {
// Set starting value for curLevel.
pq.resetCurrentLevel()
// Loop through each priority level.
for i := 0; i <= 255; i++ {
// Create a new LevelDB Iterator for this priority level.
prefix := pq.generatePrefix(uint8(i))
iter := pq.db.NewIterator(util.BytesPrefix(prefix), nil)
// Create a new priorityLevel.
pl := &priorityLevel{
head: 0,
tail: 0,
}
// Set priority level head to the first item.
if iter.First() {
pl.head = keyToID(iter.Key()[2:]) - 1
// Since this priority level has item(s), handle updating curLevel.
if pq.cmpAsc(uint8(i)) || pq.cmpDesc(uint8(i)) {
pq.curLevel = uint8(i)
}
}
// Set priority level tail to the last item.
if iter.Last() {
pl.tail = keyToID(iter.Key()[2:])
}
if iter.Error() != nil {
return iter.Error()
}
pq.levels[i] = pl
iter.Release()
}
return nil
} | go | func (pq *PriorityQueue) init() error {
// Set starting value for curLevel.
pq.resetCurrentLevel()
// Loop through each priority level.
for i := 0; i <= 255; i++ {
// Create a new LevelDB Iterator for this priority level.
prefix := pq.generatePrefix(uint8(i))
iter := pq.db.NewIterator(util.BytesPrefix(prefix), nil)
// Create a new priorityLevel.
pl := &priorityLevel{
head: 0,
tail: 0,
}
// Set priority level head to the first item.
if iter.First() {
pl.head = keyToID(iter.Key()[2:]) - 1
// Since this priority level has item(s), handle updating curLevel.
if pq.cmpAsc(uint8(i)) || pq.cmpDesc(uint8(i)) {
pq.curLevel = uint8(i)
}
}
// Set priority level tail to the last item.
if iter.Last() {
pl.tail = keyToID(iter.Key()[2:])
}
if iter.Error() != nil {
return iter.Error()
}
pq.levels[i] = pl
iter.Release()
}
return nil
} | [
"func",
"(",
"pq",
"*",
"PriorityQueue",
")",
"init",
"(",
")",
"error",
"{",
"// Set starting value for curLevel.",
"pq",
".",
"resetCurrentLevel",
"(",
")",
"\n\n",
"// Loop through each priority level.",
"for",
"i",
":=",
"0",
";",
"i",
"<=",
"255",
";",
"i",
"++",
"{",
"// Create a new LevelDB Iterator for this priority level.",
"prefix",
":=",
"pq",
".",
"generatePrefix",
"(",
"uint8",
"(",
"i",
")",
")",
"\n",
"iter",
":=",
"pq",
".",
"db",
".",
"NewIterator",
"(",
"util",
".",
"BytesPrefix",
"(",
"prefix",
")",
",",
"nil",
")",
"\n\n",
"// Create a new priorityLevel.",
"pl",
":=",
"&",
"priorityLevel",
"{",
"head",
":",
"0",
",",
"tail",
":",
"0",
",",
"}",
"\n\n",
"// Set priority level head to the first item.",
"if",
"iter",
".",
"First",
"(",
")",
"{",
"pl",
".",
"head",
"=",
"keyToID",
"(",
"iter",
".",
"Key",
"(",
")",
"[",
"2",
":",
"]",
")",
"-",
"1",
"\n\n",
"// Since this priority level has item(s), handle updating curLevel.",
"if",
"pq",
".",
"cmpAsc",
"(",
"uint8",
"(",
"i",
")",
")",
"||",
"pq",
".",
"cmpDesc",
"(",
"uint8",
"(",
"i",
")",
")",
"{",
"pq",
".",
"curLevel",
"=",
"uint8",
"(",
"i",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Set priority level tail to the last item.",
"if",
"iter",
".",
"Last",
"(",
")",
"{",
"pl",
".",
"tail",
"=",
"keyToID",
"(",
"iter",
".",
"Key",
"(",
")",
"[",
"2",
":",
"]",
")",
"\n",
"}",
"\n\n",
"if",
"iter",
".",
"Error",
"(",
")",
"!=",
"nil",
"{",
"return",
"iter",
".",
"Error",
"(",
")",
"\n",
"}",
"\n\n",
"pq",
".",
"levels",
"[",
"i",
"]",
"=",
"pl",
"\n",
"iter",
".",
"Release",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // init initializes the priority queue data. | [
"init",
"initializes",
"the",
"priority",
"queue",
"data",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/priority_queue.go#L483-L523 |
5,870 | beeker1121/goque | item.go | idToKey | func idToKey(id uint64) []byte {
key := make([]byte, 8)
binary.BigEndian.PutUint64(key, id)
return key
} | go | func idToKey(id uint64) []byte {
key := make([]byte, 8)
binary.BigEndian.PutUint64(key, id)
return key
} | [
"func",
"idToKey",
"(",
"id",
"uint64",
")",
"[",
"]",
"byte",
"{",
"key",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"8",
")",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint64",
"(",
"key",
",",
"id",
")",
"\n",
"return",
"key",
"\n",
"}"
] | // idToKey converts and returns the given ID to a key. | [
"idToKey",
"converts",
"and",
"returns",
"the",
"given",
"ID",
"to",
"a",
"key",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/item.go#L59-L63 |
5,871 | beeker1121/goque | stack.go | OpenStack | func OpenStack(dataDir string) (*Stack, error) {
var err error
// Create a new Stack.
s := &Stack{
DataDir: dataDir,
db: &leveldb.DB{},
head: 0,
tail: 0,
isOpen: false,
}
// Open database for the stack.
s.db, err = leveldb.OpenFile(dataDir, nil)
if err != nil {
return s, err
}
// Check if this Goque type can open the requested data directory.
ok, err := checkGoqueType(dataDir, goqueStack)
if err != nil {
return s, err
}
if !ok {
return s, ErrIncompatibleType
}
// Set isOpen and return.
s.isOpen = true
return s, s.init()
} | go | func OpenStack(dataDir string) (*Stack, error) {
var err error
// Create a new Stack.
s := &Stack{
DataDir: dataDir,
db: &leveldb.DB{},
head: 0,
tail: 0,
isOpen: false,
}
// Open database for the stack.
s.db, err = leveldb.OpenFile(dataDir, nil)
if err != nil {
return s, err
}
// Check if this Goque type can open the requested data directory.
ok, err := checkGoqueType(dataDir, goqueStack)
if err != nil {
return s, err
}
if !ok {
return s, ErrIncompatibleType
}
// Set isOpen and return.
s.isOpen = true
return s, s.init()
} | [
"func",
"OpenStack",
"(",
"dataDir",
"string",
")",
"(",
"*",
"Stack",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// Create a new Stack.",
"s",
":=",
"&",
"Stack",
"{",
"DataDir",
":",
"dataDir",
",",
"db",
":",
"&",
"leveldb",
".",
"DB",
"{",
"}",
",",
"head",
":",
"0",
",",
"tail",
":",
"0",
",",
"isOpen",
":",
"false",
",",
"}",
"\n\n",
"// Open database for the stack.",
"s",
".",
"db",
",",
"err",
"=",
"leveldb",
".",
"OpenFile",
"(",
"dataDir",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"s",
",",
"err",
"\n",
"}",
"\n\n",
"// Check if this Goque type can open the requested data directory.",
"ok",
",",
"err",
":=",
"checkGoqueType",
"(",
"dataDir",
",",
"goqueStack",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"s",
",",
"err",
"\n",
"}",
"\n",
"if",
"!",
"ok",
"{",
"return",
"s",
",",
"ErrIncompatibleType",
"\n",
"}",
"\n\n",
"// Set isOpen and return.",
"s",
".",
"isOpen",
"=",
"true",
"\n",
"return",
"s",
",",
"s",
".",
"init",
"(",
")",
"\n",
"}"
] | // OpenStack opens a stack if one exists at the given directory. If one
// does not already exist, a new stack is created. | [
"OpenStack",
"opens",
"a",
"stack",
"if",
"one",
"exists",
"at",
"the",
"given",
"directory",
".",
"If",
"one",
"does",
"not",
"already",
"exist",
"a",
"new",
"stack",
"is",
"created",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/stack.go#L24-L54 |
5,872 | beeker1121/goque | stack.go | Push | func (s *Stack) Push(value []byte) (*Item, error) {
s.Lock()
defer s.Unlock()
// Check if stack is closed.
if !s.isOpen {
return nil, ErrDBClosed
}
// Create new Item.
item := &Item{
ID: s.head + 1,
Key: idToKey(s.head + 1),
Value: value,
}
// Add it to the stack.
if err := s.db.Put(item.Key, item.Value, nil); err != nil {
return nil, err
}
// Increment head position.
s.head++
return item, nil
} | go | func (s *Stack) Push(value []byte) (*Item, error) {
s.Lock()
defer s.Unlock()
// Check if stack is closed.
if !s.isOpen {
return nil, ErrDBClosed
}
// Create new Item.
item := &Item{
ID: s.head + 1,
Key: idToKey(s.head + 1),
Value: value,
}
// Add it to the stack.
if err := s.db.Put(item.Key, item.Value, nil); err != nil {
return nil, err
}
// Increment head position.
s.head++
return item, nil
} | [
"func",
"(",
"s",
"*",
"Stack",
")",
"Push",
"(",
"value",
"[",
"]",
"byte",
")",
"(",
"*",
"Item",
",",
"error",
")",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n\n",
"// Check if stack is closed.",
"if",
"!",
"s",
".",
"isOpen",
"{",
"return",
"nil",
",",
"ErrDBClosed",
"\n",
"}",
"\n\n",
"// Create new Item.",
"item",
":=",
"&",
"Item",
"{",
"ID",
":",
"s",
".",
"head",
"+",
"1",
",",
"Key",
":",
"idToKey",
"(",
"s",
".",
"head",
"+",
"1",
")",
",",
"Value",
":",
"value",
",",
"}",
"\n\n",
"// Add it to the stack.",
"if",
"err",
":=",
"s",
".",
"db",
".",
"Put",
"(",
"item",
".",
"Key",
",",
"item",
".",
"Value",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Increment head position.",
"s",
".",
"head",
"++",
"\n\n",
"return",
"item",
",",
"nil",
"\n",
"}"
] | // Push adds an item to the stack. | [
"Push",
"adds",
"an",
"item",
"to",
"the",
"stack",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/stack.go#L57-L82 |
5,873 | beeker1121/goque | stack.go | PushString | func (s *Stack) PushString(value string) (*Item, error) {
return s.Push([]byte(value))
} | go | func (s *Stack) PushString(value string) (*Item, error) {
return s.Push([]byte(value))
} | [
"func",
"(",
"s",
"*",
"Stack",
")",
"PushString",
"(",
"value",
"string",
")",
"(",
"*",
"Item",
",",
"error",
")",
"{",
"return",
"s",
".",
"Push",
"(",
"[",
"]",
"byte",
"(",
"value",
")",
")",
"\n",
"}"
] | // PushString is a helper function for Push that accepts a
// value as a string rather than a byte slice. | [
"PushString",
"is",
"a",
"helper",
"function",
"for",
"Push",
"that",
"accepts",
"a",
"value",
"as",
"a",
"string",
"rather",
"than",
"a",
"byte",
"slice",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/stack.go#L86-L88 |
5,874 | beeker1121/goque | stack.go | Pop | func (s *Stack) Pop() (*Item, error) {
s.Lock()
defer s.Unlock()
// Check if stack is closed.
if !s.isOpen {
return nil, ErrDBClosed
}
// Try to get the next item in the stack.
item, err := s.getItemByID(s.head)
if err != nil {
return nil, err
}
// Remove this item from the stack.
if err := s.db.Delete(item.Key, nil); err != nil {
return nil, err
}
// Decrement head position.
s.head--
return item, nil
} | go | func (s *Stack) Pop() (*Item, error) {
s.Lock()
defer s.Unlock()
// Check if stack is closed.
if !s.isOpen {
return nil, ErrDBClosed
}
// Try to get the next item in the stack.
item, err := s.getItemByID(s.head)
if err != nil {
return nil, err
}
// Remove this item from the stack.
if err := s.db.Delete(item.Key, nil); err != nil {
return nil, err
}
// Decrement head position.
s.head--
return item, nil
} | [
"func",
"(",
"s",
"*",
"Stack",
")",
"Pop",
"(",
")",
"(",
"*",
"Item",
",",
"error",
")",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n\n",
"// Check if stack is closed.",
"if",
"!",
"s",
".",
"isOpen",
"{",
"return",
"nil",
",",
"ErrDBClosed",
"\n",
"}",
"\n\n",
"// Try to get the next item in the stack.",
"item",
",",
"err",
":=",
"s",
".",
"getItemByID",
"(",
"s",
".",
"head",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Remove this item from the stack.",
"if",
"err",
":=",
"s",
".",
"db",
".",
"Delete",
"(",
"item",
".",
"Key",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Decrement head position.",
"s",
".",
"head",
"--",
"\n\n",
"return",
"item",
",",
"nil",
"\n",
"}"
] | // Pop removes the next item in the stack and returns it. | [
"Pop",
"removes",
"the",
"next",
"item",
"in",
"the",
"stack",
"and",
"returns",
"it",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/stack.go#L103-L127 |
5,875 | beeker1121/goque | stack.go | Peek | func (s *Stack) Peek() (*Item, error) {
s.RLock()
defer s.RUnlock()
// Check if stack is closed.
if !s.isOpen {
return nil, ErrDBClosed
}
return s.getItemByID(s.head)
} | go | func (s *Stack) Peek() (*Item, error) {
s.RLock()
defer s.RUnlock()
// Check if stack is closed.
if !s.isOpen {
return nil, ErrDBClosed
}
return s.getItemByID(s.head)
} | [
"func",
"(",
"s",
"*",
"Stack",
")",
"Peek",
"(",
")",
"(",
"*",
"Item",
",",
"error",
")",
"{",
"s",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"RUnlock",
"(",
")",
"\n\n",
"// Check if stack is closed.",
"if",
"!",
"s",
".",
"isOpen",
"{",
"return",
"nil",
",",
"ErrDBClosed",
"\n",
"}",
"\n\n",
"return",
"s",
".",
"getItemByID",
"(",
"s",
".",
"head",
")",
"\n",
"}"
] | // Peek returns the next item in the stack without removing it. | [
"Peek",
"returns",
"the",
"next",
"item",
"in",
"the",
"stack",
"without",
"removing",
"it",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/stack.go#L130-L140 |
5,876 | beeker1121/goque | stack.go | PeekByOffset | func (s *Stack) PeekByOffset(offset uint64) (*Item, error) {
s.RLock()
defer s.RUnlock()
// Check if stack is closed.
if !s.isOpen {
return nil, ErrDBClosed
}
return s.getItemByID(s.head - offset)
} | go | func (s *Stack) PeekByOffset(offset uint64) (*Item, error) {
s.RLock()
defer s.RUnlock()
// Check if stack is closed.
if !s.isOpen {
return nil, ErrDBClosed
}
return s.getItemByID(s.head - offset)
} | [
"func",
"(",
"s",
"*",
"Stack",
")",
"PeekByOffset",
"(",
"offset",
"uint64",
")",
"(",
"*",
"Item",
",",
"error",
")",
"{",
"s",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"RUnlock",
"(",
")",
"\n\n",
"// Check if stack is closed.",
"if",
"!",
"s",
".",
"isOpen",
"{",
"return",
"nil",
",",
"ErrDBClosed",
"\n",
"}",
"\n\n",
"return",
"s",
".",
"getItemByID",
"(",
"s",
".",
"head",
"-",
"offset",
")",
"\n",
"}"
] | // PeekByOffset returns the item located at the given offset,
// starting from the head of the stack, without removing it. | [
"PeekByOffset",
"returns",
"the",
"item",
"located",
"at",
"the",
"given",
"offset",
"starting",
"from",
"the",
"head",
"of",
"the",
"stack",
"without",
"removing",
"it",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/stack.go#L144-L154 |
5,877 | beeker1121/goque | stack.go | Update | func (s *Stack) Update(id uint64, newValue []byte) (*Item, error) {
s.Lock()
defer s.Unlock()
// Check if stack is closed.
if !s.isOpen {
return nil, ErrDBClosed
}
// Check if item exists in stack.
if id > s.head || id <= s.tail {
return nil, ErrOutOfBounds
}
// Create new Item.
item := &Item{
ID: id,
Key: idToKey(id),
Value: newValue,
}
// Update this item in the stack.
if err := s.db.Put(item.Key, item.Value, nil); err != nil {
return nil, err
}
return item, nil
} | go | func (s *Stack) Update(id uint64, newValue []byte) (*Item, error) {
s.Lock()
defer s.Unlock()
// Check if stack is closed.
if !s.isOpen {
return nil, ErrDBClosed
}
// Check if item exists in stack.
if id > s.head || id <= s.tail {
return nil, ErrOutOfBounds
}
// Create new Item.
item := &Item{
ID: id,
Key: idToKey(id),
Value: newValue,
}
// Update this item in the stack.
if err := s.db.Put(item.Key, item.Value, nil); err != nil {
return nil, err
}
return item, nil
} | [
"func",
"(",
"s",
"*",
"Stack",
")",
"Update",
"(",
"id",
"uint64",
",",
"newValue",
"[",
"]",
"byte",
")",
"(",
"*",
"Item",
",",
"error",
")",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n\n",
"// Check if stack is closed.",
"if",
"!",
"s",
".",
"isOpen",
"{",
"return",
"nil",
",",
"ErrDBClosed",
"\n",
"}",
"\n\n",
"// Check if item exists in stack.",
"if",
"id",
">",
"s",
".",
"head",
"||",
"id",
"<=",
"s",
".",
"tail",
"{",
"return",
"nil",
",",
"ErrOutOfBounds",
"\n",
"}",
"\n\n",
"// Create new Item.",
"item",
":=",
"&",
"Item",
"{",
"ID",
":",
"id",
",",
"Key",
":",
"idToKey",
"(",
"id",
")",
",",
"Value",
":",
"newValue",
",",
"}",
"\n\n",
"// Update this item in the stack.",
"if",
"err",
":=",
"s",
".",
"db",
".",
"Put",
"(",
"item",
".",
"Key",
",",
"item",
".",
"Value",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"item",
",",
"nil",
"\n",
"}"
] | // Update updates an item in the stack without changing its position. | [
"Update",
"updates",
"an",
"item",
"in",
"the",
"stack",
"without",
"changing",
"its",
"position",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/stack.go#L170-L197 |
5,878 | beeker1121/goque | stack.go | Close | func (s *Stack) Close() error {
s.Lock()
defer s.Unlock()
// Check if stack is already closed.
if !s.isOpen {
return nil
}
// Close the LevelDB database.
if err := s.db.Close(); err != nil {
return err
}
// Reset stack head and tail and set
// isOpen to false.
s.head = 0
s.tail = 0
s.isOpen = false
return nil
} | go | func (s *Stack) Close() error {
s.Lock()
defer s.Unlock()
// Check if stack is already closed.
if !s.isOpen {
return nil
}
// Close the LevelDB database.
if err := s.db.Close(); err != nil {
return err
}
// Reset stack head and tail and set
// isOpen to false.
s.head = 0
s.tail = 0
s.isOpen = false
return nil
} | [
"func",
"(",
"s",
"*",
"Stack",
")",
"Close",
"(",
")",
"error",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n\n",
"// Check if stack is already closed.",
"if",
"!",
"s",
".",
"isOpen",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// Close the LevelDB database.",
"if",
"err",
":=",
"s",
".",
"db",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Reset stack head and tail and set",
"// isOpen to false.",
"s",
".",
"head",
"=",
"0",
"\n",
"s",
".",
"tail",
"=",
"0",
"\n",
"s",
".",
"isOpen",
"=",
"false",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Close closes the LevelDB database of the stack. | [
"Close",
"closes",
"the",
"LevelDB",
"database",
"of",
"the",
"stack",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/stack.go#L223-L244 |
5,879 | beeker1121/goque | stack.go | Drop | func (s *Stack) Drop() error {
if err := s.Close(); err != nil {
return err
}
return os.RemoveAll(s.DataDir)
} | go | func (s *Stack) Drop() error {
if err := s.Close(); err != nil {
return err
}
return os.RemoveAll(s.DataDir)
} | [
"func",
"(",
"s",
"*",
"Stack",
")",
"Drop",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"s",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"os",
".",
"RemoveAll",
"(",
"s",
".",
"DataDir",
")",
"\n",
"}"
] | // Drop closes and deletes the LevelDB database of the stack. | [
"Drop",
"closes",
"and",
"deletes",
"the",
"LevelDB",
"database",
"of",
"the",
"stack",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/stack.go#L247-L253 |
5,880 | beeker1121/goque | stack.go | init | func (s *Stack) init() error {
// Create a new LevelDB Iterator.
iter := s.db.NewIterator(nil, nil)
defer iter.Release()
// Set stack head to the last item.
if iter.Last() {
s.head = keyToID(iter.Key())
}
// Set stack tail to the first item.
if iter.First() {
s.tail = keyToID(iter.Key()) - 1
}
return iter.Error()
} | go | func (s *Stack) init() error {
// Create a new LevelDB Iterator.
iter := s.db.NewIterator(nil, nil)
defer iter.Release()
// Set stack head to the last item.
if iter.Last() {
s.head = keyToID(iter.Key())
}
// Set stack tail to the first item.
if iter.First() {
s.tail = keyToID(iter.Key()) - 1
}
return iter.Error()
} | [
"func",
"(",
"s",
"*",
"Stack",
")",
"init",
"(",
")",
"error",
"{",
"// Create a new LevelDB Iterator.",
"iter",
":=",
"s",
".",
"db",
".",
"NewIterator",
"(",
"nil",
",",
"nil",
")",
"\n",
"defer",
"iter",
".",
"Release",
"(",
")",
"\n\n",
"// Set stack head to the last item.",
"if",
"iter",
".",
"Last",
"(",
")",
"{",
"s",
".",
"head",
"=",
"keyToID",
"(",
"iter",
".",
"Key",
"(",
")",
")",
"\n",
"}",
"\n\n",
"// Set stack tail to the first item.",
"if",
"iter",
".",
"First",
"(",
")",
"{",
"s",
".",
"tail",
"=",
"keyToID",
"(",
"iter",
".",
"Key",
"(",
")",
")",
"-",
"1",
"\n",
"}",
"\n\n",
"return",
"iter",
".",
"Error",
"(",
")",
"\n",
"}"
] | // init initializes the stack data. | [
"init",
"initializes",
"the",
"stack",
"data",
"."
] | 4044bc29b28064db4f08e947c4972d5ca3e0f3c8 | https://github.com/beeker1121/goque/blob/4044bc29b28064db4f08e947c4972d5ca3e0f3c8/stack.go#L275-L291 |
5,881 | russellhaering/gosaml2 | retrieve_assertion.go | RetrieveAssertionInfo | func (sp *SAMLServiceProvider) RetrieveAssertionInfo(encodedResponse string) (*AssertionInfo, error) {
assertionInfo := &AssertionInfo{
Values: make(Values),
}
response, err := sp.ValidateEncodedResponse(encodedResponse)
if err != nil {
return nil, ErrVerification{Cause: err}
}
// TODO: Support multiple assertions
if len(response.Assertions) == 0 {
return nil, ErrMissingAssertion
}
assertion := response.Assertions[0]
assertionInfo.Assertions = response.Assertions
assertionInfo.ResponseSignatureValidated = response.SignatureValidated
warningInfo, err := sp.VerifyAssertionConditions(&assertion)
if err != nil {
return nil, err
}
//Get the NameID
subject := assertion.Subject
if subject == nil {
return nil, ErrMissingElement{Tag: SubjectTag}
}
nameID := subject.NameID
if nameID == nil {
return nil, ErrMissingElement{Tag: NameIdTag}
}
assertionInfo.NameID = nameID.Value
//Get the actual assertion attributes
attributeStatement := assertion.AttributeStatement
if attributeStatement == nil && !sp.AllowMissingAttributes {
return nil, ErrMissingElement{Tag: AttributeStatementTag}
}
if attributeStatement != nil {
for _, attribute := range attributeStatement.Attributes {
assertionInfo.Values[attribute.Name] = attribute
}
}
if assertion.AuthnStatement != nil {
if assertion.AuthnStatement.AuthnInstant != nil {
assertionInfo.AuthnInstant = assertion.AuthnStatement.AuthnInstant
}
if assertion.AuthnStatement.SessionNotOnOrAfter != nil {
assertionInfo.SessionNotOnOrAfter = assertion.AuthnStatement.SessionNotOnOrAfter
}
}
assertionInfo.WarningInfo = warningInfo
return assertionInfo, nil
} | go | func (sp *SAMLServiceProvider) RetrieveAssertionInfo(encodedResponse string) (*AssertionInfo, error) {
assertionInfo := &AssertionInfo{
Values: make(Values),
}
response, err := sp.ValidateEncodedResponse(encodedResponse)
if err != nil {
return nil, ErrVerification{Cause: err}
}
// TODO: Support multiple assertions
if len(response.Assertions) == 0 {
return nil, ErrMissingAssertion
}
assertion := response.Assertions[0]
assertionInfo.Assertions = response.Assertions
assertionInfo.ResponseSignatureValidated = response.SignatureValidated
warningInfo, err := sp.VerifyAssertionConditions(&assertion)
if err != nil {
return nil, err
}
//Get the NameID
subject := assertion.Subject
if subject == nil {
return nil, ErrMissingElement{Tag: SubjectTag}
}
nameID := subject.NameID
if nameID == nil {
return nil, ErrMissingElement{Tag: NameIdTag}
}
assertionInfo.NameID = nameID.Value
//Get the actual assertion attributes
attributeStatement := assertion.AttributeStatement
if attributeStatement == nil && !sp.AllowMissingAttributes {
return nil, ErrMissingElement{Tag: AttributeStatementTag}
}
if attributeStatement != nil {
for _, attribute := range attributeStatement.Attributes {
assertionInfo.Values[attribute.Name] = attribute
}
}
if assertion.AuthnStatement != nil {
if assertion.AuthnStatement.AuthnInstant != nil {
assertionInfo.AuthnInstant = assertion.AuthnStatement.AuthnInstant
}
if assertion.AuthnStatement.SessionNotOnOrAfter != nil {
assertionInfo.SessionNotOnOrAfter = assertion.AuthnStatement.SessionNotOnOrAfter
}
}
assertionInfo.WarningInfo = warningInfo
return assertionInfo, nil
} | [
"func",
"(",
"sp",
"*",
"SAMLServiceProvider",
")",
"RetrieveAssertionInfo",
"(",
"encodedResponse",
"string",
")",
"(",
"*",
"AssertionInfo",
",",
"error",
")",
"{",
"assertionInfo",
":=",
"&",
"AssertionInfo",
"{",
"Values",
":",
"make",
"(",
"Values",
")",
",",
"}",
"\n\n",
"response",
",",
"err",
":=",
"sp",
".",
"ValidateEncodedResponse",
"(",
"encodedResponse",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"ErrVerification",
"{",
"Cause",
":",
"err",
"}",
"\n",
"}",
"\n\n",
"// TODO: Support multiple assertions",
"if",
"len",
"(",
"response",
".",
"Assertions",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"ErrMissingAssertion",
"\n",
"}",
"\n\n",
"assertion",
":=",
"response",
".",
"Assertions",
"[",
"0",
"]",
"\n",
"assertionInfo",
".",
"Assertions",
"=",
"response",
".",
"Assertions",
"\n",
"assertionInfo",
".",
"ResponseSignatureValidated",
"=",
"response",
".",
"SignatureValidated",
"\n\n",
"warningInfo",
",",
"err",
":=",
"sp",
".",
"VerifyAssertionConditions",
"(",
"&",
"assertion",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"//Get the NameID",
"subject",
":=",
"assertion",
".",
"Subject",
"\n",
"if",
"subject",
"==",
"nil",
"{",
"return",
"nil",
",",
"ErrMissingElement",
"{",
"Tag",
":",
"SubjectTag",
"}",
"\n",
"}",
"\n\n",
"nameID",
":=",
"subject",
".",
"NameID",
"\n",
"if",
"nameID",
"==",
"nil",
"{",
"return",
"nil",
",",
"ErrMissingElement",
"{",
"Tag",
":",
"NameIdTag",
"}",
"\n",
"}",
"\n\n",
"assertionInfo",
".",
"NameID",
"=",
"nameID",
".",
"Value",
"\n\n",
"//Get the actual assertion attributes",
"attributeStatement",
":=",
"assertion",
".",
"AttributeStatement",
"\n",
"if",
"attributeStatement",
"==",
"nil",
"&&",
"!",
"sp",
".",
"AllowMissingAttributes",
"{",
"return",
"nil",
",",
"ErrMissingElement",
"{",
"Tag",
":",
"AttributeStatementTag",
"}",
"\n",
"}",
"\n\n",
"if",
"attributeStatement",
"!=",
"nil",
"{",
"for",
"_",
",",
"attribute",
":=",
"range",
"attributeStatement",
".",
"Attributes",
"{",
"assertionInfo",
".",
"Values",
"[",
"attribute",
".",
"Name",
"]",
"=",
"attribute",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"assertion",
".",
"AuthnStatement",
"!=",
"nil",
"{",
"if",
"assertion",
".",
"AuthnStatement",
".",
"AuthnInstant",
"!=",
"nil",
"{",
"assertionInfo",
".",
"AuthnInstant",
"=",
"assertion",
".",
"AuthnStatement",
".",
"AuthnInstant",
"\n",
"}",
"\n",
"if",
"assertion",
".",
"AuthnStatement",
".",
"SessionNotOnOrAfter",
"!=",
"nil",
"{",
"assertionInfo",
".",
"SessionNotOnOrAfter",
"=",
"assertion",
".",
"AuthnStatement",
".",
"SessionNotOnOrAfter",
"\n",
"}",
"\n",
"}",
"\n\n",
"assertionInfo",
".",
"WarningInfo",
"=",
"warningInfo",
"\n",
"return",
"assertionInfo",
",",
"nil",
"\n",
"}"
] | //RetrieveAssertionInfo takes an encoded response and returns the AssertionInfo
//contained, or an error message if an error has been encountered. | [
"RetrieveAssertionInfo",
"takes",
"an",
"encoded",
"response",
"and",
"returns",
"the",
"AssertionInfo",
"contained",
"or",
"an",
"error",
"message",
"if",
"an",
"error",
"has",
"been",
"encountered",
"."
] | 2506a07af0643ab4bb14100ae8c3254421cd78d7 | https://github.com/russellhaering/gosaml2/blob/2506a07af0643ab4bb14100ae8c3254421cd78d7/retrieve_assertion.go#L35-L95 |
5,882 | russellhaering/gosaml2 | build_request.go | BuildAuthURL | func (sp *SAMLServiceProvider) BuildAuthURL(relayState string) (string, error) {
doc, err := sp.BuildAuthRequestDocument()
if err != nil {
return "", err
}
return sp.BuildAuthURLFromDocument(relayState, doc)
} | go | func (sp *SAMLServiceProvider) BuildAuthURL(relayState string) (string, error) {
doc, err := sp.BuildAuthRequestDocument()
if err != nil {
return "", err
}
return sp.BuildAuthURLFromDocument(relayState, doc)
} | [
"func",
"(",
"sp",
"*",
"SAMLServiceProvider",
")",
"BuildAuthURL",
"(",
"relayState",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"doc",
",",
"err",
":=",
"sp",
".",
"BuildAuthRequestDocument",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"sp",
".",
"BuildAuthURLFromDocument",
"(",
"relayState",
",",
"doc",
")",
"\n",
"}"
] | // BuildAuthURL builds redirect URL to be sent to principal | [
"BuildAuthURL",
"builds",
"redirect",
"URL",
"to",
"be",
"sent",
"to",
"principal"
] | 2506a07af0643ab4bb14100ae8c3254421cd78d7 | https://github.com/russellhaering/gosaml2/blob/2506a07af0643ab4bb14100ae8c3254421cd78d7/build_request.go#L177-L183 |
5,883 | russellhaering/gosaml2 | build_request.go | AuthRedirect | func (sp *SAMLServiceProvider) AuthRedirect(w http.ResponseWriter, r *http.Request, relayState string) (err error) {
url, err := sp.BuildAuthURL(relayState)
if err != nil {
return err
}
http.Redirect(w, r, url, http.StatusFound)
return nil
} | go | func (sp *SAMLServiceProvider) AuthRedirect(w http.ResponseWriter, r *http.Request, relayState string) (err error) {
url, err := sp.BuildAuthURL(relayState)
if err != nil {
return err
}
http.Redirect(w, r, url, http.StatusFound)
return nil
} | [
"func",
"(",
"sp",
"*",
"SAMLServiceProvider",
")",
"AuthRedirect",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"relayState",
"string",
")",
"(",
"err",
"error",
")",
"{",
"url",
",",
"err",
":=",
"sp",
".",
"BuildAuthURL",
"(",
"relayState",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"http",
".",
"Redirect",
"(",
"w",
",",
"r",
",",
"url",
",",
"http",
".",
"StatusFound",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // AuthRedirect takes a ResponseWriter and Request from an http interaction and
// redirects to the SAMLServiceProvider's configured IdP, including the
// relayState provided, if any. | [
"AuthRedirect",
"takes",
"a",
"ResponseWriter",
"and",
"Request",
"from",
"an",
"http",
"interaction",
"and",
"redirects",
"to",
"the",
"SAMLServiceProvider",
"s",
"configured",
"IdP",
"including",
"the",
"relayState",
"provided",
"if",
"any",
"."
] | 2506a07af0643ab4bb14100ae8c3254421cd78d7 | https://github.com/russellhaering/gosaml2/blob/2506a07af0643ab4bb14100ae8c3254421cd78d7/build_request.go#L188-L196 |
5,884 | russellhaering/gosaml2 | decode_response.go | validateResponseAttributes | func (sp *SAMLServiceProvider) validateResponseAttributes(response *types.Response) error {
if response.Destination != "" && response.Destination != sp.AssertionConsumerServiceURL {
return ErrInvalidValue{
Key: DestinationAttr,
Expected: sp.AssertionConsumerServiceURL,
Actual: response.Destination,
}
}
if response.Version != "2.0" {
return ErrInvalidValue{
Reason: ReasonUnsupported,
Key: "SAML version",
Expected: "2.0",
Actual: response.Version,
}
}
return nil
} | go | func (sp *SAMLServiceProvider) validateResponseAttributes(response *types.Response) error {
if response.Destination != "" && response.Destination != sp.AssertionConsumerServiceURL {
return ErrInvalidValue{
Key: DestinationAttr,
Expected: sp.AssertionConsumerServiceURL,
Actual: response.Destination,
}
}
if response.Version != "2.0" {
return ErrInvalidValue{
Reason: ReasonUnsupported,
Key: "SAML version",
Expected: "2.0",
Actual: response.Version,
}
}
return nil
} | [
"func",
"(",
"sp",
"*",
"SAMLServiceProvider",
")",
"validateResponseAttributes",
"(",
"response",
"*",
"types",
".",
"Response",
")",
"error",
"{",
"if",
"response",
".",
"Destination",
"!=",
"\"",
"\"",
"&&",
"response",
".",
"Destination",
"!=",
"sp",
".",
"AssertionConsumerServiceURL",
"{",
"return",
"ErrInvalidValue",
"{",
"Key",
":",
"DestinationAttr",
",",
"Expected",
":",
"sp",
".",
"AssertionConsumerServiceURL",
",",
"Actual",
":",
"response",
".",
"Destination",
",",
"}",
"\n",
"}",
"\n\n",
"if",
"response",
".",
"Version",
"!=",
"\"",
"\"",
"{",
"return",
"ErrInvalidValue",
"{",
"Reason",
":",
"ReasonUnsupported",
",",
"Key",
":",
"\"",
"\"",
",",
"Expected",
":",
"\"",
"\"",
",",
"Actual",
":",
"response",
".",
"Version",
",",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // validateResponseAttributes validates a SAML Response's tag and attributes. It does
// not inspect child elements of the Response at all. | [
"validateResponseAttributes",
"validates",
"a",
"SAML",
"Response",
"s",
"tag",
"and",
"attributes",
".",
"It",
"does",
"not",
"inspect",
"child",
"elements",
"of",
"the",
"Response",
"at",
"all",
"."
] | 2506a07af0643ab4bb14100ae8c3254421cd78d7 | https://github.com/russellhaering/gosaml2/blob/2506a07af0643ab4bb14100ae8c3254421cd78d7/decode_response.go#L28-L47 |
5,885 | russellhaering/gosaml2 | decode_response.go | ValidateEncodedResponse | func (sp *SAMLServiceProvider) ValidateEncodedResponse(encodedResponse string) (*types.Response, error) {
raw, err := base64.StdEncoding.DecodeString(encodedResponse)
if err != nil {
return nil, err
}
// Parse the raw response
doc, el, err := parseResponse(raw)
if err != nil {
return nil, err
}
var responseSignatureValidated bool
if !sp.SkipSignatureValidation {
el, err = sp.validateElementSignature(el)
if err == dsig.ErrMissingSignature {
// Unfortunately we just blew away our Response
el = doc.Root()
} else if err != nil {
return nil, err
} else if el == nil {
return nil, fmt.Errorf("missing transformed response")
} else {
responseSignatureValidated = true
}
}
err = sp.decryptAssertions(el)
if err != nil {
return nil, err
}
var assertionSignaturesValidated bool
if !sp.SkipSignatureValidation {
err = sp.validateAssertionSignatures(el)
if err == dsig.ErrMissingSignature {
if !responseSignatureValidated {
return nil, fmt.Errorf("response and/or assertions must be signed")
}
} else if err != nil {
return nil, err
} else {
assertionSignaturesValidated = true
}
}
decodedResponse := &types.Response{}
err = xmlUnmarshalElement(el, decodedResponse)
if err != nil {
return nil, fmt.Errorf("unable to unmarshal response: %v", err)
}
decodedResponse.SignatureValidated = responseSignatureValidated
if assertionSignaturesValidated {
for idx := 0; idx < len(decodedResponse.Assertions); idx++ {
decodedResponse.Assertions[idx].SignatureValidated = true
}
}
err = sp.Validate(decodedResponse)
if err != nil {
return nil, err
}
return decodedResponse, nil
} | go | func (sp *SAMLServiceProvider) ValidateEncodedResponse(encodedResponse string) (*types.Response, error) {
raw, err := base64.StdEncoding.DecodeString(encodedResponse)
if err != nil {
return nil, err
}
// Parse the raw response
doc, el, err := parseResponse(raw)
if err != nil {
return nil, err
}
var responseSignatureValidated bool
if !sp.SkipSignatureValidation {
el, err = sp.validateElementSignature(el)
if err == dsig.ErrMissingSignature {
// Unfortunately we just blew away our Response
el = doc.Root()
} else if err != nil {
return nil, err
} else if el == nil {
return nil, fmt.Errorf("missing transformed response")
} else {
responseSignatureValidated = true
}
}
err = sp.decryptAssertions(el)
if err != nil {
return nil, err
}
var assertionSignaturesValidated bool
if !sp.SkipSignatureValidation {
err = sp.validateAssertionSignatures(el)
if err == dsig.ErrMissingSignature {
if !responseSignatureValidated {
return nil, fmt.Errorf("response and/or assertions must be signed")
}
} else if err != nil {
return nil, err
} else {
assertionSignaturesValidated = true
}
}
decodedResponse := &types.Response{}
err = xmlUnmarshalElement(el, decodedResponse)
if err != nil {
return nil, fmt.Errorf("unable to unmarshal response: %v", err)
}
decodedResponse.SignatureValidated = responseSignatureValidated
if assertionSignaturesValidated {
for idx := 0; idx < len(decodedResponse.Assertions); idx++ {
decodedResponse.Assertions[idx].SignatureValidated = true
}
}
err = sp.Validate(decodedResponse)
if err != nil {
return nil, err
}
return decodedResponse, nil
} | [
"func",
"(",
"sp",
"*",
"SAMLServiceProvider",
")",
"ValidateEncodedResponse",
"(",
"encodedResponse",
"string",
")",
"(",
"*",
"types",
".",
"Response",
",",
"error",
")",
"{",
"raw",
",",
"err",
":=",
"base64",
".",
"StdEncoding",
".",
"DecodeString",
"(",
"encodedResponse",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse the raw response",
"doc",
",",
"el",
",",
"err",
":=",
"parseResponse",
"(",
"raw",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"responseSignatureValidated",
"bool",
"\n",
"if",
"!",
"sp",
".",
"SkipSignatureValidation",
"{",
"el",
",",
"err",
"=",
"sp",
".",
"validateElementSignature",
"(",
"el",
")",
"\n",
"if",
"err",
"==",
"dsig",
".",
"ErrMissingSignature",
"{",
"// Unfortunately we just blew away our Response",
"el",
"=",
"doc",
".",
"Root",
"(",
")",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"else",
"if",
"el",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"responseSignatureValidated",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"err",
"=",
"sp",
".",
"decryptAssertions",
"(",
"el",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"assertionSignaturesValidated",
"bool",
"\n",
"if",
"!",
"sp",
".",
"SkipSignatureValidation",
"{",
"err",
"=",
"sp",
".",
"validateAssertionSignatures",
"(",
"el",
")",
"\n",
"if",
"err",
"==",
"dsig",
".",
"ErrMissingSignature",
"{",
"if",
"!",
"responseSignatureValidated",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"else",
"{",
"assertionSignaturesValidated",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"decodedResponse",
":=",
"&",
"types",
".",
"Response",
"{",
"}",
"\n",
"err",
"=",
"xmlUnmarshalElement",
"(",
"el",
",",
"decodedResponse",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"decodedResponse",
".",
"SignatureValidated",
"=",
"responseSignatureValidated",
"\n",
"if",
"assertionSignaturesValidated",
"{",
"for",
"idx",
":=",
"0",
";",
"idx",
"<",
"len",
"(",
"decodedResponse",
".",
"Assertions",
")",
";",
"idx",
"++",
"{",
"decodedResponse",
".",
"Assertions",
"[",
"idx",
"]",
".",
"SignatureValidated",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"err",
"=",
"sp",
".",
"Validate",
"(",
"decodedResponse",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"decodedResponse",
",",
"nil",
"\n",
"}"
] | //ValidateEncodedResponse both decodes and validates, based on SP
//configuration, an encoded, signed response. It will also appropriately
//decrypt a response if the assertion was encrypted | [
"ValidateEncodedResponse",
"both",
"decodes",
"and",
"validates",
"based",
"on",
"SP",
"configuration",
"an",
"encoded",
"signed",
"response",
".",
"It",
"will",
"also",
"appropriately",
"decrypt",
"a",
"response",
"if",
"the",
"assertion",
"was",
"encrypted"
] | 2506a07af0643ab4bb14100ae8c3254421cd78d7 | https://github.com/russellhaering/gosaml2/blob/2506a07af0643ab4bb14100ae8c3254421cd78d7/decode_response.go#L214-L278 |
5,886 | russellhaering/gosaml2 | decode_response.go | DecodeUnverifiedBaseResponse | func DecodeUnverifiedBaseResponse(encodedResponse string) (*types.UnverifiedBaseResponse, error) {
raw, err := base64.StdEncoding.DecodeString(encodedResponse)
if err != nil {
return nil, err
}
var response *types.UnverifiedBaseResponse
err = maybeDeflate(raw, func(maybeXML []byte) error {
response = &types.UnverifiedBaseResponse{}
return xml.Unmarshal(maybeXML, response)
})
if err != nil {
return nil, err
}
return response, nil
} | go | func DecodeUnverifiedBaseResponse(encodedResponse string) (*types.UnverifiedBaseResponse, error) {
raw, err := base64.StdEncoding.DecodeString(encodedResponse)
if err != nil {
return nil, err
}
var response *types.UnverifiedBaseResponse
err = maybeDeflate(raw, func(maybeXML []byte) error {
response = &types.UnverifiedBaseResponse{}
return xml.Unmarshal(maybeXML, response)
})
if err != nil {
return nil, err
}
return response, nil
} | [
"func",
"DecodeUnverifiedBaseResponse",
"(",
"encodedResponse",
"string",
")",
"(",
"*",
"types",
".",
"UnverifiedBaseResponse",
",",
"error",
")",
"{",
"raw",
",",
"err",
":=",
"base64",
".",
"StdEncoding",
".",
"DecodeString",
"(",
"encodedResponse",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"response",
"*",
"types",
".",
"UnverifiedBaseResponse",
"\n\n",
"err",
"=",
"maybeDeflate",
"(",
"raw",
",",
"func",
"(",
"maybeXML",
"[",
"]",
"byte",
")",
"error",
"{",
"response",
"=",
"&",
"types",
".",
"UnverifiedBaseResponse",
"{",
"}",
"\n",
"return",
"xml",
".",
"Unmarshal",
"(",
"maybeXML",
",",
"response",
")",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | // DecodeUnverifiedBaseResponse decodes several attributes from a SAML response for the purpose
// of determining how to validate the response. This is useful for Service Providers which
// expose a single Assertion Consumer Service URL but consume Responses from many IdPs. | [
"DecodeUnverifiedBaseResponse",
"decodes",
"several",
"attributes",
"from",
"a",
"SAML",
"response",
"for",
"the",
"purpose",
"of",
"determining",
"how",
"to",
"validate",
"the",
"response",
".",
"This",
"is",
"useful",
"for",
"Service",
"Providers",
"which",
"expose",
"a",
"single",
"Assertion",
"Consumer",
"Service",
"URL",
"but",
"consume",
"Responses",
"from",
"many",
"IdPs",
"."
] | 2506a07af0643ab4bb14100ae8c3254421cd78d7 | https://github.com/russellhaering/gosaml2/blob/2506a07af0643ab4bb14100ae8c3254421cd78d7/decode_response.go#L283-L300 |
5,887 | russellhaering/gosaml2 | decode_response.go | maybeDeflate | func maybeDeflate(data []byte, decoder func([]byte) error) error {
err := decoder(data)
if err == nil {
return nil
}
deflated, err := ioutil.ReadAll(flate.NewReader(bytes.NewReader(data)))
if err != nil {
return err
}
return decoder(deflated)
} | go | func maybeDeflate(data []byte, decoder func([]byte) error) error {
err := decoder(data)
if err == nil {
return nil
}
deflated, err := ioutil.ReadAll(flate.NewReader(bytes.NewReader(data)))
if err != nil {
return err
}
return decoder(deflated)
} | [
"func",
"maybeDeflate",
"(",
"data",
"[",
"]",
"byte",
",",
"decoder",
"func",
"(",
"[",
"]",
"byte",
")",
"error",
")",
"error",
"{",
"err",
":=",
"decoder",
"(",
"data",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"deflated",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"flate",
".",
"NewReader",
"(",
"bytes",
".",
"NewReader",
"(",
"data",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"decoder",
"(",
"deflated",
")",
"\n",
"}"
] | // maybeDeflate invokes the passed decoder over the passed data. If an error is
// returned, it then attempts to deflate the passed data before re-invoking
// the decoder over the deflated data. | [
"maybeDeflate",
"invokes",
"the",
"passed",
"decoder",
"over",
"the",
"passed",
"data",
".",
"If",
"an",
"error",
"is",
"returned",
"it",
"then",
"attempts",
"to",
"deflate",
"the",
"passed",
"data",
"before",
"re",
"-",
"invoking",
"the",
"decoder",
"over",
"the",
"deflated",
"data",
"."
] | 2506a07af0643ab4bb14100ae8c3254421cd78d7 | https://github.com/russellhaering/gosaml2/blob/2506a07af0643ab4bb14100ae8c3254421cd78d7/decode_response.go#L305-L317 |
5,888 | russellhaering/gosaml2 | decode_response.go | parseResponse | func parseResponse(xml []byte) (*etree.Document, *etree.Element, error) {
var doc *etree.Document
err := maybeDeflate(xml, func(xml []byte) error {
doc = etree.NewDocument()
return doc.ReadFromBytes(xml)
})
if err != nil {
return nil, nil, err
}
el := doc.Root()
if el == nil {
return nil, nil, fmt.Errorf("unable to parse response")
}
return doc, el, nil
} | go | func parseResponse(xml []byte) (*etree.Document, *etree.Element, error) {
var doc *etree.Document
err := maybeDeflate(xml, func(xml []byte) error {
doc = etree.NewDocument()
return doc.ReadFromBytes(xml)
})
if err != nil {
return nil, nil, err
}
el := doc.Root()
if el == nil {
return nil, nil, fmt.Errorf("unable to parse response")
}
return doc, el, nil
} | [
"func",
"parseResponse",
"(",
"xml",
"[",
"]",
"byte",
")",
"(",
"*",
"etree",
".",
"Document",
",",
"*",
"etree",
".",
"Element",
",",
"error",
")",
"{",
"var",
"doc",
"*",
"etree",
".",
"Document",
"\n\n",
"err",
":=",
"maybeDeflate",
"(",
"xml",
",",
"func",
"(",
"xml",
"[",
"]",
"byte",
")",
"error",
"{",
"doc",
"=",
"etree",
".",
"NewDocument",
"(",
")",
"\n",
"return",
"doc",
".",
"ReadFromBytes",
"(",
"xml",
")",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"el",
":=",
"doc",
".",
"Root",
"(",
")",
"\n",
"if",
"el",
"==",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"doc",
",",
"el",
",",
"nil",
"\n",
"}"
] | // parseResponse is a helper function that was refactored out so that the XML parsing behavior can be isolated and unit tested | [
"parseResponse",
"is",
"a",
"helper",
"function",
"that",
"was",
"refactored",
"out",
"so",
"that",
"the",
"XML",
"parsing",
"behavior",
"can",
"be",
"isolated",
"and",
"unit",
"tested"
] | 2506a07af0643ab4bb14100ae8c3254421cd78d7 | https://github.com/russellhaering/gosaml2/blob/2506a07af0643ab4bb14100ae8c3254421cd78d7/decode_response.go#L320-L337 |
5,889 | russellhaering/gosaml2 | types/encrypted_assertion.go | Decrypt | func (ea *EncryptedAssertion) Decrypt(cert *tls.Certificate) (*Assertion, error) {
plaintext, err := ea.DecryptBytes(cert)
if err != nil {
return nil, fmt.Errorf("Error decrypting assertion: %v", err)
}
assertion := &Assertion{}
err = xml.Unmarshal(plaintext, assertion)
if err != nil {
return nil, fmt.Errorf("Error unmarshaling assertion: %v", err)
}
return assertion, nil
} | go | func (ea *EncryptedAssertion) Decrypt(cert *tls.Certificate) (*Assertion, error) {
plaintext, err := ea.DecryptBytes(cert)
if err != nil {
return nil, fmt.Errorf("Error decrypting assertion: %v", err)
}
assertion := &Assertion{}
err = xml.Unmarshal(plaintext, assertion)
if err != nil {
return nil, fmt.Errorf("Error unmarshaling assertion: %v", err)
}
return assertion, nil
} | [
"func",
"(",
"ea",
"*",
"EncryptedAssertion",
")",
"Decrypt",
"(",
"cert",
"*",
"tls",
".",
"Certificate",
")",
"(",
"*",
"Assertion",
",",
"error",
")",
"{",
"plaintext",
",",
"err",
":=",
"ea",
".",
"DecryptBytes",
"(",
"cert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"assertion",
":=",
"&",
"Assertion",
"{",
"}",
"\n\n",
"err",
"=",
"xml",
".",
"Unmarshal",
"(",
"plaintext",
",",
"assertion",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"assertion",
",",
"nil",
"\n",
"}"
] | // Decrypt decrypts and unmarshals the EncryptedAssertion. | [
"Decrypt",
"decrypts",
"and",
"unmarshals",
"the",
"EncryptedAssertion",
"."
] | 2506a07af0643ab4bb14100ae8c3254421cd78d7 | https://github.com/russellhaering/gosaml2/blob/2506a07af0643ab4bb14100ae8c3254421cd78d7/types/encrypted_assertion.go#L69-L83 |
5,890 | russellhaering/gosaml2 | types/encrypted_key.go | DecryptSymmetricKey | func (ek *EncryptedKey) DecryptSymmetricKey(cert *tls.Certificate) (cipher.Block, error) {
if len(cert.Certificate) < 1 {
return nil, fmt.Errorf("decryption tls.Certificate has no public certs attached")
}
// The EncryptedKey may or may not include X509Data (certificate).
// If included, the EncryptedKey certificate:
// - is FYI only (fail if it does not match the SP certificate)
// - is NOT used to decrypt CipherData
if ek.X509Data != "" {
if encCert, err := base64.StdEncoding.DecodeString(ek.X509Data); err != nil {
return nil, fmt.Errorf("error decoding EncryptedKey certificate: %v", err)
} else if !bytes.Equal(cert.Certificate[0], encCert) {
return nil, fmt.Errorf("key decryption attempted with mismatched cert, SP cert(%.11s), assertion cert(%.11s)",
debugKeyFp(cert.Certificate[0]), debugKeyFp(encCert))
}
}
cipherText, err := base64.StdEncoding.DecodeString(ek.CipherValue)
if err != nil {
return nil, err
}
switch pk := cert.PrivateKey.(type) {
case *rsa.PrivateKey:
var h hash.Hash
switch ek.EncryptionMethod.DigestMethod.Algorithm {
case "", MethodSHA1:
h = sha1.New() // default
case MethodSHA256:
h = sha256.New()
case MethodSHA512:
h = sha512.New()
default:
return nil, fmt.Errorf("unsupported digest algorithm: %v",
ek.EncryptionMethod.DigestMethod.Algorithm)
}
switch ek.EncryptionMethod.Algorithm {
case "":
return nil, fmt.Errorf("missing encryption algorithm")
case MethodRSAOAEP, MethodRSAOAEP2:
pt, err := rsa.DecryptOAEP(h, rand.Reader, pk, cipherText, nil)
if err != nil {
return nil, fmt.Errorf("rsa internal error: %v", err)
}
b, err := aes.NewCipher(pt)
if err != nil {
return nil, err
}
return b, nil
default:
return nil, fmt.Errorf("unsupported encryption algorithm: %s", ek.EncryptionMethod.Algorithm)
}
}
return nil, fmt.Errorf("no cipher for decoding symmetric key")
} | go | func (ek *EncryptedKey) DecryptSymmetricKey(cert *tls.Certificate) (cipher.Block, error) {
if len(cert.Certificate) < 1 {
return nil, fmt.Errorf("decryption tls.Certificate has no public certs attached")
}
// The EncryptedKey may or may not include X509Data (certificate).
// If included, the EncryptedKey certificate:
// - is FYI only (fail if it does not match the SP certificate)
// - is NOT used to decrypt CipherData
if ek.X509Data != "" {
if encCert, err := base64.StdEncoding.DecodeString(ek.X509Data); err != nil {
return nil, fmt.Errorf("error decoding EncryptedKey certificate: %v", err)
} else if !bytes.Equal(cert.Certificate[0], encCert) {
return nil, fmt.Errorf("key decryption attempted with mismatched cert, SP cert(%.11s), assertion cert(%.11s)",
debugKeyFp(cert.Certificate[0]), debugKeyFp(encCert))
}
}
cipherText, err := base64.StdEncoding.DecodeString(ek.CipherValue)
if err != nil {
return nil, err
}
switch pk := cert.PrivateKey.(type) {
case *rsa.PrivateKey:
var h hash.Hash
switch ek.EncryptionMethod.DigestMethod.Algorithm {
case "", MethodSHA1:
h = sha1.New() // default
case MethodSHA256:
h = sha256.New()
case MethodSHA512:
h = sha512.New()
default:
return nil, fmt.Errorf("unsupported digest algorithm: %v",
ek.EncryptionMethod.DigestMethod.Algorithm)
}
switch ek.EncryptionMethod.Algorithm {
case "":
return nil, fmt.Errorf("missing encryption algorithm")
case MethodRSAOAEP, MethodRSAOAEP2:
pt, err := rsa.DecryptOAEP(h, rand.Reader, pk, cipherText, nil)
if err != nil {
return nil, fmt.Errorf("rsa internal error: %v", err)
}
b, err := aes.NewCipher(pt)
if err != nil {
return nil, err
}
return b, nil
default:
return nil, fmt.Errorf("unsupported encryption algorithm: %s", ek.EncryptionMethod.Algorithm)
}
}
return nil, fmt.Errorf("no cipher for decoding symmetric key")
} | [
"func",
"(",
"ek",
"*",
"EncryptedKey",
")",
"DecryptSymmetricKey",
"(",
"cert",
"*",
"tls",
".",
"Certificate",
")",
"(",
"cipher",
".",
"Block",
",",
"error",
")",
"{",
"if",
"len",
"(",
"cert",
".",
"Certificate",
")",
"<",
"1",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// The EncryptedKey may or may not include X509Data (certificate).",
"// If included, the EncryptedKey certificate:",
"// - is FYI only (fail if it does not match the SP certificate)",
"// - is NOT used to decrypt CipherData",
"if",
"ek",
".",
"X509Data",
"!=",
"\"",
"\"",
"{",
"if",
"encCert",
",",
"err",
":=",
"base64",
".",
"StdEncoding",
".",
"DecodeString",
"(",
"ek",
".",
"X509Data",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"else",
"if",
"!",
"bytes",
".",
"Equal",
"(",
"cert",
".",
"Certificate",
"[",
"0",
"]",
",",
"encCert",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"debugKeyFp",
"(",
"cert",
".",
"Certificate",
"[",
"0",
"]",
")",
",",
"debugKeyFp",
"(",
"encCert",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"cipherText",
",",
"err",
":=",
"base64",
".",
"StdEncoding",
".",
"DecodeString",
"(",
"ek",
".",
"CipherValue",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"switch",
"pk",
":=",
"cert",
".",
"PrivateKey",
".",
"(",
"type",
")",
"{",
"case",
"*",
"rsa",
".",
"PrivateKey",
":",
"var",
"h",
"hash",
".",
"Hash",
"\n\n",
"switch",
"ek",
".",
"EncryptionMethod",
".",
"DigestMethod",
".",
"Algorithm",
"{",
"case",
"\"",
"\"",
",",
"MethodSHA1",
":",
"h",
"=",
"sha1",
".",
"New",
"(",
")",
"// default",
"\n",
"case",
"MethodSHA256",
":",
"h",
"=",
"sha256",
".",
"New",
"(",
")",
"\n",
"case",
"MethodSHA512",
":",
"h",
"=",
"sha512",
".",
"New",
"(",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"ek",
".",
"EncryptionMethod",
".",
"DigestMethod",
".",
"Algorithm",
")",
"\n",
"}",
"\n\n",
"switch",
"ek",
".",
"EncryptionMethod",
".",
"Algorithm",
"{",
"case",
"\"",
"\"",
":",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"case",
"MethodRSAOAEP",
",",
"MethodRSAOAEP2",
":",
"pt",
",",
"err",
":=",
"rsa",
".",
"DecryptOAEP",
"(",
"h",
",",
"rand",
".",
"Reader",
",",
"pk",
",",
"cipherText",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"b",
",",
"err",
":=",
"aes",
".",
"NewCipher",
"(",
"pt",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"b",
",",
"nil",
"\n",
"default",
":",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"ek",
".",
"EncryptionMethod",
".",
"Algorithm",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | //DecryptSymmetricKey returns the private key contained in the EncryptedKey document | [
"DecryptSymmetricKey",
"returns",
"the",
"private",
"key",
"contained",
"in",
"the",
"EncryptedKey",
"document"
] | 2506a07af0643ab4bb14100ae8c3254421cd78d7 | https://github.com/russellhaering/gosaml2/blob/2506a07af0643ab4bb14100ae8c3254421cd78d7/types/encrypted_key.go#L81-L140 |
5,891 | russellhaering/gosaml2 | validate.go | VerifyAssertionConditions | func (sp *SAMLServiceProvider) VerifyAssertionConditions(assertion *types.Assertion) (*WarningInfo, error) {
warningInfo := &WarningInfo{}
now := sp.Clock.Now()
conditions := assertion.Conditions
if conditions == nil {
return nil, ErrMissingElement{Tag: ConditionsTag}
}
if conditions.NotBefore == "" {
return nil, ErrMissingElement{Tag: ConditionsTag, Attribute: NotBeforeAttr}
}
notBefore, err := time.Parse(time.RFC3339, conditions.NotBefore)
if err != nil {
return nil, ErrParsing{Tag: NotBeforeAttr, Value: conditions.NotBefore, Type: "time.RFC3339"}
}
if now.Before(notBefore) {
warningInfo.InvalidTime = true
}
if conditions.NotOnOrAfter == "" {
return nil, ErrMissingElement{Tag: ConditionsTag, Attribute: NotOnOrAfterAttr}
}
notOnOrAfter, err := time.Parse(time.RFC3339, conditions.NotOnOrAfter)
if err != nil {
return nil, ErrParsing{Tag: NotOnOrAfterAttr, Value: conditions.NotOnOrAfter, Type: "time.RFC3339"}
}
if now.After(notOnOrAfter) {
warningInfo.InvalidTime = true
}
for _, audienceRestriction := range conditions.AudienceRestrictions {
matched := false
for _, audience := range audienceRestriction.Audiences {
if audience.Value == sp.AudienceURI {
matched = true
break
}
}
if !matched {
warningInfo.NotInAudience = true
break
}
}
if conditions.OneTimeUse != nil {
warningInfo.OneTimeUse = true
}
proxyRestriction := conditions.ProxyRestriction
if proxyRestriction != nil {
proxyRestrictionInfo := &ProxyRestriction{
Count: proxyRestriction.Count,
Audience: []string{},
}
for _, audience := range proxyRestriction.Audience {
proxyRestrictionInfo.Audience = append(proxyRestrictionInfo.Audience, audience.Value)
}
warningInfo.ProxyRestriction = proxyRestrictionInfo
}
return warningInfo, nil
} | go | func (sp *SAMLServiceProvider) VerifyAssertionConditions(assertion *types.Assertion) (*WarningInfo, error) {
warningInfo := &WarningInfo{}
now := sp.Clock.Now()
conditions := assertion.Conditions
if conditions == nil {
return nil, ErrMissingElement{Tag: ConditionsTag}
}
if conditions.NotBefore == "" {
return nil, ErrMissingElement{Tag: ConditionsTag, Attribute: NotBeforeAttr}
}
notBefore, err := time.Parse(time.RFC3339, conditions.NotBefore)
if err != nil {
return nil, ErrParsing{Tag: NotBeforeAttr, Value: conditions.NotBefore, Type: "time.RFC3339"}
}
if now.Before(notBefore) {
warningInfo.InvalidTime = true
}
if conditions.NotOnOrAfter == "" {
return nil, ErrMissingElement{Tag: ConditionsTag, Attribute: NotOnOrAfterAttr}
}
notOnOrAfter, err := time.Parse(time.RFC3339, conditions.NotOnOrAfter)
if err != nil {
return nil, ErrParsing{Tag: NotOnOrAfterAttr, Value: conditions.NotOnOrAfter, Type: "time.RFC3339"}
}
if now.After(notOnOrAfter) {
warningInfo.InvalidTime = true
}
for _, audienceRestriction := range conditions.AudienceRestrictions {
matched := false
for _, audience := range audienceRestriction.Audiences {
if audience.Value == sp.AudienceURI {
matched = true
break
}
}
if !matched {
warningInfo.NotInAudience = true
break
}
}
if conditions.OneTimeUse != nil {
warningInfo.OneTimeUse = true
}
proxyRestriction := conditions.ProxyRestriction
if proxyRestriction != nil {
proxyRestrictionInfo := &ProxyRestriction{
Count: proxyRestriction.Count,
Audience: []string{},
}
for _, audience := range proxyRestriction.Audience {
proxyRestrictionInfo.Audience = append(proxyRestrictionInfo.Audience, audience.Value)
}
warningInfo.ProxyRestriction = proxyRestrictionInfo
}
return warningInfo, nil
} | [
"func",
"(",
"sp",
"*",
"SAMLServiceProvider",
")",
"VerifyAssertionConditions",
"(",
"assertion",
"*",
"types",
".",
"Assertion",
")",
"(",
"*",
"WarningInfo",
",",
"error",
")",
"{",
"warningInfo",
":=",
"&",
"WarningInfo",
"{",
"}",
"\n",
"now",
":=",
"sp",
".",
"Clock",
".",
"Now",
"(",
")",
"\n\n",
"conditions",
":=",
"assertion",
".",
"Conditions",
"\n",
"if",
"conditions",
"==",
"nil",
"{",
"return",
"nil",
",",
"ErrMissingElement",
"{",
"Tag",
":",
"ConditionsTag",
"}",
"\n",
"}",
"\n\n",
"if",
"conditions",
".",
"NotBefore",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"ErrMissingElement",
"{",
"Tag",
":",
"ConditionsTag",
",",
"Attribute",
":",
"NotBeforeAttr",
"}",
"\n",
"}",
"\n\n",
"notBefore",
",",
"err",
":=",
"time",
".",
"Parse",
"(",
"time",
".",
"RFC3339",
",",
"conditions",
".",
"NotBefore",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"ErrParsing",
"{",
"Tag",
":",
"NotBeforeAttr",
",",
"Value",
":",
"conditions",
".",
"NotBefore",
",",
"Type",
":",
"\"",
"\"",
"}",
"\n",
"}",
"\n\n",
"if",
"now",
".",
"Before",
"(",
"notBefore",
")",
"{",
"warningInfo",
".",
"InvalidTime",
"=",
"true",
"\n",
"}",
"\n\n",
"if",
"conditions",
".",
"NotOnOrAfter",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"ErrMissingElement",
"{",
"Tag",
":",
"ConditionsTag",
",",
"Attribute",
":",
"NotOnOrAfterAttr",
"}",
"\n",
"}",
"\n\n",
"notOnOrAfter",
",",
"err",
":=",
"time",
".",
"Parse",
"(",
"time",
".",
"RFC3339",
",",
"conditions",
".",
"NotOnOrAfter",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"ErrParsing",
"{",
"Tag",
":",
"NotOnOrAfterAttr",
",",
"Value",
":",
"conditions",
".",
"NotOnOrAfter",
",",
"Type",
":",
"\"",
"\"",
"}",
"\n",
"}",
"\n\n",
"if",
"now",
".",
"After",
"(",
"notOnOrAfter",
")",
"{",
"warningInfo",
".",
"InvalidTime",
"=",
"true",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"audienceRestriction",
":=",
"range",
"conditions",
".",
"AudienceRestrictions",
"{",
"matched",
":=",
"false",
"\n\n",
"for",
"_",
",",
"audience",
":=",
"range",
"audienceRestriction",
".",
"Audiences",
"{",
"if",
"audience",
".",
"Value",
"==",
"sp",
".",
"AudienceURI",
"{",
"matched",
"=",
"true",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"!",
"matched",
"{",
"warningInfo",
".",
"NotInAudience",
"=",
"true",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"conditions",
".",
"OneTimeUse",
"!=",
"nil",
"{",
"warningInfo",
".",
"OneTimeUse",
"=",
"true",
"\n",
"}",
"\n\n",
"proxyRestriction",
":=",
"conditions",
".",
"ProxyRestriction",
"\n",
"if",
"proxyRestriction",
"!=",
"nil",
"{",
"proxyRestrictionInfo",
":=",
"&",
"ProxyRestriction",
"{",
"Count",
":",
"proxyRestriction",
".",
"Count",
",",
"Audience",
":",
"[",
"]",
"string",
"{",
"}",
",",
"}",
"\n\n",
"for",
"_",
",",
"audience",
":=",
"range",
"proxyRestriction",
".",
"Audience",
"{",
"proxyRestrictionInfo",
".",
"Audience",
"=",
"append",
"(",
"proxyRestrictionInfo",
".",
"Audience",
",",
"audience",
".",
"Value",
")",
"\n",
"}",
"\n\n",
"warningInfo",
".",
"ProxyRestriction",
"=",
"proxyRestrictionInfo",
"\n",
"}",
"\n\n",
"return",
"warningInfo",
",",
"nil",
"\n",
"}"
] | //VerifyAssertionConditions inspects an assertion element and makes sure that
//all SAML2 contracts are upheld. | [
"VerifyAssertionConditions",
"inspects",
"an",
"assertion",
"element",
"and",
"makes",
"sure",
"that",
"all",
"SAML2",
"contracts",
"are",
"upheld",
"."
] | 2506a07af0643ab4bb14100ae8c3254421cd78d7 | https://github.com/russellhaering/gosaml2/blob/2506a07af0643ab4bb14100ae8c3254421cd78d7/validate.go#L48-L118 |
5,892 | russellhaering/gosaml2 | validate.go | Validate | func (sp *SAMLServiceProvider) Validate(response *types.Response) error {
err := sp.validateResponseAttributes(response)
if err != nil {
return err
}
if len(response.Assertions) == 0 {
return ErrMissingAssertion
}
issuer := response.Issuer
if issuer == nil {
// FIXME?: SAML Core 2.0 Section 3.2.2 has Response.Issuer as [Optional]
return ErrMissingElement{Tag: IssuerTag}
}
if sp.IdentityProviderIssuer != "" && response.Issuer.Value != sp.IdentityProviderIssuer {
return ErrInvalidValue{
Key: IssuerTag,
Expected: sp.IdentityProviderIssuer,
Actual: response.Issuer.Value,
}
}
status := response.Status
if status == nil {
return ErrMissingElement{Tag: StatusTag}
}
statusCode := status.StatusCode
if statusCode == nil {
return ErrMissingElement{Tag: StatusCodeTag}
}
if statusCode.Value != StatusCodeSuccess {
return ErrInvalidValue{
Key: StatusCodeTag,
Expected: StatusCodeSuccess,
Actual: statusCode.Value,
}
}
for _, assertion := range response.Assertions {
issuer = assertion.Issuer
if issuer == nil {
return ErrMissingElement{Tag: IssuerTag}
}
if sp.IdentityProviderIssuer != "" && assertion.Issuer.Value != sp.IdentityProviderIssuer {
return ErrInvalidValue{
Key: IssuerTag,
Expected: sp.IdentityProviderIssuer,
Actual: issuer.Value,
}
}
subject := assertion.Subject
if subject == nil {
return ErrMissingElement{Tag: SubjectTag}
}
subjectConfirmation := subject.SubjectConfirmation
if subjectConfirmation == nil {
return ErrMissingElement{Tag: SubjectConfirmationTag}
}
if subjectConfirmation.Method != SubjMethodBearer {
return ErrInvalidValue{
Reason: ReasonUnsupported,
Key: SubjectConfirmationTag,
Expected: SubjMethodBearer,
Actual: subjectConfirmation.Method,
}
}
subjectConfirmationData := subjectConfirmation.SubjectConfirmationData
if subjectConfirmationData == nil {
return ErrMissingElement{Tag: SubjectConfirmationDataTag}
}
if subjectConfirmationData.Recipient != sp.AssertionConsumerServiceURL {
return ErrInvalidValue{
Key: RecipientAttr,
Expected: sp.AssertionConsumerServiceURL,
Actual: subjectConfirmationData.Recipient,
}
}
if subjectConfirmationData.NotOnOrAfter == "" {
return ErrMissingElement{Tag: SubjectConfirmationDataTag, Attribute: NotOnOrAfterAttr}
}
notOnOrAfter, err := time.Parse(time.RFC3339, subjectConfirmationData.NotOnOrAfter)
if err != nil {
return ErrParsing{Tag: NotOnOrAfterAttr, Value: subjectConfirmationData.NotOnOrAfter, Type: "time.RFC3339"}
}
now := sp.Clock.Now()
if now.After(notOnOrAfter) {
return ErrInvalidValue{
Reason: ReasonExpired,
Key: NotOnOrAfterAttr,
Expected: now.Format(time.RFC3339),
Actual: subjectConfirmationData.NotOnOrAfter,
}
}
}
return nil
} | go | func (sp *SAMLServiceProvider) Validate(response *types.Response) error {
err := sp.validateResponseAttributes(response)
if err != nil {
return err
}
if len(response.Assertions) == 0 {
return ErrMissingAssertion
}
issuer := response.Issuer
if issuer == nil {
// FIXME?: SAML Core 2.0 Section 3.2.2 has Response.Issuer as [Optional]
return ErrMissingElement{Tag: IssuerTag}
}
if sp.IdentityProviderIssuer != "" && response.Issuer.Value != sp.IdentityProviderIssuer {
return ErrInvalidValue{
Key: IssuerTag,
Expected: sp.IdentityProviderIssuer,
Actual: response.Issuer.Value,
}
}
status := response.Status
if status == nil {
return ErrMissingElement{Tag: StatusTag}
}
statusCode := status.StatusCode
if statusCode == nil {
return ErrMissingElement{Tag: StatusCodeTag}
}
if statusCode.Value != StatusCodeSuccess {
return ErrInvalidValue{
Key: StatusCodeTag,
Expected: StatusCodeSuccess,
Actual: statusCode.Value,
}
}
for _, assertion := range response.Assertions {
issuer = assertion.Issuer
if issuer == nil {
return ErrMissingElement{Tag: IssuerTag}
}
if sp.IdentityProviderIssuer != "" && assertion.Issuer.Value != sp.IdentityProviderIssuer {
return ErrInvalidValue{
Key: IssuerTag,
Expected: sp.IdentityProviderIssuer,
Actual: issuer.Value,
}
}
subject := assertion.Subject
if subject == nil {
return ErrMissingElement{Tag: SubjectTag}
}
subjectConfirmation := subject.SubjectConfirmation
if subjectConfirmation == nil {
return ErrMissingElement{Tag: SubjectConfirmationTag}
}
if subjectConfirmation.Method != SubjMethodBearer {
return ErrInvalidValue{
Reason: ReasonUnsupported,
Key: SubjectConfirmationTag,
Expected: SubjMethodBearer,
Actual: subjectConfirmation.Method,
}
}
subjectConfirmationData := subjectConfirmation.SubjectConfirmationData
if subjectConfirmationData == nil {
return ErrMissingElement{Tag: SubjectConfirmationDataTag}
}
if subjectConfirmationData.Recipient != sp.AssertionConsumerServiceURL {
return ErrInvalidValue{
Key: RecipientAttr,
Expected: sp.AssertionConsumerServiceURL,
Actual: subjectConfirmationData.Recipient,
}
}
if subjectConfirmationData.NotOnOrAfter == "" {
return ErrMissingElement{Tag: SubjectConfirmationDataTag, Attribute: NotOnOrAfterAttr}
}
notOnOrAfter, err := time.Parse(time.RFC3339, subjectConfirmationData.NotOnOrAfter)
if err != nil {
return ErrParsing{Tag: NotOnOrAfterAttr, Value: subjectConfirmationData.NotOnOrAfter, Type: "time.RFC3339"}
}
now := sp.Clock.Now()
if now.After(notOnOrAfter) {
return ErrInvalidValue{
Reason: ReasonExpired,
Key: NotOnOrAfterAttr,
Expected: now.Format(time.RFC3339),
Actual: subjectConfirmationData.NotOnOrAfter,
}
}
}
return nil
} | [
"func",
"(",
"sp",
"*",
"SAMLServiceProvider",
")",
"Validate",
"(",
"response",
"*",
"types",
".",
"Response",
")",
"error",
"{",
"err",
":=",
"sp",
".",
"validateResponseAttributes",
"(",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"response",
".",
"Assertions",
")",
"==",
"0",
"{",
"return",
"ErrMissingAssertion",
"\n",
"}",
"\n\n",
"issuer",
":=",
"response",
".",
"Issuer",
"\n",
"if",
"issuer",
"==",
"nil",
"{",
"// FIXME?: SAML Core 2.0 Section 3.2.2 has Response.Issuer as [Optional]",
"return",
"ErrMissingElement",
"{",
"Tag",
":",
"IssuerTag",
"}",
"\n",
"}",
"\n\n",
"if",
"sp",
".",
"IdentityProviderIssuer",
"!=",
"\"",
"\"",
"&&",
"response",
".",
"Issuer",
".",
"Value",
"!=",
"sp",
".",
"IdentityProviderIssuer",
"{",
"return",
"ErrInvalidValue",
"{",
"Key",
":",
"IssuerTag",
",",
"Expected",
":",
"sp",
".",
"IdentityProviderIssuer",
",",
"Actual",
":",
"response",
".",
"Issuer",
".",
"Value",
",",
"}",
"\n",
"}",
"\n\n",
"status",
":=",
"response",
".",
"Status",
"\n",
"if",
"status",
"==",
"nil",
"{",
"return",
"ErrMissingElement",
"{",
"Tag",
":",
"StatusTag",
"}",
"\n",
"}",
"\n\n",
"statusCode",
":=",
"status",
".",
"StatusCode",
"\n",
"if",
"statusCode",
"==",
"nil",
"{",
"return",
"ErrMissingElement",
"{",
"Tag",
":",
"StatusCodeTag",
"}",
"\n",
"}",
"\n\n",
"if",
"statusCode",
".",
"Value",
"!=",
"StatusCodeSuccess",
"{",
"return",
"ErrInvalidValue",
"{",
"Key",
":",
"StatusCodeTag",
",",
"Expected",
":",
"StatusCodeSuccess",
",",
"Actual",
":",
"statusCode",
".",
"Value",
",",
"}",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"assertion",
":=",
"range",
"response",
".",
"Assertions",
"{",
"issuer",
"=",
"assertion",
".",
"Issuer",
"\n",
"if",
"issuer",
"==",
"nil",
"{",
"return",
"ErrMissingElement",
"{",
"Tag",
":",
"IssuerTag",
"}",
"\n",
"}",
"\n",
"if",
"sp",
".",
"IdentityProviderIssuer",
"!=",
"\"",
"\"",
"&&",
"assertion",
".",
"Issuer",
".",
"Value",
"!=",
"sp",
".",
"IdentityProviderIssuer",
"{",
"return",
"ErrInvalidValue",
"{",
"Key",
":",
"IssuerTag",
",",
"Expected",
":",
"sp",
".",
"IdentityProviderIssuer",
",",
"Actual",
":",
"issuer",
".",
"Value",
",",
"}",
"\n",
"}",
"\n\n",
"subject",
":=",
"assertion",
".",
"Subject",
"\n",
"if",
"subject",
"==",
"nil",
"{",
"return",
"ErrMissingElement",
"{",
"Tag",
":",
"SubjectTag",
"}",
"\n",
"}",
"\n\n",
"subjectConfirmation",
":=",
"subject",
".",
"SubjectConfirmation",
"\n",
"if",
"subjectConfirmation",
"==",
"nil",
"{",
"return",
"ErrMissingElement",
"{",
"Tag",
":",
"SubjectConfirmationTag",
"}",
"\n",
"}",
"\n\n",
"if",
"subjectConfirmation",
".",
"Method",
"!=",
"SubjMethodBearer",
"{",
"return",
"ErrInvalidValue",
"{",
"Reason",
":",
"ReasonUnsupported",
",",
"Key",
":",
"SubjectConfirmationTag",
",",
"Expected",
":",
"SubjMethodBearer",
",",
"Actual",
":",
"subjectConfirmation",
".",
"Method",
",",
"}",
"\n",
"}",
"\n\n",
"subjectConfirmationData",
":=",
"subjectConfirmation",
".",
"SubjectConfirmationData",
"\n",
"if",
"subjectConfirmationData",
"==",
"nil",
"{",
"return",
"ErrMissingElement",
"{",
"Tag",
":",
"SubjectConfirmationDataTag",
"}",
"\n",
"}",
"\n\n",
"if",
"subjectConfirmationData",
".",
"Recipient",
"!=",
"sp",
".",
"AssertionConsumerServiceURL",
"{",
"return",
"ErrInvalidValue",
"{",
"Key",
":",
"RecipientAttr",
",",
"Expected",
":",
"sp",
".",
"AssertionConsumerServiceURL",
",",
"Actual",
":",
"subjectConfirmationData",
".",
"Recipient",
",",
"}",
"\n",
"}",
"\n\n",
"if",
"subjectConfirmationData",
".",
"NotOnOrAfter",
"==",
"\"",
"\"",
"{",
"return",
"ErrMissingElement",
"{",
"Tag",
":",
"SubjectConfirmationDataTag",
",",
"Attribute",
":",
"NotOnOrAfterAttr",
"}",
"\n",
"}",
"\n\n",
"notOnOrAfter",
",",
"err",
":=",
"time",
".",
"Parse",
"(",
"time",
".",
"RFC3339",
",",
"subjectConfirmationData",
".",
"NotOnOrAfter",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"ErrParsing",
"{",
"Tag",
":",
"NotOnOrAfterAttr",
",",
"Value",
":",
"subjectConfirmationData",
".",
"NotOnOrAfter",
",",
"Type",
":",
"\"",
"\"",
"}",
"\n",
"}",
"\n\n",
"now",
":=",
"sp",
".",
"Clock",
".",
"Now",
"(",
")",
"\n",
"if",
"now",
".",
"After",
"(",
"notOnOrAfter",
")",
"{",
"return",
"ErrInvalidValue",
"{",
"Reason",
":",
"ReasonExpired",
",",
"Key",
":",
"NotOnOrAfterAttr",
",",
"Expected",
":",
"now",
".",
"Format",
"(",
"time",
".",
"RFC3339",
")",
",",
"Actual",
":",
"subjectConfirmationData",
".",
"NotOnOrAfter",
",",
"}",
"\n",
"}",
"\n\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | //Validate ensures that the assertion passed is valid for the current Service
//Provider. | [
"Validate",
"ensures",
"that",
"the",
"assertion",
"passed",
"is",
"valid",
"for",
"the",
"current",
"Service",
"Provider",
"."
] | 2506a07af0643ab4bb14100ae8c3254421cd78d7 | https://github.com/russellhaering/gosaml2/blob/2506a07af0643ab4bb14100ae8c3254421cd78d7/validate.go#L122-L231 |
5,893 | jacobsa/go-serial | serial/open_linux.go | makeTermios2 | func makeTermios2(options OpenOptions) (*termios2, error) {
// Sanity check inter-character timeout and minimum read size options.
vtime := uint(round(float64(options.InterCharacterTimeout)/100.0) * 100)
vmin := options.MinimumReadSize
if vmin == 0 && vtime < 100 {
return nil, errors.New("invalid values for InterCharacterTimeout and MinimumReadSize")
}
if vtime > 25500 {
return nil, errors.New("invalid value for InterCharacterTimeout")
}
ccOpts := [kNCCS]cc_t{}
ccOpts[syscall.VTIME] = cc_t(vtime / 100)
ccOpts[syscall.VMIN] = cc_t(vmin)
t2 := &termios2{
c_cflag: syscall.CLOCAL | syscall.CREAD | kBOTHER,
c_ispeed: speed_t(options.BaudRate),
c_ospeed: speed_t(options.BaudRate),
c_cc: ccOpts,
}
switch options.StopBits {
case 1:
case 2:
t2.c_cflag |= syscall.CSTOPB
default:
return nil, errors.New("invalid setting for StopBits")
}
switch options.ParityMode {
case PARITY_NONE:
case PARITY_ODD:
t2.c_cflag |= syscall.PARENB
t2.c_cflag |= syscall.PARODD
case PARITY_EVEN:
t2.c_cflag |= syscall.PARENB
default:
return nil, errors.New("invalid setting for ParityMode")
}
switch options.DataBits {
case 5:
t2.c_cflag |= syscall.CS5
case 6:
t2.c_cflag |= syscall.CS6
case 7:
t2.c_cflag |= syscall.CS7
case 8:
t2.c_cflag |= syscall.CS8
default:
return nil, errors.New("invalid setting for DataBits")
}
if options.RTSCTSFlowControl {
t2.c_cflag |= unix.CRTSCTS
}
return t2, nil
} | go | func makeTermios2(options OpenOptions) (*termios2, error) {
// Sanity check inter-character timeout and minimum read size options.
vtime := uint(round(float64(options.InterCharacterTimeout)/100.0) * 100)
vmin := options.MinimumReadSize
if vmin == 0 && vtime < 100 {
return nil, errors.New("invalid values for InterCharacterTimeout and MinimumReadSize")
}
if vtime > 25500 {
return nil, errors.New("invalid value for InterCharacterTimeout")
}
ccOpts := [kNCCS]cc_t{}
ccOpts[syscall.VTIME] = cc_t(vtime / 100)
ccOpts[syscall.VMIN] = cc_t(vmin)
t2 := &termios2{
c_cflag: syscall.CLOCAL | syscall.CREAD | kBOTHER,
c_ispeed: speed_t(options.BaudRate),
c_ospeed: speed_t(options.BaudRate),
c_cc: ccOpts,
}
switch options.StopBits {
case 1:
case 2:
t2.c_cflag |= syscall.CSTOPB
default:
return nil, errors.New("invalid setting for StopBits")
}
switch options.ParityMode {
case PARITY_NONE:
case PARITY_ODD:
t2.c_cflag |= syscall.PARENB
t2.c_cflag |= syscall.PARODD
case PARITY_EVEN:
t2.c_cflag |= syscall.PARENB
default:
return nil, errors.New("invalid setting for ParityMode")
}
switch options.DataBits {
case 5:
t2.c_cflag |= syscall.CS5
case 6:
t2.c_cflag |= syscall.CS6
case 7:
t2.c_cflag |= syscall.CS7
case 8:
t2.c_cflag |= syscall.CS8
default:
return nil, errors.New("invalid setting for DataBits")
}
if options.RTSCTSFlowControl {
t2.c_cflag |= unix.CRTSCTS
}
return t2, nil
} | [
"func",
"makeTermios2",
"(",
"options",
"OpenOptions",
")",
"(",
"*",
"termios2",
",",
"error",
")",
"{",
"// Sanity check inter-character timeout and minimum read size options.",
"vtime",
":=",
"uint",
"(",
"round",
"(",
"float64",
"(",
"options",
".",
"InterCharacterTimeout",
")",
"/",
"100.0",
")",
"*",
"100",
")",
"\n",
"vmin",
":=",
"options",
".",
"MinimumReadSize",
"\n\n",
"if",
"vmin",
"==",
"0",
"&&",
"vtime",
"<",
"100",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"vtime",
">",
"25500",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"ccOpts",
":=",
"[",
"kNCCS",
"]",
"cc_t",
"{",
"}",
"\n",
"ccOpts",
"[",
"syscall",
".",
"VTIME",
"]",
"=",
"cc_t",
"(",
"vtime",
"/",
"100",
")",
"\n",
"ccOpts",
"[",
"syscall",
".",
"VMIN",
"]",
"=",
"cc_t",
"(",
"vmin",
")",
"\n\n",
"t2",
":=",
"&",
"termios2",
"{",
"c_cflag",
":",
"syscall",
".",
"CLOCAL",
"|",
"syscall",
".",
"CREAD",
"|",
"kBOTHER",
",",
"c_ispeed",
":",
"speed_t",
"(",
"options",
".",
"BaudRate",
")",
",",
"c_ospeed",
":",
"speed_t",
"(",
"options",
".",
"BaudRate",
")",
",",
"c_cc",
":",
"ccOpts",
",",
"}",
"\n\n",
"switch",
"options",
".",
"StopBits",
"{",
"case",
"1",
":",
"case",
"2",
":",
"t2",
".",
"c_cflag",
"|=",
"syscall",
".",
"CSTOPB",
"\n\n",
"default",
":",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"switch",
"options",
".",
"ParityMode",
"{",
"case",
"PARITY_NONE",
":",
"case",
"PARITY_ODD",
":",
"t2",
".",
"c_cflag",
"|=",
"syscall",
".",
"PARENB",
"\n",
"t2",
".",
"c_cflag",
"|=",
"syscall",
".",
"PARODD",
"\n\n",
"case",
"PARITY_EVEN",
":",
"t2",
".",
"c_cflag",
"|=",
"syscall",
".",
"PARENB",
"\n\n",
"default",
":",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"switch",
"options",
".",
"DataBits",
"{",
"case",
"5",
":",
"t2",
".",
"c_cflag",
"|=",
"syscall",
".",
"CS5",
"\n",
"case",
"6",
":",
"t2",
".",
"c_cflag",
"|=",
"syscall",
".",
"CS6",
"\n",
"case",
"7",
":",
"t2",
".",
"c_cflag",
"|=",
"syscall",
".",
"CS7",
"\n",
"case",
"8",
":",
"t2",
".",
"c_cflag",
"|=",
"syscall",
".",
"CS8",
"\n",
"default",
":",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"options",
".",
"RTSCTSFlowControl",
"{",
"t2",
".",
"c_cflag",
"|=",
"unix",
".",
"CRTSCTS",
"\n",
"}",
"\n\n",
"return",
"t2",
",",
"nil",
"\n",
"}"
] | //
// Returns a pointer to an instantiates termios2 struct, based on the given
// OpenOptions. Termios2 is a Linux extension which allows arbitrary baud rates
// to be specified.
// | [
"Returns",
"a",
"pointer",
"to",
"an",
"instantiates",
"termios2",
"struct",
"based",
"on",
"the",
"given",
"OpenOptions",
".",
"Termios2",
"is",
"a",
"Linux",
"extension",
"which",
"allows",
"arbitrary",
"baud",
"rates",
"to",
"be",
"specified",
"."
] | 15cf729a72d49e837fa047a4142fa6e4d5ab45a1 | https://github.com/jacobsa/go-serial/blob/15cf729a72d49e837fa047a4142fa6e4d5ab45a1/serial/open_linux.go#L73-L139 |
5,894 | jacobsa/go-serial | serial/open_darwin.go | setTermios | func setTermios(fd uintptr, src *termios) error {
// Make the ioctl syscall that sets the termios struct.
r1, _, errno :=
syscall.Syscall(
syscall.SYS_IOCTL,
fd,
uintptr(kTIOCSETA),
uintptr(unsafe.Pointer(src)))
// Did the syscall return an error?
if errno != 0 {
return os.NewSyscallError("SYS_IOCTL", errno)
}
// Just in case, check the return value as well.
if r1 != 0 {
return errors.New("Unknown error from SYS_IOCTL.")
}
return nil
} | go | func setTermios(fd uintptr, src *termios) error {
// Make the ioctl syscall that sets the termios struct.
r1, _, errno :=
syscall.Syscall(
syscall.SYS_IOCTL,
fd,
uintptr(kTIOCSETA),
uintptr(unsafe.Pointer(src)))
// Did the syscall return an error?
if errno != 0 {
return os.NewSyscallError("SYS_IOCTL", errno)
}
// Just in case, check the return value as well.
if r1 != 0 {
return errors.New("Unknown error from SYS_IOCTL.")
}
return nil
} | [
"func",
"setTermios",
"(",
"fd",
"uintptr",
",",
"src",
"*",
"termios",
")",
"error",
"{",
"// Make the ioctl syscall that sets the termios struct.",
"r1",
",",
"_",
",",
"errno",
":=",
"syscall",
".",
"Syscall",
"(",
"syscall",
".",
"SYS_IOCTL",
",",
"fd",
",",
"uintptr",
"(",
"kTIOCSETA",
")",
",",
"uintptr",
"(",
"unsafe",
".",
"Pointer",
"(",
"src",
")",
")",
")",
"\n\n",
"// Did the syscall return an error?",
"if",
"errno",
"!=",
"0",
"{",
"return",
"os",
".",
"NewSyscallError",
"(",
"\"",
"\"",
",",
"errno",
")",
"\n",
"}",
"\n\n",
"// Just in case, check the return value as well.",
"if",
"r1",
"!=",
"0",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // setTermios updates the termios struct associated with a serial port file
// descriptor. This sets appropriate options for how the OS interacts with the
// port. | [
"setTermios",
"updates",
"the",
"termios",
"struct",
"associated",
"with",
"a",
"serial",
"port",
"file",
"descriptor",
".",
"This",
"sets",
"appropriate",
"options",
"for",
"how",
"the",
"OS",
"interacts",
"with",
"the",
"port",
"."
] | 15cf729a72d49e837fa047a4142fa6e4d5ab45a1 | https://github.com/jacobsa/go-serial/blob/15cf729a72d49e837fa047a4142fa6e4d5ab45a1/serial/open_darwin.go#L87-L107 |
5,895 | judwhite/go-svc | svc/svc_windows.go | Execute | func (ws *windowsService) Execute(args []string, r <-chan wsvc.ChangeRequest, changes chan<- wsvc.Status) (bool, uint32) {
const cmdsAccepted = wsvc.AcceptStop | wsvc.AcceptShutdown
changes <- wsvc.Status{State: wsvc.StartPending}
if err := ws.i.Start(); err != nil {
ws.setError(err)
return true, 1
}
changes <- wsvc.Status{State: wsvc.Running, Accepts: cmdsAccepted}
loop:
for {
c := <-r
switch c.Cmd {
case wsvc.Interrogate:
changes <- c.CurrentStatus
case wsvc.Stop, wsvc.Shutdown:
changes <- wsvc.Status{State: wsvc.StopPending}
err := ws.i.Stop()
if err != nil {
ws.setError(err)
return true, 2
}
break loop
default:
continue loop
}
}
return false, 0
} | go | func (ws *windowsService) Execute(args []string, r <-chan wsvc.ChangeRequest, changes chan<- wsvc.Status) (bool, uint32) {
const cmdsAccepted = wsvc.AcceptStop | wsvc.AcceptShutdown
changes <- wsvc.Status{State: wsvc.StartPending}
if err := ws.i.Start(); err != nil {
ws.setError(err)
return true, 1
}
changes <- wsvc.Status{State: wsvc.Running, Accepts: cmdsAccepted}
loop:
for {
c := <-r
switch c.Cmd {
case wsvc.Interrogate:
changes <- c.CurrentStatus
case wsvc.Stop, wsvc.Shutdown:
changes <- wsvc.Status{State: wsvc.StopPending}
err := ws.i.Stop()
if err != nil {
ws.setError(err)
return true, 2
}
break loop
default:
continue loop
}
}
return false, 0
} | [
"func",
"(",
"ws",
"*",
"windowsService",
")",
"Execute",
"(",
"args",
"[",
"]",
"string",
",",
"r",
"<-",
"chan",
"wsvc",
".",
"ChangeRequest",
",",
"changes",
"chan",
"<-",
"wsvc",
".",
"Status",
")",
"(",
"bool",
",",
"uint32",
")",
"{",
"const",
"cmdsAccepted",
"=",
"wsvc",
".",
"AcceptStop",
"|",
"wsvc",
".",
"AcceptShutdown",
"\n",
"changes",
"<-",
"wsvc",
".",
"Status",
"{",
"State",
":",
"wsvc",
".",
"StartPending",
"}",
"\n\n",
"if",
"err",
":=",
"ws",
".",
"i",
".",
"Start",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"ws",
".",
"setError",
"(",
"err",
")",
"\n",
"return",
"true",
",",
"1",
"\n",
"}",
"\n\n",
"changes",
"<-",
"wsvc",
".",
"Status",
"{",
"State",
":",
"wsvc",
".",
"Running",
",",
"Accepts",
":",
"cmdsAccepted",
"}",
"\n",
"loop",
":",
"for",
"{",
"c",
":=",
"<-",
"r",
"\n",
"switch",
"c",
".",
"Cmd",
"{",
"case",
"wsvc",
".",
"Interrogate",
":",
"changes",
"<-",
"c",
".",
"CurrentStatus",
"\n",
"case",
"wsvc",
".",
"Stop",
",",
"wsvc",
".",
"Shutdown",
":",
"changes",
"<-",
"wsvc",
".",
"Status",
"{",
"State",
":",
"wsvc",
".",
"StopPending",
"}",
"\n",
"err",
":=",
"ws",
".",
"i",
".",
"Stop",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"ws",
".",
"setError",
"(",
"err",
")",
"\n",
"return",
"true",
",",
"2",
"\n",
"}",
"\n",
"break",
"loop",
"\n",
"default",
":",
"continue",
"loop",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"false",
",",
"0",
"\n",
"}"
] | // Execute is invoked by Windows | [
"Execute",
"is",
"invoked",
"by",
"Windows"
] | d83e900e4a688aad49f41263bebf8793f0bf6add | https://github.com/judwhite/go-svc/blob/d83e900e4a688aad49f41263bebf8793f0bf6add/svc/svc_windows.go#L125-L155 |
5,896 | judwhite/go-svc | svc/svc_other.go | Run | func Run(service Service, sig ...os.Signal) error {
env := environment{}
if err := service.Init(env); err != nil {
return err
}
if err := service.Start(); err != nil {
return err
}
if len(sig) == 0 {
sig = []os.Signal{syscall.SIGINT, syscall.SIGTERM}
}
signalChan := make(chan os.Signal, 1)
signalNotify(signalChan, sig...)
<-signalChan
return service.Stop()
} | go | func Run(service Service, sig ...os.Signal) error {
env := environment{}
if err := service.Init(env); err != nil {
return err
}
if err := service.Start(); err != nil {
return err
}
if len(sig) == 0 {
sig = []os.Signal{syscall.SIGINT, syscall.SIGTERM}
}
signalChan := make(chan os.Signal, 1)
signalNotify(signalChan, sig...)
<-signalChan
return service.Stop()
} | [
"func",
"Run",
"(",
"service",
"Service",
",",
"sig",
"...",
"os",
".",
"Signal",
")",
"error",
"{",
"env",
":=",
"environment",
"{",
"}",
"\n",
"if",
"err",
":=",
"service",
".",
"Init",
"(",
"env",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"service",
".",
"Start",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"sig",
")",
"==",
"0",
"{",
"sig",
"=",
"[",
"]",
"os",
".",
"Signal",
"{",
"syscall",
".",
"SIGINT",
",",
"syscall",
".",
"SIGTERM",
"}",
"\n",
"}",
"\n\n",
"signalChan",
":=",
"make",
"(",
"chan",
"os",
".",
"Signal",
",",
"1",
")",
"\n",
"signalNotify",
"(",
"signalChan",
",",
"sig",
"...",
")",
"\n",
"<-",
"signalChan",
"\n\n",
"return",
"service",
".",
"Stop",
"(",
")",
"\n",
"}"
] | // Run runs your Service.
//
// Run will block until one of the signals specified in sig is received.
// If sig is empty syscall.SIGINT and syscall.SIGTERM are used by default. | [
"Run",
"runs",
"your",
"Service",
".",
"Run",
"will",
"block",
"until",
"one",
"of",
"the",
"signals",
"specified",
"in",
"sig",
"is",
"received",
".",
"If",
"sig",
"is",
"empty",
"syscall",
".",
"SIGINT",
"and",
"syscall",
".",
"SIGTERM",
"are",
"used",
"by",
"default",
"."
] | d83e900e4a688aad49f41263bebf8793f0bf6add | https://github.com/judwhite/go-svc/blob/d83e900e4a688aad49f41263bebf8793f0bf6add/svc/svc_other.go#L14-L33 |
5,897 | z7zmey/php-parser | node/stmt/n_switch.go | NewSwitch | func NewSwitch(Cond node.Node, CaseList *CaseList) *Switch {
return &Switch{
FreeFloating: nil,
Cond: Cond,
CaseList: CaseList,
}
} | go | func NewSwitch(Cond node.Node, CaseList *CaseList) *Switch {
return &Switch{
FreeFloating: nil,
Cond: Cond,
CaseList: CaseList,
}
} | [
"func",
"NewSwitch",
"(",
"Cond",
"node",
".",
"Node",
",",
"CaseList",
"*",
"CaseList",
")",
"*",
"Switch",
"{",
"return",
"&",
"Switch",
"{",
"FreeFloating",
":",
"nil",
",",
"Cond",
":",
"Cond",
",",
"CaseList",
":",
"CaseList",
",",
"}",
"\n",
"}"
] | // NewSwitch node constructor | [
"NewSwitch",
"node",
"constructor"
] | 394f8821001f38fe5b4c4aaffd4fa20e50927a3f | https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/stmt/n_switch.go#L19-L25 |
5,898 | z7zmey/php-parser | node/stmt/n_constant.go | NewConstant | func NewConstant(ConstantName node.Node, Expr node.Node, PhpDocComment string) *Constant {
return &Constant{
FreeFloating: nil,
PhpDocComment: PhpDocComment,
ConstantName: ConstantName,
Expr: Expr,
}
} | go | func NewConstant(ConstantName node.Node, Expr node.Node, PhpDocComment string) *Constant {
return &Constant{
FreeFloating: nil,
PhpDocComment: PhpDocComment,
ConstantName: ConstantName,
Expr: Expr,
}
} | [
"func",
"NewConstant",
"(",
"ConstantName",
"node",
".",
"Node",
",",
"Expr",
"node",
".",
"Node",
",",
"PhpDocComment",
"string",
")",
"*",
"Constant",
"{",
"return",
"&",
"Constant",
"{",
"FreeFloating",
":",
"nil",
",",
"PhpDocComment",
":",
"PhpDocComment",
",",
"ConstantName",
":",
"ConstantName",
",",
"Expr",
":",
"Expr",
",",
"}",
"\n",
"}"
] | // NewConstant node constructor | [
"NewConstant",
"node",
"constructor"
] | 394f8821001f38fe5b4c4aaffd4fa20e50927a3f | https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/stmt/n_constant.go#L20-L27 |
5,899 | z7zmey/php-parser | node/expr/binary/n_identical.go | NewIdentical | func NewIdentical(Variable node.Node, Expression node.Node) *Identical {
return &Identical{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
} | go | func NewIdentical(Variable node.Node, Expression node.Node) *Identical {
return &Identical{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
} | [
"func",
"NewIdentical",
"(",
"Variable",
"node",
".",
"Node",
",",
"Expression",
"node",
".",
"Node",
")",
"*",
"Identical",
"{",
"return",
"&",
"Identical",
"{",
"FreeFloating",
":",
"nil",
",",
"Left",
":",
"Variable",
",",
"Right",
":",
"Expression",
",",
"}",
"\n",
"}"
] | // NewIdentical node constructor | [
"NewIdentical",
"node",
"constructor"
] | 394f8821001f38fe5b4c4aaffd4fa20e50927a3f | https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/binary/n_identical.go#L19-L25 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.