Datasets:

Anonymous2023

/

KGSum

like 0

[ "increments", "and", "returns", "pending", "predecessor", "task", "count" ]

[ "public", "int", "increment", "and", "get", "pending", "predecessor", "tasks", "(", ")", "{", "return", "number", "of", "pending", "predecessor", "tasks", "increment", "and", "get", "(", ")", ";", "}" ]

[ "actually", "resolve", "the", "given", "exception", "that", "got", "thrown", "during", "handler", "execution", ",", "returning", "a", "{", "@", "link", "model", "and", "view", "}", "that", "represents", "a", "specific", "error", "page", "if", "appropriate", "may", "be", "overridden", "in", "subclasses", ",", "in", "order", "to", "apply", "specific", "exception", "checks", "note", "that", "this", "template", "method", "will", "be", "invoked", "after", "checking", "whether", "this", "resolved", "applies", "(", "\"", "mapped", "handlers", "\"", "etc", ")", ",", "so", "an", "implementation", "may", "simply", "proceed", "with", "its", "actual", "exception", "handling" ]

[ "protected", "abstract", "model", "and", "view", "do", "resolve", "exception", "(", "http", "servlet", "request", "request", ",", "http", "servlet", "response", "response", ",", "@", "nullable", "object", "handler", ",", "exception", "ex", ")", ";" ]

[ "create", "the", "rpc", "server", "implementation", "used", "as", "an", "extension", "point", "for", "the", "backup", "node" ]

[ "protected", "name", "node", "rpc", "server", "create", "rpc", "server", "(", "configuration", "conf", ")", "throws", "i", "o", "exception", "{", "return", "new", "name", "node", "rpc", "server", "(", "conf", ",", "this", ")", ";", "}" ]

[ "get", "remote", "path", "through", "json", "api" ]

[ "private", "string", "get", "remote", "f", "s", "(", "node", "node", ",", "string", "user", ")", "throws", "exception", "{", "jenkins", "rule", "web", "client", "wc", "=", "j", "create", "web", "client", "(", ")", ";", "if", "(", "user", "!", "=", "null", ")", "{", "wc", "login", "(", "user", ")", ";", "}", "web", "response", "response", "=", "wc", "go", "to", "(", "\"", "computer", "/", "\"", "+", "node", "get", "node", "name", "(", ")", "+", "\"", "/", "api", "/", "json", "\"", ",", "\"", "application", "/", "json", "\"", ")", "get", "web", "response", "(", ")", ";", "j", "s", "o", "n", "object", "json", "=", "j", "s", "o", "n", "object", "from", "object", "(", "response", "get", "content", "as", "string", "(", ")", ")", ";", "object", "path", "obj", "=", "json", "get", "(", "\"", "absolute", "remote", "path", "\"", ")", ";", "if", "(", "path", "obj", "instanceof", "j", "s", "o", "n", "null", ")", "{", "return", "null", ";", "/", "/", "the", "value", "is", "null", "in", "here", "}", "else", "{", "return", "path", "obj", "to", "string", "(", ")", ";", "}", "}" ]

[ "test", "that", "setting", "parameters", "has", "the", "desired", "effect" ]

[ "public", "void", "check", "configuration", "(", ")", "{", "configuration", "conf", "=", "new", "configuration", "(", ")", ";", "test", "num", "retries", "(", "conf", ")", ";", "test", "wait", "interval", "(", "conf", ")", ";", "test", "timeout", "(", "conf", ")", ";", "test", "proxy", "configuration", "(", "conf", ")", ";", "}" ]

[ "set", "the", "persistence", "unit", "post", "processors", "to", "be", "applied", "to", "each", "persistence", "unit", "info", "that", "has", "been", "parsed", "by", "this", "manager", "such", "post", "-", "processors", "can", ",", "for", "example", ",", "register", "further", "entity", "classes", "and", "jar", "files", ",", "in", "addition", "to", "the", "metadata", "read", "from", "{", "@", "code", "persistence", "xml", "}" ]

[ "public", "void", "set", "persistence", "unit", "post", "processors", "(", "@", "nullable", "persistence", "unit", "post", "processor", "post", "processors", ")", "{", "this", "persistence", "unit", "post", "processors", "=", "post", "processors", ";", "}" ]

[ "handles", "a", "{", "@", "code", "evaluate", "request", "}", "and", "returns", "its", "response" ]

[ "private", "starlark", "debugging", "protos", "debug", "event", "evaluate", "(", "long", "sequence", "number", ",", "starlark", "debugging", "protos", "evaluate", "request", "request", ")", "throws", "debug", "request", "exception", "{", "return", "debug", "event", "helper", "evaluate", "response", "(", "sequence", "number", ",", "thread", "handler", "evaluate", "(", "request", "get", "thread", "id", "(", ")", ",", "request", "get", "statement", "(", ")", ")", ")", ";", "}" ]

[ "returns", "the", "list", "of", "symbols", "i", "ds", "that", "have", "been", "added" ]

[ "long", "[", "]", "get", "symbol", "additions", "(", ")", ";" ]

[ "due", "to", "a", "bug", "in", "mod", "-", "auth", "-", "cas", "and", "possibly", "other", "clients", "in", "the", "way", "tickets", "are", "parsed", ",", "the", "ticket", "id", "body", "is", "sanitized", "to", "remove", "the", "character", "\"", "\"", ",", "replacing", "it", "with", "\"", "-", "\"", "instead", "this", "might", "be", "revisited", "in", "the", "future", "and", "removed", ",", "once", "at", "least", "mod", "-", "auth", "-", "cas", "fixes", "the", "issue" ]

[ "public", "string", "get", "new", "ticket", "id", "(", "final", "string", "prefix", ")", "{", "val", "number", "=", "this", "numeric", "generator", "get", "next", "number", "as", "string", "(", ")", ";", "val", "ticket", "body", "=", "this", "random", "string", "generator", "get", "new", "string", "(", ")", "replace", "(", "'", "'", ",", "separator", ")", ";", "val", "orig", "suffix", "=", "string", "utils", "default", "string", "(", "this", "suffix", ")", ";", "val", "finalized", "suffix", "=", "string", "utils", "is", "empty", "(", "orig", "suffix", ")", "?", "orig", "suffix", ":", "separator", "+", "orig", "suffix", ";", "return", "prefix", "+", "separator", "+", "number", "+", "separator", "+", "ticket", "body", "+", "finalized", "suffix", ";", "}" ]

