Datasets:
Anonymous2023
/
KGSum

Dataset card Data Studio Files Community
docstring_tokens
list
code_tokens
list
[ "returns", "the", "status", "of", "the", "allocator", "(", "which", "contains", "all", "metrics", ")", "as", "string", "be", "aware", "this", "may", "be", "expensive", "and", "so", "should", "not", "called", "too", "frequently" ]
[ "public", "string", "dump", "stats", "(", ")", "{", "int", "heap", "arenas", "len", "=", "heap", "arenas", "=", "=", "null", "?", "0", ":", "heap", "arenas", "length", ";", "string", "builder", "buf", "=", "new", "string", "builder", "(", "512", ")", "append", "(", "heap", "arenas", "len", ")", "append", "(", "\"", "heap", "arena", "(", "s", ")", ":", "\"", ")", "append", "(", "string", "util", "newline", ")", ";", "if", "(", "heap", "arenas", "len", ">", "0", ")", "{", "for", "(", "pool", "arena", "<", "byte", "[", "]", ">", "a", ":", "heap", "arenas", ")", "{", "buf", "append", "(", "a", ")", ";", "}", "}", "int", "direct", "arenas", "len", "=", "direct", "arenas", "=", "=", "null", "?", "0", ":", "direct", "arenas", "length", ";", "buf", "append", "(", "direct", "arenas", "len", ")", "append", "(", "\"", "direct", "arena", "(", "s", ")", ":", "\"", ")", "append", "(", "string", "util", "newline", ")", ";", "if", "(", "direct", "arenas", "len", ">", "0", ")", "{", "for", "(", "pool", "arena", "<", "byte", "buffer", ">", "a", ":", "direct", "arenas", ")", "{", "buf", "append", "(", "a", ")", ";", "}", "}", "return", "buf", "to", "string", "(", ")", ";", "}" ]
[ "simple", "sets", "the", "routing", "since", "the", "parent", "is", "only", "used", "to", "get", "to", "the", "right", "shard" ]
[ "public", "explain", "request", "parent", "(", "string", "parent", ")", "{", "this", "routing", "=", "parent", ";", "return", "this", ";", "}" ]
[ "creates", "a", "dns", "error", "response" ]
[ "public", "byte", "[", "]", "form", "error", "message", "(", "byte", "[", "]", "in", ")", "{", "header", "header", ";", "try", "{", "header", "=", "new", "header", "(", "in", ")", ";", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "return", "null", ";", "}", "return", "build", "error", "message", "(", "header", ",", "rcode", "formerr", ",", "null", ")", ";", "}" ]
[ "sets", "the", "policy", "for", "checking", "if", "third", "party", "rules", "declare", "<", "code", ">", "licenses", "(", ")", "<", "code", ">", "see", "{", "@", "link", "#", "third", "party", "license", "existence", "policy", "}", "for", "the", "default", "value" ]
[ "public", "builder", "set", "third", "party", "license", "existence", "policy", "(", "third", "party", "license", "existence", "policy", "policy", ")", "{", "this", "third", "party", "license", "existence", "policy", "=", "policy", ";", "return", "this", ";", "}" ]
[ "returns", "the", "utf", "-", "8", "data", "as", "an", "array", "of", "bytes" ]
[ "public", "byte", "[", "]", "get", "bytes", "(", ")", "{", "try", "{", "switch", "to", "byte", "array", "representation", "(", ")", ";", "}", "catch", "(", "unsupported", "encoding", "exception", "ex", ")", "{", "throw", "new", "runtime", "exception", "(", "ex", "get", "message", "(", ")", ")", ";", "}", "return", "bytes", ";", "}" ]
[ "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", "\"", ")", ";", "}" ]
[ "set", "by", "column", "vectors" ]
[ "public", "final", "void", "set", "(", "final", "vec", "2", "c", "1", ",", "final", "vec", "2", "c", "2", ")", "{", "ex", "x", "=", "c", "1", "x", ";", "ey", "x", "=", "c", "2", "x", ";", "ex", "y", "=", "c", "1", "y", ";", "ey", "y", "=", "c", "2", "y", ";", "}" ]
[ "set", "a", "location", "of", "a", "properties", "file", "to", "be", "loaded", "can", "point", "to", "a", "classic", "properties", "file", "or", "to", "an", "xml", "file", "that", "follows", "jdk", "1", "5", "'", "s", "properties", "xml", "format" ]
[ "public", "void", "set", "location", "(", "resource", "location", ")", "{", "this", "locations", "=", "new", "resource", "[", "]", "{", "location", "}", ";", "}" ]
[ "exit", "a", "parse", "tree", "produced", "by", "{", "@", "link", "sql", "base", "parser", "#", "limit", "clause", "}" ]
[ "void", "exit", "limit", "clause", "(", "sql", "base", "parser", "limit", "clause", "context", "ctx", ")", ";" ]
[ "register", "a", "listener", "that", "will", "be", "called", "when", "this", "model", "is", "bound", "to", "a", "view", "the", "listener", "will", "contribute", "to", "this", "model", "'", "s", "hash", "code", "state", "per", "the", "{", "@", "link", "com", "airbnb", "epoxy", "epoxy", "attribute", "option", "#", "do", "not", "hash", "}", "rules", "you", "may", "clear", "the", "listener", "by", "setting", "a", "null", "value", ",", "or", "by", "calling", "{", "@", "link", "#", "reset", "(", ")", "}" ]
[ "public", "test", "field", "prop", "null", "on", "recycle", "option", "view", "model", "on", "bind", "(", "on", "model", "bound", "listener", "<", "test", "field", "prop", "null", "on", "recycle", "option", "view", "model", ",", "test", "field", "prop", "null", "on", "recycle", "option", "view", ">", "listener", ")", "{", "on", "mutation", "(", ")", ";", "this", "on", "model", "bound", "listener", "epoxy", "generated", "model", "=", "listener", ";", "return", "this", ";", "}" ]
[ "get", "attribute", "boolean" ]
[ "public", "boolean", "get", "attribute", "boolean", "(", ")", "{", "return", "attribute", "boolean", ";", "}" ]
[ "get", "the", "total", "amount", "of", "buffer", "memory", ",", "in", "bytes" ]
[ "public", "int", "get", "memory", "(", ")", "{", "return", "memory", ";", "}" ]
[ "return", "{", "@", "link", "scheduling", "request", "#", "get", "allocation", "tags", "(", ")", "}", "specified", "by", "am" ]
[ "set", "<", "string", ">", "get", "allocation", "tags", "(", ")", ";" ]
[ "returns", "a", "view", "of", "the", "portion", "of", "this", "map", "whose", "values", "range", "from", "{", "@", "code", "from", "value", "}", "to", "{", "@", "code", "to", "value", "}", "the", "returned", "map", "is", "an", "unmodifiable", "view" ]
[ "value", "sorted", "map", "<", "k", ",", "v", ">", "sub", "map", "by", "value", "(", "v", "from", "value", ",", "boolean", "from", "inclusive", ",", "v", "to", "value", ",", "boolean", "to", "inclusive", ")", ";" ]
[ "returns", "the", "profile", "results", "for", "this", "search", "response", "(", "including", "all", "shards", ")", "an", "empty", "map", "is", "returned", "if", "profiling", "was", "not", "enabled" ]
[ "public", "final", "map", "<", "string", ",", "profile", "shard", "result", ">", "profile", "(", ")", "{", "if", "(", "profile", "results", "=", "=", "null", ")", "{", "return", "collections", "empty", "map", "(", ")", ";", "}", "return", "profile", "results", "get", "shard", "results", "(", ")", ";", "}" ]
[ "test", "the", "property", "'", "prefix", "ns", "number", "'" ]
[ "public", "void", "prefix", "ns", "number", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "prefix", "ns", "number", "}" ]
[ "returns", "the", "{", "@", "link", "type", "}", "values", "corresponding", "to", "the", "argument", "types", "of", "the", "given", "method" ]
[ "public", "static", "type", "[", "]", "get", "argument", "types", "(", "final", "method", "method", ")", "{", "class", "<", "?", ">", "[", "]", "classes", "=", "method", "get", "parameter", "types", "(", ")", ";", "type", "[", "]", "types", "=", "new", "type", "[", "classes", "length", "]", ";", "for", "(", "int", "i", "=", "classes", "length", "-", "1", ";", "i", ">", "=", "0", ";", "-", "-", "i", ")", "{", "types", "[", "i", "]", "=", "get", "type", "(", "classes", "[", "i", "]", ")", ";", "}", "return", "types", ";", "}" ]
[ "retrieve", "the", "value", "of", "the", "indicated", "column", "in", "the", "current", "row", "as", "a", "timestamp", "object" ]
[ "timestamp", "get", "timestamp", "(", "string", "column", "label", ",", "calendar", "cal", ")", "throws", "invalid", "result", "set", "access", "exception", ";", "/", "/", "row", "set", "navigation", "methods" ]
[ "on", "console", "connect" ]
[ "protected", "void", "on", "console", "connect", "(", "int", "session", "id", ")", "{", "system", "out", "println", "(", "\"", "on", "console", "connect", ":", "\"", "+", "session", "id", ")", ";", "}" ]
[ "model", "tests", "for", "order" ]
[ "public", "void", "test", "order", "(", ")", "{", "/", "/", "todo", ":", "test", "order", "}" ]
[ "creates", "a", "gateway", "server", "run", "in", "a", "daemon", "thread" ]
[ "static", "gateway", "server", "start", "gateway", "server", "(", ")", "throws", "execution", "exception", ",", "interrupted", "exception", "{", "completable", "future", "<", "gateway", "server", ">", "gateway", "server", "future", "=", "new", "completable", "future", "<", ">", "(", ")", ";", "thread", "thread", "=", "new", "thread", "(", "(", ")", "-", ">", "{", "try", "{", "int", "free", "port", "=", "net", "utils", "get", "available", "port", "(", ")", ";", "gateway", "server", "server", "=", "new", "gateway", "server", "gateway", "server", "builder", "(", ")", "gateway", "(", "new", "gateway", "(", "new", "concurrent", "hash", "map", "<", "string", ",", "object", ">", "(", ")", ",", "new", "callback", "client", "(", "free", "port", ")", ")", ")", "java", "port", "(", "0", ")", "build", "(", ")", ";", "reset", "callback", "client", "executor", "service", "(", "server", ")", ";", "gateway", "server", "future", "complete", "(", "server", ")", ";", "server", "start", "(", "true", ")", ";", "}", "catch", "(", "throwable", "e", ")", "{", "gateway", "server", "future", "complete", "exceptionally", "(", "e", ")", ";", "}", "}", ")", ";", "thread", "set", "name", "(", "\"", "py", "4j", "-", "gateway", "\"", ")", ";", "thread", "set", "daemon", "(", "true", ")", ";", "thread", "start", "(", ")", ";", "thread", "join", "(", ")", ";", "return", "gateway", "server", "future", "get", "(", ")", ";", "}" ]
[ "creates", "a", "dns", "cname", "record" ]
[ "@", "override", "public", "c", "n", "a", "m", "e", "record", "create", "(", "name", "name", ",", "name", "target", ")", "{", "return", "new", "c", "n", "a", "m", "e", "record", "(", "name", ",", "d", "class", "in", ",", "ttl", ",", "target", ")", ";", "}" ]
[ "return", "the", "resource", "pattern", "resolver", "to", "use", "for", "resolving", "location", "patterns", "into", "resource", "instances", "default", "is", "a", "{", "@", "link", "org", "springframework", "core", "io", "support", "path", "matching", "resource", "pattern", "resolver", "}", ",", "supporting", "ant", "-", "style", "location", "patterns", "can", "be", "overridden", "in", "subclasses", ",", "for", "extended", "resolution", "strategies", ",", "for", "example", "in", "a", "web", "environment", "<", "b", ">", "do", "not", "call", "this", "when", "needing", "to", "resolve", "a", "location", "pattern", "<", "b", ">", "call", "the", "context", "'", "s", "{", "@", "code", "get", "resources", "}", "method", "instead", ",", "which", "will", "delegate", "to", "the", "resource", "pattern", "resolver" ]
[ "protected", "resource", "pattern", "resolver", "get", "resource", "pattern", "resolver", "(", ")", "{", "return", "new", "path", "matching", "resource", "pattern", "resolver", "(", "this", ")", ";", "}", "/", "/", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "/", "/", "implementation", "of", "configurable", "application", "context", "interface", "/", "/", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-" ]
[ "called", "on", "the", "main", "thread", "when", "the", "test", "is", "started", "the", "test", "will", "not", "be", "started", "until", "the", "{", "@", "link", "host", "activity", "}", "has", "been", "resumed", "and", "its", "{", "@", "link", "surface", "}", "has", "been", "created" ]
[ "void", "on", "start", "(", "host", "activity", "host", ",", "surface", "surface", ",", "frame", "layout", "overlay", "frame", "layout", ")", ";" ]
[ "rename", "and", "deletion", "snapshot", "under", "the", "same", "the", "snapshottable", "directory" ]
[ "public", "void", "test", "rename", "dir", "and", "delete", "snapshot", "6", "(", ")", "throws", "exception", "{", "final", "path", "test", "=", "new", "path", "(", "\"", "/", "test", "\"", ")", ";", "final", "path", "dir", "1", "=", "new", "path", "(", "test", ",", "\"", "dir", "1", "\"", ")", ";", "final", "path", "dir", "2", "=", "new", "path", "(", "test", ",", "\"", "dir", "2", "\"", ")", ";", "hdfs", "mkdirs", "(", "dir", "1", ")", ";", "hdfs", "mkdirs", "(", "dir", "2", ")", ";", "final", "path", "foo", "=", "new", "path", "(", "dir", "2", ",", "\"", "foo", "\"", ")", ";", "final", "path", "bar", "=", "new", "path", "(", "foo", ",", "\"", "bar", "\"", ")", ";", "final", "path", "file", "=", "new", "path", "(", "bar", ",", "\"", "file", "\"", ")", ";", "d", "f", "s", "test", "util", "create", "file", "(", "hdfs", ",", "file", ",", "blocksize", ",", "repl", ",", "seed", ")", ";", "/", "/", "take", "a", "snapshot", "on", "/", "test", "snapshot", "test", "helper", "create", "snapshot", "(", "hdfs", ",", "test", ",", "\"", "s", "0", "\"", ")", ";", "/", "/", "delete", "/", "test", "/", "dir", "2", "/", "foo", "/", "bar", "/", "file", "after", "snapshot", "s", "0", ",", "so", "that", "there", "is", "a", "/", "/", "snapshot", "copy", "recorded", "in", "bar", "hdfs", "delete", "(", "file", ",", "true", ")", ";", "/", "/", "rename", "foo", "from", "dir", "2", "to", "dir", "1", "final", "path", "newfoo", "=", "new", "path", "(", "dir", "1", ",", "foo", "get", "name", "(", ")", ")", ";", "hdfs", "rename", "(", "foo", ",", "newfoo", ")", ";", "final", "path", "foo", "s", "0", "=", "snapshot", "test", "helper", "get", "snapshot", "path", "(", "test", ",", "\"", "s", "0", "\"", ",", "\"", "dir", "2", "/", "foo", "\"", ")", ";", "assert", "true", "(", "\"", "the", "snapshot", "path", "\"", "+", "foo", "s", "0", "+", "\"", "should", "exist", "\"", ",", "hdfs", "exists", "(", "foo", "s", "0", ")", ")", ";", "/", "/", "delete", "snapshot", "s", "0", "the", "deletion", "will", "first", "go", "down", "through", "dir", "1", ",", "and", "/", "/", "find", "foo", "in", "the", "created", "list", "of", "dir", "1", "then", "it", "will", "use", "null", "as", "the", "prior", "/", "/", "snapshot", "and", "continue", "the", "snapshot", "deletion", "process", "in", "the", "subtree", "of", "/", "/", "foo", "we", "need", "to", "make", "sure", "the", "snapshot", "s", "0", "can", "be", "deleted", "cleanly", "in", "the", "/", "/", "foo", "subtree", "hdfs", "delete", "snapshot", "(", "test", ",", "\"", "s", "0", "\"", ")", ";", "/", "/", "check", "the", "internal", "assert", "false", "(", "\"", "after", "deleting", "s", "0", ",", "\"", "+", "foo", "s", "0", "+", "\"", "should", "not", "exist", "\"", ",", "hdfs", "exists", "(", "foo", "s", "0", ")", ")", ";", "i", "node", "directory", "dir", "2", "node", "=", "fsdir", "get", "i", "node", "4", "write", "(", "dir", "2", "to", "string", "(", ")", ")", "as", "directory", "(", ")", ";", "assert", "true", "(", "\"", "the", "diff", "list", "of", "\"", "+", "dir", "2", "+", "\"", "should", "be", "empty", "after", "deleting", "s", "0", "\"", ",", "!", "dir", "2", "node", "is", "with", "snapshot", "(", ")", ")", ";", "assert", "true", "(", "hdfs", "exists", "(", "newfoo", ")", ")", ";", "i", "node", "foo", "ref", "node", "=", "fsdir", "get", "i", "node", "4", "write", "(", "newfoo", "to", "string", "(", ")", ")", ";", "assert", "true", "(", "foo", "ref", "node", "instanceof", "i", "node", "reference", "dst", "reference", ")", ";", "restart", "cluster", "and", "check", "image", "(", "true", ")", ";", "}" ]
[ "com", "alibaba", "csp", "sentinel", "node", "statistic", "node", "#", "cur", "thread", "num", "using", "long", "adder", "replace", "the", "atomic", "integer", "now", "test", "the", "long", "adder", "is", "fast", "than", "atomic", "integer", "and", "get", "the", "right", "statistic", "or", "not" ]
[ "public", "void", "test", "statistic", "long", "adder", "(", ")", "throws", "interrupted", "exception", "{", "atomic", "integer", "atomic", "integer", "=", "new", "atomic", "integer", "(", "0", ")", ";", "statistic", "node", "statistic", "node", "=", "new", "statistic", "node", "(", ")", ";", "executor", "service", "biz", "es", "1", "=", "new", "thread", "pool", "executor", "(", "thread", "count", ",", "thread", "count", ",", "0l", ",", "time", "unit", "milliseconds", ",", "new", "linked", "blocking", "queue", "<", "runnable", ">", "(", ")", ")", ";", "executor", "service", "biz", "es", "2", "=", "new", "thread", "pool", "executor", "(", "thread", "count", ",", "thread", "count", ",", "0l", ",", "time", "unit", "milliseconds", ",", "new", "linked", "blocking", "queue", "<", "runnable", ">", "(", ")", ")", ";", "int", "task", "count", "=", "100", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "task", "count", ";", "i", "+", "+", ")", "{", "int", "op", "=", "i", "%", "2", ";", "biz", "es", "2", "submit", "(", "new", "statistic", "atomic", "integer", "task", "(", "atomic", "integer", ",", "op", ",", "i", ")", ")", ";", "biz", "es", "1", "submit", "(", "new", "statistic", "long", "adder", "task", "(", "statistic", "node", ",", "op", ",", "i", ")", ")", ";", "}", "thread", "sleep", "(", "5000", ")", ";", "log", "(", "\"", "long", "adder", "total", "cost", ":", "\"", "+", "statistic", "long", "adder", "task", "total", "cost", "(", ")", "+", "\"", "ms", "\"", ")", ";", "log", "(", "\"", "atomic", "integer", "total", "cost", ":", "\"", "+", "statistic", "atomic", "integer", "task", "total", "cost", "(", ")", "+", "\"", "ms", "\"", ")", ";", "assert", "assert", "equals", "(", "statistic", "node", "cur", "thread", "num", "(", ")", ",", "atomic", "integer", "get", "(", ")", ")", ";", "}" ]
[ "validate", "label", "expression", "string" ]
[ "public", "static", "@", "non", "null", "form", "validation", "validate", "label", "expression", "(", "string", "value", ",", "@", "check", "for", "null", "abstract", "project", "<", "?", ",", "?", ">", "project", ")", "{", "return", "label", "expression", "validate", "(", "value", ",", "project", ")", ";", "}" ]
[ "return", "a", "http", "server", "builder", "that", "the", "journalnode", "namenode", "secondary", "namenode", "can", "use", "to", "initialize", "their", "http", "https", "server" ]
[ "public", "static", "http", "server", "2", "builder", "http", "server", "template", "for", "n", "n", "and", "j", "n", "(", "configuration", "conf", ",", "final", "inet", "socket", "address", "http", "addr", ",", "final", "inet", "socket", "address", "https", "addr", ",", "string", "name", ",", "string", "spnego", "user", "name", "key", ",", "string", "spnego", "keytab", "file", "key", ")", "throws", "i", "o", "exception", "{", "http", "config", "policy", "policy", "=", "get", "http", "policy", "(", "conf", ")", ";", "string", "filter", "initializer", "conf", "key", "=", "\"", "hadoop", "http", "filter", "initializers", "\"", ";", "string", "initializers", "=", "conf", "get", "(", "filter", "initializer", "conf", "key", ",", "\"", "\"", ")", ";", "string", "[", "]", "parts", "=", "initializers", "split", "(", "\"", ",", "\"", ")", ";", "set", "<", "string", ">", "target", "=", "new", "linked", "hash", "set", "<", "string", ">", "(", ")", ";", "for", "(", "string", "filter", "initializer", ":", "parts", ")", "{", "filter", "initializer", "=", "filter", "initializer", "trim", "(", ")", ";", "if", "(", "filter", "initializer", "equals", "(", "authentication", "filter", "initializer", "class", "get", "name", "(", ")", ")", "|", "|", "filter", "initializer", "equals", "(", "proxy", "user", "authentication", "filter", "initializer", "class", "get", "name", "(", ")", ")", "|", "|", "filter", "initializer", "is", "empty", "(", ")", ")", "{", "continue", ";", "}", "target", "add", "(", "filter", "initializer", ")", ";", "}", "target", "add", "(", "auth", "filter", "initializer", "class", "get", "name", "(", ")", ")", ";", "initializers", "=", "string", "utils", "join", "(", "target", ",", "\"", ",", "\"", ")", ";", "conf", "set", "(", "filter", "initializer", "conf", "key", ",", "initializers", ")", ";", "log", "info", "(", "\"", "filter", "initializers", "set", ":", "\"", "+", "initializers", ")", ";", "http", "server", "2", "builder", "builder", "=", "new", "http", "server", "2", "builder", "(", ")", "set", "name", "(", "name", ")", "set", "conf", "(", "conf", ")", "set", "a", "c", "l", "(", "new", "access", "control", "list", "(", "conf", "get", "(", "dfs", "admin", ",", "\"", "\"", ")", ")", ")", "set", "security", "enabled", "(", "user", "group", "information", "is", "security", "enabled", "(", ")", ")", "set", "username", "conf", "key", "(", "spnego", "user", "name", "key", ")", "set", "keytab", "conf", "key", "(", "get", "spnego", "keytab", "key", "(", "conf", ",", "spnego", "keytab", "file", "key", ")", ")", ";", "/", "/", "initialize", "the", "webserver", "for", "uploading", "/", "downloading", "files", "if", "(", "user", "group", "information", "is", "security", "enabled", "(", ")", ")", "{", "log", "info", "(", "\"", "starting", "web", "server", "as", ":", "\"", "+", "security", "util", "get", "server", "principal", "(", "conf", "get", "(", "spnego", "user", "name", "key", ")", ",", "http", "addr", "get", "host", "name", "(", ")", ")", ")", ";", "}", "if", "(", "policy", "is", "http", "enabled", "(", ")", ")", "{", "if", "(", "http", "addr", "get", "port", "(", ")", "=", "=", "0", ")", "{", "builder", "set", "find", "port", "(", "true", ")", ";", "}", "uri", "uri", "=", "uri", "create", "(", "\"", "http", ":", "/", "/", "\"", "+", "net", "utils", "get", "host", "port", "string", "(", "http", "addr", ")", ")", ";", "builder", "add", "endpoint", "(", "uri", ")", ";", "log", "info", "(", "\"", "starting", "web", "-", "server", "for", "\"", "+", "name", "+", "\"", "at", ":", "\"", "+", "uri", ")", ";", "}", "if", "(", "policy", "is", "https", "enabled", "(", ")", "&", "&", "https", "addr", "!", "=", "null", ")", "{", "configuration", "ssl", "conf", "=", "load", "ssl", "configuration", "(", "conf", ")", ";", "load", "ssl", "conf", "to", "http", "server", "builder", "(", "builder", ",", "ssl", "conf", ")", ";", "if", "(", "https", "addr", "get", "port", "(", ")", "=", "=", "0", ")", "{", "builder", "set", "find", "port", "(", "true", ")", ";", "}", "uri", "uri", "=", "uri", "create", "(", "\"", "https", ":", "/", "/", "\"", "+", "net", "utils", "get", "host", "port", "string", "(", "https", "addr", ")", ")", ";", "builder", "add", "endpoint", "(", "uri", ")", ";", "log", "info", "(", "\"", "starting", "web", "-", "server", "for", "\"", "+", "name", "+", "\"", "at", ":", "\"", "+", "uri", ")", ";", "}", "return", "builder", ";", "}" ]
[ "add", "another", "mean", "statistic" ]
[ "public", "synchronized", "mean", "statistic", "add", "(", "final", "mean", "statistic", "other", ")", "{", "if", "(", "other", "is", "empty", "(", ")", ")", "{", "return", "this", ";", "}", "long", "other", "samples", ";", "long", "other", "sum", ";", "synchronized", "(", "other", ")", "{", "other", "samples", "=", "other", "samples", ";", "other", "sum", "=", "other", "sum", ";", "}", "if", "(", "is", "empty", "(", ")", ")", "{", "samples", "=", "other", "samples", ";", "sum", "=", "other", "sum", ";", "return", "this", ";", "}", "samples", "+", "=", "other", "samples", ";", "sum", "+", "=", "other", "sum", ";", "return", "this", ";", "}" ]
[ "reset", "the", "timer", "'", "s", "deadline", "directly" ]
[ "public", "void", "reset", "deadline", "(", "long", "deadline", "ms", ")", "{", "if", "(", "deadline", "ms", "<", "0", ")", "throw", "new", "illegal", "argument", "exception", "(", "\"", "invalid", "negative", "deadline", "\"", "+", "deadline", "ms", ")", ";", "this", "timeout", "ms", "=", "math", "max", "(", "0", ",", "deadline", "ms", "-", "this", "current", "time", "ms", ")", ";", "this", "start", "ms", "=", "this", "current", "time", "ms", ";", "this", "deadline", "ms", "=", "deadline", "ms", ";", "}" ]
[ "provide", "the", "implementation", "of", "the", "platform", "decoder", "for", "the", "current", "platform", "using", "the", "provided", "pool", "factory" ]
[ "public", "static", "platform", "decoder", "build", "platform", "decoder", "(", "pool", "factory", "pool", "factory", ",", "boolean", "gingerbread", "decoder", "enabled", ")", "{", "if", "(", "build", "version", "sdk", "int", ">", "=", "build", "version", "codes", "o", ")", "{", "int", "max", "num", "threads", "=", "pool", "factory", "get", "flex", "byte", "array", "pool", "max", "num", "threads", "(", ")", ";", "return", "new", "oreo", "decoder", "(", "pool", "factory", "get", "bitmap", "pool", "(", ")", ",", "max", "num", "threads", ",", "new", "pools", "synchronized", "pool", "<", ">", "(", "max", "num", "threads", ")", ")", ";", "}", "else", "if", "(", "build", "version", "sdk", "int", ">", "=", "build", "version", "codes", "lollipop", "|", "|", "!", "native", "code", "setup", "get", "use", "native", "code", "(", ")", ")", "{", "int", "max", "num", "threads", "=", "pool", "factory", "get", "flex", "byte", "array", "pool", "max", "num", "threads", "(", ")", ";", "return", "new", "art", "decoder", "(", "pool", "factory", "get", "bitmap", "pool", "(", ")", ",", "max", "num", "threads", ",", "new", "pools", "synchronized", "pool", "<", ">", "(", "max", "num", "threads", ")", ")", ";", "}", "else", "{", "try", "{", "if", "(", "gingerbread", "decoder", "enabled", "&", "&", "build", "version", "sdk", "int", "<", "build", "version", "codes", "kitkat", ")", "{", "class", "<", "?", ">", "clazz", "=", "class", "for", "name", "(", "\"", "com", "facebook", "imagepipeline", "platform", "gingerbread", "purgeable", "decoder", "\"", ")", ";", "return", "(", "platform", "decoder", ")", "clazz", "get", "constructor", "(", ")", "new", "instance", "(", ")", ";", "}", "else", "{", "class", "<", "?", ">", "clazz", "=", "class", "for", "name", "(", "\"", "com", "facebook", "imagepipeline", "platform", "kit", "kat", "purgeable", "decoder", "\"", ")", ";", "return", "(", "platform", "decoder", ")", "clazz", "get", "constructor", "(", "flex", "byte", "array", "pool", "class", ")", "new", "instance", "(", "pool", "factory", "get", "flex", "byte", "array", "pool", "(", ")", ")", ";", "}", "}", "catch", "(", "class", "not", "found", "exception", "e", ")", "{", "throw", "new", "runtime", "exception", "(", "\"", "wrong", "native", "code", "setup", ",", "reflection", "failed", "\"", ",", "e", ")", ";", "}", "catch", "(", "illegal", "access", "exception", "e", ")", "{", "throw", "new", "runtime", "exception", "(", "\"", "wrong", "native", "code", "setup", ",", "reflection", "failed", "\"", ",", "e", ")", ";", "}", "catch", "(", "no", "such", "method", "exception", "e", ")", "{", "throw", "new", "runtime", "exception", "(", "\"", "wrong", "native", "code", "setup", ",", "reflection", "failed", "\"", ",", "e", ")", ";", "}", "catch", "(", "invocation", "target", "exception", "e", ")", "{", "throw", "new", "runtime", "exception", "(", "\"", "wrong", "native", "code", "setup", ",", "reflection", "failed", "\"", ",", "e", ")", ";", "}", "catch", "(", "instantiation", "exception", "e", ")", "{", "throw", "new", "runtime", "exception", "(", "\"", "wrong", "native", "code", "setup", ",", "reflection", "failed", "\"", ",", "e", ")", ";", "}", "}", "}" ]
[ "used", "to", "judge", "that", "an", "object", "is", "a", "file", "or", "folder" ]
[ "static", "boolean", "fs", "is", "folder", "(", "final", "obs", "f", "s", "attribute", "attr", ")", "{", "final", "int", "if", "dir", "=", "0x", "0", "0", "4", "0", "0", "0", ";", "int", "mode", "=", "attr", "get", "mode", "(", ")", ";", "/", "/", "object", "mode", "is", "-", "1", "when", "the", "object", "is", "migrated", "from", "/", "/", "object", "bucket", "to", "posix", "bucket", "/", "/", "-", "1", "is", "a", "file", ",", "not", "folder", "if", "(", "mode", "<", "0", ")", "{", "return", "false", ";", "}", "return", "(", "mode", "&", "if", "dir", ")", "!", "=", "0", ";", "}" ]
[ "{", "@", "inherit", "doc", "}", "this", "can", "be", "safely", "cast", "to", "{", "@", "link", "oio", "datagram", "channel", "config", "}" ]
[ "public", "datagram", "channel", "config", "config", "(", ")", "{", "return", "config", ";", "}" ]
[ "batch", "delete", "undo", "log" ]
[ "public", "void", "batch", "delete", "undo", "log", "(", "set", "<", "string", ">", "xids", ",", "set", "<", "long", ">", "branch", "ids", ",", "connection", "conn", ")", "throws", "s", "q", "l", "exception", "{", "if", "(", "collection", "utils", "is", "empty", "(", "xids", ")", "|", "|", "collection", "utils", "is", "empty", "(", "branch", "ids", ")", ")", "{", "return", ";", "}", "int", "xid", "size", "=", "xids", "size", "(", ")", ";", "int", "branch", "id", "size", "=", "branch", "ids", "size", "(", ")", ";", "string", "batch", "delete", "sql", "=", "to", "batch", "delete", "undo", "log", "sql", "(", "xid", "size", ",", "branch", "id", "size", ")", ";", "try", "(", "prepared", "statement", "delete", "p", "s", "t", "=", "conn", "prepare", "statement", "(", "batch", "delete", "sql", ")", ")", "{", "int", "params", "index", "=", "1", ";", "for", "(", "long", "branch", "id", ":", "branch", "ids", ")", "{", "delete", "p", "s", "t", "set", "long", "(", "params", "index", "+", "+", ",", "branch", "id", ")", ";", "}", "for", "(", "string", "xid", ":", "xids", ")", "{", "delete", "p", "s", "t", "set", "string", "(", "params", "index", "+", "+", ",", "xid", ")", ";", "}", "int", "delete", "rows", "=", "delete", "p", "s", "t", "execute", "update", "(", ")", ";", "if", "(", "logger", "is", "debug", "enabled", "(", ")", ")", "{", "logger", "debug", "(", "\"", "batch", "delete", "undo", "log", "size", "{", "}", "\"", ",", "delete", "rows", ")", ";", "}", "}", "catch", "(", "exception", "e", ")", "{", "if", "(", "!", "(", "e", "instanceof", "s", "q", "l", "exception", ")", ")", "{", "e", "=", "new", "s", "q", "l", "exception", "(", "e", ")", ";", "}", "throw", "(", "s", "q", "l", "exception", ")", "e", ";", "}", "}" ]
[ "returns", "the", "number", "of", "addresses", "in", "this", "set" ]
[ "public", "long", "get", "num", "addresses", "(", ")", "{", "return", "address", "set", "get", "num", "addresses", "(", ")", ";", "}" ]
[ "see", "{", "@", "link", "socket", "#", "connect", "(", "socket", "address", ",", "int", ")", "}", "calling", "this", "method", "does", "not", "trigger", "mode", "detection" ]
[ "public", "void", "connect", "(", "socket", "address", "endpoint", ",", "int", "timeout", ")", "throws", "i", "o", "exception", "{", "get", "socket", "allow", "unknown", "mode", "(", ")", "connect", "(", "endpoint", ",", "timeout", ")", ";", "}" ]
[ "constructs", "a", "module", "with", "the", "specified", "predeclared", "bindings", ",", "filtered", "by", "the", "semantics", ",", "in", "addition", "to", "the", "standard", "environment", ",", "{", "@", "link", "starlark", "#", "universe", "}" ]
[ "public", "static", "module", "with", "predeclared", "(", "starlark", "semantics", "semantics", ",", "map", "<", "string", ",", "object", ">", "predeclared", ")", "{", "return", "new", "module", "(", "filter", "(", "predeclared", ",", "semantics", ")", ")", ";", "}" ]
[ "logs", "out", "current", "logged", "in", "user", "session" ]
[ "public", "void", "logout", "user", "test", "(", ")", "{", "/", "/", "api", "logout", "user", "(", ")", ";", "/", "/", "todo", ":", "test", "validations", "}" ]
[ "find", "the", "fields", "constant", "that", "matches", "field", "id", ",", "throwing", "an", "exception", "if", "it", "is", "not", "found" ]
[ "public", "static", "fields", "find", "by", "thrift", "id", "or", "throw", "(", "int", "field", "id", ")", "{", "fields", "fields", "=", "find", "by", "thrift", "id", "(", "field", "id", ")", ";", "if", "(", "fields", "=", "=", "null", ")", "throw", "new", "illegal", "argument", "exception", "(", "\"", "field", "\"", "+", "field", "id", "+", "\"", "doesn", "'", "t", "exist", "!", "\"", ")", ";", "return", "fields", ";", "}" ]
[ "the", "{", "@", "link", "user", "get", "id", "(", ")", "user", "id", "}", "of", "the", "person", "responsible", "for", "this", "task" ]
[ "void", "set", "owner", "(", "string", "owner", ")", ";" ]
[ "returns", "the", "cipher", "suites", "to", "use", "for", "a", "connection", "this", "method", "can", "return", "{", "@", "code", "null", "}", "if", "the", "cipher", "suites", "enabled", "by", "default", "should", "be", "used" ]
[ "public", "list", "<", "cipher", "suite", ">", "cipher", "suites", "(", ")", "{", "if", "(", "cipher", "suites", "=", "=", "null", ")", "{", "return", "null", ";", "}", "cipher", "suite", "[", "]", "result", "=", "new", "cipher", "suite", "[", "cipher", "suites", "length", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "cipher", "suites", "length", ";", "i", "+", "+", ")", "{", "result", "[", "i", "]", "=", "cipher", "suite", "for", "java", "name", "(", "cipher", "suites", "[", "i", "]", ")", ";", "}", "return", "util", "immutable", "list", "(", "result", ")", ";", "}" ]
[ "bind", "a", "value", "to", "an", "index", "indexes", "are", "zero", "-", "based" ]
[ "void", "bind", "(", "int", "index", ",", "object", "value", ")", ";" ]
[ "test", "the", "property", "'", "name", "'" ]
[ "public", "void", "name", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "name", "}" ]
[ "emit", "a", "record", "with", "a", "timestamp", "use", "this", "method", "if", "the", "source", "system", "has", "timestamps", "attached", "to", "records", "typical", "examples", "would", "be", "logs", ",", "pub", "subs", ",", "or", "message", "queues", ",", "like", "kafka", "or", "kinesis", ",", "which", "store", "a", "timestamp", "with", "each", "event", "the", "events", "typically", "still", "pass", "through", "a", "{", "@", "link", "timestamp", "assigner", "}", ",", "which", "may", "decide", "to", "either", "use", "this", "source", "-", "provided", "timestamp", ",", "or", "replace", "it", "with", "a", "timestamp", "stored", "within", "the", "event", "(", "for", "example", "if", "the", "event", "was", "a", "json", "object", "one", "could", "configure", "a", "timestamp", "assigner", "that", "extracts", "one", "of", "the", "object", "'", "s", "fields", "and", "uses", "that", "as", "a", "timestamp", ")" ]
[ "void", "collect", "(", "t", "record", ",", "long", "timestamp", ")", ";" ]
[ "list", "of", "mime", "types", "for", "file", "upload", "(", "csv", ")" ]
[ "input", "$", "accept", "(", "string", "content", "types", ")", ";" ]
[ "return", "the", "context", "associated", "with", "the", "current", "scope", ",", "will", "never", "return", "{", "@", "code", "null", "}", "will", "never", "return", "{", "@", "link", "cancellable", "context", "}", "even", "if", "one", "is", "attached", ",", "instead", "a", "{", "@", "link", "context", "}", "is", "returned", "with", "the", "same", "properties", "and", "lifetime", "this", "is", "to", "avoid", "code", "stealing", "the", "ability", "to", "cancel", "arbitrarily" ]
[ "public", "static", "context", "current", "(", ")", "{", "context", "current", "=", "storage", "(", ")", "current", "(", ")", ";", "if", "(", "current", "=", "=", "null", ")", "{", "return", "root", ";", "}", "return", "current", ";", "}" ]
[ "blocks", "until", "all", "ongoing", "edits", "have", "been", "synced", "to", "disk", "this", "differs", "from", "log", "sync", "in", "that", "it", "waits", "for", "edits", "that", "have", "been", "written", "by", "other", "threads", ",", "not", "just", "edits", "from", "the", "calling", "thread", "note", ":", "this", "should", "be", "done", "while", "holding", "the", "f", "s", "namesystem", "lock", ",", "or", "else", "more", "operations", "can", "start", "writing", "while", "this", "is", "in", "progress" ]
[ "void", "log", "sync", "all", "(", ")", "{", "/", "/", "make", "sure", "we", "'", "re", "synced", "up", "to", "the", "most", "recent", "transaction", "id", "long", "last", "written", "tx", "id", "=", "get", "last", "written", "tx", "id", "(", ")", ";", "log", "info", "(", "\"", "log", "sync", "all", "to", "sync", "to", "tx", "id", "=", "\"", "+", "last", "written", "tx", "id", "+", "\"", "last", "synced", "txid", "=", "\"", "+", "synctxid", "+", "\"", "most", "recent", "txid", "=", "\"", "+", "txid", ")", ";", "log", "sync", "(", "last", "written", "tx", "id", ")", ";", "last", "written", "tx", "id", "=", "get", "last", "written", "tx", "id", "(", ")", ";", "log", "info", "(", "\"", "done", "log", "sync", "all", "last", "written", "tx", "id", "=", "\"", "+", "last", "written", "tx", "id", "+", "\"", "last", "synced", "txid", "=", "\"", "+", "synctxid", "+", "\"", "most", "recent", "txid", "=", "\"", "+", "txid", ")", ";", "}" ]
[ "paths", "to", "use", "during", "snapshot", "generation", ",", "which", "should", "only", "use", "the", "current", "version" ]
[ "private", "path", "get", "generate", "data", "file", "path", "(", ")", "{", "return", "paths", "get", "(", "get", "generate", "resource", "directory", "(", ")", "+", "\"", "/", "test", "-", "data", "\"", ")", ";", "}" ]
[ "compute", "a", "reduced", "classpath", "that", "is", "comprised", "of", "the", "header", "jars", "of", "all", "the", "direct", "dependencies", "and", "the", "jars", "needed", "to", "build", "those", "(", "read", "from", "the", "produced", "jdeps", "file", ")", "this", "duplicates", "the", "logic", "from", "{", "@", "link", "com", "google", "devtools", "build", "buildjar", "javac", "plugins", "dependency", "dependency", "module", "#", "compute", "strict", "classpath", "}" ]
[ "reduced", "classpath", "get", "reduced", "classpath", "(", "action", "execution", "context", "action", "execution", "context", ",", "java", "compile", "action", "context", "context", ")", "throws", "i", "o", "exception", "{", "hash", "set", "<", "string", ">", "direct", "=", "new", "hash", "set", "<", ">", "(", ")", ";", "for", "(", "artifact", "direct", "jar", ":", "direct", "jars", "to", "list", "(", ")", ")", "{", "direct", "add", "(", "direct", "jar", "get", "exec", "path", "string", "(", ")", ")", ";", "}", "for", "(", "artifact", "dep", "artifact", ":", "dependency", "artifacts", "to", "list", "(", ")", ")", "{", "for", "(", "deps", "dependency", "dep", ":", "context", "get", "dependencies", "(", "dep", "artifact", ",", "action", "execution", "context", ")", "get", "dependency", "list", "(", ")", ")", "{", "direct", "add", "(", "dep", "get", "path", "(", ")", ")", ";", "}", "}", "immutable", "list", "<", "artifact", ">", "transitive", "collection", "=", "transitive", "inputs", "to", "list", "(", ")", ";", "immutable", "list", "<", "artifact", ">", "reduced", "jars", "=", "immutable", "list", "copy", "of", "(", "iterables", "filter", "(", "transitive", "collection", ",", "input", "-", ">", "direct", "contains", "(", "input", "get", "exec", "path", "string", "(", ")", ")", ")", ")", ";", "return", "new", "reduced", "classpath", "(", "reduced", "jars", ",", "transitive", "collection", "size", "(", ")", ")", ";", "}" ]
[ "reads", "a", "single", "-", "precision", "floating", "point", "value", "(", "3", "2bit", ",", "4", "bytes", ")", "from", "the", "given", "position", ",", "in", "the", "system", "'", "s", "native", "byte", "order", "this", "method", "offers", "the", "best", "speed", "for", "float", "reading", "and", "should", "be", "used", "unless", "a", "specific", "byte", "order", "is", "required", "in", "most", "cases", ",", "it", "suffices", "to", "know", "that", "the", "byte", "order", "in", "which", "the", "value", "is", "written", "is", "the", "same", "as", "the", "one", "in", "which", "it", "is", "read", "(", "such", "as", "transient", "storage", "in", "memory", ",", "or", "serialization", "for", "io", "and", "network", ")", ",", "making", "this", "method", "the", "preferable", "choice" ]
[ "public", "final", "float", "get", "float", "(", "int", "index", ")", "{", "return", "float", "int", "bits", "to", "float", "(", "get", "int", "(", "index", ")", ")", ";", "}" ]
[ "return", "the", "program", "on", "this", "event" ]
[ "public", "program", "get", "program", "(", ")", "{", "return", "program", "ref", "get", "(", ")", ";", "}" ]
[ "trigger", "a", "fetch", "if", "an", "entry", "is", "needed" ]
[ "public", "boolean", "has", "next", "(", ")", "throws", "i", "o", "exception", "{", "if", "(", "next", "!", "=", "null", ")", "{", "return", "true", ";", "}", "return", "fetch", "(", ")", ";", "}" ]
[ "create", "a", "new", "debug", "overlay", "for", "the", "given", "fresco", "state", "returns", "null", "when", "debug", "overlays", "are", "disabled" ]
[ "drawable", "create", "(", "fresco", "state", "fresco", "state", ")", ";" ]
[ "get", "global", "status" ]
[ "public", "static", "global", "status", "get", "(", "int", "code", ")", "{", "global", "status", "value", "=", "null", ";", "try", "{", "value", "=", "global", "status", "values", "(", ")", "[", "code", "]", ";", "}", "catch", "(", "exception", "e", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "unknown", "global", "status", "[", "\"", "+", "code", "+", "\"", "]", "\"", ")", ";", "}", "return", "value", ";", "}" ]
[ "tries", "to", "shut", "down", "all", "network", "io", "components" ]
[ "public", "void", "close", "(", ")", "{", "synchronized", "(", "lock", ")", "{", "if", "(", "is", "closed", ")", "{", "return", ";", "}", "log", "info", "(", "\"", "shutting", "down", "the", "network", "environment", "and", "its", "components", "\"", ")", ";", "/", "/", "terminate", "all", "network", "connections", "try", "{", "log", "debug", "(", "\"", "shutting", "down", "network", "connection", "manager", "\"", ")", ";", "connection", "manager", "shutdown", "(", ")", ";", "}", "catch", "(", "throwable", "t", ")", "{", "log", "warn", "(", "\"", "cannot", "shut", "down", "the", "network", "connection", "manager", "\"", ",", "t", ")", ";", "}", "/", "/", "shutdown", "all", "intermediate", "results", "try", "{", "log", "debug", "(", "\"", "shutting", "down", "intermediate", "result", "partition", "manager", "\"", ")", ";", "result", "partition", "manager", "shutdown", "(", ")", ";", "}", "catch", "(", "throwable", "t", ")", "{", "log", "warn", "(", "\"", "cannot", "shut", "down", "the", "result", "partition", "manager", "\"", ",", "t", ")", ";", "}", "/", "/", "make", "sure", "that", "the", "global", "buffer", "pool", "re", "-", "acquires", "all", "buffers", "network", "buffer", "pool", "destroy", "all", "buffer", "pools", "(", ")", ";", "/", "/", "destroy", "the", "buffer", "pool", "try", "{", "network", "buffer", "pool", "destroy", "(", ")", ";", "}", "catch", "(", "throwable", "t", ")", "{", "log", "warn", "(", "\"", "network", "buffer", "pool", "did", "not", "shut", "down", "properly", "\"", ",", "t", ")", ";", "}", "/", "/", "delete", "all", "the", "temp", "directories", "try", "{", "file", "channel", "manager", "close", "(", ")", ";", "}", "catch", "(", "throwable", "t", ")", "{", "log", "warn", "(", "\"", "cannot", "close", "the", "file", "channel", "manager", "properly", "\"", ",", "t", ")", ";", "}", "is", "closed", "=", "true", ";", "}", "}" ]
[ "the", "children", "of", "this", "element", "<", "code", ">", "repeated", "aapt", "pb", "xml", "node", "child", "=", "5", ";", "<", "code", ">" ]
[ "public", "java", "util", "list", "<", "com", "android", "aapt", "resources", "xml", "node", ">", "get", "child", "list", "(", ")", "{", "return", "child", ";", "}" ]
[ "binary", "searches", "the", "list", "for", "the", "specified", "key", ",", "using", "the", "specified", "key", "function", "equivalent", "to", "{", "@", "link", "#", "binary", "search", "(", "list", ",", "object", ",", "comparator", ",", "key", "present", "behavior", ",", "key", "absent", "behavior", ")", "}", "using", "{", "@", "link", "lists", "#", "transform", "(", "list", ",", "function", ")", "lists", "transform", "(", "list", ",", "key", "function", ")", "}" ]
[ "public", "static", "<", "e", ",", "k", ">", "int", "binary", "search", "(", "list", "<", "e", ">", "list", ",", "function", "<", "?", "super", "e", ",", "k", ">", "key", "function", ",", "@", "nullable", "decl", "k", "key", ",", "comparator", "<", "?", "super", "k", ">", "key", "comparator", ",", "key", "present", "behavior", "present", "behavior", ",", "key", "absent", "behavior", "absent", "behavior", ")", "{", "return", "binary", "search", "(", "lists", "transform", "(", "list", ",", "key", "function", ")", ",", "key", ",", "key", "comparator", ",", "present", "behavior", ",", "absent", "behavior", ")", ";", "}" ]
[ "test", "serialization", "of", "object", "with", "outer", "number", "type", "<", "b", ">", "200", "<", "b", ">", "-", "output", "composite" ]
[ "public", "outer", "composite", "fake", "outer", "composite", "serialize", "(", "outer", "composite", "body", ")", "throws", "i", "o", "exception", "{", "http", "response", "response", "=", "fake", "outer", "composite", "serialize", "for", "http", "response", "(", "body", ")", ";", "type", "reference", "<", "outer", "composite", ">", "type", "ref", "=", "new", "type", "reference", "<", "outer", "composite", ">", "(", ")", "{", "}", ";", "return", "api", "client", "get", "object", "mapper", "(", ")", "read", "value", "(", "response", "get", "content", "(", ")", ",", "type", "ref", ")", ";", "}" ]
[ "hook", "for", "preparing", "a", "test", "instance", "prior", "to", "execution", "of", "any", "individual", "test", "methods", ",", "for", "example", "for", "injecting", "dependencies", ",", "etc", "should", "be", "called", "immediately", "after", "instantiation", "of", "the", "test", "instance", "the", "managed", "{", "@", "link", "test", "context", "}", "will", "be", "updated", "with", "the", "supplied", "{", "@", "code", "test", "instance", "}", "an", "attempt", "will", "be", "made", "to", "give", "each", "registered", "{", "@", "link", "test", "execution", "listener", "}", "a", "chance", "to", "prepare", "the", "test", "instance", "if", "a", "listener", "throws", "an", "exception", ",", "however", ",", "the", "remaining", "registered", "listeners", "will", "not", "be", "called" ]
[ "public", "void", "prepare", "test", "instance", "(", "object", "test", "instance", ")", "throws", "exception", "{", "if", "(", "logger", "is", "trace", "enabled", "(", ")", ")", "{", "logger", "trace", "(", "\"", "prepare", "test", "instance", "(", ")", ":", "instance", "[", "\"", "+", "test", "instance", "+", "\"", "]", "\"", ")", ";", "}", "get", "test", "context", "(", ")", "update", "state", "(", "test", "instance", ",", "null", ",", "null", ")", ";", "for", "(", "test", "execution", "listener", "test", "execution", "listener", ":", "get", "test", "execution", "listeners", "(", ")", ")", "{", "try", "{", "test", "execution", "listener", "prepare", "test", "instance", "(", "get", "test", "context", "(", ")", ")", ";", "}", "catch", "(", "throwable", "ex", ")", "{", "if", "(", "logger", "is", "error", "enabled", "(", ")", ")", "{", "logger", "error", "(", "\"", "caught", "exception", "while", "allowing", "test", "execution", "listener", "[", "\"", "+", "test", "execution", "listener", "+", "\"", "]", "to", "prepare", "test", "instance", "[", "\"", "+", "test", "instance", "+", "\"", "]", "\"", ",", "ex", ")", ";", "}", "reflection", "utils", "rethrow", "exception", "(", "ex", ")", ";", "}", "}", "}" ]
[ "@", "inherit", "doc" ]
[ "public", "int", "write", "proto", "id", "(", "proto", "id", "proto", "id", ")", "{", "ensure", "four", "bytes", "aligned", "(", "table", "of", "contents", "proto", "ids", ",", "true", ")", ";", "return", "super", "write", "proto", "id", "(", "proto", "id", ")", ";", "}" ]
[ "tests", "that", "the", "zoo", "keeper", "server", "will", "fail", "to", "start", "if", "the", "snapshot", "directory", "is", "read", "only", "this", "test", "will", "fail", "if", "it", "is", "executed", "as", "root", "user" ]
[ "public", "void", "test", "read", "only", "snapshot", "dir", "(", ")", "throws", "exception", "{", "client", "base", "setup", "test", "env", "(", ")", ";", "final", "int", "client", "port", "=", "port", "assignment", "unique", "(", ")", ";", "/", "/", "start", "up", "the", "zk", "server", "to", "automatically", "create", "the", "necessary", "directories", "/", "/", "and", "capture", "the", "directory", "where", "data", "is", "stored", "main", "thread", "main", "=", "new", "main", "thread", "(", "client", "port", ",", "true", ",", "null", ")", ";", "file", "tmp", "dir", "=", "main", "tmp", "dir", ";", "main", "start", "(", ")", ";", "assert", "true", "(", "client", "base", "wait", "for", "server", "up", "(", "\"", "127", "0", "0", "1", ":", "\"", "+", "client", "port", ",", "connection", "timeout", "/", "2", ")", ",", "\"", "waiting", "for", "server", "being", "up", "\"", ")", ";", "main", "shutdown", "(", ")", ";", "/", "/", "make", "the", "snapshot", "directory", "read", "only", "file", "snap", "dir", "=", "new", "file", "(", "main", "data", "dir", ",", "file", "txn", "snap", "log", "version", "+", "file", "txn", "snap", "log", "version", ")", ";", "snap", "dir", "set", "writable", "(", "false", ")", ";", "/", "/", "restart", "zk", "and", "observe", "a", "failure", "main", "=", "new", "main", "thread", "(", "client", "port", ",", "null", ",", "false", ",", "tmp", "dir", ",", "null", ")", ";", "main", "start", "(", ")", ";", "assert", "false", "(", "client", "base", "wait", "for", "server", "up", "(", "\"", "127", "0", "0", "1", ":", "\"", "+", "client", "port", ",", "connection", "timeout", "/", "2", ")", ",", "\"", "waiting", "for", "server", "being", "up", "\"", ")", ";", "main", "shutdown", "(", ")", ";", "snap", "dir", "set", "writable", "(", "true", ")", ";", "main", "delete", "dirs", "(", ")", ";", "}" ]
[ "method", "called", "when", "the", "action", "is", "invoked" ]
[ "public", "void", "action", "performed", "(", "listing", "action", "context", "context", ")", "{", "function", "function", "=", "func", "plugin", "get", "function", "(", "context", ")", ";", "if", "(", "function", "=", "=", "null", ")", "{", "return", ";", "}", "address", "entry", "=", "function", "get", "entry", "point", "(", ")", ";", "func", "plugin", "execute", "(", "context", "get", "program", "(", ")", ",", "new", "create", "function", "definition", "cmd", "(", "entry", ",", "func", "plugin", "get", "tool", "(", ")", ")", ")", ";", "}" ]
[ "returns", "a", "list", "of", "{", "@", "link", "d", "i", "e", "aggregate", "}", "s", "that", "refer", "to", "the", "target", "d", "i", "e", "a", "via", "an", "attribute", "of", "the", "specified", "tag", "type" ]
[ "public", "list", "<", "d", "i", "e", "aggregate", ">", "get", "type", "referers", "(", "d", "i", "e", "aggregate", "target", "d", "i", "e", "a", ",", "int", "tag", ")", "{", "list", "<", "d", "i", "e", "aggregate", ">", "result", "=", "new", "array", "list", "<", ">", "(", ")", ";", "for", "(", "d", "i", "e", "aggregate", "referer", ":", "get", "type", "referers", "(", "target", "d", "i", "e", "a", ")", ")", "{", "if", "(", "referer", "get", "tag", "(", ")", "=", "=", "tag", ")", "{", "result", "add", "(", "referer", ")", ";", "}", "}", "return", "result", ";", "}" ]
[ "executes", "the", "execution", "listeners", "defined", "on", "the", "given", "element", ",", "with", "the", "given", "event", "type", ",", "and", "passing", "the", "provided", "execution", "to", "the", "{", "@", "link", "execution", "listener", "}", "instances" ]
[ "protected", "void", "execute", "execution", "listeners", "(", "has", "execution", "listeners", "element", "with", "execution", "listeners", ",", "execution", "entity", "execution", "entity", ",", "string", "event", "type", ")", "{", "command", "context", "get", "process", "engine", "configuration", "(", ")", "get", "listener", "notification", "helper", "(", ")", "execute", "execution", "listeners", "(", "element", "with", "execution", "listeners", ",", "execution", "entity", ",", "event", "type", ")", ";", "}" ]
[ "create", "a", "new", "types", "list", "that", "prepends", "the", "bigint", "type", "in", "front", "if", "add", "pre", "computed", "hash", "block", "is", "true", ",", "and", "append", "the", "bigint", "type", "at", "the", "end", "if", "add", "null", "block", "is", "true" ]
[ "public", "static", "list", "<", "type", ">", "update", "block", "types", "with", "hash", "block", "and", "null", "block", "(", "list", "<", "type", ">", "types", ",", "boolean", "add", "pre", "computed", "hash", "block", ",", "boolean", "add", "null", "block", ")", "{", "immutable", "list", "builder", "<", "type", ">", "new", "types", "=", "immutable", "list", "builder", "(", ")", ";", "if", "(", "add", "pre", "computed", "hash", "block", ")", "{", "new", "types", "add", "(", "bigint", ")", ";", "}", "new", "types", "add", "all", "(", "types", ")", ";", "if", "(", "add", "null", "block", ")", "{", "new", "types", "add", "(", "bigint", ")", ";", "}", "return", "new", "types", "build", "(", ")", ";", "}" ]
[ "check", "that", "this", "entry", "point", "leads", "to", "a", "well", "behaved", "subroutine", ",", "allow", "it", "to", "fall", "into", "existing", "code", "it", "should", "return", "hit", "no", "bad", "instructions", "have", "only", "one", "entry", "point", "not", "overlap", "any", "existing", "data", "or", "cause", "offcut", "references" ]
[ "public", "boolean", "is", "valid", "subroutine", "(", "address", "entry", "point", ",", "boolean", "allow", "existing", "code", ")", "{", "return", "check", "valid", "subroutine", "(", "entry", "point", ",", "allow", "existing", "code", ")", ";", "}" ]
[ "returns", "whether", "the", "bound", "camera", "supports", "zooming" ]
[ "public", "boolean", "is", "zoom", "supported", "(", ")", "{", "return", "m", "camera", "module", "is", "zoom", "supported", "(", ")", ";", "}" ]
[ "applies", "the", "given", "visitor", "to", "all", "class", "annotations" ]
[ "public", "void", "type", "annotations", "accept", "(", "clazz", "clazz", ",", "type", "annotation", "visitor", "type", "annotation", "visitor", ")", "{", "type", "annotation", "[", "]", "annotations", "=", "(", "type", "annotation", "[", "]", ")", "this", "annotations", ";", "for", "(", "int", "index", "=", "0", ";", "index", "<", "u", "2annotations", "count", ";", "index", "+", "+", ")", "{", "/", "/", "we", "don", "'", "t", "need", "double", "dispatching", "here", ",", "since", "there", "is", "only", "one", "/", "/", "type", "of", "annotation", "type", "annotation", "visitor", "visit", "type", "annotation", "(", "clazz", ",", "annotations", "[", "index", "]", ")", ";", "}", "}" ]
[ "build", "a", "host", "and", "port", "instance", "from", "separate", "host", "and", "port", "values", "note", ":", "non", "-", "bracketed", "i", "pv", "6", "literals", "are", "allowed", "use", "{", "@", "link", "#", "require", "brackets", "for", "i", "pv", "6", "(", ")", "}", "to", "prohibit", "these" ]
[ "public", "static", "host", "and", "port", "from", "parts", "(", "string", "host", ",", "int", "port", ")", "{", "check", "argument", "(", "is", "valid", "port", "(", "port", ")", ",", "\"", "port", "out", "of", "range", ":", "%", "s", "\"", ",", "port", ")", ";", "host", "and", "port", "parsed", "host", "=", "from", "string", "(", "host", ")", ";", "check", "argument", "(", "!", "parsed", "host", "has", "port", "(", ")", ",", "\"", "host", "has", "a", "port", ":", "%", "s", "\"", ",", "host", ")", ";", "return", "new", "host", "and", "port", "(", "parsed", "host", "host", ",", "port", ",", "parsed", "host", "has", "bracketless", "colons", ")", ";", "}" ]
[ "sets", "a", "custom", "error", "message", "to", "be", "displayed", "by", "the", "view", "the", "error", "message", "will", "be", "displayed", "permanently", ",", "unless", "it", "is", "cleared", "by", "passing", "{", "@", "code", "null", "}", "to", "this", "method" ]
[ "public", "void", "set", "custom", "error", "message", "(", "@", "nullable", "char", "sequence", "message", ")", "{", "assertions", "check", "state", "(", "error", "message", "view", "!", "=", "null", ")", ";", "custom", "error", "message", "=", "message", ";", "update", "error", "message", "(", ")", ";", "}" ]
[ "verify", "name", "node", "behavior", "when", "a", "given", "dn", "reports", "multiple", "replicas", "of", "a", "given", "block" ]
[ "public", "void", "test", "block", "has", "multiple", "replicas", "on", "same", "d", "n", "(", ")", "throws", "i", "o", "exception", "{", "string", "filename", "=", "make", "file", "name", "(", "generic", "test", "utils", "get", "method", "name", "(", ")", ")", ";", "path", "file", "path", "=", "new", "path", "(", "filename", ")", ";", "/", "/", "write", "out", "a", "file", "with", "a", "few", "blocks", "d", "f", "s", "test", "util", "create", "file", "(", "fs", ",", "file", "path", ",", "block", "size", ",", "block", "size", "*", "num", "blocks", ",", "block", "size", ",", "num", "datanodes", ",", "seed", ")", ";", "/", "/", "get", "the", "block", "list", "for", "the", "file", "with", "the", "block", "locations", "located", "blocks", "located", "blocks", "=", "client", "get", "located", "blocks", "(", "file", "path", "to", "string", "(", ")", ",", "0", ",", "block", "size", "*", "num", "blocks", ")", ";", "/", "/", "generate", "a", "fake", "block", "report", "from", "one", "of", "the", "data", "nodes", ",", "such", "/", "/", "that", "it", "reports", "one", "copy", "of", "each", "block", "on", "either", "storage", "data", "node", "dn", "=", "cluster", "get", "data", "nodes", "(", ")", "get", "(", "0", ")", ";", "datanode", "registration", "dn", "reg", "=", "dn", "get", "d", "n", "registration", "for", "b", "p", "(", "bpid", ")", ";", "storage", "block", "report", "reports", "[", "]", "=", "new", "storage", "block", "report", "[", "cluster", "get", "storages", "per", "datanode", "(", ")", "]", ";", "array", "list", "<", "replica", "info", ">", "blocks", "=", "new", "array", "list", "<", ">", "(", ")", ";", "for", "(", "located", "block", "located", "block", ":", "located", "blocks", "get", "located", "blocks", "(", ")", ")", "{", "block", "local", "block", "=", "located", "block", "get", "block", "(", ")", "get", "local", "block", "(", ")", ";", "blocks", "add", "(", "new", "finalized", "replica", "(", "local", "block", ",", "null", ",", "null", ")", ")", ";", "}", "collections", "sort", "(", "blocks", ")", ";", "try", "(", "fs", "dataset", "spi", "fs", "volume", "references", "volumes", "=", "dn", "get", "f", "s", "dataset", "(", ")", "get", "fs", "volume", "references", "(", ")", ")", "{", "block", "list", "as", "longs", "bll", "=", "block", "list", "as", "longs", "encode", "(", "blocks", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "cluster", "get", "storages", "per", "datanode", "(", ")", ";", "+", "+", "i", ")", "{", "datanode", "storage", "dns", "=", "new", "datanode", "storage", "(", "volumes", "get", "(", "i", ")", "get", "storage", "i", "d", "(", ")", ")", ";", "reports", "[", "i", "]", "=", "new", "storage", "block", "report", "(", "dns", ",", "bll", ")", ";", "}", "}", "/", "/", "should", "not", "assert", "!", "cluster", "get", "name", "node", "rpc", "(", ")", "block", "report", "(", "dn", "reg", ",", "bpid", ",", "reports", ",", "new", "block", "report", "context", "(", "1", ",", "0", ",", "system", "nano", "time", "(", ")", ",", "0l", ",", "true", ")", ")", ";", "/", "/", "get", "the", "block", "locations", "once", "again", "located", "blocks", "=", "client", "get", "located", "blocks", "(", "filename", ",", "0", ",", "block", "size", "*", "num", "blocks", ")", ";", "/", "/", "make", "sure", "that", "each", "block", "has", "two", "replicas", ",", "one", "on", "each", "data", "node", "for", "(", "located", "block", "located", "block", ":", "located", "blocks", "get", "located", "blocks", "(", ")", ")", "{", "datanode", "info", "[", "]", "locations", "=", "located", "block", "get", "locations", "(", ")", ";", "assert", "that", "(", "locations", "length", ",", "is", "(", "(", "int", ")", "num", "datanodes", ")", ")", ";", "assert", "that", "(", "locations", "[", "0", "]", "get", "datanode", "uuid", "(", ")", ",", "not", "(", "locations", "[", "1", "]", "get", "datanode", "uuid", "(", ")", ")", ")", ";", "}", "}" ]
[ "test", "the", "property", "'", "class", "name", "'" ]
[ "public", "void", "class", "name", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "class", "name", "}" ]
[ "@", "inherit", "doc" ]
[ "public", "int", "next", "(", ")", "{", "if", "(", "!", "has", "next", "(", ")", ")", "{", "throw", "new", "no", "such", "element", "exception", "(", ")", ";", "}", "return", "ints", "get", "(", "idx", "+", "+", ")", ";", "}" ]
[ "this", "implementation", "returns", "just", "the", "view", "name", ",", "as", "xml", "view", "resolver", "doesn", "'", "t", "support", "localized", "resolution" ]
[ "protected", "object", "get", "cache", "key", "(", "string", "view", "name", ",", "locale", "locale", ")", "{", "return", "view", "name", ";", "}" ]
[ "to", "test", "\\", "&", "quot", ";", "client", "\\", "&", "quot", ";", "model", "to", "test", "\\", "&", "quot", ";", "client", "\\", "&", "quot", ";", "model" ]
[ "public", "void", "test", "client", "model", "test", "(", ")", "throws", "api", "exception", "{", "client", "body", "=", "null", ";", "client", "response", "=", "api", "test", "client", "model", "(", "body", ")", ";", "/", "/", "todo", ":", "test", "validations", "}" ]
[ "{", "@", "link", "#", "remove", "listener", "(", "string", ",", "string", ",", "configuration", "listener", ")", "}" ]
[ "default", "void", "remove", "listener", "(", "string", "key", ",", "configuration", "listener", "listener", ")", "{", "remove", "listener", "(", "key", ",", "default", "group", ",", "listener", ")", ";", "}" ]
[ "closes", "all", "resources", "used" ]
[ "public", "void", "close", "(", ")", "throws", "i", "o", "exception", "{", "if", "(", "result", "set", "=", "=", "null", ")", "{", "return", ";", "}", "try", "{", "result", "set", "close", "(", ")", ";", "}", "catch", "(", "s", "q", "l", "exception", "se", ")", "{", "log", "info", "(", "\"", "inputformat", "result", "set", "couldn", "'", "t", "be", "closed", "-", "\"", "+", "se", "get", "message", "(", ")", ")", ";", "}", "}" ]
[ "the", "entries", "defined", "for", "this", "type", "<", "code", ">", "repeated", "aapt", "pb", "entry", "entry", "=", "3", ";", "<", "code", ">" ]
[ "public", "builder", "set", "entry", "(", "int", "index", ",", "com", "android", "aapt", "resources", "entry", "builder", "builder", "for", "value", ")", "{", "copy", "on", "write", "(", ")", ";", "instance", "set", "entry", "(", "index", ",", "builder", "for", "value", ")", ";", "return", "this", ";", "}" ]
[ "gets", "a", "new", "{", "@", "link", "byte", "buffer", "}", "instance", "wrapping", "this", "buffer", "'", "s", "readable", "bytes", ",", "i", "e", "between", "{", "@", "link", "#", "get", "reader", "index", "(", ")", "}", "and", "{", "@", "link", "#", "get", "size", "(", ")", "}", "please", "note", "that", "neither", "index", "is", "updated", "by", "the", "returned", "buffer" ]
[ "byte", "buffer", "get", "nio", "buffer", "readable", "(", ")", ";" ]
[ "captures", "the", "end", "of", "the", "continuation", "for", "stolen", "work" ]
[ "void", "on", "end", "work", "(", "object", "token", ")", ";" ]
[ "returns", "an", "authenticated", "{", "@", "link", "http", "u", "r", "l", "connection", "}" ]
[ "public", "http", "u", "r", "l", "connection", "open", "connection", "(", "url", "url", ",", "token", "token", ")", "throws", "i", "o", "exception", ",", "authentication", "exception", "{", "if", "(", "url", "=", "=", "null", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "url", "cannot", "be", "null", "\"", ")", ";", "}", "if", "(", "!", "url", "get", "protocol", "(", ")", "equals", "ignore", "case", "(", "\"", "http", "\"", ")", "&", "&", "!", "url", "get", "protocol", "(", ")", "equals", "ignore", "case", "(", "\"", "https", "\"", ")", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "url", "must", "be", "for", "a", "http", "or", "https", "resource", "\"", ")", ";", "}", "if", "(", "token", "=", "=", "null", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "token", "cannot", "be", "null", "\"", ")", ";", "}", "authenticator", "authenticate", "(", "url", ",", "token", ")", ";", "/", "/", "allow", "the", "token", "to", "create", "the", "connection", "with", "a", "cookie", "handler", "for", "/", "/", "managing", "session", "cookies", "return", "token", "open", "connection", "(", "url", ",", "conn", "configurator", ")", ";", "}" ]
[ "output", "the", "api", "(", "class", ")", "name", "(", "capitalized", ")", "ending", "with", "the", "specified", "or", "default", "suffix", "return", "default", "api", "if", "name", "is", "empty" ]
[ "public", "string", "to", "api", "name", "(", "string", "name", ")", "{", "if", "(", "name", "length", "(", ")", "=", "=", "0", ")", "{", "return", "\"", "default", "api", "\"", ";", "}", "return", "camelize", "(", "api", "name", "prefix", "+", "\"", "\"", "+", "name", "+", "\"", "\"", "+", "api", "name", "suffix", ")", ";", "}" ]
[ "specifies", "the", "executor", "to", "use", "when", "running", "asynchronous", "tasks", "the", "executor", "is", "delegated", "to", "when", "sending", "removal", "notifications", ",", "when", "asynchronous", "computations", "are", "performed", "by", "{", "@", "link", "async", "cache", "}", "or", "{", "@", "link", "loading", "cache", "#", "refresh", "}", "or", "{", "@", "link", "#", "refresh", "after", "write", "}", ",", "or", "when", "performing", "periodic", "maintenance", "by", "default", ",", "{", "@", "link", "fork", "join", "pool", "#", "common", "pool", "(", ")", "}", "is", "used", "the", "primary", "intent", "of", "this", "method", "is", "to", "facilitate", "testing", "of", "caches", "which", "have", "been", "configured", "with", "{", "@", "link", "#", "removal", "listener", "}", "or", "utilize", "asynchronous", "computations", "a", "test", "may", "instead", "prefer", "to", "configure", "the", "cache", "to", "execute", "tasks", "directly", "on", "the", "same", "thread", "beware", "that", "configuring", "a", "cache", "with", "an", "executor", "that", "throws", "{", "@", "link", "rejected", "execution", "exception", "}", "may", "experience", "non", "-", "deterministic", "behavior" ]
[ "public", "caffeine", "<", "k", ",", "v", ">", "executor", "(", "@", "non", "null", "executor", "executor", ")", "{", "require", "state", "(", "this", "executor", "=", "=", "null", ",", "\"", "executor", "was", "already", "set", "to", "%", "s", "\"", ",", "this", "executor", ")", ";", "this", "executor", "=", "require", "non", "null", "(", "executor", ")", ";", "return", "this", ";", "}" ]
[ "returns", "a", "place", "-", "holder", "required", "shuffle", "type", "currently", "{", "@", "link", "exec", "edge", "}", "is", "only", "used", "for", "deadlock", "breakup", "and", "multi", "-", "input", "in", "batch", "mode", ",", "so", "for", "{", "@", "link", "exec", "node", "}", "s", "not", "affecting", "the", "algorithm", "we", "use", "this", "place", "-", "holder", "we", "should", "fill", "out", "the", "detailed", "{", "@", "link", "exec", "edge", "}", "for", "each", "sub", "-", "class", "of", "{", "@", "link", "exec", "node", "}", "in", "the", "future" ]
[ "public", "static", "required", "shuffle", "unknown", "(", ")", "{", "return", "new", "required", "shuffle", "(", "shuffle", "type", "unknown", ")", ";", "}" ]
[ "configures", "rocks", "d", "b", "to", "use", "a", "fixed", "amount", "of", "memory", "shared", "between", "all", "instances", "(", "operators", ")", "in", "a", "slot", "see", "{", "@", "link", "#", "set", "fixed", "memory", "per", "slot", "(", "memory", "size", ")", "}", "for", "details" ]
[ "public", "void", "set", "fixed", "memory", "per", "slot", "(", "string", "total", "memory", "per", "slot", "str", ")", "{", "set", "fixed", "memory", "per", "slot", "(", "memory", "size", "parse", "(", "total", "memory", "per", "slot", "str", ")", ")", ";", "}" ]
[ "assert", "that", "the", "given", "string", "contains", "valid", "text", "content", ";", "that", "is", ",", "it", "must", "not", "be", "{", "@", "code", "null", "}", "and", "must", "contain", "at", "least", "one", "non", "-", "whitespace", "character", "<", "pre", "class", "=", "\"", "code", "\"", ">", "assert", "has", "text", "(", "account", "get", "name", "(", ")", ",", "(", ")", "-", "&", "gt", ";", "\"", "name", "for", "account", "'", "\"", "+", "account", "get", "id", "(", ")", "+", "\"", "'", "must", "not", "be", "empty", "\"", ")", ";" ]
[ "public", "static", "void", "has", "text", "(", "@", "nullable", "string", "text", ",", "supplier", "<", "string", ">", "message", "supplier", ")", "{", "if", "(", "!", "string", "utils", "has", "text", "(", "text", ")", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "null", "safe", "get", "(", "message", "supplier", ")", ")", ";", "}", "}" ]
[ "returns", "the", "value", "pointer" ]
[ "public", "static", "long", "get", "value", "pointer", "(", "memory", "segment", "memory", "segment", ",", "int", "offset", ")", "{", "return", "memory", "segment", "get", "long", "(", "offset", "+", "value", "pointer", "offset", ")", ";", "}" ]
[ "computes", "the", "average", "response", "time", ",", "by", "taking", "the", "time", "out", "into", "account" ]
[ "public", "long", "get", "average", "(", ")", "{", "long", "total", "=", "0", ";", "for", "(", "long", "l", ":", "past", "5", ")", "{", "if", "(", "l", "<", "0", ")", "total", "+", "=", "timeout", ";", "else", "total", "+", "=", "l", ";", "}", "return", "total", "/", "past", "5", "length", ";", "}" ]
[ "uses", "hash", "common", "array", "size", "(", ")", "which", "does", "this", "calculation", "this", "is", "just", "a", "wrapper", "to", "name", "the", "use", "of", "this", "case" ]
[ "public", "static", "int", "compute", "bucket", "count", "(", "int", "expected", "size", ",", "float", "fill", "ratio", ")", "{", "return", "array", "size", "(", "expected", "size", ",", "fill", "ratio", ")", ";", "}" ]
[ "returns", "if", "the", "context", "should", "be", "treated", "as", "a", "prefix" ]
[ "public", "boolean", "is", "prefix", "(", ")", "{", "return", "is", "prefix", ";", "}" ]
[ "return", "the", "additional", "(", "undeclared", ")", "property" ]
[ "public", "map", "<", "string", ",", "integer", ">", "get", "additional", "properties", "(", ")", "{", "return", "additional", "properties", ";", "}" ]
[ "unqualify", "a", "string", "qualified", "by", "a", "'", "'", "dot", "character", "for", "example", ",", "\"", "this", "name", "is", "qualified", "\"", ",", "returns", "\"", "qualified", "\"" ]
[ "public", "static", "string", "unqualify", "(", "string", "qualified", "name", ")", "{", "return", "unqualify", "(", "qualified", "name", ",", "'", "'", ")", ";", "}" ]
[ "this", "method", "returns", "two", "lists", ":", "1", ")", "is", "the", "set", "of", "structs", "and", "typedefs", "to", "structs", "intended", "for", "outputting", "zero", "-", "sized", "definitions", "2", ")", "is", "the", "acyclic", "dependency", "list", "(", "broken", "at", "structs", "and", "pointers", "to", "structs", ")", "this", "works", "(", "and", "the", "dependency", "graph", "is", "able", "to", "be", "broken", "of", "cycles", ")", "because", "structures", "can", "be", "given", "zero", "size", "to", "start", "with", "and", "then", "later", "updated", "with", "full", "size" ]
[ "public", "pair", "<", "array", "list", "<", "data", "type", ">", ",", "array", "list", "<", "data", "type", ">", ">", "get", "acyclic", "dependency", "lists", "(", ")", "{", "if", "(", "processed", "=", "=", "false", ")", "{", "process", "dependency", "lists", "(", ")", ";", "}", "return", "new", "pair", "<", ">", "(", "struct", "list", ",", "ordered", "dependents", "list", ")", ";", "}" ]
[ "converts", "a", "property", "value", "to", "a", "client", "auth", "enum", "if", "the", "input", "string", "is", "empty", "or", "null", ",", "returns", "<", "code", ">", "client", "auth", "need", "<", "code", ">" ]
[ "public", "static", "client", "auth", "from", "property", "value", "(", "string", "prop", ")", "{", "if", "(", "prop", "=", "=", "null", "|", "|", "prop", "length", "(", ")", "=", "=", "0", ")", "{", "return", "need", ";", "}", "return", "client", "auth", "value", "of", "(", "prop", "to", "upper", "case", "(", ")", ")", ";", "}" ]
[ "returns", "whether", "the", "information", "contained", "in", "this", "parameter", "value", "is", "sensitive", "or", "security", "related", "used", "to", "determine", "whether", "the", "value", "provided", "by", "this", "object", "should", "be", "masked", "in", "output", "subclasses", "can", "override", "this", "to", "control", "the", "return", "value" ]
[ "public", "boolean", "is", "sensitive", "(", ")", "{", "return", "false", ";", "}" ]
[ "executes", "a", "chunk", "of", "code", "at", "the", "same", "machine", "where", "this", "process", "resides" ]
[ "public", "<", "t", ">", "t", "act", "(", "process", "callable", "<", "t", ">", "callable", ")", "throws", "i", "o", "exception", ",", "interrupted", "exception", "{", "return", "callable", "invoke", "(", "this", ",", "file", "path", "local", "channel", ")", ";", "}" ]
[ "tests", "that", "we", "can", "add", "a", "tag", "to", "a", "function" ]
[ "public", "void", "test", "add", "tag", "to", "function", "(", ")", "throws", "exception", "{", "string", "name", "=", "\"", "test", "\"", ";", "create", "tag", "(", "name", ")", ";", "add", "tag", "to", "function", "(", "name", ",", "function", "entry", "address", ")", ";", "assert", "true", "(", "tag", "exists", "(", "name", ",", "get", "tags", "(", "function", "entry", "address", ")", ")", ")", ";", "}" ]
[ "schedules", "to", "throw", "a", "playback", "exception", "on", "the", "playback", "thread" ]
[ "public", "builder", "throw", "playback", "exception", "(", "exo", "playback", "exception", "exception", ")", "{", "return", "apply", "(", "new", "throw", "playback", "exception", "(", "tag", ",", "exception", ")", ")", ";", "}" ]
[ "asserts", "that", "window", "tags", "are", "set", "correctly" ]
[ "public", "static", "void", "assert", "window", "tags", "(", "timeline", "timeline", ",", "@", "nullable", "type", "object", "expected", "window", "tags", ")", "{", "window", "window", "=", "new", "window", "(", ")", ";", "assert", "that", "(", "timeline", "get", "window", "count", "(", ")", ")", "is", "equal", "to", "(", "expected", "window", "tags", "length", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "timeline", "get", "window", "count", "(", ")", ";", "i", "+", "+", ")", "{", "timeline", "get", "window", "(", "i", ",", "window", ")", ";", "if", "(", "expected", "window", "tags", "[", "i", "]", "!", "=", "null", ")", "{", "media", "item", "playback", "properties", "playback", "properties", "=", "window", "media", "item", "playback", "properties", ";", "assert", "that", "(", "playback", "properties", ")", "is", "not", "null", "(", ")", ";", "assert", "that", "(", "util", "cast", "non", "null", "(", "playback", "properties", ")", "tag", ")", "is", "equal", "to", "(", "expected", "window", "tags", "[", "i", "]", ")", ";", "}", "}", "}" ]
[ "creates", "and", "configures", "a", "parquet", "writer", "to", "the", "given", "output", "file" ]
[ "parquet", "writer", "<", "t", ">", "create", "writer", "(", "output", "file", "out", ")", "throws", "i", "o", "exception", ";" ]