Datasets:
Anonymous2023
/
KGSum

Dataset card Data Studio Files Community
docstring_tokens
list
code_tokens
list
[ "called", "when", "a", "new", "{", "@", "link", "health", "check", "}", "is", "added", "to", "the", "registry" ]
[ "void", "on", "health", "check", "added", "(", "string", "name", ",", "health", "check", "health", "check", ")", ";" ]
[ "sets", "custom", "{", "@", "linkplain", "handler", "handler", "}", "for", "displaying", "images", "and", "firing", "{", "@", "linkplain", "image", "loading", "listener", "listener", "}", "events" ]
[ "public", "builder", "handler", "(", "handler", "handler", ")", "{", "this", "handler", "=", "handler", ";", "return", "this", ";", "}" ]
[ "scenario", ":", "an", "image", "fetch", "fails", "we", "expect", "it", "to", "be", "re", "-", "queued", ",", "and", "since", "it", "is", "hi", "-", "pri", ",", "to", "be", "retried", "immediately" ]
[ "public", "void", "test", "infinite", "retries", "requeue", "on", "fail", "(", ")", "{", "recording", "network", "fetcher", "recording", "network", "fetcher", "=", "new", "recording", "network", "fetcher", "(", ")", ";", "/", "/", "max", "hi", "-", "pri", ":", "1", ",", "max", "low", "-", "pri", ":", "0", "priority", "network", "fetcher", "<", "fetch", "state", ">", "fetcher", "=", "new", "priority", "network", "fetcher", "<", ">", "(", "recording", "network", "fetcher", ",", "false", ",", "1", ",", "0", ",", "true", ",", "true", ")", ";", "priority", "fetch", "state", "<", "fetch", "state", ">", "hipri", "1", "=", "fetch", "(", "fetcher", ",", "\"", "hipri", "1", "\"", ",", "callback", ",", "true", ")", ";", "priority", "fetch", "state", "<", "fetch", "state", ">", "hipri", "2", "=", "fetch", "(", "fetcher", ",", "\"", "hipri", "2", "\"", ",", "callback", ",", "true", ")", ";", "assert", "that", "(", "fetcher", "get", "currently", "fetching", "(", ")", ")", "contains", "exactly", "(", "hipri", "1", ")", ";", "assert", "that", "(", "fetcher", "get", "hi", "pri", "queue", "(", ")", ")", "contains", "exactly", "(", "hipri", "2", ")", ";", "assert", "that", "(", "fetcher", "get", "low", "pri", "queue", "(", ")", ")", "is", "empty", "(", ")", ";", "/", "/", "simulate", "a", "failure", "in", "hipri", "1", "get", "only", "element", "(", "recording", "network", "fetcher", "callbacks", "get", "(", "hipri", "1", "delegated", "state", ")", ")", "on", "failure", "(", "new", "exception", "(", ")", ")", ";", "assert", "that", "(", "fetcher", "get", "currently", "fetching", "(", ")", ")", "contains", "exactly", "(", "hipri", "1", ")", ";", "assert", "that", "(", "fetcher", "get", "hi", "pri", "queue", "(", ")", ")", "contains", "exactly", "(", "hipri", "2", ")", ";", "assert", "that", "(", "fetcher", "get", "low", "pri", "queue", "(", ")", ")", "is", "empty", "(", ")", ";", "assert", "that", "(", "hipri", "1", "requeue", "count", ")", "is", "equal", "to", "(", "1", ")", ";", "}" ]
[ "utility", "method", "to", "find", "the", "report", "with", "the", "highest", "health" ]
[ "public", "static", "health", "report", "max", "(", "health", "report", "a", ",", "health", "report", "b", ")", "{", "if", "(", "a", "=", "=", "null", "&", "&", "b", "=", "=", "null", ")", "return", "null", ";", "if", "(", "a", "=", "=", "null", ")", "return", "b", ";", "if", "(", "b", "=", "=", "null", ")", "return", "a", ";", "if", "(", "a", "compare", "to", "(", "b", ")", ">", "=", "0", ")", "return", "a", ";", "return", "b", ";", "}" ]
[ "returns", "number", "of", "heap", "bytes", "used", "by", "the", "indexing", "buffer", "for", "this", "shard", ",", "or", "0", "if", "the", "shard", "is", "closed" ]
[ "public", "long", "get", "index", "buffer", "r", "a", "m", "bytes", "used", "(", ")", "{", "engine", "engine", "=", "get", "engine", "or", "null", "(", ")", ";", "if", "(", "engine", "=", "=", "null", ")", "{", "return", "0", ";", "}", "try", "{", "return", "engine", "get", "index", "buffer", "r", "a", "m", "bytes", "used", "(", ")", ";", "}", "catch", "(", "already", "closed", "exception", "ex", ")", "{", "return", "0", ";", "}", "}" ]
[ "logs", "out", "current", "logged", "in", "user", "session" ]
[ "void", "logout", "user", "(", ")", ";" ]
[ "required", "the", "ports", "associated", "with", "the", "external", "service", "if", "the", "endpoints", "are", "unix", "domain", "socket", "addresses", ",", "there", "must", "be", "exactly", "one", "port", "<", "code", ">", "repeated", "istio", "networking", "v", "1alpha", "3", "port", "ports", "=", "3", ";", "<", "code", ">" ]
[ "public", "builder", "add", "ports", "(", "int", "index", ",", "com", "alibaba", "nacos", "istio", "model", "port", "builder", "builder", "for", "value", ")", "{", "if", "(", "ports", "builder", "=", "=", "null", ")", "{", "ensure", "ports", "is", "mutable", "(", ")", ";", "ports", "add", "(", "index", ",", "builder", "for", "value", "build", "(", ")", ")", ";", "on", "changed", "(", ")", ";", "}", "else", "{", "ports", "builder", "add", "message", "(", "index", ",", "builder", "for", "value", "build", "(", ")", ")", ";", "}", "return", "this", ";", "}" ]
[ "handle", "the", "case", "of", "an", "object", "property", "type" ]
[ "public", "void", "visit", "(", "object", "value", "1", ")", "{", "throw", "new", "runtime", "exception", "(", ")", ";", "}" ]
[ "read", "in", "the", "inputs", "or", "outputs", "list", "for", "this", "function", "from", "an", "xml", "rep" ]
[ "private", "void", "parse", "param", "measure", "x", "m", "l", "(", "xml", "pull", "parser", "parser", ",", "list", "<", "param", "measure", ">", "pmlist", ",", "string", "tag", ")", "throws", "pcode", "x", "m", "l", "exception", "{", "xml", "element", "el", "=", "parser", "start", "(", "tag", ")", ";", "param", "measure", "pm", "=", "new", "param", "measure", "(", ")", ";", "pm", "read", "xml", "(", "parser", ",", "this", ")", ";", "if", "(", "!", "pm", "is", "empty", "(", ")", ")", "{", "pmlist", "add", "(", "pm", ")", ";", "}", "parser", "end", "(", "el", ")", ";", "}" ]
[ "formats", "time", "in", "ms", "and", "appends", "difference", "(", "finish", "time", "-", "start", "time", ")", "as", "returned", "by", "format", "time", "diff", "(", ")", "if", "finish", "time", "is", "0", ",", "empty", "string", "is", "returned", ",", "if", "start", "time", "is", "0", "then", "difference", "is", "not", "appended", "to", "return", "value" ]
[ "public", "static", "string", "get", "formatted", "time", "with", "diff", "(", "fast", "date", "format", "date", "format", ",", "long", "finish", "time", ",", "long", "start", "time", ")", "{", "string", "formatted", "finish", "time", "=", "date", "format", "format", "(", "finish", "time", ")", ";", "return", "get", "formatted", "time", "with", "diff", "(", "formatted", "finish", "time", ",", "finish", "time", ",", "start", "time", ")", ";", "}" ]
[ "register", "a", "groovy", "markup", "view", "resolver", "with", "an", "empty", "default", "view", "name", "prefix", "and", "a", "default", "suffix", "of", "\"", "tpl", "\"" ]
[ "public", "url", "based", "view", "resolver", "registration", "groovy", "(", ")", "{", "if", "(", "!", "check", "bean", "of", "type", "(", "groovy", "markup", "configurer", "class", ")", ")", "{", "throw", "new", "bean", "initialization", "exception", "(", "\"", "in", "addition", "to", "a", "groovy", "markup", "view", "resolver", "\"", "+", "\"", "there", "must", "also", "be", "a", "single", "groovy", "markup", "config", "bean", "in", "this", "web", "application", "context", "\"", "+", "\"", "(", "or", "its", "parent", ")", ":", "groovy", "markup", "configurer", "is", "the", "usual", "implementation", "\"", "+", "\"", "this", "bean", "may", "be", "given", "any", "name", "\"", ")", ";", "}", "groovy", "markup", "registration", "registration", "=", "new", "groovy", "markup", "registration", "(", ")", ";", "this", "view", "resolvers", "add", "(", "registration", "get", "view", "resolver", "(", ")", ")", ";", "return", "registration", ";", "}" ]
[ "sets", "the", "image", "bounds", "listener" ]
[ "public", "void", "set", "image", "bounds", "listener", "(", "@", "nullable", "image", "bounds", "listener", "image", "bounds", "listener", ")", "{", "m", "image", "bounds", "listener", "=", "image", "bounds", "listener", ";", "}" ]
[ "<", "code", ">", "map", "&", "lt", ";", "string", ",", "org", "apache", "dubbo", "common", "serialize", "protobuf", "model", "phone", "number", "&", "gt", ";", "double", "map", "=", "9", ";", "<", "code", ">" ]
[ "public", "java", "util", "map", "<", "string", ",", "phone", "number", ">", "get", "double", "map", "map", "(", ")", "{", "return", "internal", "get", "double", "map", "(", ")", "get", "map", "(", ")", ";", "}" ]
[ "reads", "unsigned", "integer", "in", "little", "-", "endian", "byte", "order" ]
[ "private", "long", "read", "unsigned", "int", "(", ")", "{", "long", "s", "=", "read", "unsigned", "short", "(", ")", ";", "return", "(", "(", "long", ")", "read", "unsigned", "short", "(", ")", "<", "<", "16", ")", "|", "s", ";", "}" ]
[ "returns", "true", "if", "this", "plugin", "has", "data", "that", "needs", "saving", ";" ]
[ "protected", "boolean", "has", "unsave", "data", "(", ")", "{", "return", "false", ";", "}" ]
[ "copies", "the", "inter", "stage", "state", "(", "if", "any", ")", "from", "the", "diff", "node", "'", "s", "component", "to", "the", "layout", "node", "'", "s", "component", ",", "and", "declares", "that", "the", "cached", "measures", "on", "the", "diff", "node", "are", "valid", "for", "the", "layout", "node" ]
[ "private", "static", "void", "apply", "diff", "node", "to", "layout", "node", "(", "final", "internal", "node", "layout", "node", ",", "final", "diff", "node", "diff", "node", ")", "{", "final", "component", "component", "=", "layout", "node", "get", "tail", "component", "(", ")", ";", "if", "(", "component", "!", "=", "null", ")", "{", "component", "copy", "inter", "stage", "impl", "(", "diff", "node", "get", "component", "(", ")", ")", ";", "}", "layout", "node", "set", "cached", "measures", "valid", "(", "true", ")", ";", "}" ]
[ "test", "the", "property", "'", "name", "'" ]
[ "public", "void", "name", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "name", "}" ]
[ "utility", "method", "that", "returns", "the", "first", "child", "element", "value", "identified", "by", "its", "name" ]
[ "public", "static", "string", "get", "child", "element", "value", "by", "tag", "name", "(", "element", "ele", ",", "string", "child", "ele", "name", ")", "{", "element", "child", "=", "get", "child", "element", "by", "tag", "name", "(", "ele", ",", "child", "ele", "name", ")", ";", "return", "(", "child", "!", "=", "null", "?", "get", "text", "value", "(", "child", ")", ":", "null", ")", ";", "}" ]
[ "retrieves", "and", "removes", "the", "first", "element", "of", "this", "deque", "this", "method", "differs", "from", "{", "@", "link", "#", "poll", "first", "poll", "first", "}", "only", "in", "that", "it", "throws", "an", "exception", "if", "this", "deque", "is", "empty" ]
[ "e", "remove", "first", "(", ")", ";" ]
[ "set", "the", "font", "for", "the", "message" ]
[ "public", "void", "set", "toaster", "message", "font", "(", "font", "f", ")", "{", "font", "=", "f", ";", "}" ]
[ "test", "unlinking", "a", "file", "whose", "blocks", "we", "are", "caching", "in", "the", "d", "f", "s", "client", "the", "data", "node", "will", "notify", "the", "d", "f", "s", "client", "that", "the", "replica", "is", "stale", "via", "the", "short", "circuit", "shm" ]
[ "public", "void", "test", "unlinking", "replicas", "in", "file", "descriptor", "cache", "(", ")", "throws", "exception", "{", "block", "reader", "test", "util", "enable", "short", "circuit", "shm", "tracing", "(", ")", ";", "temporary", "socket", "directory", "sock", "dir", "=", "new", "temporary", "socket", "directory", "(", ")", ";", "configuration", "conf", "=", "create", "short", "circuit", "conf", "(", "\"", "test", "unlinking", "replicas", "in", "file", "descriptor", "cache", "\"", ",", "sock", "dir", ")", ";", "/", "/", "we", "don", "'", "t", "want", "the", "cache", "cleaner", "to", "time", "out", "short", "-", "circuit", "shared", "memory", "/", "/", "segments", "during", "the", "test", ",", "so", "set", "the", "timeout", "really", "high", "conf", "set", "long", "(", "hdfs", "client", "config", "keys", "read", "short", "circuit", "streams", "cache", "expiry", "ms", "key", ",", "1000000000l", ")", ";", "mini", "d", "f", "s", "cluster", "cluster", "=", "new", "mini", "d", "f", "s", "cluster", "builder", "(", "conf", ")", "num", "data", "nodes", "(", "1", ")", "build", "(", ")", ";", "cluster", "wait", "active", "(", ")", ";", "distributed", "file", "system", "fs", "=", "cluster", "get", "file", "system", "(", ")", ";", "final", "short", "circuit", "cache", "cache", "=", "fs", "get", "client", "(", ")", "get", "client", "context", "(", ")", "get", "short", "circuit", "cache", "(", "0", ")", ";", "cache", "get", "dfs", "client", "shm", "manager", "(", ")", "visit", "(", "new", "visitor", "(", ")", "{", "@", "override", "public", "void", "visit", "(", "hash", "map", "<", "datanode", "info", ",", "per", "datanode", "visitor", "info", ">", "info", ")", "throws", "i", "o", "exception", "{", "/", "/", "the", "client", "shm", "manager", "starts", "off", "empty", "assert", "assert", "equals", "(", "0", ",", "info", "size", "(", ")", ")", ";", "}", "}", ")", ";", "final", "path", "test", "path", "=", "new", "path", "(", "\"", "/", "test", "file", "\"", ")", ";", "final", "int", "test", "file", "len", "=", "8193", ";", "final", "int", "seed", "=", "0x", "f", "a", "d", "e", "0", ";", "d", "f", "s", "test", "util", "create", "file", "(", "fs", ",", "test", "path", ",", "test", "file", "len", ",", "(", "short", ")", "1", ",", "seed", ")", ";", "byte", "contents", "[", "]", "=", "d", "f", "s", "test", "util", "read", "file", "buffer", "(", "fs", ",", "test", "path", ")", ";", "byte", "expected", "[", "]", "=", "d", "f", "s", "test", "util", "calculate", "file", "contents", "from", "seed", "(", "seed", ",", "test", "file", "len", ")", ";", "assert", "assert", "true", "(", "arrays", "equals", "(", "contents", ",", "expected", ")", ")", ";", "/", "/", "loading", "this", "file", "brought", "the", "short", "circuit", "replica", "into", "our", "local", "/", "/", "replica", "cache", "final", "datanode", "info", "datanode", "=", "new", "datanode", "info", "builder", "(", ")", "set", "node", "i", "d", "(", "cluster", "get", "data", "nodes", "(", ")", "get", "(", "0", ")", "get", "datanode", "id", "(", ")", ")", "build", "(", ")", ";", "cache", "get", "dfs", "client", "shm", "manager", "(", ")", "visit", "(", "new", "visitor", "(", ")", "{", "@", "override", "public", "void", "visit", "(", "hash", "map", "<", "datanode", "info", ",", "per", "datanode", "visitor", "info", ">", "info", ")", "throws", "i", "o", "exception", "{", "assert", "assert", "true", "(", "info", "get", "(", "datanode", ")", "full", "is", "empty", "(", ")", ")", ";", "assert", "assert", "false", "(", "info", "get", "(", "datanode", ")", "disabled", ")", ";", "assert", "assert", "equals", "(", "1", ",", "info", "get", "(", "datanode", ")", "not", "full", "values", "(", ")", "size", "(", ")", ")", ";", "dfs", "client", "shm", "shm", "=", "info", "get", "(", "datanode", ")", "not", "full", "values", "(", ")", "iterator", "(", ")", "next", "(", ")", ";", "assert", "assert", "false", "(", "shm", "is", "disconnected", "(", ")", ")", ";", "}", "}", ")", ";", "/", "/", "remove", "the", "file", "whose", "blocks", "we", "just", "read", "fs", "delete", "(", "test", "path", ",", "false", ")", ";", "/", "/", "wait", "for", "the", "replica", "to", "be", "purged", "from", "the", "d", "f", "s", "client", "'", "s", "cache", "generic", "test", "utils", "wait", "for", "(", "new", "supplier", "<", "boolean", ">", "(", ")", "{", "mutable", "boolean", "done", "=", "new", "mutable", "boolean", "(", "true", ")", ";", "@", "override", "public", "boolean", "get", "(", ")", "{", "try", "{", "done", "set", "value", "(", "true", ")", ";", "cache", "get", "dfs", "client", "shm", "manager", "(", ")", "visit", "(", "new", "visitor", "(", ")", "{", "@", "override", "public", "void", "visit", "(", "hash", "map", "<", "datanode", "info", ",", "per", "datanode", "visitor", "info", ">", "info", ")", "throws", "i", "o", "exception", "{", "assert", "assert", "true", "(", "info", "get", "(", "datanode", ")", "full", "is", "empty", "(", ")", ")", ";", "assert", "assert", "false", "(", "info", "get", "(", "datanode", ")", "disabled", ")", ";", "assert", "assert", "equals", "(", "1", ",", "info", "get", "(", "datanode", ")", "not", "full", "values", "(", ")", "size", "(", ")", ")", ";", "dfs", "client", "shm", "shm", "=", "info", "get", "(", "datanode", ")", "not", "full", "values", "(", ")", "iterator", "(", ")", "next", "(", ")", ";", "/", "/", "check", "that", "all", "slots", "have", "been", "invalidated", "for", "(", "iterator", "<", "slot", ">", "iter", "=", "shm", "slot", "iterator", "(", ")", ";", "iter", "has", "next", "(", ")", ";", ")", "{", "slot", "slot", "=", "iter", "next", "(", ")", ";", "if", "(", "slot", "is", "valid", "(", ")", ")", "{", "done", "set", "value", "(", "false", ")", ";", "}", "}", "}", "}", ")", ";", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "log", "error", "(", "\"", "error", "running", "visitor", "\"", ",", "e", ")", ";", "}", "return", "done", "boolean", "value", "(", ")", ";", "}", "}", ",", "10", ",", "60000", ")", ";", "cluster", "shutdown", "(", ")", ";", "sock", "dir", "close", "(", ")", ";", "}" ]
[ "validate", "that", "a", "{", "@", "link", "collection", "}", "of", "the", "elements", "held", "within", "the", "stream", "can", "be", "converted", "to", "the", "specified", "{", "@", "code", "target", "type", "}" ]
[ "public", "boolean", "matches", "from", "stream", "(", "@", "nullable", "type", "descriptor", "element", "type", ",", "type", "descriptor", "target", "type", ")", "{", "type", "descriptor", "collection", "of", "element", "=", "type", "descriptor", "collection", "(", "collection", "class", ",", "element", "type", ")", ";", "return", "this", "conversion", "service", "can", "convert", "(", "collection", "of", "element", ",", "target", "type", ")", ";", "}" ]
[ "applies", "the", "given", "{", "@", "link", "#", "get", "revision", "id", "(", "object", "metadata", ",", "string", ")", "revision", "id", "}", "as", "a", "server", "-", "side", "qualification", "on", "the", "{", "@", "code", "get", "object", "request", "}" ]
[ "public", "abstract", "void", "apply", "revision", "constraint", "(", "get", "object", "request", "request", ",", "string", "revision", "id", ")", ";" ]
[ "configure", "asynchronous", "request", "handling", "options" ]
[ "default", "void", "configure", "async", "support", "(", "async", "support", "configurer", "configurer", ")", "{", "}" ]
[ "see", "iso", "16022", ":", "2006", ",", "annex", "b", ",", "b", "2" ]
[ "private", "static", "int", "unrandomize", "2", "5", "5", "state", "(", "int", "randomized", "base", "2", "5", "6", "codeword", ",", "int", "base", "2", "5", "6", "codeword", "position", ")", "{", "int", "pseudo", "random", "number", "=", "(", "(", "149", "*", "base", "2", "5", "6", "codeword", "position", ")", "%", "255", ")", "+", "1", ";", "int", "temp", "variable", "=", "randomized", "base", "2", "5", "6", "codeword", "-", "pseudo", "random", "number", ";", "return", "temp", "variable", ">", "=", "0", "?", "temp", "variable", ":", "temp", "variable", "+", "256", ";", "}" ]
[ "get", "prefix", "ns", "array" ]
[ "public", "list", "<", "integer", ">", "get", "prefix", "ns", "array", "(", ")", "{", "return", "prefix", "ns", "array", ";", "}" ]
[ "helper", "method", "that", "returns", "a", "collection", "of", "artifacts", "that", "are", "necessary", "for", "the", "runfiles", "of", "the", "given", "target", "note", "that", "the", "runfile", "symlink", "tree", "is", "never", "built", ",", "so", "this", "may", "include", "artifacts", "that", "end", "up", "not", "being", "used", "(", "see", "{", "@", "link", "runfiles", "}", ")" ]
[ "private", "static", "runfiles", "get", "runfiles", "(", "transitive", "info", "collection", "target", ",", "string", "workspace", "name", ")", "{", "runfiles", "provider", "runfiles", "provider", "=", "target", "get", "provider", "(", "runfiles", "provider", "class", ")", ";", "if", "(", "runfiles", "provider", "!", "=", "null", ")", "{", "return", "runfiles", "provider", "get", "default", "runfiles", "(", ")", ";", "}", "else", "{", "return", "new", "runfiles", "builder", "(", "workspace", "name", ")", "add", "transitive", "artifacts", "(", "target", "get", "provider", "(", "files", "to", "run", "provider", "class", ")", "get", "files", "to", "run", "(", ")", ")", "build", "(", ")", ";", "}", "}" ]
[ "waits", "for", "any", "action", "to", "complete", ",", "or", "the", "timeout", "to", "elapse", "the", "thread", "must", "wait", "at", "least", "for", "the", "specified", "timeout", ",", "unless", "some", "action", "completes", "in", "the", "meantime", "it", "'", "s", "not", "allowed", "to", "return", "0", "too", "early", "note", "that", "it", "'", "s", "acceptable", "to", "return", "(", "any", "value", ")", "later", "than", "specified", "by", "the", "timeout" ]
[ "int", "wait", "for", "next", "completion", "(", "int", "timeout", "seconds", ")", "throws", "interrupted", "exception", ";" ]
[ "build", "a", "{", "@", "link", "field", "mapper", "}", "to", "create", "the", "{", "@", "link", "mapping", "lookup", "}", "used", "for", "the", "aggs", "{", "@", "code", "protected", "}", "so", "subclasses", "can", "have", "it" ]
[ "protected", "field", "mapper", "build", "mock", "field", "mapper", "(", "mapped", "field", "type", "ft", ")", "{", "return", "new", "mock", "field", "mapper", "(", "ft", ")", ";", "}" ]
[ "add", "a", "file", "path", "to", "the", "current", "set", "of", "classpath", "entries", "the", "file", "will", "also", "be", "added", "to", "the", "cache", "intended", "to", "be", "used", "by", "user", "code" ]
[ "public", "static", "void", "add", "file", "to", "class", "path", "(", "path", "file", ",", "configuration", "conf", ")", "throws", "i", "o", "exception", "{", "add", "file", "to", "class", "path", "(", "file", ",", "conf", ",", "file", "get", "file", "system", "(", "conf", ")", ")", ";", "}" ]
[ "get", "all", "registered", "listeners", "of", "the", "given", "type" ]
[ "public", "<", "t", ">", "t", "[", "]", "get", "listeners", "(", "class", "<", "t", ">", "listener", "type", ")", "{", "if", "(", "listener", "type", "=", "=", "autocompletion", "listener", "class", ")", "{", "return", "(", "t", "[", "]", ")", "get", "autocompletion", "listeners", "(", ")", ";", "}", "return", "null", ";", "}" ]
[ "judge", "whether", "this", "agent", "is", "supported", "to", "push" ]
[ "public", "boolean", "can", "enable", "push", "(", "string", "agent", ")", "{", "if", "(", "!", "switch", "domain", "is", "push", "enabled", "(", ")", ")", "{", "return", "false", ";", "}", "client", "info", "client", "info", "=", "new", "client", "info", "(", "agent", ")", ";", "if", "(", "client", "info", "client", "type", "java", "=", "=", "client", "info", "type", "&", "&", "client", "info", "version", "compare", "to", "(", "version", "util", "parse", "version", "(", "switch", "domain", "get", "push", "java", "version", "(", ")", ")", ")", ">", "=", "0", ")", "{", "return", "true", ";", "}", "else", "if", "(", "client", "info", "client", "type", "dns", "=", "=", "client", "info", "type", "&", "&", "client", "info", "version", "compare", "to", "(", "version", "util", "parse", "version", "(", "switch", "domain", "get", "push", "python", "version", "(", ")", ")", ")", ">", "=", "0", ")", "{", "return", "true", ";", "}", "else", "if", "(", "client", "info", "client", "type", "c", "=", "=", "client", "info", "type", "&", "&", "client", "info", "version", "compare", "to", "(", "version", "util", "parse", "version", "(", "switch", "domain", "get", "push", "c", "version", "(", ")", ")", ")", ">", "=", "0", ")", "{", "return", "true", ";", "}", "else", "if", "(", "client", "info", "client", "type", "go", "=", "=", "client", "info", "type", "&", "&", "client", "info", "version", "compare", "to", "(", "version", "util", "parse", "version", "(", "switch", "domain", "get", "push", "go", "version", "(", ")", ")", ")", ">", "=", "0", ")", "{", "return", "true", ";", "}", "else", "if", "(", "client", "info", "client", "type", "csharp", "=", "=", "client", "info", "type", "&", "&", "client", "info", "version", "compare", "to", "(", "version", "util", "parse", "version", "(", "switch", "domain", "get", "push", "c", "sharp", "version", "(", ")", ")", ")", ">", "=", "0", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}" ]
[ "gets", "all", "actions", "for", "the", "function", "comparison", "panel", "and", "all", "code", "comparison", "panels", "in", "this", "function", "comparison", "panel" ]
[ "public", "docking", "action", "[", "]", "get", "code", "comparison", "actions", "(", ")", "{", "array", "list", "<", "docking", "action", ">", "docking", "action", "list", "=", "new", "array", "list", "<", ">", "(", ")", ";", "/", "/", "get", "actions", "for", "this", "function", "comparison", "panel", "docking", "action", "[", "]", "function", "comparison", "actions", "=", "get", "actions", "(", ")", ";", "for", "(", "docking", "action", "docking", "action", ":", "function", "comparison", "actions", ")", "{", "docking", "action", "list", "add", "(", "docking", "action", ")", ";", "}", "/", "/", "get", "actions", "for", "each", "code", "comparison", "panel", "for", "(", "code", "comparison", "panel", "<", "?", "extends", "field", "panel", "coordinator", ">", "code", "comparison", "panel", ":", "code", "comparison", "panels", ")", "{", "docking", "action", "[", "]", "actions", "=", "code", "comparison", "panel", "get", "actions", "(", ")", ";", "for", "(", "docking", "action", "docking", "action", ":", "actions", ")", "{", "docking", "action", "list", "add", "(", "docking", "action", ")", ";", "}", "}", "return", "docking", "action", "list", "to", "array", "(", "new", "docking", "action", "[", "docking", "action", "list", "size", "(", ")", "]", ")", ";", "}" ]
[ "format", "to", "the", "appropriate", "rollup", "field", "name", "convention" ]
[ "public", "static", "string", "format", "field", "name", "(", "values", "source", "aggregation", "builder", "<", "?", ">", "source", ",", "string", "extra", ")", "{", "return", "source", "field", "(", ")", "+", "\"", "\"", "+", "source", "get", "type", "(", ")", "+", "\"", "\"", "+", "extra", ";", "}" ]
[ "blocks", "until", "the", "condition", "is", "open", "unlike", "{", "@", "link", "#", "block", "}", ",", "this", "method", "will", "continue", "to", "block", "if", "the", "calling", "thread", "is", "interrupted", "if", "the", "calling", "thread", "was", "interrupted", "then", "its", "{", "@", "link", "thread", "#", "is", "interrupted", "(", ")", "interrupted", "status", "}", "will", "be", "set", "when", "the", "method", "returns" ]
[ "public", "synchronized", "void", "block", "uninterruptible", "(", ")", "{", "boolean", "was", "interrupted", "=", "false", ";", "while", "(", "!", "is", "open", ")", "{", "try", "{", "wait", "(", ")", ";", "}", "catch", "(", "interrupted", "exception", "e", ")", "{", "was", "interrupted", "=", "true", ";", "}", "}", "if", "(", "was", "interrupted", ")", "{", "/", "/", "restore", "the", "interrupted", "status", "thread", "current", "thread", "(", ")", "interrupt", "(", ")", ";", "}", "}" ]
[ "replaces", "the", "function", "symbol", "at", "the", "indicated", "entry", "point", "in", "the", "\"", "to", "\"", "program", "with", "the", "function", "symbol", "in", "the", "\"", "from", "\"", "program", "if", "there", "is", "no", "function", "in", "the", "\"", "to", "\"", "program", "the", "symbol", "becomes", "a", "regular", "\"", "label", "\"", "symbol" ]
[ "private", "void", "replace", "function", "symbol", "(", "address", "from", "entry", "point", ",", "address", "to", "entry", "point", ",", "long", "long", "hashtable", "conflict", "symbol", "i", "d", "map", ",", "task", "monitor", "monitor", ")", "throws", "duplicate", "name", "exception", ",", "invalid", "input", "exception", "{", "/", "/", "assumes", ":", "the", "function", "in", "the", "destination", "program", "should", "already", "be", "replaced", "at", "this", "point", "/", "/", "however", ",", "the", "symbol", "name", "and", "name", "space", "have", "not", "been", "replaced", "function", "manager", "from", "function", "mgr", "=", "from", "program", "get", "function", "manager", "(", ")", ";", "function", "manager", "to", "function", "mgr", "=", "to", "program", "get", "function", "manager", "(", ")", ";", "function", "from", "func", "=", "from", "function", "mgr", "get", "function", "at", "(", "from", "entry", "point", ")", ";", "function", "to", "func", "=", "to", "function", "mgr", "get", "function", "at", "(", "to", "entry", "point", ")", ";", "if", "(", "from", "func", "=", "=", "null", ")", "{", "return", ";", "}", "symbol", "from", "symbol", "=", "from", "func", "get", "symbol", "(", ")", ";", "source", "type", "from", "source", "=", "from", "symbol", "get", "source", "(", ")", ";", "string", "from", "name", "=", "from", "symbol", "get", "name", "(", ")", ";", "namespace", "from", "namespace", "=", "from", "symbol", "get", "parent", "namespace", "(", ")", ";", "symbol", "to", "symbol", ";", "if", "(", "to", "func", "=", "=", "null", ")", "{", "if", "(", "from", "source", "=", "=", "source", "type", "default", ")", "{", "return", ";", "}", "namespace", "to", "namespace", "=", "to", "program", "get", "global", "namespace", "(", ")", ";", "to", "func", "=", "to", "function", "mgr", "get", "function", "containing", "(", "to", "entry", "point", ")", ";", "if", "(", "to", "func", "!", "=", "null", ")", "{", "to", "namespace", "=", "to", "func", ";", "}", "/", "/", "if", "replacing", "a", "function", "name", ",", "but", "there", "isn", "'", "t", "a", "function", "in", "the", "destination", ",", "/", "/", "create", "a", "regular", "label", "with", "the", "function", "name", "unless", "its", "the", "default", "name", "to", "symbol", "=", "to", "symbol", "table", "create", "label", "(", "to", "entry", "point", ",", "from", "name", ",", "to", "namespace", ",", "from", "source", ")", ";", "}", "else", "{", "to", "symbol", "=", "to", "func", "get", "symbol", "(", ")", ";", "/", "/", "replacing", "the", "function", "name", "if", "(", "to", "symbol", "equals", "(", "from", "symbol", ")", ")", "{", "if", "(", "from", "source", "!", "=", "source", "type", "default", "&", "&", "to", "symbol", "get", "source", "(", ")", "!", "=", "from", "source", ")", "{", "try", "{", "to", "symbol", "set", "source", "(", "from", "source", ")", ";", "}", "catch", "(", "illegal", "argument", "exception", "e", ")", "{", "msg", "warn", "(", "this", ",", "e", "get", "message", "(", ")", ")", ";", "}", "}", "boolean", "pinned", "=", "from", "symbol", "is", "pinned", "(", ")", ";", "if", "(", "to", "symbol", "is", "pinned", "(", ")", "!", "=", "pinned", ")", "{", "to", "symbol", "set", "pinned", "(", "pinned", ")", ";", "}", "return", ";", "/", "/", "symbols", "aren", "'", "t", "different", "}", "string", "to", "name", "=", "to", "symbol", "get", "name", "(", ")", ";", "namespace", "new", "to", "namespace", "=", "resolve", "namespace", "(", "from", "namespace", ",", "conflict", "symbol", "i", "d", "map", ")", ";", "if", "(", "!", "to", "name", "equals", "(", "from", "name", ")", ")", "{", "to", "func", "set", "name", "(", "from", "name", ",", "from", "source", ")", ";", "}", "try", "{", "to", "func", "set", "parent", "namespace", "(", "new", "to", "namespace", ")", ";", "}", "catch", "(", "circular", "dependency", "exception", "|", "invalid", "input", "exception", "e", ")", "{", "msg", "error", "(", "this", ",", "\"", "unexpected", "exception", ":", "\"", "+", "e", "get", "message", "(", ")", ",", "e", ")", ";", "}", "}", "boolean", "pinned", "=", "from", "symbol", "is", "pinned", "(", ")", ";", "if", "(", "to", "symbol", "is", "pinned", "(", ")", "!", "=", "pinned", ")", "{", "to", "symbol", "set", "pinned", "(", "pinned", ")", ";", "}", "}" ]
[ "generate", "random", "data", "and", "return", "a", "data", "block" ]
[ "protected", "e", "c", "block", "generate", "data", "block", "(", ")", "{", "e", "c", "chunk", "[", "]", "chunks", "=", "new", "e", "c", "chunk", "[", "num", "chunks", "in", "block", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "num", "chunks", "in", "block", ";", "+", "+", "i", ")", "{", "chunks", "[", "i", "]", "=", "generate", "data", "chunk", "(", ")", ";", "}", "return", "new", "test", "block", "(", "chunks", ")", ";", "}" ]
[ "returns", "the", "name" ]
[ "public", "string", "get", "name", "(", ")", "{", "return", "name", ";", "}" ]
[ "get", "the", "path", "for", "a", "record", "class" ]
[ "private", "<", "t", "extends", "base", "record", ">", "string", "get", "path", "for", "class", "(", "final", "class", "<", "t", ">", "clazz", ")", "{", "string", "class", "name", "=", "state", "store", "utils", "get", "record", "name", "(", "clazz", ")", ";", "string", "builder", "sb", "=", "new", "string", "builder", "(", ")", ";", "sb", "append", "(", "get", "root", "dir", "(", ")", ")", ";", "if", "(", "sb", "char", "at", "(", "sb", "length", "(", ")", "-", "1", ")", "!", "=", "'", "/", "'", ")", "{", "sb", "append", "(", "\"", "/", "\"", ")", ";", "}", "sb", "append", "(", "class", "name", ")", ";", "return", "sb", "to", "string", "(", ")", ";", "}" ]
[ "instructs", "the", "{", "@", "link", "org", "elasticsearch", "common", "inject", "injector", "}", "to", "eagerly", "initialize", "this", "singleton", "-", "scoped", "binding", "upon", "creation", "useful", "for", "application", "initialization", "logic", "see", "the", "edsl", "examples", "at", "{", "@", "link", "org", "elasticsearch", "common", "inject", "binder", "}" ]
[ "void", "as", "eager", "singleton", "(", ")", ";" ]
[ "get", "date", "time" ]
[ "public", "offset", "date", "time", "get", "date", "time", "(", ")", "{", "return", "date", "time", ";", "}" ]
[ "the", "path", "of", "temporary", "folder", "used", "to", "store", "downloaded", "files", "from", "endpoints", "with", "file", "response", "the", "default", "value", "is", "<", "code", ">", "null", "<", "code", ">", ",", "i", "e", "using", "the", "system", "'", "s", "default", "tempopary", "folder" ]
[ "public", "string", "get", "temp", "folder", "path", "(", ")", "{", "return", "temp", "folder", "path", ";", "}" ]
[ "retrieves", "the", "value", "of", "this", "variable", "from", "skyframe", "if", "the", "value", "was", "not", "set", ",", "an", "exception", "will", "be", "raised" ]
[ "public", "t", "get", "(", "sky", "function", "environment", "env", ")", "throws", "interrupted", "exception", "{", "precomputed", "value", "value", "=", "(", "precomputed", "value", ")", "env", "get", "value", "(", "key", ")", ";", "if", "(", "value", "=", "=", "null", ")", "{", "return", "null", ";", "}", "return", "(", "t", ")", "value", "get", "(", ")", ";", "}" ]
[ "tests", "forwarding", "of", "both", "{", "@", "link", "read", "only", "sliced", "network", "buffer", "#", "recycle", "buffer", "(", ")", "}", "and", "{", "@", "link", "read", "only", "sliced", "network", "buffer", "#", "is", "recycled", "(", ")", "}" ]
[ "public", "void", "test", "forwards", "retain", "buffer", "1", "(", ")", "{", "read", "only", "sliced", "network", "buffer", "slice", "=", "buffer", "read", "only", "slice", "(", ")", ";", "assert", "equals", "(", "buffer", "ref", "cnt", "(", ")", ",", "slice", "ref", "cnt", "(", ")", ")", ";", "slice", "retain", "buffer", "(", ")", ";", "assert", "equals", "(", "buffer", "ref", "cnt", "(", ")", ",", "slice", "ref", "cnt", "(", ")", ")", ";", "}" ]
[ "test", "the", "property", "'", "password", "'" ]
[ "public", "void", "password", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "password", "}" ]
[ "returns", "the", "internal", "seeds", "to", "allow", "state", "saving" ]
[ "public", "long", "get", "state", "(", "int", "seed", ")", "{", "return", "seed", "=", "=", "0", "?", "seed", "0", ":", "seed", "1", ";", "}" ]
[ "to", "test", "enum", "parameters", "to", "test", "enum", "parameters" ]
[ "public", "void", "test", "enum", "parameters", "(", "@", "header", "param", "(", "\"", "enum", "header", "string", "array", "\"", ")", "list", "<", "string", ">", "enum", "header", "string", "array", ",", "@", "header", "param", "(", "\"", "enum", "header", "string", "\"", ")", "string", "enum", "header", "string", ",", "@", "query", "param", "(", "\"", "enum", "query", "string", "array", "\"", ")", "list", "<", "string", ">", "enum", "query", "string", "array", ",", "@", "query", "param", "(", "\"", "enum", "query", "string", "\"", ")", "@", "default", "value", "(", "\"", "-", "efg", "\"", ")", "string", "enum", "query", "string", ",", "@", "query", "param", "(", "\"", "enum", "query", "integer", "\"", ")", "integer", "enum", "query", "integer", ",", "@", "query", "param", "(", "\"", "enum", "query", "double", "\"", ")", "double", "enum", "query", "double", ",", "@", "multipart", "(", "value", "=", "\"", "enum", "form", "string", "array", "\"", ",", "required", "=", "false", ")", "list", "<", "string", ">", "enum", "form", "string", "array", ",", "@", "multipart", "(", "value", "=", "\"", "enum", "form", "string", "\"", ",", "required", "=", "false", ")", "string", "enum", "form", "string", ")", ";" ]
[ "return", "the", "configured", "{", "@", "link", "router", "function", "}", "note", ":", "when", "router", "functions", "are", "detected", "from", "the", "application", "context", ",", "this", "method", "may", "return", "{", "@", "code", "null", "}", "if", "invoked", "prior", "to", "{", "@", "link", "#", "after", "properties", "set", "(", ")", "}" ]
[ "public", "router", "function", "<", "?", ">", "get", "router", "function", "(", ")", "{", "return", "this", "router", "function", ";", "}" ]
[ "given", "a", "value", "that", "comes", "from", "the", "stored", "fields", "api", ",", "convert", "it", "to", "the", "expected", "type", "for", "instance", "a", "date", "field", "would", "store", "dates", "as", "longs", "and", "format", "it", "back", "to", "a", "string", "in", "this", "method" ]
[ "public", "object", "value", "for", "display", "(", "object", "value", ")", "{", "return", "value", ";", "}" ]
[ "check", "the", "consistency", "of", "this", "database" ]
[ "public", "boolean", "is", "consistent", "(", "task", "monitor", "monitor", ")", "throws", "cancelled", "exception", "{", "int", "consistent", "count", "=", "0", ";", "for", "(", "table", "table", ":", "get", "tables", "(", ")", ")", "{", "try", "{", "if", "(", "table", "is", "consistent", "(", "monitor", ")", ")", "{", "+", "+", "consistent", "count", ";", "}", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "msg", "error", "(", "this", ",", "\"", "consistency", "check", "error", "while", "processing", "table", ":", "\"", "+", "table", "get", "name", "(", ")", ",", "e", ")", ";", "}", "}", "return", "consistent", "count", "=", "=", "tables", "size", "(", ")", ";", "}" ]
[ "returns", "a", "pointer", "to", "the", "specified", "data", "type" ]
[ "public", "data", "type", "get", "ptr", "to", "(", "data", "type", "dt", ")", "{", "return", "data", "type", "manager", "get", "pointer", "(", "dt", ")", ";", "}" ]
[ "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", "\"", ")", ";", "}" ]
[ "get", "the", "detailed", "rpc", "status", "corresponding", "to", "this", "exception" ]
[ "public", "rpc", "error", "code", "proto", "get", "rpc", "error", "code", "proto", "(", ")", "{", "return", "rpc", "error", "code", "proto", "error", "no", "such", "method", ";", "}" ]
[ "restores", "a", "reader", "from", "a", "checkpointed", "position", "this", "method", "is", "called", "when", "the", "reader", "is", "recovered", "from", "a", "checkpoint", "and", "the", "reader", "has", "previously", "stored", "an", "offset", "into", "the", "checkpoint", ",", "by", "returning", "from", "the", "{", "@", "link", "file", "record", "format", "reader", "#", "get", "checkpointed", "position", "(", ")", "}", "a", "value", "with", "non", "-", "negative", "{", "@", "link", "checkpointed", "position", "#", "get", "offset", "(", ")", "offset", "}", "that", "value", "is", "supplied", "as", "the", "{", "@", "code", "restored", "offset", "}", "if", "the", "reader", "never", "produced", "a", "{", "@", "code", "checkpointed", "position", "}", "with", "a", "non", "-", "negative", "offset", "before", ",", "then", "this", "method", "is", "not", "called", ",", "and", "the", "reader", "is", "created", "in", "the", "same", "way", "as", "a", "fresh", "reader", "via", "the", "method", "{", "@", "link", "#", "create", "reader", "(", "configuration", ",", "path", ",", "long", ",", "long", ")", "}", "and", "the", "appropriate", "number", "of", "records", "are", "read", "and", "discarded", ",", "to", "position", "to", "reader", "to", "the", "checkpointed", "position" ]
[ "file", "record", "format", "reader", "<", "t", ">", "restore", "reader", "(", "configuration", "config", ",", "path", "file", "path", ",", "long", "restored", "offset", ",", "long", "split", "offset", ",", "long", "split", "length", ")", "throws", "i", "o", "exception", ";" ]
[ "get", "map", "boolean" ]
[ "public", "map", "<", "string", ",", "boolean", ">", "get", "map", "boolean", "(", ")", "{", "return", "map", "boolean", ";", "}" ]
[ "handles", "exceptions", "thrown", "by", "subscribers" ]
[ "void", "handle", "exception", "(", "throwable", "exception", ",", "subscriber", "exception", "context", "context", ")", ";" ]
[ "get", "namespace", "string" ]
[ "public", "string", "get", "namespace", "string", "(", ")", "{", "return", "namespace", "string", ";", "}" ]
[ "returns", "an", "array", "of", "security", "certificates" ]
[ "public", "security", "certificate", "[", "]", "get", "certificate", "(", ")", "{", "return", "certificates", ";", "}" ]
[ "adds", "the", "{", "@", "code", "string", "}", "representation", "of", "the", "method", "return", "value", "to", "the", "supplied", "{", "@", "code", "string", "buffer", "}", "correctly", "handles", "{", "@", "code", "null", "}", "and", "{", "@", "code", "void", "}", "results" ]
[ "private", "void", "append", "return", "value", "(", "method", "invocation", "method", "invocation", ",", "matcher", "matcher", ",", "string", "buffer", "output", ",", "@", "nullable", "object", "return", "value", ")", "{", "if", "(", "method", "invocation", "get", "method", "(", ")", "get", "return", "type", "(", ")", "=", "=", "void", "class", ")", "{", "matcher", "append", "replacement", "(", "output", ",", "\"", "void", "\"", ")", ";", "}", "else", "if", "(", "return", "value", "=", "=", "null", ")", "{", "matcher", "append", "replacement", "(", "output", ",", "\"", "null", "\"", ")", ";", "}", "else", "{", "matcher", "append", "replacement", "(", "output", ",", "matcher", "quote", "replacement", "(", "return", "value", "to", "string", "(", ")", ")", ")", ";", "}", "}" ]
[ "get", "collide", "connected", "note", ":", "modifying", "the", "collide", "connect", "flag", "won", "'", "t", "work", "correctly", "because", "the", "flag", "is", "only", "checked", "when", "fixture", "a", "a", "b", "bs", "begin", "to", "overlap" ]
[ "public", "final", "boolean", "get", "collide", "connected", "(", ")", "{", "return", "m", "collide", "connected", ";", "}" ]
[ "forbids", "the", "corresponding", "injector", "from", "creating", "a", "binding", "to", "{", "@", "code", "key", "}", "child", "injectors", "blacklist", "their", "bound", "keys", "on", "their", "parent", "injectors", "to", "prevent", "just", "-", "in", "-", "time", "bindings", "on", "the", "parent", "injector", "that", "would", "conflict" ]
[ "void", "blacklist", "(", "key", "<", "?", ">", "key", ")", ";" ]
[ "configure", "jdbc", "authentication", "provider" ]
[ "protected", "void", "configure", "jdbc", "authentication", "provider", "(", "final", "authentication", "manager", "builder", "auth", ",", "final", "actuator", "endpoints", "monitor", "properties", "jdbc", "security", "jdbc", ")", "throws", "exception", "{", "val", "password", "encoder", "=", "password", "encoder", "utils", "new", "password", "encoder", "(", "jdbc", "get", "password", "encoder", "(", ")", ",", "application", "context", ")", ";", "auth", "jdbc", "authentication", "(", ")", "password", "encoder", "(", "password", "encoder", ")", "users", "by", "username", "query", "(", "jdbc", "get", "query", "(", ")", ")", "role", "prefix", "(", "jdbc", "get", "role", "prefix", "(", ")", ")", "data", "source", "(", "jpa", "beans", "new", "data", "source", "(", "jdbc", ")", ")", ";", "}" ]
[ "enqueues", "an", "event", "for", "uploading", "to", "a", "bes", "backend" ]
[ "void", "enqueue", "event", "(", "build", "event", "event", ")", "{", "/", "/", "this", "needs", "to", "happen", "outside", "a", "synchronized", "block", "as", "it", "may", "trigger", "/", "/", "stdout", "/", "stderr", "and", "lead", "to", "a", "deadlock", "see", "b", "/", "109725432", "listenable", "future", "<", "path", "converter", ">", "local", "file", "upload", "future", "=", "build", "event", "uploader", "upload", "referenced", "local", "files", "(", "event", "referenced", "local", "files", "(", ")", ")", ";", "/", "/", "the", "generation", "of", "the", "sequence", "number", "and", "the", "addition", "to", "the", "{", "@", "link", "#", "event", "queue", "}", "should", "be", "/", "/", "atomic", "since", "bes", "expects", "the", "events", "in", "that", "exact", "order", "/", "/", "more", "details", "can", "be", "found", "in", "b", "/", "131393380", "/", "/", "todo", "(", "bazel", "-", "team", ")", ":", "consider", "relaxing", "this", "invariant", "by", "having", "a", "more", "relaxed", "order", "synchronized", "(", "lock", ")", "{", "if", "(", "started", "close", ")", "{", "return", ";", "}", "/", "/", "build", "completing", "event", "marks", "the", "end", "of", "the", "build", "in", "the", "bep", "event", "stream", "if", "(", "event", "instanceof", "build", "completing", "event", ")", "{", "exit", "code", "exit", "code", "=", "(", "(", "build", "completing", "event", ")", "event", ")", "get", "exit", "code", "(", ")", ";", "if", "(", "exit", "code", "!", "=", "null", "&", "&", "exit", "code", "get", "numeric", "exit", "code", "(", ")", "=", "=", "0", ")", "{", "build", "status", "=", "command", "succeeded", ";", "}", "else", "{", "build", "status", "=", "command", "failed", ";", "}", "}", "else", "if", "(", "event", "instanceof", "aborted", "event", "&", "&", "event", "get", "event", "id", "(", ")", "has", "build", "finished", "(", ")", ")", "{", "/", "/", "an", "aborted", "event", "with", "a", "build", "finished", "id", "means", "we", "are", "crashing", "build", "status", "=", "command", "failed", ";", "}", "ensure", "upload", "thread", "started", "(", ")", ";", "/", "/", "todo", "(", "b", "/", "131393380", ")", ":", "{", "@", "link", "#", "next", "seq", "num", "}", "doesn", "'", "t", "need", "to", "be", "an", "atomic", "integer", "if", "it", "'", "s", "/", "/", "always", "used", "under", "lock", "it", "would", "be", "cleaner", "and", "more", "performant", "to", "update", "the", "sequence", "/", "/", "number", "when", "we", "take", "the", "item", "off", "the", "queue", "event", "queue", "add", "last", "(", "new", "send", "regular", "build", "event", "command", "(", "event", ",", "local", "file", "upload", "future", ",", "next", "seq", "num", "get", "and", "increment", "(", ")", ",", "timestamps", "from", "millis", "(", "clock", "current", "time", "millis", "(", ")", ")", ")", ")", ";", "}", "}" ]
[ "get", "prefix", "array" ]
[ "public", "list", "<", "integer", ">", "get", "prefix", "array", "(", ")", "{", "return", "prefix", "array", ";", "}" ]
[ "parses", "the", "given", "command", "line", "options", "from", "the", "deployment", "properties", "ignores", "properties", "that", "are", "not", "defined", "by", "options" ]
[ "public", "command", "line", "get", "command", "line", "(", "options", "command", "line", "options", ")", "throws", "exception", "{", "final", "list", "<", "string", ">", "args", "=", "new", "array", "list", "<", ">", "(", ")", ";", "properties", "as", "map", "(", ")", "for", "each", "(", "(", "k", ",", "v", ")", "-", ">", "{", "/", "/", "only", "add", "supported", "options", "if", "(", "command", "line", "options", "has", "option", "(", "k", ")", ")", "{", "final", "option", "o", "=", "command", "line", "options", "get", "option", "(", "k", ")", ";", "final", "string", "argument", "=", "\"", "-", "-", "\"", "+", "o", "get", "long", "opt", "(", ")", ";", "/", "/", "options", "without", "args", "if", "(", "!", "o", "has", "arg", "(", ")", ")", "{", "final", "boolean", "flag", "=", "boolean", "parse", "boolean", "(", "v", ")", ";", "/", "/", "add", "key", "only", "if", "(", "flag", ")", "{", "args", "add", "(", "argument", ")", ";", "}", "}", "/", "/", "add", "key", "and", "value", "else", "if", "(", "!", "o", "has", "args", "(", ")", ")", "{", "args", "add", "(", "argument", ")", ";", "args", "add", "(", "v", ")", ";", "}", "/", "/", "options", "with", "multiple", "args", "are", "not", "supported", "yet", "else", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "option", "'", "\"", "+", "o", "+", "\"", "'", "is", "not", "supported", "yet", "\"", ")", ";", "}", "}", "}", ")", ";", "return", "cli", "frontend", "parser", "parse", "(", "command", "line", "options", ",", "args", "to", "array", "(", "new", "string", "[", "args", "size", "(", ")", "]", ")", ",", "true", ")", ";", "}" ]
[ "returns", "the", "name", "of", "a", "plugin", "based", "on", "its", "class" ]
[ "public", "static", "string", "get", "plugin", "name", "from", "class", "(", "class", "<", "?", "extends", "plugin", ">", "plugin", "class", ")", "{", "return", "plugin", "class", "get", "simple", "name", "(", ")", ";", "}" ]
[ "create", "a", "kafka", "topic", "with", "1", "partition", "and", "a", "replication", "factor", "of", "1" ]
[ "public", "void", "create", "topic", "(", "string", "topic", ")", "{", "create", "topic", "(", "topic", ",", "1", ")", ";", "}" ]
[ "create", "a", "(", "hostname", ",", "port", ")", "address", "pair" ]
[ "public", "static", "map", "<", "string", ",", "string", ">", "hostname", "port", "pair", "(", "string", "hostname", ",", "int", "port", ")", "{", "map", "<", "string", ",", "string", ">", "map", "=", "map", "(", "address", "hostname", "field", ",", "hostname", ")", ";", "map", "put", "(", "address", "port", "field", ",", "integer", "to", "string", "(", "port", ")", ")", ";", "return", "map", ";", "}" ]
[ "query", "given", "sql", "to", "create", "a", "prepared", "statement", "from", "sql", "and", "a", "list", "of", "arguments", "to", "bind", "to", "the", "query", ",", "expecting", "a", "result", "map", "the", "{", "@", "code", "query", "for", "map", "}", "methods", "defined", "by", "this", "interface", "are", "appropriate", "when", "you", "don", "'", "t", "have", "a", "domain", "model", "otherwise", ",", "consider", "using", "one", "of", "the", "{", "@", "code", "query", "for", "object", "}", "methods", "the", "query", "is", "expected", "to", "be", "a", "single", "row", "query", ";", "the", "result", "row", "will", "be", "mapped", "to", "a", "map", "(", "one", "entry", "for", "each", "column", ",", "using", "the", "column", "name", "as", "the", "key", ")" ]
[ "map", "<", "string", ",", "object", ">", "query", "for", "map", "(", "string", "sql", ",", "@", "nullable", "object", "args", ")", "throws", "data", "access", "exception", ";" ]
[ "equivalent", "to", "{", "@", "code", "disconnect", "(", "null", ")", "}" ]
[ "public", "future", "<", "?", ">", "disconnect", "(", ")", "{", "record", "termination", "(", ")", ";", "if", "(", "util", "is", "overridden", "(", "computer", "class", ",", "get", "class", "(", ")", ",", "\"", "disconnect", "\"", ",", "offline", "cause", "class", ")", ")", "/", "/", "if", "the", "subtype", "already", "derives", "disconnect", "(", "offline", "cause", ")", ",", "delegate", "to", "it", "return", "disconnect", "(", "null", ")", ";", "connect", "time", "=", "0", ";", "return", "futures", "precomputed", "(", "null", ")", ";", "}" ]
[ "template", "method", "for", "creating", "a", "plain", "new", "{", "@", "link", "properties", "}", "instance", "the", "default", "implementation", "simply", "calls", "{", "@", "link", "properties", "#", "properties", "(", ")", "}", "allows", "for", "returning", "a", "custom", "{", "@", "link", "properties", "}", "extension", "in", "subclasses", "overriding", "methods", "should", "just", "instantiate", "a", "custom", "{", "@", "link", "properties", "}", "subclass", ",", "with", "no", "further", "initialization", "or", "population", "to", "be", "performed", "at", "that", "point" ]
[ "protected", "properties", "new", "properties", "(", ")", "{", "return", "new", "properties", "(", ")", ";", "}" ]
[ "return", "any", "exception", "raised", "by", "a", "handler", "and", "successfully", "resolved", "through", "a", "{", "@", "link", "handler", "exception", "resolver", "}" ]
[ "exception", "get", "resolved", "exception", "(", ")", ";" ]
[ "the", "entries", "defined", "for", "this", "type", "<", "code", ">", "repeated", "aapt", "pb", "entry", "entry", "=", "3", ";", "<", "code", ">" ]
[ "private", "void", "add", "entry", "(", "int", "index", ",", "com", "android", "aapt", "resources", "entry", "builder", "builder", "for", "value", ")", "{", "ensure", "entry", "is", "mutable", "(", ")", ";", "entry", "add", "(", "index", ",", "builder", "for", "value", "build", "(", ")", ")", ";", "}" ]
[ "model", "tests", "for", "inline", "object", "4" ]
[ "public", "void", "test", "inline", "object", "4", "(", ")", "{", "/", "/", "todo", ":", "test", "inline", "object", "4", "}" ]
[ "return", "an", "address", "set", "that", "contains", "all", "addresses", "that", "make", "up", "the", "code", "units", "containing", "the", "indicated", "addresses", "in", "the", "latest", ",", "my", ",", "and", "original", "programs" ]
[ "protected", "address", "set", "view", "get", "code", "unit", "address", "set", "(", "address", "set", "addrs", ")", "{", "address", "set", "code", "set", "=", "new", "address", "set", "(", ")", ";", "code", "set", "add", "(", "diff", "utility", "get", "code", "unit", "set", "(", "addrs", ",", "latest", "pgm", ")", ")", ";", "code", "set", "add", "(", "diff", "utility", "get", "code", "unit", "set", "(", "addrs", ",", "my", "pgm", ")", ")", ";", "code", "set", "add", "(", "diff", "utility", "get", "code", "unit", "set", "(", "addrs", ",", "original", "pgm", ")", ")", ";", "return", "code", "set", ";", "}" ]
[ "get", "namespace", "wrapped", "array" ]
[ "public", "list", "<", "integer", ">", "get", "namespace", "wrapped", "array", "(", ")", "{", "return", "namespace", "wrapped", "array", ";", "}" ]
[ "returns", "an", "{", "@", "link", "annotation", "}", "object", "reflecting", "the", "annotation", "provided", ",", "or", "null", "of", "this", "method", "doesn", "'", "t", "have", "such", "an", "annotation", "this", "is", "a", "convenience", "function", "if", "the", "caller", "knows", "already", "which", "annotation", "type", "he", "'", "s", "looking", "for" ]
[ "public", "annotation", "get", "declared", "annotation", "(", "class", "<", "?", "extends", "java", "lang", "annotation", "annotation", ">", "annotation", "type", ")", "{", "java", "lang", "annotation", "annotation", "[", "]", "annotations", "=", "method", "get", "declared", "annotations", "(", ")", ";", "if", "(", "annotations", "=", "=", "null", ")", "{", "return", "null", ";", "}", "for", "(", "java", "lang", "annotation", "annotation", "annotation", ":", "annotations", ")", "{", "if", "(", "annotation", "annotation", "type", "(", ")", "equals", "(", "annotation", "type", ")", ")", "{", "return", "new", "annotation", "(", "annotation", ")", ";", "}", "}", "return", "null", ";", "}" ]
[ "a", "sequence", "of", "requests", "followed", "by", "one", "response", "(", "streamed", "upload", ")", "the", "server", "returns", "the", "aggregated", "size", "of", "client", "payload", "as", "the", "result" ]
[ "public", "io", "grpc", "stub", "stream", "observer", "<", "io", "grpc", "testing", "integration", "messages", "streaming", "input", "call", "request", ">", "streaming", "input", "call", "(", "io", "grpc", "stub", "stream", "observer", "<", "io", "grpc", "testing", "integration", "messages", "streaming", "input", "call", "response", ">", "response", "observer", ")", "{", "return", "io", "grpc", "stub", "client", "calls", "async", "client", "streaming", "call", "(", "get", "channel", "(", ")", "new", "call", "(", "get", "streaming", "input", "call", "method", "(", ")", ",", "get", "call", "options", "(", ")", ")", ",", "response", "observer", ")", ";", "}" ]
[ "add", "an", "existing", "secondary", "index", "note", ":", "records", "for", "this", "table", "instance", "must", "not", "be", "modified", "until", "after", "all", "existing", "secondary", "indexes", "are", "added", "failure", "to", "comply", "may", "result", "in", "an", "inconsistent", "index" ]
[ "void", "add", "index", "(", "index", "table", "index", "table", ")", "{", "secondary", "indexes", "put", "(", "index", "table", "get", "column", "index", "(", ")", ",", "index", "table", ")", ";", "indexed", "columns", "=", "secondary", "indexes", "get", "keys", "(", ")", ";", "is", "indexed", "=", "true", ";", "}" ]
[ "testing", "statistics", "by", "creating", "files", "and", "directories" ]
[ "public", "void", "test", "create", "statistics", "(", ")", "throws", "i", "o", "exception", "{", "describe", "(", "\"", "testing", "counter", "values", "got", "by", "creating", "directories", "and", "files", "in", "\"", "+", "\"", "abfs", "\"", ")", ";", "azure", "blob", "file", "system", "fs", "=", "get", "file", "system", "(", ")", ";", "path", "create", "file", "path", "=", "path", "(", "get", "method", "name", "(", ")", ")", ";", "path", "create", "directory", "path", "=", "path", "(", "get", "method", "name", "(", ")", "+", "\"", "dir", "\"", ")", ";", "fs", "mkdirs", "(", "create", "directory", "path", ")", ";", "fs", "create", "non", "recursive", "(", "create", "file", "path", ",", "fs", "permission", "get", "default", "(", ")", ",", "false", ",", "1024", ",", "(", "short", ")", "1", ",", "1024", ",", "null", ")", ";", "map", "<", "string", ",", "long", ">", "metric", "map", "=", "fs", "get", "instrumentation", "map", "(", ")", ";", "/", "*", "test", "of", "statistic", "values", "after", "creating", "a", "directory", "and", "a", "file", ";", "get", "file", "status", "is", "called", "1", "time", "after", "creating", "file", "and", "1", "time", "at", "time", "of", "initialising", "*", "/", "assert", "abfs", "statistics", "(", "abfs", "statistic", "call", "create", ",", "1", ",", "metric", "map", ")", ";", "assert", "abfs", "statistics", "(", "abfs", "statistic", "call", "create", "non", "recursive", ",", "1", ",", "metric", "map", ")", ";", "assert", "abfs", "statistics", "(", "abfs", "statistic", "files", "created", ",", "1", ",", "metric", "map", ")", ";", "assert", "abfs", "statistics", "(", "abfs", "statistic", "directories", "created", ",", "1", ",", "metric", "map", ")", ";", "assert", "abfs", "statistics", "(", "abfs", "statistic", "call", "mkdirs", ",", "1", ",", "metric", "map", ")", ";", "assert", "abfs", "statistics", "(", "abfs", "statistic", "call", "get", "file", "status", ",", "2", ",", "metric", "map", ")", ";", "/", "/", "re", "-", "initialising", "abfs", "to", "reset", "statistic", "values", "fs", "initialize", "(", "fs", "get", "uri", "(", ")", ",", "fs", "get", "conf", "(", ")", ")", ";", "/", "*", "creating", "10", "directories", "and", "files", ";", "directories", "and", "files", "can", "'", "t", "be", "created", "with", "same", "name", ",", "hence", "<", "name", ">", "+", "i", "to", "give", "unique", "names", "*", "/", "for", "(", "int", "i", "=", "0", ";", "i", "<", "number", "of", "ops", ";", "i", "+", "+", ")", "{", "fs", "mkdirs", "(", "path", "(", "get", "method", "name", "(", ")", "+", "\"", "dir", "\"", "+", "i", ")", ")", ";", "fs", "create", "non", "recursive", "(", "path", "(", "get", "method", "name", "(", ")", "+", "i", ")", ",", "fs", "permission", "get", "default", "(", ")", ",", "false", ",", "1024", ",", "(", "short", ")", "1", ",", "1024", ",", "null", ")", ";", "}", "metric", "map", "=", "fs", "get", "instrumentation", "map", "(", ")", ";", "/", "*", "test", "of", "statistics", "values", "after", "creating", "10", "directories", "and", "files", ";", "get", "file", "status", "is", "called", "1", "time", "at", "initialise", "(", ")", "plus", "number", "of", "times", "file", "is", "created", "*", "/", "assert", "abfs", "statistics", "(", "abfs", "statistic", "call", "create", ",", "number", "of", "ops", ",", "metric", "map", ")", ";", "assert", "abfs", "statistics", "(", "abfs", "statistic", "call", "create", "non", "recursive", ",", "number", "of", "ops", ",", "metric", "map", ")", ";", "assert", "abfs", "statistics", "(", "abfs", "statistic", "files", "created", ",", "number", "of", "ops", ",", "metric", "map", ")", ";", "assert", "abfs", "statistics", "(", "abfs", "statistic", "directories", "created", ",", "number", "of", "ops", ",", "metric", "map", ")", ";", "assert", "abfs", "statistics", "(", "abfs", "statistic", "call", "mkdirs", ",", "number", "of", "ops", ",", "metric", "map", ")", ";", "assert", "abfs", "statistics", "(", "abfs", "statistic", "call", "get", "file", "status", ",", "1", "+", "number", "of", "ops", ",", "metric", "map", ")", ";", "}" ]
[ "shortcut", "to", "visit", "a", "user", "expression", "node", "with", "additional", "checks", "common", "to", "most", "expression", "nodes", "these", "additional", "checks", "include", "looking", "for", "an", "escaped", "partial", "canonical", "type", ",", "an", "unexpected", "static", "type", ",", "and", "an", "unexpected", "value", "type" ]
[ "public", "void", "checked", "visit", "(", "a", "expression", "user", "expression", "node", ",", "semantic", "scope", "semantic", "scope", ")", "{", "if", "(", "user", "expression", "node", "!", "=", "null", ")", "{", "user", "expression", "node", "visit", "(", "this", ",", "semantic", "scope", ")", ";", "if", "(", "semantic", "scope", "has", "decoration", "(", "user", "expression", "node", ",", "partial", "canonical", "type", "name", "class", ")", ")", "{", "throw", "user", "expression", "node", "create", "error", "(", "new", "illegal", "argument", "exception", "(", "\"", "cannot", "resolve", "symbol", "[", "\"", "+", "semantic", "scope", "get", "decoration", "(", "user", "expression", "node", ",", "partial", "canonical", "type", "name", "class", ")", "get", "partial", "canonical", "type", "name", "(", ")", "+", "\"", "]", "\"", ")", ")", ";", "}", "if", "(", "semantic", "scope", "has", "decoration", "(", "user", "expression", "node", ",", "static", "type", "class", ")", ")", "{", "throw", "user", "expression", "node", "create", "error", "(", "new", "illegal", "argument", "exception", "(", "\"", "value", "required", ":", "instead", "found", "unexpected", "type", "\"", "+", "\"", "[", "\"", "+", "semantic", "scope", "get", "decoration", "(", "user", "expression", "node", ",", "static", "type", "class", ")", "get", "static", "canonical", "type", "name", "(", ")", "+", "\"", "]", "\"", ")", ")", ";", "}", "if", "(", "semantic", "scope", "has", "decoration", "(", "user", "expression", "node", ",", "value", "type", "class", ")", "=", "=", "false", ")", "{", "throw", "user", "expression", "node", "create", "error", "(", "new", "illegal", "state", "exception", "(", "\"", "value", "required", ":", "instead", "found", "no", "value", "\"", ")", ")", ";", "}", "}", "}" ]
[ "gets", "branch", "id" ]
[ "public", "long", "get", "branch", "id", "(", ")", "{", "return", "branch", "id", "!", "=", "null", "?", "long", "parse", "long", "(", "branch", "id", ")", ":", "-", "1", ";", "}" ]
[ "add", "current", "cpu", "usage", "and", "load", "to", "the", "metric", "list" ]
[ "private", "void", "add", "cpu", "usage", "and", "load", "(", "list", "<", "metric", "node", ">", "list", ")", "{", "long", "time", "=", "time", "util", "current", "time", "millis", "(", ")", "/", "1000", "*", "1000", ";", "double", "load", "=", "system", "rule", "manager", "get", "current", "system", "avg", "load", "(", ")", ";", "double", "usage", "=", "system", "rule", "manager", "get", "current", "cpu", "usage", "(", ")", ";", "if", "(", "load", ">", "0", ")", "{", "metric", "node", "load", "node", "=", "to", "node", "(", "load", ",", "time", ",", "constants", "system", "load", "resource", "name", ")", ";", "list", "add", "(", "load", "node", ")", ";", "}", "if", "(", "usage", ">", "0", ")", "{", "metric", "node", "usage", "node", "=", "to", "node", "(", "usage", ",", "time", ",", "constants", "cpu", "usage", "resource", "name", ")", ";", "list", "add", "(", "usage", "node", ")", ";", "}", "}" ]
[ "the", "current", "cluster", "state", "exposed", "by", "the", "discovery", "layer", "package", "-", "visible", "for", "tests" ]
[ "cluster", "state", "state", "(", ")", "{", "return", "cluster", "state", "supplier", "get", "(", ")", ";", "}" ]
[ "converts", "this", "configuration", "to", "a", "map", "the", "returned", "map", "is", "mutable", ",", "and", "changes", "to", "it", "do", "not", "reflect", "back", "into", "this", "configuration" ]
[ "public", "map", "<", "string", ",", "object", ">", "to", "map", "(", ")", "{", "map", "<", "string", ",", "object", ">", "conf", "=", "new", "linked", "hash", "map", "<", "string", ",", "object", ">", "(", ")", ";", "conf", "put", "(", "key", "client", "port", ",", "client", "port", ")", ";", "conf", "put", "(", "key", "data", "dir", ",", "data", "dir", ")", ";", "conf", "put", "(", "key", "data", "log", "dir", ",", "data", "log", "dir", ")", ";", "conf", "put", "(", "key", "tick", "time", ",", "tick", "time", ")", ";", "conf", "put", "(", "key", "max", "client", "cnxns", ",", "max", "client", "cnxns", "per", "host", ")", ";", "conf", "put", "(", "key", "min", "session", "timeout", ",", "min", "session", "timeout", ")", ";", "conf", "put", "(", "key", "max", "session", "timeout", ",", "max", "session", "timeout", ")", ";", "conf", "put", "(", "key", "server", "id", ",", "server", "id", ")", ";", "conf", "put", "(", "key", "client", "port", "listen", "backlog", ",", "client", "port", "listen", "backlog", ")", ";", "return", "conf", ";", "}" ]
[ "this", "version", "of", "the", "mkdirs", "method", "assumes", "that", "the", "permission", "is", "absolute", "it", "has", "been", "added", "to", "support", "the", "file", "context", "that", "processes", "the", "permission", "with", "umask", "before", "calling", "this", "method", "this", "a", "temporary", "method", "added", "to", "support", "the", "transition", "from", "file", "system", "to", "file", "context", "for", "user", "applications" ]
[ "protected", "boolean", "primitive", "mkdir", "(", "path", "f", ",", "fs", "permission", "absolute", "permission", ")", "throws", "i", "o", "exception", "{", "return", "this", "mkdirs", "(", "f", ",", "absolute", "permission", ")", ";", "}" ]
[ "get", "prefix", "integer" ]
[ "public", "integer", "get", "prefix", "integer", "(", ")", "{", "return", "prefix", "integer", ";", "}" ]
[ "build", "the", "string", "for", "declaring", "the", "variable", "holding", "the", "array", "-", "like", "-", "object", "to", "test", "so", "{", "@", "code", "int", "[", "]", "}", "for", "arrays", "and", "{", "@", "code", "list", "}", "for", "lists" ]
[ "protected", "abstract", "string", "decl", "type", "(", "string", "value", "type", ")", ";" ]
[ "set", "the", "transaction", "synchronization", "by", "the", "name", "of", "the", "corresponding", "constant", "in", "this", "class", ",", "e", "g", "\"", "synchronization", "always", "\"" ]
[ "public", "final", "void", "set", "transaction", "synchronization", "name", "(", "string", "constant", "name", ")", "{", "set", "transaction", "synchronization", "(", "constants", "as", "number", "(", "constant", "name", ")", "int", "value", "(", ")", ")", ";", "}" ]
[ "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", "\"", ")", ";", "}" ]
[ "forwards", "any", "instrumented", "files", "from", "the", "given", "target", "'", "s", "dependencies", "(", "as", "defined", "in", "{", "@", "code", "dependency", "attributes", "}", ")", "for", "further", "export", "no", "files", "from", "this", "target", "are", "considered", "instrumented" ]
[ "public", "static", "instrumented", "files", "info", "forward", "(", "rule", "context", "rule", "context", ",", "string", "dependency", "attributes", ")", "{", "return", "collect", "(", "rule", "context", ",", "new", "instrumentation", "spec", "(", "file", "type", "set", "no", "file", ")", "with", "dependency", "attributes", "(", "dependency", "attributes", ")", ",", "/", "*", "local", "metadata", "collector", "=", "*", "/", "null", ",", "/", "*", "root", "files", "=", "*", "/", "null", ",", "/", "*", "reported", "to", "actual", "sources", "=", "*", "/", "nested", "set", "builder", "<", "pair", "<", "string", ",", "string", ">", ">", "empty", "set", "(", "order", "stable", "order", ")", ")", ";", "}" ]
[ "checks", "if", "first", "header", "size", "bytes", "of", "image", "header", "bytes", "constitute", "a", "valid", "header", "for", "a", "bmp", "image", "details", "on", "bmp", "header", "can", "be", "found", "<", "a", "href", "=", "\"", "http", ":", "www", "onicos", "comstaffizformatsbmp", "html", "\"", ">" ]
[ "private", "static", "boolean", "is", "bmp", "header", "(", "final", "byte", "[", "]", "image", "header", "bytes", ",", "final", "int", "header", "size", ")", "{", "if", "(", "header", "size", "<", "bmp", "header", "length", ")", "{", "return", "false", ";", "}", "return", "image", "format", "checker", "utils", "starts", "with", "pattern", "(", "image", "header", "bytes", ",", "bmp", "header", ")", ";", "}" ]
[ "return", "an", "empty", "target", "source", "for", "the", "given", "target", "class" ]
[ "public", "static", "empty", "target", "source", "for", "class", "(", "@", "nullable", "class", "<", "?", ">", "target", "class", ",", "boolean", "is", "static", ")", "{", "return", "(", "target", "class", "=", "=", "null", "&", "&", "is", "static", "?", "instance", ":", "new", "empty", "target", "source", "(", "target", "class", ",", "is", "static", ")", ")", ";", "}" ]
[ "clone", "the", "subscribed", "u", "r", "ls", "based", "on", "the", "template", "u", "r", "ls" ]
[ "private", "list", "<", "url", ">", "clone", "exported", "u", "r", "ls", "(", "url", "subscribed", "u", "r", "l", ",", "list", "<", "service", "instance", ">", "service", "instances", ")", "{", "list", "<", "url", ">", "cloned", "exported", "u", "r", "ls", "=", "new", "linked", "list", "<", ">", "(", ")", ";", "service", "instances", "for", "each", "(", "service", "instance", "-", ">", "{", "string", "host", "=", "service", "instance", "get", "host", "(", ")", ";", "get", "template", "exported", "u", "r", "ls", "(", "subscribed", "u", "r", "l", ",", "service", "instances", ")", "stream", "(", ")", "map", "(", "template", "u", "r", "l", "-", ">", "template", "u", "r", "l", "remove", "parameter", "(", "timestamp", "key", ")", ")", "map", "(", "template", "u", "r", "l", "-", ">", "template", "u", "r", "l", "remove", "parameter", "(", "pid", "key", ")", ")", "map", "(", "template", "u", "r", "l", "-", ">", "{", "string", "protocol", "=", "template", "u", "r", "l", "get", "protocol", "(", ")", ";", "integer", "port", "=", "repository", "get", "dubbo", "protocol", "port", "(", "service", "instance", ",", "protocol", ")", ";", "if", "(", "objects", "equals", "(", "template", "u", "r", "l", "get", "host", "(", ")", ",", "host", ")", "&", "&", "objects", "equals", "(", "template", "u", "r", "l", "get", "port", "(", ")", ",", "port", ")", ")", "{", "/", "/", "use", "/", "/", "template", "u", "r", "l", "/", "/", "if", "/", "/", "equals", "return", "template", "u", "r", "l", ";", "}", "if", "(", "port", "=", "=", "null", ")", "{", "if", "(", "logger", "is", "warn", "enabled", "(", ")", ")", "{", "logger", "warn", "(", "\"", "the", "protocol", "[", "{", "}", "]", "port", "of", "dubbo", "service", "instance", "[", "host", ":", "{", "}", "]", "\"", "+", "\"", "can", "'", "t", "be", "resolved", "\"", ",", "protocol", ",", "host", ")", ";", "}", "return", "null", ";", "}", "else", "{", "u", "r", "l", "builder", "cloned", "u", "r", "l", "builder", "=", "from", "(", "template", "u", "r", "l", ")", "/", "/", "remove", "the", "/", "/", "parameters", "from", "/", "/", "the", "template", "/", "/", "url", "set", "host", "(", "host", ")", "/", "/", "reset", "the", "host", "set", "port", "(", "port", ")", ";", "/", "/", "reset", "the", "port", "return", "cloned", "u", "r", "l", "builder", "build", "(", ")", ";", "}", "}", ")", "filter", "(", "objects", ":", ":", "non", "null", ")", "for", "each", "(", "cloned", "exported", "u", "r", "ls", ":", ":", "add", ")", ";", "}", ")", ";", "return", "cloned", "exported", "u", "r", "ls", ";", "}" ]
[ "build", "the", "{", "@", "link", "http", "handler", "}" ]
[ "public", "http", "handler", "build", "(", ")", "{", "web", "handler", "decorated", "=", "new", "filtering", "web", "handler", "(", "this", "web", "handler", ",", "this", "filters", ")", ";", "decorated", "=", "new", "exception", "handling", "web", "handler", "(", "decorated", ",", "this", "exception", "handlers", ")", ";", "http", "web", "handler", "adapter", "adapted", "=", "new", "http", "web", "handler", "adapter", "(", "decorated", ")", ";", "if", "(", "this", "session", "manager", "!", "=", "null", ")", "{", "adapted", "set", "session", "manager", "(", "this", "session", "manager", ")", ";", "}", "if", "(", "this", "codec", "configurer", "!", "=", "null", ")", "{", "adapted", "set", "codec", "configurer", "(", "this", "codec", "configurer", ")", ";", "}", "if", "(", "this", "locale", "context", "resolver", "!", "=", "null", ")", "{", "adapted", "set", "locale", "context", "resolver", "(", "this", "locale", "context", "resolver", ")", ";", "}", "if", "(", "this", "forwarded", "header", "transformer", "!", "=", "null", ")", "{", "adapted", "set", "forwarded", "header", "transformer", "(", "this", "forwarded", "header", "transformer", ")", ";", "}", "if", "(", "this", "application", "context", "!", "=", "null", ")", "{", "adapted", "set", "application", "context", "(", "this", "application", "context", ")", ";", "}", "adapted", "after", "properties", "set", "(", ")", ";", "return", "(", "this", "http", "handler", "decorator", "!", "=", "null", "?", "this", "http", "handler", "decorator", "apply", "(", "adapted", ")", ":", "adapted", ")", ";", "}" ]
[ "headers", "are", "compressed", ",", "then", "framed" ]
[ "@", "test", "public", "void", "headers", "frame", "then", "continuation", "(", ")", "throws", "i", "o", "exception", "{", "final", "list", "<", "header", ">", "sent", "headers", "=", "large", "headers", "(", ")", ";", "buffer", "header", "block", "=", "literal", "headers", "(", "sent", "headers", ")", ";", "/", "/", "write", "the", "first", "headers", "frame", "write", "medium", "(", "frame", ",", "http", "2", "initial", "max", "frame", "size", ")", ";", "frame", "write", "byte", "(", "http", "2", "type", "headers", ")", ";", "frame", "write", "byte", "(", "http", "2", "flag", "none", ")", ";", "frame", "write", "int", "(", "expected", "stream", "id", "&", "0x", "7fffffff", ")", ";", "frame", "write", "(", "header", "block", ",", "http", "2", "initial", "max", "frame", "size", ")", ";", "/", "/", "write", "the", "continuation", "frame", ",", "specifying", "no", "more", "frames", "are", "expected", "write", "medium", "(", "frame", ",", "(", "int", ")", "header", "block", "size", "(", ")", ")", ";", "frame", "write", "byte", "(", "http", "2", "type", "continuation", ")", ";", "frame", "write", "byte", "(", "flag", "end", "headers", ")", ";", "frame", "write", "int", "(", "expected", "stream", "id", "&", "0x", "7fffffff", ")", ";", "frame", "write", "all", "(", "header", "block", ")", ";", "/", "/", "check", "writer", "sends", "the", "same", "bytes", "assert", "that", "(", "send", "header", "frames", "(", "false", ",", "sent", "headers", ")", ")", "is", "equal", "to", "(", "frame", ")", ";", "/", "/", "reading", "the", "above", "frames", "should", "result", "in", "a", "concatenated", "header", "block", "reader", "next", "frame", "(", "false", ",", "new", "base", "test", "handler", "(", ")", "{", "@", "override", "public", "void", "headers", "(", "boolean", "in", "finished", ",", "int", "stream", "id", ",", "int", "associated", "stream", "id", ",", "list", "<", "header", ">", "header", "block", ")", "{", "assert", "that", "(", "in", "finished", ")", "is", "false", "(", ")", ";", "assert", "that", "(", "stream", "id", ")", "is", "equal", "to", "(", "expected", "stream", "id", ")", ";", "assert", "that", "(", "associated", "stream", "id", ")", "is", "equal", "to", "(", "-", "1", ")", ";", "assert", "that", "(", "header", "block", ")", "is", "equal", "to", "(", "sent", "headers", ")", ";", "}", "}", ")", ";", "}" ]
[ "test", "the", "property", "'", "array", "array", "of", "integer", "'" ]
[ "public", "void", "array", "array", "of", "integer", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "array", "array", "of", "integer", "}" ]
[ "returns", "whether", "or", "not", "the", "checkbox", "is", "selected" ]
[ "boolean", "get", "use", "for", "all", "(", ")", "{", "return", "use", "for", "all", "c", "b", "is", "selected", "(", ")", ";", "}" ]
[ "<", "code", ">", "optional", "string", "name", "=", "6", ";", "<", "code", ">" ]
[ "public", "boolean", "has", "name", "(", ")", "{", "return", "(", "(", "bit", "field", "0", "&", "0x", "0", "0", "0", "0", "0", "0", "2", "0", ")", "=", "=", "0x", "0", "0", "0", "0", "0", "0", "2", "0", ")", ";", "}" ]
[ "returns", "the", "zero", "-", "relative", "index", "of", "the", "item", "which", "is", "currently", "selected", "in", "the", "receiver", ",", "or", "-", "1", "if", "no", "item", "is", "selected" ]
[ "public", "int", "get", "selection", "index", "(", ")", "{", "return", "selected", "element", "index", ";", "}" ]