[ "determine", "if", "specified", "program", "already", "exists", "with", "the", "program", "cache" ]

[ "public", "boolean", "is", "program", "cached", "(", "string", "program", "name", ")", "{", "return", "program", "manager", "is", "program", "cached", "(", "program", "name", ")", ";", "}" ]

[ "set", "the", "error", "response", "factory", "to", "be", "used", "when", "an", "error", "is", "triggered", "this", "factory", "may", "only", "return", "responses", "for", "which", "{", "@", "link", "response", "#", "is", "successful", "(", ")", "}", "returns", "false" ]

[ "public", "void", "set", "error", "factory", "(", "callable", "<", "response", "<", "?", ">", ">", "error", "factory", ")", "{", "if", "(", "error", "factory", "=", "=", "null", ")", "{", "throw", "new", "null", "pointer", "exception", "(", "\"", "error", "factory", "=", "=", "null", "\"", ")", ";", "}", "this", "error", "factory", "=", "error", "factory", ";", "}" ]

[ "returns", "a", "memoizing", "{", "@", "link", "serialization", "context", "}", ",", "as", "get", "memoizing", "context", "above", "unlike", "get", "memoizing", "context", ",", "this", "method", "is", "not", "idempotent", "-", "the", "returned", "context", "will", "always", "be", "fresh" ]

[ "public", "serialization", "context", "get", "new", "memoizing", "context", "(", ")", "{", "return", "get", "new", "memoizing", "context", "(", "allow", "futures", "to", "block", "writing", "on", ")", ";", "}" ]

[ "execute", "the", "command" ]

[ "public", "static", "command", "result", "exec", "cmd", "(", "final", "string", "[", "]", "commands", ",", "final", "boolean", "is", "rooted", ",", "final", "boolean", "is", "need", "result", "msg", ")", "{", "int", "result", "=", "-", "1", ";", "if", "(", "commands", "=", "=", "null", "|", "|", "commands", "length", "=", "=", "0", ")", "{", "return", "new", "command", "result", "(", "result", ",", "\"", "\"", ",", "\"", "\"", ")", ";", "}", "process", "process", "=", "null", ";", "buffered", "reader", "success", "result", "=", "null", ";", "buffered", "reader", "error", "result", "=", "null", ";", "string", "builder", "success", "msg", "=", "null", ";", "string", "builder", "error", "msg", "=", "null", ";", "data", "output", "stream", "os", "=", "null", ";", "try", "{", "process", "=", "runtime", "get", "runtime", "(", ")", "exec", "(", "is", "rooted", "?", "\"", "su", "\"", ":", "\"", "sh", "\"", ")", ";", "os", "=", "new", "data", "output", "stream", "(", "process", "get", "output", "stream", "(", ")", ")", ";", "for", "(", "string", "command", ":", "commands", ")", "{", "if", "(", "command", "=", "=", "null", ")", "continue", ";", "os", "write", "(", "command", "get", "bytes", "(", ")", ")", ";", "os", "write", "bytes", "(", "line", "sep", ")", ";", "os", "flush", "(", ")", ";", "}", "os", "write", "bytes", "(", "\"", "exit", "\"", "+", "line", "sep", ")", ";", "os", "flush", "(", ")", ";", "result", "=", "process", "wait", "for", "(", ")", ";", "if", "(", "is", "need", "result", "msg", ")", "{", "success", "msg", "=", "new", "string", "builder", "(", ")", ";", "error", "msg", "=", "new", "string", "builder", "(", ")", ";", "success", "result", "=", "new", "buffered", "reader", "(", "new", "input", "stream", "reader", "(", "process", "get", "input", "stream", "(", ")", ",", "\"", "utf", "-", "8", "\"", ")", ")", ";", "error", "result", "=", "new", "buffered", "reader", "(", "new", "input", "stream", "reader", "(", "process", "get", "error", "stream", "(", ")", ",", "\"", "utf", "-", "8", "\"", ")", ")", ";", "string", "line", ";", "if", "(", "(", "line", "=", "success", "result", "read", "line", "(", ")", ")", "!", "=", "null", ")", "{", "success", "msg", "append", "(", "line", ")", ";", "while", "(", "(", "line", "=", "success", "result", "read", "line", "(", ")", ")", "!", "=", "null", ")", "{", "success", "msg", "append", "(", "line", "sep", ")", "append", "(", "line", ")", ";", "}", "}", "if", "(", "(", "line", "=", "error", "result", "read", "line", "(", ")", ")", "!", "=", "null", ")", "{", "error", "msg", "append", "(", "line", ")", ";", "while", "(", "(", "line", "=", "error", "result", "read", "line", "(", ")", ")", "!", "=", "null", ")", "{", "error", "msg", "append", "(", "line", "sep", ")", "append", "(", "line", ")", ";", "}", "}", "}", "}", "catch", "(", "exception", "e", ")", "{", "e", "print", "stack", "trace", "(", ")", ";", "}", "finally", "{", "try", "{", "if", "(", "os", "!", "=", "null", ")", "{", "os", "close", "(", ")", ";", "}", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "e", "print", "stack", "trace", "(", ")", ";", "}", "try", "{", "if", "(", "success", "result", "!", "=", "null", ")", "{", "success", "result", "close", "(", ")", ";", "}", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "e", "print", "stack", "trace", "(", ")", ";", "}", "try", "{", "if", "(", "error", "result", "!", "=", "null", ")", "{", "error", "result", "close", "(", ")", ";", "}", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "e", "print", "stack", "trace", "(", ")", ";", "}", "if", "(", "process", "!", "=", "null", ")", "{", "process", "destroy", "(", ")", ";", "}", "}", "return", "new", "command", "result", "(", "result", ",", "success", "msg", "=", "=", "null", "?", "\"", "\"", ":", "success", "msg", "to", "string", "(", ")", ",", "error", "msg", "=", "=", "null", "?", "\"", "\"", ":", "error", "msg", "to", "string", "(", ")", ")", ";", "}" ]

[ "remove", "an", "existing", "key", "from", "the", "array", "map" ]

[ "public", "v", "remove", "(", "object", "key", ")", "{", "final", "int", "index", "=", "index", "of", "key", "(", "key", ")", ";", "if", "(", "index", ">", "=", "0", ")", "{", "return", "remove", "at", "(", "index", ")", ";", "}", "return", "null", ";", "}" ]

[ "model", "tests", "for", "format", "test" ]

[ "public", "void", "test", "format", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "format", "test", "}" ]

[ "find", "pet", "by", "id", "returns", "a", "single", "pet" ]

[ "public", "single", "<", "pet", ">", "rx", "get", "pet", "by", "id", "(", "long", "pet", "id", ")", "{", "return", "single", "create", "(", "new", "io", "vertx", "rx", "java", "single", "on", "subscribe", "adapter", "<", ">", "(", "fut", "-", ">", "delegate", "get", "pet", "by", "id", "(", "pet", "id", ",", "fut", ")", ")", ")", ";", "}" ]

[ "returns", "whether", "or", "not", "the", "given", "value", "appears", "in", "the", "list", "this", "will", "do", "a", "binary", "search", "if", "the", "list", "is", "sorted", "or", "a", "linear", "search", "if", "not" ]

[ "public", "boolean", "contains", "(", "int", "value", ")", "{", "return", "index", "of", "(", "value", ")", ">", "=", "0", ";", "}" ]

[ "\"", "constraining", "\"", "a", "rule", "'", "s", "environments", "explicitly", "sets", "them" ]

[ "public", "void", "constrained", "supported", "environments", "(", ")", "throws", "exception", "{", "new", "environment", "group", "maker", "(", "\"", "buildenv", "/", "foo", "\"", ")", "set", "environments", "(", "\"", "a", "\"", ",", "\"", "b", "\"", ",", "\"", "c", "\"", ")", "set", "defaults", "(", "\"", "a", "\"", ")", "make", "(", ")", ";", "string", "rule", "def", "=", "get", "dependency", "rule", "(", "constrained", "to", "(", "\"", "/", "/", "buildenv", "/", "foo", ":", "c", "\"", ")", ")", ";", "assert", "that", "(", "supported", "environments", "(", "\"", "dep", "\"", ",", "rule", "def", ")", ")", "contains", "exactly", "elements", "in", "(", "as", "label", "set", "(", "\"", "/", "/", "buildenv", "/", "foo", ":", "c", "\"", ")", ")", ";", "}" ]

[ "seeks", "inside", "this", "sample", "stream", "seeks", "to", "just", "before", "the", "first", "sample", "with", "{", "@", "code", "sample", "time", ">", "=", "time", "us", "}", ",", "or", "to", "the", "end", "of", "the", "stream", "otherwise" ]

[ "public", "void", "seek", "to", "(", "long", "time", "us", ")", "{", "format", "applicable", "format", "=", "initial", "format", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "fake", "sample", "stream", "items", "size", "(", ")", ";", "i", "+", "+", ")", "{", "@", "nullable", "sample", "info", "sample", "info", "=", "fake", "sample", "stream", "items", "get", "(", "i", ")", "sample", "info", ";", "if", "(", "sample", "info", "=", "=", "null", ")", "{", "applicable", "format", "=", "assertions", "check", "not", "null", "(", "fake", "sample", "stream", "items", "get", "(", "i", ")", "format", ")", ";", "continue", ";", "}", "if", "(", "sample", "info", "time", "us", ">", "=", "time", "us", ")", "{", "sample", "item", "index", "=", "i", ";", "read", "e", "o", "s", "buffer", "=", "false", ";", "if", "(", "downstream", "format", "!", "=", "null", "&", "&", "!", "applicable", "format", "equals", "(", "downstream", "format", ")", ")", "{", "notify", "event", "dispatcher", "(", "applicable", "format", ")", ";", "}", "return", ";", "}", "}", "sample", "item", "index", "=", "fake", "sample", "stream", "items", "size", "(", ")", ";", "@", "nullable", "fake", "sample", "stream", "item", "last", "item", "=", "iterables", "get", "last", "(", "fake", "sample", "stream", "items", ",", "/", "*", "default", "value", "=", "*", "/", "null", ")", ";", "read", "e", "o", "s", "buffer", "=", "last", "item", "!", "=", "null", "&", "&", "last", "item", "sample", "info", "!", "=", "null", "&", "&", "(", "(", "last", "item", "sample", "info", "flags", "&", "c", "buffer", "flag", "end", "of", "stream", ")", "!", "=", "0", ")", ";", "}" ]

[ "this", "should", "return", "the", "initial", "endpoints", "in", "a", "single", "-", "string", "without", "resolving", "them" ]

[ "@", "override", "string", "to", "string", "(", ")", ";" ]

[ "get", "the", "offset", "storage", "reader", "for", "this", "source", "task" ]

[ "offset", "storage", "reader", "offset", "storage", "reader", "(", ")", ";" ]

[ "check", "if", "the", "iterator", "is", "still", "valid", "getters", "like", "{", "@", "link", "#", "key", "(", ")", "}", ",", "{", "@", "link", "#", "value", "(", ")", "}", ",", "etc", "as", "well", "as", "{", "@", "link", "#", "next", "(", ")", "}", "should", "only", "be", "called", "if", "valid", "returned", "true", "should", "be", "checked", "after", "each", "call", "to", "{", "@", "link", "#", "next", "(", ")", "}", "before", "accessing", "iterator", "state" ]

[ "public", "boolean", "is", "valid", "(", ")", "{", "return", "valid", ";", "}" ]

[ "call", "this", "method", "to", "register", "a", "custom", "attribute", "type", ",", "see", "the", "wiki", "for", "an", "example", "if", "the", "alias", "already", "exists", ",", "then", "that", "id", "will", "be", "reused", "the", "alias", "should", "be", "unambiguously", "and", "will", "by", "default", "be", "returned", "by", "the", "call", "to", "{", "@", "link", "#", "to", "string", "(", ")", "}" ]

[ "protected", "final", "static", "long", "register", "(", "final", "string", "alias", ")", "{", "long", "result", "=", "get", "attribute", "type", "(", "alias", ")", ";", "if", "(", "result", ">", "0", ")", "return", "result", ";", "types", "add", "(", "alias", ")", ";", "return", "1l", "<", "<", "(", "types", "size", "-", "1", ")", ";", "}" ]

[ "get", "the", "data", "format", "model", "of", "the", "view", "that", "is", "in", "focus" ]

[ "data", "format", "model", "get", "current", "model", "(", ")", "{", "if", "(", "current", "view", "=", "=", "null", ")", "{", "return", "null", ";", "}", "return", "current", "view", "get", "data", "model", "(", ")", ";", "}" ]

[ "check", "that", "whether", "debugging", "is", "enabled", "for", "this", "api", "client" ]

[ "public", "boolean", "is", "debugging", "(", ")", "{", "return", "debugging", ";", "}" ]

[ "return", "a", "full", "description", "of", "this", "event", ",", "involving", "all", "available", "context", "data" ]

[ "public", "string", "get", "description", "(", ")", "{", "string", "builder", "sb", "=", "new", "string", "builder", "(", ")", ";", "sb", "append", "(", "\"", "session", "=", "[", "\"", ")", "append", "(", "this", "session", "id", ")", "append", "(", "\"", "]", ";", "\"", ")", ";", "sb", "append", "(", "\"", "user", "=", "[", "\"", ")", "append", "(", "this", "user", "name", ")", "append", "(", "\"", "]", ";", "\"", ")", ";", "sb", "append", "(", "\"", "time", "=", "[", "\"", ")", "append", "(", "this", "processing", "time", "millis", ")", "append", "(", "\"", "ms", "]", ";", "\"", ")", ";", "sb", "append", "(", "\"", "status", "=", "[", "\"", ")", ";", "if", "(", "!", "was", "failure", "(", ")", ")", "{", "sb", "append", "(", "\"", "ok", "\"", ")", ";", "}", "else", "{", "sb", "append", "(", "\"", "failed", ":", "\"", ")", "append", "(", "this", "failure", "cause", ")", ";", "}", "sb", "append", "(", "'", "]", "'", ")", ";", "return", "sb", "to", "string", "(", ")", ";", "}" ]

[ "convert", "the", "given", "object", "to", "string", "with", "each", "line", "indented", "by", "4", "spaces", "(", "except", "the", "first", "line", ")" ]

[ "private", "string", "to", "indented", "string", "(", "object", "o", ")", "{", "if", "(", "o", "=", "=", "null", ")", "{", "return", "\"", "null", "\"", ";", "}", "return", "o", "to", "string", "(", ")", "replace", "(", "\"", "\\", "n", "\"", ",", "\"", "\\", "n", "\"", ")", ";", "}" ]

[ "stores", "the", "jvm", "property", "value", "of", "https", "cipher", "suites", "and", "sets", "its", "value", "to", "an", "empty", "string", "this", "ensures", "that", "the", "value", "https", "cipher", "suites", "does", "not", "affect", "the", "result", "of", "tests" ]

[ "static", "void", "store", "https", "cipher", "suites", "(", ")", "{", "string", "cipher", "suites", "=", "system", "get", "property", "(", "https", "cipher", "suites", "key", ")", ";", "if", "(", "cipher", "suites", "!", "=", "null", ")", "{", "log", "info", "(", "\"", "found", "value", "for", "property", "{", "}", ":", "{", "}", "\"", ",", "https", "cipher", "suites", "key", ",", "cipher", "suites", ")", ";", "cipher", "suites", "property", "value", "=", "cipher", "suites", ";", "}", "system", "clear", "property", "(", "https", "cipher", "suites", "key", ")", ";", "}" ]

[ "clears", "the", "playlist", ",", "adds", "the", "specified", "{", "@", "link", "media", "source", "}", "and", "resets", "the", "position", "to", "the", "default", "position" ]

[ "void", "set", "media", "source", "(", "media", "source", "media", "source", ")", ";" ]

[ "handle", "udp", "l", "4" ]

[ "private", "void", "handle", "u", "d", "p", "(", "channel", "handler", "context", "ctx", ",", "object", "msg", ")", "{", "byte", "buf", "udp", "buf", "=", "ctx", "alloc", "(", ")", "buffer", "(", ")", ";", "try", "{", "if", "(", "msg", "instanceof", "datagram", "packet", ")", "{", "/", "/", "if", "bytes", "are", "0", "and", "`", "capture", "zero", "byte", "`", "is", "false", ",", "we", "won", "'", "t", "capture", "this", "if", "(", "(", "(", "datagram", "packet", ")", "msg", ")", "content", "(", ")", "readable", "bytes", "(", ")", "=", "=", "0", "&", "&", "!", "capture", "zero", "byte", ")", "{", "logger", "debug", "(", "\"", "discarding", "zero", "byte", "udp", "packet", "\"", ")", ";", "return", ";", "}", "datagram", "packet", "datagram", "packet", "=", "(", "(", "datagram", "packet", ")", "msg", ")", "duplicate", "(", ")", ";", "inet", "socket", "address", "src", "addr", "=", "datagram", "packet", "sender", "(", ")", ";", "inet", "socket", "address", "dst", "addr", "=", "datagram", "packet", "recipient", "(", ")", ";", "/", "/", "if", "`", "datagram", "packet", "sender", "(", ")", "`", "is", "`", "null", "`", "then", "datagram", "packet", "is", "initialized", "/", "/", "`", "sender", "`", "(", "local", ")", "address", "in", "this", "case", ",", "we", "'", "ll", "get", "source", "address", "from", "channel", "if", "(", "src", "addr", "=", "=", "null", ")", "{", "src", "addr", "=", "(", "inet", "socket", "address", ")", "ctx", "channel", "(", ")", "local", "address", "(", ")", ";", "}", "logger", "debug", "(", "\"", "writing", "udp", "data", "of", "{", "}", "bytes", ",", "src", "addr", "{", "}", ",", "dst", "addr", "{", "}", "\"", ",", "datagram", "packet", "content", "(", ")", "readable", "bytes", "(", ")", ",", "src", "addr", ",", "dst", "addr", ")", ";", "u", "d", "p", "packet", "write", "packet", "(", "udp", "buf", ",", "datagram", "packet", "content", "(", ")", ",", "src", "addr", "get", "port", "(", ")", ",", "dst", "addr", "get", "port", "(", ")", ")", ";", "complete", "u", "d", "p", "write", "(", "src", "addr", ",", "dst", "addr", ",", "udp", "buf", ",", "ctx", "alloc", "(", ")", ",", "ctx", ")", ";", "}", "else", "if", "(", "msg", "instanceof", "byte", "buf", "&", "&", "(", "(", "datagram", "channel", ")", "ctx", "channel", "(", ")", ")", "is", "connected", "(", ")", ")", "{", "/", "/", "if", "bytes", "are", "0", "and", "`", "capture", "zero", "byte", "`", "is", "false", ",", "we", "won", "'", "t", "capture", "this", "if", "(", "(", "(", "byte", "buf", ")", "msg", ")", "readable", "bytes", "(", ")", "=", "=", "0", "&", "&", "!", "capture", "zero", "byte", ")", "{", "logger", "debug", "(", "\"", "discarding", "zero", "byte", "udp", "packet", "\"", ")", ";", "return", ";", "}", "byte", "buf", "byte", "buf", "=", "(", "(", "byte", "buf", ")", "msg", ")", "duplicate", "(", ")", ";", "logger", "debug", "(", "\"", "writing", "udp", "data", "of", "{", "}", "bytes", ",", "src", "addr", "{", "}", ",", "dst", "addr", "{", "}", "\"", ",", "byte", "buf", "readable", "bytes", "(", ")", ",", "src", "addr", ",", "dst", "addr", ")", ";", "u", "d", "p", "packet", "write", "packet", "(", "udp", "buf", ",", "byte", "buf", ",", "src", "addr", "get", "port", "(", ")", ",", "dst", "addr", "get", "port", "(", ")", ")", ";", "complete", "u", "d", "p", "write", "(", "src", "addr", ",", "dst", "addr", ",", "udp", "buf", ",", "ctx", "alloc", "(", ")", ",", "ctx", ")", ";", "}", "else", "{", "logger", "debug", "(", "\"", "discarding", "pcap", "write", "for", "udp", "object", ":", "{", "}", "\"", ",", "msg", ")", ";", "}", "}", "finally", "{", "udp", "buf", "release", "(", ")", ";", "}", "}" ]

[ "executes", "the", "given", "task", "in", "a", "single", "thread", "pool", "at", "fix", "rate" ]

[ "public", "static", "<", "t", ">", "void", "execute", "by", "single", "at", "fix", "rate", "(", "final", "task", "<", "t", ">", "task", ",", "long", "initial", "delay", ",", "final", "long", "period", ",", "final", "time", "unit", "unit", ")", "{", "execute", "at", "fixed", "rate", "(", "get", "pool", "by", "type", "and", "priority", "(", "type", "single", ")", ",", "task", ",", "initial", "delay", ",", "period", ",", "unit", ")", ";", "}" ]

[ "removes", "any", "temporary", "storage", "leftovers", "removes", "all", "temp", "files", "and", "folder", "which", "might", "be", "there", "as", "a", "result", "of", "an", "unclean", "node", "shutdown", "or", "broken", "clients", "do", "not", "call", "while", "there", "are", "running", "jobs" ]

[ "public", "void", "cleanup", "local", "tmp", "storage", "in", "case", "of", "unclean", "shutdown", "(", ")", "{", "try", "{", "for", "(", "path", "p", ":", "environment", "data", "files", "(", ")", ")", "{", "i", "o", "utils", "rm", "(", "p", "resolve", "(", "local", "storage", "subfolder", ")", "resolve", "(", "local", "storage", "tmp", "folder", ")", ")", ";", "}", "}", "catch", "(", "exception", "e", ")", "{", "logger", "warn", "(", "\"", "failed", "to", "cleanup", "native", "storage", "from", "previous", "invocation", "\"", ",", "e", ")", ";", "}", "}" ]

[ "set", "the", "\"", "global", "\"", "cors", "configuration", "source", "by", "default", "the", "first", "matching", "url", "pattern", "is", "combined", "with", "the", "cors", "configuration", "for", "the", "handler", ",", "if", "any" ]

[ "public", "void", "set", "cors", "configuration", "source", "(", "cors", "configuration", "source", "cors", "configuration", "source", ")", "{", "assert", "not", "null", "(", "cors", "configuration", "source", ",", "\"", "cors", "configuration", "source", "must", "not", "be", "null", "\"", ")", ";", "this", "cors", "configuration", "source", "=", "cors", "configuration", "source", ";", "}" ]

[ "<", "code", ">", "optional", "string", "foo", "=", "1", ";", "<", "code", ">" ]

[ "public", "builder", "set", "foo", "bytes", "(", "com", "google", "protobuf", "byte", "string", "value", ")", "{", "if", "(", "value", "=", "=", "null", ")", "{", "throw", "new", "null", "pointer", "exception", "(", ")", ";", "}", "bit", "field", "0", "|", "=", "0x", "0", "0", "0", "0", "0", "0", "0", "1", ";", "foo", "=", "value", ";", "on", "changed", "(", ")", ";", "return", "this", ";", "}" ]

[ "rollback", "the", "instruction", "stream", "for", "a", "program", "so", "that", "the", "indicated", "instruction", "(", "via", "instruction", "index", ")", "is", "no", "longer", "in", "the", "stream", "untested", "!" ]

[ "public", "void", "rollback", "(", "string", "program", "name", ",", "int", "instruction", "index", ")", "{", "list", "<", "rewrite", "operation", ">", "is", "=", "programs", "get", "(", "program", "name", ")", ";", "if", "(", "is", "!", "=", "null", ")", "{", "programs", "put", "(", "program", "name", ",", "is", "sub", "list", "(", "min", "token", "index", ",", "instruction", "index", ")", ")", ";", "}", "}" ]

[ "set", "the", "job", "retire", "flag", "to", "true" ]

[ "protected", "synchronized", "void", "set", "retired", "(", ")", "{", "this", "is", "retired", "=", "true", ";", "}" ]

[ "creates", "the", "kind", "of", "array", "for", "{", "@", "link", "list", "#", "to", "array", "(", "object", "[", "]", ")", "}" ]

[ "private", "static", "object", "[", "]", "create", "object", "array", "kind", "(", "class", "<", "?", ">", "element", "clazz", ")", "{", "/", "/", "e", "g", "int", "[", "]", "is", "not", "a", "object", "[", "]", "if", "(", "element", "clazz", "is", "primitive", "(", ")", ")", "{", "return", "(", "object", "[", "]", ")", "array", "new", "instance", "(", "primitive", "to", "wrapper", "(", "element", "clazz", ")", ",", "0", ")", ";", "}", "/", "/", "e", "g", "int", "[", "]", "[", "]", "and", "integer", "[", "]", "are", "object", "[", "]", "return", "(", "object", "[", "]", ")", "array", "new", "instance", "(", "element", "clazz", ",", "0", ")", ";", "}" ]

[ "decrease", "current", "thread", "count" ]

[ "void", "decrease", "thread", "num", "(", ")", ";" ]

[ "logs", "a", "message" ]

[ "public", "abstract", "void", "log", "(", "channel", "log", "level", "level", ",", "string", "message", ")", ";" ]

[ "marks", "the", "stack", "entries", "andor", "their", "producing", "instructions", "at", "the", "given", "offsets" ]

[ "private", "void", "mark", "stack", "entry", "producers", "(", "instruction", "offset", "value", "producer", "offsets", ",", "int", "stack", "index", ",", "boolean", "mark", "producing", "instructions", ",", "boolean", "mark", "produced", "stack", "entries", ")", "{", "if", "(", "producer", "offsets", "!", "=", "null", ")", "{", "int", "offset", "count", "=", "producer", "offsets", "instruction", "offset", "count", "(", ")", ";", "for", "(", "int", "offset", "index", "=", "0", ";", "offset", "index", "<", "offset", "count", ";", "offset", "index", "+", "+", ")", "{", "/", "/", "make", "sure", "the", "stack", "entry", "and", "the", "instruction", "are", "marked", "/", "/", "at", "the", "producing", "offset", "int", "offset", "=", "producer", "offsets", "instruction", "offset", "(", "offset", "index", ")", ";", "/", "/", "mark", "the", "producing", "instruction", ",", "if", "specified", "if", "(", "mark", "producing", "instructions", ")", "{", "mark", "instruction", "(", "offset", ")", ";", "}", "/", "/", "mark", "the", "produced", "stack", "entry", ",", "if", "specified", "if", "(", "mark", "produced", "stack", "entries", ")", "{", "mark", "stack", "entry", "after", "(", "offset", ",", "stack", "index", ")", ";", "}", "}", "}", "}" ]

[ "tests", "that", "the", "sampler", "aggregation", "works", "correctly", "if", "the", "parent", "bucket", "does", "not", "contain", "any", "hit" ]

[ "public", "void", "test", "empty", "parent", "bucket", "(", ")", "throws", "exception", "{", "index", "writer", "config", "index", "writer", "config", "=", "new", "index", "writer", "config", "(", ")", ";", "try", "(", "directory", "dir", "=", "new", "directory", "(", ")", ";", "index", "writer", "writer", "=", "new", "index", "writer", "(", "dir", ",", "index", "writer", "config", ")", ")", "{", "writer", "add", "document", "(", "new", "document", "(", ")", ")", ";", "try", "(", "index", "reader", "reader", "=", "directory", "reader", "open", "(", "writer", ")", ")", "{", "index", "searcher", "searcher", "=", "new", "index", "searcher", "(", "reader", ")", ";", "query", "builder", "[", "]", "filters", "=", "new", "query", "builder", "[", "]", "{", "new", "match", "all", "query", "builder", "(", ")", ",", "new", "match", "none", "query", "builder", "(", ")", "}", ";", "filters", "aggregation", "builder", "sampler", "parent", "=", "new", "filters", "aggregation", "builder", "(", "\"", "filters", "\"", ",", "filters", ")", ";", "terms", "aggregation", "builder", "sampler", "child", "=", "new", "terms", "aggregation", "builder", "(", "\"", "child", "\"", ")", "field", "(", "\"", "field", "\"", ")", ";", "sampler", "aggregation", "builder", "sampler", "=", "new", "sampler", "aggregation", "builder", "(", "\"", "sampler", "\"", ")", "sub", "aggregation", "(", "sampler", "child", ")", ";", "sampler", "parent", "sub", "aggregation", "(", "sampler", ")", ";", "internal", "filters", "response", "=", "search", "and", "reduce", "(", "searcher", ",", "new", "match", "all", "docs", "query", "(", ")", ",", "sampler", "parent", ")", ";", "assert", "equals", "(", "response", "get", "buckets", "(", ")", "size", "(", ")", ",", "2", ")", ";", "assert", "equals", "(", "response", "get", "buckets", "(", ")", "get", "(", "0", ")", "get", "doc", "count", "(", ")", ",", "1", ")", ";", "assert", "equals", "(", "response", "get", "buckets", "(", ")", "get", "(", "1", ")", "get", "doc", "count", "(", ")", ",", "0", ")", ";", "}", "}", "}" ]

[ "unregister", "task", "manager", "from", "this", "pool", ",", "all", "the", "related", "slots", "will", "be", "released", "and", "tasks", "be", "canceled", "called", "when", "we", "find", "some", "task", "manager", "becomes", "\"", "dead", "\"", "or", "\"", "abnormal", "\"", ",", "and", "we", "decide", "to", "not", "using", "slots", "from", "it", "anymore" ]

[ "public", "boolean", "release", "task", "manager", "(", "final", "resource", "i", "d", "resource", "id", ",", "final", "exception", "cause", ")", "{", "component", "main", "thread", "executor", "assert", "running", "in", "main", "thread", "(", ")", ";", "if", "(", "registered", "task", "managers", "remove", "(", "resource", "id", ")", ")", "{", "release", "task", "manager", "internal", "(", "resource", "id", ",", "cause", ")", ";", "return", "true", ";", "}", "else", "{", "return", "false", ";", "}", "}" ]

[ "submits", "a", "runnable", "to", "be", "executed", "by", "this", "thread", "pool" ]

[ "public", "<", "t", ">", "future", "<", "t", ">", "submit", "(", "runnable", "task", ",", "t", "result", ")", "{", "return", "executor", "submit", "(", "task", ",", "result", ")", ";", "}" ]

[ "set", "whether", "or", "not", "version", "conflicts", "cause", "the", "action", "to", "abort" ]

[ "public", "self", "set", "abort", "on", "version", "conflict", "(", "boolean", "abort", "on", "version", "conflict", ")", "{", "this", "abort", "on", "version", "conflict", "=", "abort", "on", "version", "conflict", ";", "return", "self", "(", ")", ";", "}" ]

[ "determines", "if", "a", "function", "match", "can", "be", "created", "for", "the", "selected", "source", "and", "destination" ]

[ "public", "boolean", "can", "create", "match", "(", ")", ";" ]

[ "returns", "the", "configuration", "properties", "for", "orm", "tools" ]

[ "map", "<", "string", ",", "string", ">", "get", "properties", "(", ")", ";" ]

[ "test", "{", "@", "code", "map", "file", "reader", "final", "key", "(", ")", "}", "method" ]

[ "public", "void", "test", "on", "final", "key", "(", ")", "{", "final", "string", "test", "method", "key", "=", "\"", "test", "on", "final", "key", "mapfile", "\"", ";", "int", "size", "=", "10", ";", "map", "file", "writer", "writer", "=", "null", ";", "map", "file", "reader", "reader", "=", "null", ";", "try", "{", "writer", "=", "create", "writer", "(", "test", "method", "key", ",", "int", "writable", "class", ",", "int", "writable", "class", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "size", ";", "i", "+", "+", ")", "writer", "append", "(", "new", "int", "writable", "(", "i", ")", ",", "new", "int", "writable", "(", "i", ")", ")", ";", "writer", "close", "(", ")", ";", "reader", "=", "create", "reader", "(", "test", "method", "key", ",", "int", "writable", "class", ")", ";", "int", "writable", "expected", "key", "=", "new", "int", "writable", "(", "0", ")", ";", "reader", "final", "key", "(", "expected", "key", ")", ";", "assert", "equals", "(", "\"", "test", "on", "final", "key", "not", "same", "!", "!", "!", "\"", ",", "expected", "key", ",", "new", "int", "writable", "(", "9", ")", ")", ";", "}", "catch", "(", "i", "o", "exception", "ex", ")", "{", "fail", "(", "\"", "test", "on", "final", "key", "error", "!", "!", "!", "\"", ")", ";", "}", "finally", "{", "i", "o", "utils", "cleanup", "with", "logger", "(", "log", ",", "writer", ",", "reader", ")", ";", "}", "}" ]

[ "submit", "a", "local", "file", "to", "the", "filesystem", "references", "by", "the", "instance", "'", "s", "cluster", "filesystem" ]

[ "public", "local", "resource", "submit", "file", "(", "file", "local", "file", ",", "path", "temp", "path", ",", "string", "subdir", ",", "string", "dest", "file", "name", ")", "throws", "i", "o", "exception", "{", "path", "src", "=", "new", "path", "(", "local", "file", "to", "string", "(", ")", ")", ";", "path", "subdir", "path", "=", "new", "path", "(", "temp", "path", ",", "subdir", ")", ";", "file", "system", "mkdirs", "(", "subdir", "path", ")", ";", "path", "dest", "path", "=", "new", "path", "(", "subdir", "path", ",", "dest", "file", "name", ")", ";", "log", "debug", "(", "\"", "copying", "{", "}", "(", "size", "=", "{", "}", "bytes", ")", "to", "{", "}", "\"", ",", "local", "file", ",", "local", "file", "length", "(", ")", ",", "dest", "path", ")", ";", "file", "system", "copy", "from", "local", "file", "(", "false", ",", "true", ",", "src", ",", "dest", "path", ")", ";", "/", "/", "set", "the", "type", "of", "resource", "-", "file", "or", "archive", "/", "/", "archives", "are", "untarred", "at", "destination", "/", "/", "we", "don", "'", "t", "need", "the", "jar", "file", "to", "be", "untarred", "for", "now", "return", "create", "am", "resource", "(", "dest", "path", ",", "local", "resource", "type", "file", ",", "local", "resource", "visibility", "application", ")", ";", "}" ]

[ "this", "test", "will", "fail", "whenever", "someone", "updatesreorders", "the", "bloom", "filter", "strategies", "constants", "only", "appending", "a", "new", "constant", "is", "allowed" ]

[ "public", "void", "test", "bloom", "filter", "strategies", "(", ")", "{", "assert", "that", "(", "bloom", "filter", "strategies", "values", "(", ")", ")", "has", "length", "(", "2", ")", ";", "assert", "equals", "(", "bloom", "filter", "strategies", "murmur128", "mitz", "32", ",", "bloom", "filter", "strategies", "values", "(", ")", "[", "0", "]", ")", ";", "assert", "equals", "(", "bloom", "filter", "strategies", "murmur128", "mitz", "64", ",", "bloom", "filter", "strategies", "values", "(", ")", "[", "1", "]", ")", ";", "}" ]

[ "sets", "the", "visibility", "of", "the", "given", "models", ",", "and", "notifies", "that", "the", "items", "changed", "if", "the", "new", "visibility", "is", "different", "from", "the", "previous" ]

[ "protected", "void", "show", "models", "(", "boolean", "show", ",", "epoxy", "model", "<", "?", ">", "models", ")", "{", "show", "models", "(", "arrays", "as", "list", "(", "models", ")", ",", "show", ")", ";", "}" ]

[ "save", "off", "the", "current", "context", "and", "set", "the", "current", "context", "to", "a", "copy", "this", "is", "done", "so", "that", "the", "values", "in", "the", "context", "are", "not", "changed", ",", "but", "can", "be", "used", "for", "computation" ]

[ "protected", "varnode", "context", "save", "off", "current", "context", "(", "address", "start", "addr", ")", "{", "language", "language", "=", "program", "get", "language", "(", ")", ";", "program", "context", "new", "value", "context", "=", "new", "program", "context", "impl", "(", "language", ")", ";", "program", "context", "new", "space", "context", "=", "new", "program", "context", "impl", "(", "language", ")", ";", "varnode", "context", "new", "context", "=", "new", "varnode", "context", "(", "program", ",", "new", "value", "context", ",", "new", "space", "context", ")", ";", "new", "context", "set", "debug", "(", "debug", ")", ";", "int", "constant", "space", "i", "d", "=", "program", "get", "address", "factory", "(", ")", "get", "constant", "space", "(", ")", "get", "space", "i", "d", "(", ")", ";", "/", "/", "copy", "any", "current", "registers", "with", "values", "into", "the", "context", "register", "[", "]", "reg", "with", "vals", "=", "program", "context", "get", "registers", "with", "values", "(", ")", ";", "for", "(", "register", "reg", "with", "val", ":", "reg", "with", "vals", ")", "{", "register", "value", "reg", "val", ";", "reg", "val", "=", "program", "context", "get", "register", "value", "(", "reg", "with", "val", ",", "start", "addr", ")", ";", "register", "value", "sp", "reg", "val", ";", "sp", "reg", "val", "=", "space", "context", "get", "register", "value", "(", "reg", "with", "val", ",", "start", "addr", ")", ";", "/", "/", "for", "now", "only", "copy", "constants", "into", "start", "of", "current", "flow", ",", "/", "/", "maybe", "should", "do", "any", "value", "/", "/", "todo", ":", "need", "a", "better", "way", "to", "figure", "this", "out", "!", "if", "(", "reg", "val", "!", "=", "null", "&", "&", "(", "sp", "reg", "val", "=", "=", "null", "|", "|", "(", "sp", "reg", "val", "get", "unsigned", "value", "(", ")", "!", "=", "null", "&", "&", "sp", "reg", "val", "get", "unsigned", "value", "(", ")", "long", "value", "(", ")", "=", "=", "constant", "space", "i", "d", ")", ")", ")", "{", "new", "context", "set", "future", "register", "value", "(", "start", "addr", ",", "reg", "val", ")", ";", "}", "}", "program", "context", "=", "new", "value", "context", ";", "space", "context", "=", "new", "space", "context", ";", "return", "new", "context", ";", "}" ]

[ "logs", "out", "current", "logged", "in", "user", "session" ]

[ "completion", "stage", "<", "response", "<", "void", ">", ">", "logout", "user", "(", ")", ";" ]

[ "add", "new", "bean", "post", "processors", "that", "will", "get", "applied", "to", "beans", "created", "by", "this", "factory", "to", "be", "invoked", "during", "factory", "configuration" ]

[ "public", "void", "add", "bean", "post", "processors", "(", "collection", "<", "?", "extends", "bean", "post", "processor", ">", "bean", "post", "processors", ")", "{", "this", "bean", "post", "processors", "remove", "all", "(", "bean", "post", "processors", ")", ";", "this", "bean", "post", "processors", "add", "all", "(", "bean", "post", "processors", ")", ";", "}" ]

[ "get", "the", "configured", "trash", "policy" ]

[ "trash", "policy", "get", "trash", "policy", "(", ")", "{", "return", "trash", "policy", ";", "}" ]

[ "loads", "the", "resource", "at", "a", "given", "index", "into", "the", "properties" ]

[ "private", "synchronized", "void", "load", "props", "(", "final", "properties", "props", ",", "final", "int", "start", "idx", ",", "final", "boolean", "full", "reload", ")", "{", "if", "(", "props", "!", "=", "null", ")", "{", "map", "<", "string", ",", "string", "[", "]", ">", "backup", "=", "updating", "resource", "!", "=", "null", "?", "new", "concurrent", "hash", "map", "<", ">", "(", "updating", "resource", ")", ":", "null", ";", "load", "resources", "(", "props", ",", "resources", ",", "start", "idx", ",", "full", "reload", ",", "quietmode", ")", ";", "if", "(", "overlay", "!", "=", "null", ")", "{", "props", "put", "all", "(", "overlay", ")", ";", "if", "(", "backup", "!", "=", "null", ")", "{", "for", "(", "map", "entry", "<", "object", ",", "object", ">", "item", ":", "overlay", "entry", "set", "(", ")", ")", "{", "string", "key", "=", "(", "string", ")", "item", "get", "key", "(", ")", ";", "string", "[", "]", "source", "=", "backup", "get", "(", "key", ")", ";", "if", "(", "source", "!", "=", "null", ")", "{", "updating", "resource", "put", "(", "key", ",", "source", ")", ";", "}", "}", "}", "}", "}", "}" ]

[ "set", "the", "response", "as", "an", "error", "response", "plus", "some", "data" ]

[ "public", "static", "http", "response", "error", "j", "s", "o", "n", "(", "@", "non", "null", "string", "message", ",", "@", "non", "null", "j", "s", "o", "n", "object", "data", ")", "{", "return", "new", "j", "s", "o", "n", "object", "response", "(", "data", ")", "error", "(", "message", ")", ";", "}" ]

[ "delete", "user", "this", "can", "only", "be", "done", "by", "the", "logged", "in", "user" ]

[ "public", "api", "response", "<", "void", ">", "delete", "user", "with", "http", "info", "(", "string", "username", ")", "throws", "api", "exception", "{", "http", "request", "builder", "local", "var", "request", "builder", "=", "delete", "user", "request", "builder", "(", "username", ")", ";", "try", "{", "http", "response", "<", "input", "stream", ">", "local", "var", "response", "=", "member", "var", "http", "client", "send", "(", "local", "var", "request", "builder", "build", "(", ")", ",", "http", "response", "body", "handlers", "of", "input", "stream", "(", ")", ")", ";", "if", "(", "member", "var", "response", "interceptor", "!", "=", "null", ")", "{", "member", "var", "response", "interceptor", "accept", "(", "local", "var", "response", ")", ";", "}", "if", "(", "local", "var", "response", "status", "code", "(", ")", "/", "100", "!", "=", "2", ")", "{", "throw", "new", "api", "exception", "(", "local", "var", "response", "status", "code", "(", ")", ",", "\"", "delete", "user", "call", "received", "non", "-", "success", "response", "\"", ",", "local", "var", "response", "headers", "(", ")", ",", "local", "var", "response", "body", "(", ")", "=", "=", "null", "?", "null", ":", "new", "string", "(", "local", "var", "response", "body", "(", ")", "read", "all", "bytes", "(", ")", ")", ")", ";", "}", "return", "new", "api", "response", "<", "void", ">", "(", "local", "var", "response", "status", "code", "(", ")", ",", "local", "var", "response", "headers", "(", ")", "map", "(", ")", ",", "null", ")", ";", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "throw", "new", "api", "exception", "(", "e", ")", ";", "}", "catch", "(", "interrupted", "exception", "e", ")", "{", "thread", "current", "thread", "(", ")", "interrupt", "(", ")", ";", "throw", "new", "api", "exception", "(", "e", ")", ";", "}", "}" ]