Datasets:
Anonymous2023
/
KGSum

Dataset card Data Studio Files Community
docstring_tokens
list
code_tokens
list
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "int", "get", "access", "flags", "(", ")", "{", "parse", "to", "interfaces", "if", "necessary", "(", ")", ";", "return", "access", "flags", ";", "}" ]
[ "test", "upgrade", "from", "0", "22", "image" ]
[ "public", "void", "test", "upgrade", "from", "rel", "2", "2", "image", "(", ")", "throws", "i", "o", "exception", "{", "unpack", "storage", "(", "hadoop22", "image", ",", "hadoop", "dfs", "dir", "txt", ")", ";", "upgrade", "and", "verify", "(", "new", "mini", "d", "f", "s", "cluster", "builder", "(", "upgrade", "conf", ")", "num", "data", "nodes", "(", "4", ")", ",", "null", ")", ";", "}" ]
[ "create", "an", "iterator", "over", "objects", "in", "s3", "only", ";", "s", "3", "guard", "is", "not", "involved", "the", "listing", "includes", "the", "key", "itself", ",", "if", "found" ]
[ "remote", "iterator", "<", "s", "3", "a", "file", "status", ">", "list", "objects", "(", "path", "path", ",", "string", "key", ")", "throws", "i", "o", "exception", ";" ]
[ "get", "an", "optional", "int", "value", "associated", "with", "a", "key", ",", "or", "the", "default", "if", "there", "is", "no", "such", "key", "or", "if", "the", "value", "is", "not", "a", "number", "if", "the", "value", "is", "a", "string", ",", "an", "attempt", "will", "be", "made", "to", "evaluate", "it", "as", "a", "number" ]
[ "public", "int", "opt", "int", "(", "string", "key", ",", "int", "default", "value", ")", "{", "try", "{", "return", "get", "int", "(", "key", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "return", "default", "value", ";", "}", "}" ]
[ "the", "query", "to", "validate" ]
[ "public", "validate", "query", "request", "builder", "set", "query", "(", "query", "builder", "query", "builder", ")", "{", "request", "query", "(", "query", "builder", ")", ";", "return", "this", ";", "}" ]
[ "returns", "the", "class", "name", "for", "{", "@", "code", "element", "}" ]
[ "public", "static", "class", "name", "get", "(", "type", "element", "element", ")", "{", "check", "not", "null", "(", "element", ",", "\"", "element", "=", "=", "null", "\"", ")", ";", "string", "simple", "name", "=", "element", "get", "simple", "name", "(", ")", "to", "string", "(", ")", ";", "return", "element", "get", "enclosing", "element", "(", ")", "accept", "(", "new", "simple", "element", "visitor", "8", "<", "class", "name", ",", "void", ">", "(", ")", "{", "@", "override", "public", "class", "name", "visit", "package", "(", "package", "element", "package", "element", ",", "void", "p", ")", "{", "return", "new", "class", "name", "(", "package", "element", "get", "qualified", "name", "(", ")", "to", "string", "(", ")", ",", "null", ",", "simple", "name", ")", ";", "}", "@", "override", "public", "class", "name", "visit", "type", "(", "type", "element", "enclosing", "class", ",", "void", "p", ")", "{", "return", "class", "name", "get", "(", "enclosing", "class", ")", "nested", "class", "(", "simple", "name", ")", ";", "}", "@", "override", "public", "class", "name", "visit", "unknown", "(", "element", "unknown", ",", "void", "p", ")", "{", "return", "get", "(", "\"", "\"", ",", "simple", "name", ")", ";", "}", "@", "override", "public", "class", "name", "default", "action", "(", "element", "enclosing", "element", ",", "void", "p", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "unexpected", "type", "nesting", ":", "\"", "+", "element", ")", ";", "}", "}", ",", "null", ")", ";", "}" ]
[ "make", "the", "given", "path", "and", "all", "non", "-", "existent", "parents", "into", "directories" ]
[ "static", "boolean", "inner", "mkdirs", "(", "final", "o", "b", "s", "file", "system", "owner", ",", "final", "path", "path", ")", "throws", "i", "o", "exception", ",", "file", "already", "exists", "exception", ",", "obs", "exception", "{", "log", "debug", "(", "\"", "making", "directory", ":", "{", "}", "\"", ",", "path", ")", ";", "file", "status", "file", "status", ";", "try", "{", "file", "status", "=", "owner", "get", "file", "status", "(", "path", ")", ";", "if", "(", "file", "status", "is", "directory", "(", ")", ")", "{", "return", "true", ";", "}", "else", "{", "throw", "new", "file", "already", "exists", "exception", "(", "\"", "path", "is", "a", "file", ":", "\"", "+", "path", ")", ";", "}", "}", "catch", "(", "file", "not", "found", "exception", "e", ")", "{", "path", "f", "part", "=", "path", "get", "parent", "(", ")", ";", "do", "{", "try", "{", "file", "status", "=", "owner", "get", "file", "status", "(", "f", "part", ")", ";", "if", "(", "file", "status", "is", "directory", "(", ")", ")", "{", "break", ";", "}", "if", "(", "file", "status", "is", "file", "(", ")", ")", "{", "throw", "new", "file", "already", "exists", "exception", "(", "string", "format", "(", "\"", "can", "'", "t", "make", "directory", "for", "path", "'", "%", "s", "'", "\"", "+", "\"", "since", "it", "is", "a", "file", "\"", ",", "f", "part", ")", ")", ";", "}", "}", "catch", "(", "file", "not", "found", "exception", "fnfe", ")", "{", "log", "debug", "(", "\"", "file", "{", "}", "not", "fount", ",", "but", "ignore", "\"", ",", "path", ")", ";", "}", "f", "part", "=", "f", "part", "get", "parent", "(", ")", ";", "}", "while", "(", "f", "part", "!", "=", "null", ")", ";", "string", "key", "=", "path", "to", "key", "(", "owner", ",", "path", ")", ";", "if", "(", "owner", "is", "fs", "bucket", "(", ")", ")", "{", "o", "b", "s", "posix", "bucket", "utils", "fs", "create", "folder", "(", "owner", ",", "key", ")", ";", "}", "else", "{", "o", "b", "s", "object", "bucket", "utils", "create", "fake", "directory", "(", "owner", ",", "key", ")", ";", "}", "return", "true", ";", "}", "}" ]
[ "add", "a", "<", "code", ">", "-", "d", "key", "=", "val", "<", "code", ">", "command", "to", "the", "cli", "this", "is", "very", "hadoop", "api" ]
[ "public", "void", "define", "(", "string", "key", ",", "string", "val", ")", "{", "preconditions", "check", "argument", "(", "key", "!", "=", "null", ",", "\"", "null", "key", "\"", ")", ";", "preconditions", "check", "argument", "(", "val", "!", "=", "null", ",", "\"", "null", "value", "\"", ")", ";", "add", "(", "\"", "-", "d", "\"", ",", "key", "+", "\"", "=", "\"", "+", "val", ")", ";", "}" ]
[ "evaluate", "the", "x", "path", "and", "assert", "the", "{", "@", "link", "boolean", "}", "value", "found" ]
[ "public", "result", "matcher", "boolean", "value", "(", "boolean", "value", ")", "{", "return", "result", "-", ">", "{", "mock", "http", "servlet", "response", "response", "=", "result", "get", "response", "(", ")", ";", "this", "xpath", "helper", "assert", "boolean", "(", "response", "get", "content", "as", "byte", "array", "(", ")", ",", "get", "defined", "encoding", "(", "response", ")", ",", "value", ")", ";", "}", ";", "}" ]
[ "authenticate", "internal", "authentication", "builder" ]
[ "protected", "authentication", "builder", "authenticate", "internal", "(", "final", "authentication", "transaction", "transaction", ")", "throws", "authentication", "exception", "{", "val", "credentials", "=", "transaction", "get", "credentials", "(", ")", ";", "logger", "debug", "(", "\"", "authentication", "credentials", "provided", "for", "this", "transaction", "are", "[", "{", "}", "]", "\"", ",", "credentials", ")", ";", "if", "(", "credentials", "is", "empty", "(", ")", ")", "{", "logger", "error", "(", "\"", "resolved", "authentication", "handlers", "for", "this", "transaction", "are", "empty", "\"", ")", ";", "throw", "new", "authentication", "exception", "(", "\"", "resolved", "credentials", "for", "this", "transaction", "are", "empty", "\"", ")", ";", "}", "val", "builder", "=", "new", "default", "authentication", "builder", "(", "null", "principal", "get", "instance", "(", ")", ")", ";", "credentials", "for", "each", "(", "cred", "-", ">", "builder", "add", "credential", "(", "new", "basic", "credential", "meta", "data", "(", "cred", ")", ")", ")", ";", "val", "handler", "set", "=", "this", "authentication", "event", "execution", "plan", "get", "authentication", "handlers", "(", "transaction", ")", ";", "logger", "debug", "(", "\"", "candidate", "resolved", "authentication", "handlers", "for", "this", "transaction", "are", "[", "{", "}", "]", "\"", ",", "handler", "set", ")", ";", "try", "{", "val", "it", "=", "credentials", "iterator", "(", ")", ";", "authentication", "credentials", "thread", "local", "binder", "clear", "in", "progress", "authentication", "(", ")", ";", "while", "(", "it", "has", "next", "(", ")", ")", "{", "val", "credential", "=", "it", "next", "(", ")", ";", "logger", "debug", "(", "\"", "attempting", "to", "authenticate", "credential", "[", "{", "}", "]", "\"", ",", "credential", ")", ";", "val", "it", "handlers", "=", "handler", "set", "iterator", "(", ")", ";", "var", "proceed", "with", "next", "handler", "=", "true", ";", "while", "(", "proceed", "with", "next", "handler", "&", "&", "it", "handlers", "has", "next", "(", ")", ")", "{", "val", "handler", "=", "it", "handlers", "next", "(", ")", ";", "if", "(", "handler", "supports", "(", "credential", ")", ")", "{", "try", "{", "val", "resolver", "=", "get", "principal", "resolver", "linked", "to", "handler", "if", "any", "(", "handler", ",", "transaction", ")", ";", "logger", "debug", "(", "\"", "attempting", "authentication", "of", "[", "{", "}", "]", "using", "[", "{", "}", "]", "\"", ",", "credential", "get", "id", "(", ")", ",", "handler", "get", "name", "(", ")", ")", ";", "authenticate", "and", "resolve", "principal", "(", "builder", ",", "credential", ",", "resolver", ",", "handler", ")", ";", "val", "authn", "result", "=", "builder", "build", "(", ")", ";", "authentication", "credentials", "thread", "local", "binder", "bind", "in", "progress", "(", "authn", "result", ")", ";", "val", "execution", "result", "=", "evaluate", "authentication", "policies", "(", "authn", "result", ",", "transaction", ",", "handler", "set", ")", ";", "proceed", "with", "next", "handler", "=", "!", "execution", "result", "is", "success", "(", ")", ";", "}", "catch", "(", "final", "general", "security", "exception", "e", ")", "{", "handle", "authentication", "exception", "(", "e", ",", "handler", "get", "name", "(", ")", ",", "builder", ")", ";", "proceed", "with", "next", "handler", "=", "should", "authentication", "chain", "proceed", "on", "failure", "(", "transaction", ",", "e", ")", ";", "}", "catch", "(", "final", "exception", "e", ")", "{", "logger", "error", "(", "\"", "authentication", "has", "failed", "credentials", "may", "be", "incorrect", "or", "cas", "cannot", "\"", "+", "\"", "find", "authentication", "handler", "that", "supports", "[", "{", "}", "]", "of", "type", "[", "{", "}", "]", "examine", "the", "configuration", "to", "\"", "+", "\"", "ensure", "a", "method", "of", "authentication", "is", "defined", "and", "analyze", "cas", "logs", "at", "debug", "level", "to", "trace", "\"", "+", "\"", "the", "authentication", "event", "\"", ",", "credential", ",", "credential", "get", "class", "(", ")", "get", "simple", "name", "(", ")", ")", ";", "handle", "authentication", "exception", "(", "e", ",", "handler", "get", "name", "(", ")", ",", "builder", ")", ";", "proceed", "with", "next", "handler", "=", "should", "authentication", "chain", "proceed", "on", "failure", "(", "transaction", ",", "e", ")", ";", "}", "}", "else", "{", "logger", "debug", "(", "\"", "authentication", "handler", "[", "{", "}", "]", "does", "not", "support", "the", "credential", "type", "[", "{", "}", "]", "\"", ",", "handler", "get", "name", "(", ")", ",", "credential", ")", ";", "}", "}", "}", "evaluate", "final", "authentication", "(", "builder", ",", "transaction", ",", "handler", "set", ")", ";", "return", "builder", ";", "}", "finally", "{", "authentication", "credentials", "thread", "local", "binder", "clear", "in", "progress", "authentication", "(", ")", ";", "}", "}" ]
[ "take", "a", "hadoop", "path", "and", "return", "one", "which", "uses", "the", "uri", "prefix", "and", "authority", "of", "this", "fs", "it", "doesn", "'", "t", "make", "a", "relative", "path", "absolute" ]
[ "public", "path", "get", "correct", "swift", "path", "(", "path", "path", ")", "throws", "swift", "exception", "{", "try", "{", "final", "uri", "full", "uri", "=", "new", "uri", "(", "uri", "get", "scheme", "(", ")", ",", "uri", "get", "authority", "(", ")", ",", "path", "to", "uri", "(", ")", "get", "path", "(", ")", ",", "null", ",", "null", ")", ";", "return", "new", "path", "(", "full", "uri", ")", ";", "}", "catch", "(", "u", "r", "i", "syntax", "exception", "e", ")", "{", "throw", "new", "swift", "exception", "(", "\"", "specified", "path", "\"", "+", "path", "+", "\"", "is", "incorrect", "\"", ",", "e", ")", ";", "}", "}" ]
[ "resolved", "schema", "of", "this", "operation" ]
[ "table", "schema", "get", "table", "schema", "(", ")", ";" ]
[ "returns", "the", "artifacts", "this", "instance", "contains", "in", "an", "{", "@", "link", "immutable", "list", "}" ]
[ "public", "immutable", "list", "<", "artifact", ">", "list", "(", ")", "{", "return", "artifacts", ";", "}" ]
[ "the", "most", "up", "-", "to", "-", "date", "(", "maximum", ")", "configuration", "offset", "according", "known", "to", "this", "worker" ]
[ "public", "long", "offset", "(", ")", "{", "return", "offset", ";", "}" ]
[ "attribute", "index", "in", "result", "set" ]
[ "public", "int", "get", "ordinal", "position", "(", ")", "{", "return", "meta", "attribute", "get", "ordinal", "position", "(", ")", ";", "}" ]
[ "get", "the", "default", "json", "instance" ]
[ "public", "static", "json", "get", "default", "(", ")", "{", "return", "json", ";", "}" ]
[ "called", "by", "{", "@", "link", "m", "bean", "exporter", "}", "after", "an", "m", "bean", "has", "been", "successfully", "registered", "with", "an", "{", "@", "link", "javax", "management", "m", "bean", "server", "}" ]
[ "void", "mbean", "registered", "(", "object", "name", "object", "name", ")", ";" ]
[ "get", "all", "paths", "from", "the", "local", "fs", "for", "reading", "for", "a", "given", "auxiliary", "service" ]
[ "iterable", "<", "path", ">", "get", "all", "local", "paths", "for", "read", "(", "string", "path", ")", "throws", "i", "o", "exception", ";" ]
[ "print", "out", "a", "whole", "tree", ",", "not", "just", "a", "node", ",", "in", "lisp", "format", "(", "root", "child", "1", "child", "n", ")", "print", "just", "a", "node", "if", "this", "is", "a", "leaf", "we", "have", "to", "know", "the", "recognizer", "so", "we", "can", "get", "rule", "names" ]
[ "public", "string", "to", "string", "tree", "(", "parser", "recog", ")", "{", "return", "trees", "to", "string", "tree", "(", "this", ",", "recog", ")", ";", "}" ]
[ "verify", "that", "the", "committer", "binding", "is", "happy" ]
[ "public", "void", "test", "000", "(", ")", "throws", "throwable", "{", "committer", "test", "binding", "validate", "(", ")", ";", "}" ]
[ "tries", "to", "terminate", "this", "atomic", "throwable", "(", "by", "swapping", "in", "the", "terminated", "indicator", ")", "and", "notifies", "the", "consumer", "if", "there", "was", "no", "error", "(", "on", "complete", ")", "or", "there", "was", "a", "non", "-", "null", ",", "non", "-", "indicator", "exception", "contained", "before", "(", "on", "error", ")", "if", "there", "was", "a", "terminated", "indicator", ",", "the", "consumer", "is", "not", "signaled" ]
[ "public", "void", "try", "terminate", "consumer", "(", "single", "observer", "<", "?", ">", "consumer", ")", "{", "throwable", "ex", "=", "terminate", "(", ")", ";", "if", "(", "ex", "!", "=", "null", "&", "&", "ex", "!", "=", "exception", "helper", "terminated", ")", "{", "consumer", "on", "error", "(", "ex", ")", ";", "}", "}" ]
[ "get", "key", "of", "the", "firing", "timer" ]
[ "public", "abstract", "k", "get", "current", "key", "(", ")", ";" ]
[ "returns", "true", "if", "this", "task", "is", "a", "worker", "task", "that", "performs", "search", "requests", "false", "otherwise" ]
[ "public", "boolean", "is", "worker", "(", ")", "{", "return", "worker", "state", "!", "=", "null", ";", "}" ]
[ "returns", "true", "if", "this", "configuration", "is", "semantically", "equal", "to", "the", "other", ",", "with", "the", "possible", "exception", "that", "the", "other", "has", "fewer", "fragments", "this", "is", "useful", "for", "trimming", ":", "as", "the", "same", "configuration", "gets", "\"", "trimmed", "\"", "while", "going", "down", "a", "dependency", "chain", ",", "it", "'", "s", "still", "the", "same", "configuration", "but", "loses", "some", "of", "its", "fragments", "so", "we", "need", "a", "more", "nuanced", "concept", "of", "\"", "equality", "\"", "than", "simple", "reference", "equality" ]
[ "public", "boolean", "equals", "or", "is", "superset", "of", "(", "build", "configuration", "other", ")", "{", "return", "this", "equals", "(", "other", ")", "|", "|", "(", "other", "!", "=", "null", "/", "/", "todo", "(", "gregce", ")", ":", "add", "back", "in", "output", "root", "checking", "this", "requires", "a", "better", "approach", "to", "/", "/", "configuration", "-", "safe", "output", "paths", "if", "the", "parent", "config", "has", "a", "fragment", "the", "child", "config", "/", "/", "doesn", "'", "t", ",", "it", "may", "inject", "$", "(", "foo", ")", "into", "the", "output", "roots", "so", "the", "child", "bindir", "might", "be", "/", "/", "\"", "bazel", "-", "out", "/", "arm", "-", "linux", "-", "fastbuild", "/", "bin", "\"", "while", "the", "parent", "bindir", "is", "/", "/", "\"", "bazel", "-", "out", "/", "android", "-", "arm", "-", "linux", "-", "fastbuild", "/", "bin", "\"", "that", "'", "s", "pretty", "awkward", "to", "check", "here", "/", "/", "&", "&", "output", "roots", "equals", "(", "other", "output", "roots", ")", "&", "&", "fragments", "values", "(", ")", "contains", "all", "(", "other", "fragments", "values", "(", ")", ")", "&", "&", "build", "options", "get", "native", "options", "(", ")", "contains", "all", "(", "other", "build", "options", "get", "native", "options", "(", ")", ")", ")", ";", "}" ]
[ "get", "namespace", "array" ]
[ "public", "list", "<", "integer", ">", "get", "namespace", "array", "(", ")", "{", "return", "namespace", "array", ";", "}" ]
[ "returns", "the", "string", "representation", "of", "this", "{", "@", "link", "permission", "}", ",", "which", "can", "be", "converted", "back", "to", "{", "@", "link", "permission", "}", "via", "the", "{", "@", "link", "#", "from", "id", "(", "string", ")", "}", "method", "this", "string", "representation", "is", "suitable", "for", "persistence" ]
[ "public", "@", "non", "null", "string", "get", "id", "(", ")", "{", "if", "(", "id", "=", "=", "null", ")", "{", "return", "owner", "get", "name", "(", ")", "+", "'", "'", "+", "name", ";", "}", "return", "id", ";", "}" ]
[ "deletes", "a", "pet", "(", "asynchronously", ")" ]
[ "public", "okhttp", "3", "call", "delete", "pet", "async", "(", "long", "pet", "id", ",", "string", "api", "key", ",", "final", "api", "callback", "<", "void", ">", "callback", ")", "throws", "api", "exception", "{", "okhttp", "3", "call", "local", "var", "call", "=", "delete", "pet", "validate", "before", "call", "(", "pet", "id", ",", "api", "key", ",", "callback", ")", ";", "local", "var", "api", "client", "execute", "async", "(", "local", "var", "call", ",", "callback", ")", ";", "return", "local", "var", "call", ";", "}" ]
[ "callback", "on", "job", "submission", "this", "is", "called", "when", "{", "@", "code", "execute", "(", ")", "}", "or", "{", "@", "code", "execute", "async", "(", ")", "}", "is", "called", "exactly", "one", "of", "the", "passed", "parameters", "is", "null", ",", "respectively", "for", "failure", "or", "success" ]
[ "void", "on", "job", "submitted", "(", "@", "nullable", "job", "client", "job", "client", ",", "@", "nullable", "throwable", "throwable", ")", ";" ]
[ "return", "the", "interval", "with", "elements", "from", "this", "not", "in", "other", ";", "other", "must", "not", "be", "totally", "enclosed", "(", "properly", "contained", ")", "within", "this", ",", "which", "would", "result", "in", "two", "disjoint", "intervals", "instead", "of", "the", "single", "one", "returned", "by", "this", "method" ]
[ "public", "interval", "difference", "not", "properly", "contained", "(", "interval", "other", ")", "{", "interval", "diff", "=", "null", ";", "/", "/", "other", "a", "to", "left", "of", "this", "a", "(", "or", "same", ")", "if", "(", "other", "starts", "before", "non", "disjoint", "(", "this", ")", ")", "{", "diff", "=", "interval", "of", "(", "math", "max", "(", "this", "a", ",", "other", "b", "+", "1", ")", ",", "this", "b", ")", ";", "}", "/", "/", "other", "a", "to", "right", "of", "this", "a", "else", "if", "(", "other", "starts", "after", "non", "disjoint", "(", "this", ")", ")", "{", "diff", "=", "interval", "of", "(", "this", "a", ",", "other", "a", "-", "1", ")", ";", "}", "return", "diff", ";", "}" ]
[ "compute", "the", "checksum", "of", "the", "record", "from", "the", "record", "contents" ]
[ "public", "long", "compute", "checksum", "(", ")", "{", "return", "crc", "3", "2", "crc", "3", "2", "(", "buffer", ",", "magic", "offset", ",", "buffer", "limit", "(", ")", "-", "magic", "offset", ")", ";", "}" ]
[ "customize", "response", "specification" ]
[ "public", "create", "xml", "item", "oper", "resp", "spec", "(", "consumer", "<", "response", "spec", "builder", ">", "resp", "spec", "customizer", ")", "{", "resp", "spec", "customizer", "accept", "(", "resp", "spec", ")", ";", "return", "this", ";", "}" ]
[ "reads", "a", "constant", "class", "constant", "pool", "entry", "in", "this", "{", "@", "link", "class", "reader", "}", "this", "method", "is", "intended", "for", "{", "@", "link", "attribute", "}", "sub", "classes", ",", "and", "is", "normally", "not", "needed", "by", "class", "generators", "or", "adapters" ]
[ "public", "string", "read", "class", "(", "final", "int", "offset", ",", "final", "char", "[", "]", "char", "buffer", ")", "{", "return", "read", "stringish", "(", "offset", ",", "char", "buffer", ")", ";", "}" ]
[ "get", "the", "progress", "of", "the", "task", "progress", "is", "represented", "as", "a", "number", "between", "0", "and", "1", "(", "inclusive", ")" ]
[ "public", "float", "get", "progress", "(", ")", ";" ]
[ "refresh", "{", "@", "link", "extension", "list", "}", "s", "by", "adding", "all", "the", "newly", "discovered", "extensions", "exposed", "only", "for", "{", "@", "link", "plugin", "manager", "#", "dynamic", "load", "(", "file", ")", "}" ]
[ "public", "void", "refresh", "extensions", "(", ")", "throws", "extension", "refresh", "exception", "{", "extension", "list", "<", "extension", "finder", ">", "finders", "=", "get", "extension", "list", "(", "extension", "finder", "class", ")", ";", "for", "(", "extension", "finder", "ef", ":", "finders", ")", "{", "if", "(", "!", "ef", "is", "refreshable", "(", ")", ")", "throw", "new", "extension", "refresh", "exception", "(", "ef", "+", "\"", "doesn", "'", "t", "support", "refresh", "\"", ")", ";", "}", "list", "<", "extension", "component", "set", ">", "fragments", "=", "lists", "new", "array", "list", "(", ")", ";", "for", "(", "extension", "finder", "ef", ":", "finders", ")", "{", "fragments", "add", "(", "ef", "refresh", "(", ")", ")", ";", "}", "extension", "component", "set", "delta", "=", "extension", "component", "set", "union", "(", "fragments", ")", "filtered", "(", ")", ";", "/", "/", "if", "we", "find", "a", "new", "extension", "finder", ",", "we", "need", "it", "to", "list", "up", "all", "the", "extension", "points", "as", "well", "list", "<", "extension", "component", "<", "extension", "finder", ">", ">", "new", "finders", "=", "lists", "new", "array", "list", "(", "delta", "find", "(", "extension", "finder", "class", ")", ")", ";", "while", "(", "!", "new", "finders", "is", "empty", "(", ")", ")", "{", "extension", "finder", "f", "=", "new", "finders", "remove", "(", "new", "finders", "size", "(", ")", "-", "1", ")", "get", "instance", "(", ")", ";", "extension", "component", "set", "ecs", "=", "extension", "component", "set", "all", "of", "(", "f", ")", "filtered", "(", ")", ";", "new", "finders", "add", "all", "(", "ecs", "find", "(", "extension", "finder", "class", ")", ")", ";", "delta", "=", "extension", "component", "set", "union", "(", "delta", ",", "ecs", ")", ";", "}", "for", "(", "extension", "list", "el", ":", "extension", "lists", "values", "(", ")", ")", "{", "el", "refresh", "(", "delta", ")", ";", "}", "for", "(", "extension", "list", "el", ":", "descriptor", "lists", "values", "(", ")", ")", "{", "el", "refresh", "(", "delta", ")", ";", "}", "/", "/", "todo", ":", "we", "need", "some", "generalization", "here", "so", "that", "extension", "points", "can", "be", "notified", "when", "a", "refresh", "happens", "?", "for", "(", "extension", "component", "<", "root", "action", ">", "ea", ":", "delta", "find", "(", "root", "action", "class", ")", ")", "{", "action", "a", "=", "ea", "get", "instance", "(", ")", ";", "if", "(", "!", "actions", "contains", "(", "a", ")", ")", "actions", "add", "(", "a", ")", ";", "}", "}" ]
[ "use", "the", "given", "string", "to", "use", "as", "the", "separator", "for", "values" ]
[ "public", "builder", "with", "separator", "(", "string", "separator", ")", "{", "this", "separator", "=", "separator", ";", "return", "this", ";", "}" ]
[ "reads", "num", "to", "read", "bytes", "from", "the", "stream", "starting", "at", "stream", "offset", "within", "the", "stream", "returns", "the", "byte", "array", "containing", "the", "read", "information", "if", "not", "all", "bytes", "are", "available", "to", "be", "read", ",", "an", "i", "o", "exception", "will", "be", "thrown" ]
[ "public", "byte", "[", "]", "read", "(", "int", "stream", "offset", ",", "int", "num", "to", "read", ",", "task", "monitor", "monitor", ")", "throws", "i", "o", "exception", ",", "cancelled", "exception", "{", "if", "(", "num", "to", "read", "<", "=", "0", ")", "{", "return", "null", ";", "}", "byte", "[", "]", "bytes", "=", "new", "byte", "[", "num", "to", "read", "]", ";", "read", "(", "stream", "offset", ",", "bytes", ",", "0", ",", "num", "to", "read", ",", "monitor", ")", ";", "return", "bytes", ";", "}" ]
[ "build", "an", "empty", "temporary", "bucket" ]
[ "abstract", "supplier", "<", "b", ">", "empty", "bucket", "builder", "(", "long", "owning", "bucket", "ord", ")", ";" ]
[ "sign", "extend", "-", "val", "-", "above", "-", "bit", "-" ]
[ "public", "static", "long", "sign", "extend", "(", "long", "val", ",", "int", "bit", ")", "{", "long", "mask", "=", "0", ";", "mask", "=", "(", "~", "mask", ")", "<", "<", "bit", ";", "if", "(", "(", "(", "val", ">", ">", "bit", ")", "&", "1", ")", "!", "=", "0", ")", "val", "|", "=", "mask", ";", "else", "val", "&", "=", "(", "~", "mask", ")", ";", "return", "val", ";", "}" ]
[ "cancel", "the", "delegation", "token" ]
[ "void", "cancel", "delegation", "token", "(", "token", "<", "?", ">", "token", ")", "throws", "i", "o", "exception", ";" ]
[ "lets", "the", "visitor", "visit", ",", "with", "field", "null" ]
[ "public", "void", "accept", "(", "clazz", "clazz", ",", "type", "annotation", "type", "annotation", ",", "target", "info", "visitor", "target", "info", "visitor", ")", "{", "target", "info", "visitor", "visit", "empty", "target", "info", "(", "clazz", ",", "(", "field", ")", "null", ",", "type", "annotation", ",", "this", ")", ";", "}" ]
[ "configure", "facebook", "client" ]
[ "protected", "void", "configure", "facebook", "client", "(", "final", "collection", "<", "indirect", "client", ">", "properties", ")", "{", "val", "pac", "4j", "properties", "=", "cas", "properties", "get", "authn", "(", ")", "get", "pac", "4j", "(", ")", ";", "val", "fb", "=", "pac", "4j", "properties", "get", "facebook", "(", ")", ";", "if", "(", "fb", "is", "enabled", "(", ")", "&", "&", "string", "utils", "is", "not", "blank", "(", "fb", "get", "id", "(", ")", ")", "&", "&", "string", "utils", "is", "not", "blank", "(", "fb", "get", "secret", "(", ")", ")", ")", "{", "val", "client", "=", "new", "facebook", "client", "(", "fb", "get", "id", "(", ")", ",", "fb", "get", "secret", "(", ")", ")", ";", "configure", "client", "(", "client", ",", "fb", ")", ";", "if", "(", "string", "utils", "is", "not", "blank", "(", "fb", "get", "scope", "(", ")", ")", ")", "{", "client", "set", "scope", "(", "fb", "get", "scope", "(", ")", ")", ";", "}", "if", "(", "string", "utils", "is", "not", "blank", "(", "fb", "get", "fields", "(", ")", ")", ")", "{", "client", "set", "fields", "(", "fb", "get", "fields", "(", ")", ")", ";", "}", "logger", "debug", "(", "\"", "created", "client", "[", "{", "}", "]", "with", "identifier", "[", "{", "}", "]", "\"", ",", "client", "get", "name", "(", ")", ",", "client", "get", "key", "(", ")", ")", ";", "properties", "add", "(", "client", ")", ";", "}", "}" ]
[ "find", "pet", "by", "id", "returns", "a", "single", "pet" ]
[ "public", "void", "get", "pet", "by", "id", "test", "(", ")", "{", "long", "pet", "id", "=", "null", ";", "/", "/", "pet", "response", "=", "api", "get", "pet", "by", "id", "(", "pet", "id", ")", ";", "/", "/", "todo", ":", "test", "validations", "}" ]
[ "returns", "the", "{", "@", "link", "allocation", "decision", "}", "denoting", "the", "result", "of", "an", "allocation", "attempt", "if", "{", "@", "link", "#", "is", "decision", "taken", "(", ")", "}", "returns", "{", "@", "code", "false", "}", ",", "then", "invoking", "this", "method", "will", "throw", "an", "{", "@", "code", "illegal", "state", "exception", "}" ]
[ "public", "allocation", "decision", "get", "allocation", "decision", "(", ")", "{", "check", "decision", "state", "(", ")", ";", "return", "allocation", "decision", "from", "allocation", "status", "(", "allocation", "status", ")", ";", "}" ]
[ "get", "md", "5" ]
[ "public", "static", "byte", "[", "]", "get", "m", "d", "5", "(", "byte", "[", "]", "source", ")", "{", "message", "digest", "md", "=", "get", "message", "digest", "(", ")", ";", "return", "md", "digest", "(", "source", ")", ";", "}" ]
[ "test", "json", "serialization", "of", "form", "data" ]
[ "public", "void", "test", "json", "form", "data", "(", "string", "param", ",", "string", "param", "2", ")", "throws", "api", "exception", "{", "test", "json", "form", "data", "with", "http", "info", "(", "param", ",", "param", "2", ")", ";", "}" ]
[ "create", "a", "name", "that", "is", "unique", "in", "the", "indicated", "namespace", "of", "the", "symbol", "table" ]
[ "public", "static", "string", "get", "unique", "name", "(", "symbol", "table", "symbol", "table", ",", "string", "name", ",", "address", "address", ",", "namespace", "namespace", ",", "symbol", "type", "type", ")", "{", "string", "new", "name", "=", "name", ";", "int", "i", "=", "1", ";", "for", "(", ";", "i", "<", "integer", "max", "value", ";", "i", "+", "+", ")", "{", "boolean", "can", "create", "symbol", "=", "is", "unique", "symbol", "name", "(", "symbol", "table", ",", "namespace", ",", "new", "name", ",", "address", ",", "type", ")", ";", "if", "(", "can", "create", "symbol", ")", "{", "return", "new", "name", ";", "}", "new", "name", "=", "name", "+", "program", "merge", "symbol", "conflict", "suffix", "+", "i", ";", "}", "throw", "new", "assert", "exception", "(", "\"", "couldn", "'", "t", "get", "a", "unique", "symbol", "name", "for", "\"", "+", "name", ")", ";", "}" ]
[ "tests", "that", "round", "tripping", "of", "all", "two", "byte", "permutations", "work" ]
[ "public", "void", "test", "is", "well", "formed", "2", "bytes", "(", ")", "{", "test", "bytes", "(", "2", ",", "expected", "two", "byte", "roundtrippable", "count", ")", ";", "}" ]
[ "determine", "the", "bean", "type", "for", "a", "factory", "bean", "by", "inspecting", "its", "attributes", "for", "a", "{", "@", "link", "factory", "bean", "#", "object", "type", "attribute", "}", "value" ]
[ "resolvable", "type", "get", "type", "for", "factory", "bean", "from", "attributes", "(", "attribute", "accessor", "attributes", ")", "{", "object", "attribute", "=", "attributes", "get", "attribute", "(", "factory", "bean", "object", "type", "attribute", ")", ";", "if", "(", "attribute", "instanceof", "resolvable", "type", ")", "{", "return", "(", "resolvable", "type", ")", "attribute", ";", "}", "if", "(", "attribute", "instanceof", "class", ")", "{", "return", "resolvable", "type", "for", "class", "(", "(", "class", "<", "?", ">", ")", "attribute", ")", ";", "}", "return", "resolvable", "type", "none", ";", "}" ]
[ "figures", "out", "the", "charset", "from", "the", "content", "-", "type", "header" ]
[ "private", "string", "get", "charset", "(", "u", "r", "l", "connection", "con", ")", "{", "for", "(", "string", "t", ":", "con", "get", "content", "type", "(", ")", "split", "(", "\"", ";", "\"", ")", ")", "{", "t", "=", "t", "trim", "(", ")", "to", "lower", "case", "(", "locale", "english", ")", ";", "if", "(", "t", "starts", "with", "(", "\"", "charset", "=", "\"", ")", ")", "return", "t", "substring", "(", "8", ")", ";", "}", "/", "/", "couldn", "'", "t", "find", "it", "html", "spec", "says", "default", "is", "us", "-", "ascii", ",", "/", "/", "but", "utf", "-", "8", "is", "a", "better", "choice", "since", "/", "/", "(", "1", ")", "it", "'", "s", "compatible", "with", "us", "-", "ascii", "/", "/", "(", "2", ")", "a", "well", "-", "written", "web", "applications", "tend", "to", "use", "utf", "-", "8", "return", "\"", "utf", "-", "8", "\"", ";", "}" ]
[ "returns", "a", "string", "(", "of", "one", "or", "more", "lines", ")", "required", "by", "build", "files", "which", "reference", "targets", "of", "this", "rule", "type", "subclasses", "of", "{", "@", "link", "rule", "type", "}", "should", "override", "this", "method", "if", "using", "the", "rule", "requires", "starlark", "files", "to", "be", "loaded" ]
[ "public", "string", "starlark", "load", "prerequisites", "(", ")", "{", "return", "\"", "\"", ";", "}" ]
[ "set", "for", "tracking", "if", "a", "secure", "client", "falls", "back", "to", "simple", "auth", "this", "method", "is", "synchronized", "only", "to", "stifle", "a", "findbugs", "warning" ]
[ "public", "synchronized", "void", "set", "fallback", "to", "simple", "auth", "(", "atomic", "boolean", "fallback", "to", "simple", "auth", ")", "{", "this", "fallback", "to", "simple", "auth", "=", "fallback", "to", "simple", "auth", ";", "}" ]
[ "return", "the", "count", "of", "cache" ]
[ "public", "static", "int", "get", "cache", "count", "(", ")", "{", "return", "get", "cache", "count", "(", "get", "default", "cache", "memory", "utils", "(", ")", ")", ";", "}" ]
[ "gets", "the", "number", "of", "words", "required", "for", "the", "given", "register", "list", ",", "where", "category", "-", "2", "values", "count", "as", "two", "words", "return", "{", "@", "code", "-", "1", "}", "if", "the", "list", "requires", "more", "than", "five", "words", "or", "contains", "registers", "that", "need", "more", "than", "a", "nibble", "to", "identify", "them" ]
[ "private", "static", "int", "word", "count", "(", "register", "spec", "list", "regs", ")", "{", "int", "sz", "=", "regs", "size", "(", ")", ";", "if", "(", "sz", ">", "max", "num", "ops", ")", "{", "/", "/", "it", "can", "'", "t", "possibly", "fit", "return", "-", "1", ";", "}", "int", "result", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "sz", ";", "i", "+", "+", ")", "{", "register", "spec", "one", "=", "regs", "get", "(", "i", ")", ";", "result", "+", "=", "one", "get", "category", "(", ")", ";", "/", "*", "*", "the", "check", "below", "adds", "(", "category", "-", "1", ")", "to", "the", "register", ",", "to", "*", "account", "for", "the", "fact", "that", "the", "second", "half", "of", "a", "*", "category", "-", "2", "register", "has", "to", "be", "represented", "explicitly", "in", "*", "the", "result", "*", "/", "if", "(", "!", "unsigned", "fits", "in", "nibble", "(", "one", "get", "reg", "(", ")", "+", "one", "get", "category", "(", ")", "-", "1", ")", ")", "{", "return", "-", "1", ";", "}", "}", "return", "(", "result", "<", "=", "max", "num", "ops", ")", "?", "result", ":", "-", "1", ";", "}" ]
[ "put", "the", "set", "of", "string", "value", "in", "sp" ]
[ "public", "void", "put", "(", "@", "non", "null", "final", "string", "key", ",", "final", "set", "<", "string", ">", "value", ")", "{", "put", "(", "key", ",", "value", ",", "false", ")", ";", "}" ]
[ "if", "profiling", "during", "the", "parselex", ",", "this", "will", "return", "decision", "info", "records", "for", "each", "decision", "in", "recognizer", "in", "a", "parse", "info", "object" ]
[ "public", "parse", "info", "get", "parse", "info", "(", ")", "{", "return", "null", ";", "}" ]
[ "select", "the", "content", "-", "type", "header", "'", "s", "value", "from", "the", "given", "array", ":", "if", "json", "exists", "in", "the", "given", "array", ",", "use", "it", ";", "otherwise", "use", "the", "first", "one", "of", "the", "array" ]
[ "public", "string", "select", "header", "content", "type", "(", "string", "[", "]", "content", "types", ")", "{", "if", "(", "content", "types", "length", "=", "=", "0", ")", "{", "return", "\"", "application", "/", "json", "\"", ";", "}", "for", "(", "string", "content", "type", ":", "content", "types", ")", "{", "if", "(", "is", "json", "mime", "(", "content", "type", ")", ")", "{", "return", "content", "type", ";", "}", "}", "return", "content", "types", "[", "0", "]", ";", "}" ]
[ "removes", "this", "provider", "from", "the", "tool" ]
[ "public", "void", "remove", "from", "tool", "(", ")", "{", "docking", "tool", "remove", "action", "(", "show", "provider", "action", ")", ";", "docking", "tool", "remove", "component", "provider", "(", "this", ")", ";", "}" ]
[ "get", "the", "{", "@", "link", "output", "format", "}", "class", "for", "the", "job" ]
[ "public", "class", "<", "?", "extends", "output", "format", "<", "?", ",", "?", ">", ">", "get", "output", "format", "class", "(", ")", "throws", "class", "not", "found", "exception", ";" ]
[ "tests", "that", "input", "splits", "assigned", "to", "an", "execution", "will", "be", "returned", "to", "the", "input", "split", "assigner", "if", "this", "execution", "fails" ]
[ "public", "void", "test", "request", "next", "input", "split", "with", "local", "failover", "(", ")", "throws", "exception", "{", "configuration", "set", "string", "(", "job", "manager", "options", "execution", "failover", "strategy", ",", "failover", "strategy", "factory", "loader", "pipelined", "region", "restart", "strategy", "name", ")", ";", "final", "function", "<", "list", "<", "list", "<", "input", "split", ">", ">", ",", "collection", "<", "input", "split", ">", ">", "expect", "failed", "execution", "input", "splits", "=", "input", "splits", "per", "task", "-", ">", "input", "splits", "per", "task", "get", "(", "0", ")", ";", "run", "request", "next", "input", "split", "test", "(", "expect", "failed", "execution", "input", "splits", ")", ";", "}" ]
[ "rename", "the", "specified", "column" ]
[ "default", "void", "rename", "column", "(", "connector", "session", "session", ",", "connector", "table", "handle", "table", "handle", ",", "column", "handle", "source", ",", "string", "target", ")", "{", "throw", "new", "presto", "exception", "(", "not", "supported", ",", "\"", "this", "connector", "does", "not", "support", "renaming", "columns", "\"", ")", ";", "}" ]
[ "set", "compaction", "parameters", "it", "is", "intended", "to", "be", "used", "for", "unit", "testing", "purposes", "only" ]
[ "void", "set", "compaction", "block", "count", "(", "int", "activation", "count", ")", "{", "activate", "compaction", "block", "count", "=", "activation", "count", ";", "}" ]
[ "returns", "a", "batch", "of", "index", "splits", "for", "the", "given", "batch", "of", "keys", "this", "method", "is", "called", "if", "index", "join", "strategy", "is", "chosen", "for", "a", "query" ]
[ "listenable", "future", "<", "presto", "thrift", "split", "batch", ">", "get", "index", "splits", "(", "@", "thrift", "field", "(", "name", "=", "\"", "schema", "table", "name", "\"", ")", "presto", "thrift", "schema", "table", "name", "schema", "table", "name", ",", "@", "thrift", "field", "(", "name", "=", "\"", "index", "column", "names", "\"", ")", "list", "<", "string", ">", "index", "column", "names", ",", "@", "thrift", "field", "(", "name", "=", "\"", "output", "column", "names", "\"", ")", "list", "<", "string", ">", "output", "column", "names", ",", "@", "thrift", "field", "(", "name", "=", "\"", "keys", "\"", ")", "presto", "thrift", "page", "result", "keys", ",", "@", "thrift", "field", "(", "name", "=", "\"", "output", "constraint", "\"", ")", "presto", "thrift", "tuple", "domain", "output", "constraint", ",", "@", "thrift", "field", "(", "name", "=", "\"", "max", "split", "count", "\"", ")", "int", "max", "split", "count", ",", "@", "thrift", "field", "(", "name", "=", "\"", "next", "token", "\"", ")", "presto", "thrift", "nullable", "token", "next", "token", ")", ";" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "int", "byte", "length", "(", ")", "{", "return", "data", "size", "(", ")", "+", "6", ";", "}" ]
[ "is", "id", "a", "valid", "token", "name", "?", "does", "id", "start", "with", "an", "uppercase", "letter", "?" ]
[ "public", "static", "boolean", "is", "token", "name", "(", "string", "id", ")", "{", "return", "character", "is", "upper", "case", "(", "id", "char", "at", "(", "0", ")", ")", ";", "}" ]
[ "does", "nothing", "all", "json", "is", "treated", "as", "elements" ]
[ "public", "string", "get", "attribute", "prefix", "(", "int", "index", ")", "{", "return", "null", ";", "}" ]
[ "invoke", "the", "registered", "error", "handler", ",", "if", "any", "log", "at", "warn", "level", "otherwise" ]
[ "protected", "void", "invoke", "error", "handler", "(", "throwable", "ex", ")", "{", "error", "handler", "error", "handler", "=", "get", "error", "handler", "(", ")", ";", "if", "(", "error", "handler", "!", "=", "null", ")", "{", "error", "handler", "handle", "error", "(", "ex", ")", ";", "}", "else", "{", "logger", "warn", "(", "\"", "execution", "of", "jms", "message", "listener", "failed", ",", "and", "no", "error", "handler", "has", "been", "set", "\"", ",", "ex", ")", ";", "}", "}" ]
[ "produce", "new", "{", "@", "link", "udt", "channel", "}", "based", "on", "factory", "{", "@", "link", "#", "kind", "(", ")", "}", "and", "{", "@", "link", "#", "type", "(", ")", "}" ]
[ "public", "t", "new", "channel", "(", ")", "{", "switch", "(", "kind", ")", "{", "case", "acceptor", ":", "switch", "(", "type", ")", "{", "case", "datagram", ":", "return", "(", "t", ")", "new", "nio", "udt", "message", "acceptor", "channel", "(", ")", ";", "case", "stream", ":", "return", "(", "t", ")", "new", "nio", "udt", "byte", "acceptor", "channel", "(", ")", ";", "default", ":", "throw", "new", "illegal", "state", "exception", "(", "\"", "wrong", "type", "=", "\"", "+", "type", ")", ";", "}", "case", "connector", ":", "switch", "(", "type", ")", "{", "case", "datagram", ":", "return", "(", "t", ")", "new", "nio", "udt", "message", "connector", "channel", "(", ")", ";", "case", "stream", ":", "return", "(", "t", ")", "new", "nio", "udt", "byte", "connector", "channel", "(", ")", ";", "default", ":", "throw", "new", "illegal", "state", "exception", "(", "\"", "wrong", "type", "=", "\"", "+", "type", ")", ";", "}", "case", "rendezvous", ":", "switch", "(", "type", ")", "{", "case", "datagram", ":", "return", "(", "t", ")", "new", "nio", "udt", "message", "rendezvous", "channel", "(", ")", ";", "case", "stream", ":", "return", "(", "t", ")", "new", "nio", "udt", "byte", "rendezvous", "channel", "(", ")", ";", "default", ":", "throw", "new", "illegal", "state", "exception", "(", "\"", "wrong", "type", "=", "\"", "+", "type", ")", ";", "}", "default", ":", "throw", "new", "illegal", "state", "exception", "(", "\"", "wrong", "kind", "=", "\"", "+", "kind", ")", ";", "}", "}" ]
[ "gets", "access", "token", "authentication", "principal" ]
[ "protected", "principal", "get", "access", "token", "authentication", "principal", "(", "final", "o", "auth", "2", "0", "access", "token", "access", "token", ",", "final", "j", "e", "e", "context", "context", ",", "final", "registered", "service", "registered", "service", ")", "{", "val", "current", "principal", "=", "access", "token", "get", "authentication", "(", ")", "get", "principal", "(", ")", ";", "logger", "debug", "(", "\"", "preparing", "user", "profile", "response", "based", "on", "cas", "principal", "[", "{", "}", "]", "\"", ",", "current", "principal", ")", ";", "val", "principal", "=", "this", "scope", "to", "attributes", "filter", "filter", "(", "access", "token", "get", "service", "(", ")", ",", "current", "principal", ",", "registered", "service", ",", "context", ",", "access", "token", ")", ";", "logger", "debug", "(", "\"", "created", "cas", "principal", "[", "{", "}", "]", "based", "on", "requested", "/", "authorized", "scopes", "\"", ",", "principal", ")", ";", "return", "principal", ";", "}" ]
[ "asserts", "if", "jenkins", "is", "in", "quiet", "mode", "will", "retry", "for", "some", "time", "before", "actually", "failing" ]
[ "private", "void", "assert", "jenkins", "in", "quiet", "mode", "(", ")", "{", "assert", "jenkins", "in", "quiet", "mode", "(", "j", ")", ";", "}" ]
[ "tries", "to", "match", "image", "header", "byte", "and", "header", "size", "against", "every", "known", "image", "format", "if", "any", "match", "succeeds", ",", "corresponding", "image", "format", "is", "returned" ]
[ "public", "final", "image", "format", "determine", "format", "(", "byte", "[", "]", "header", "bytes", ",", "int", "header", "size", ")", "{", "preconditions", "check", "not", "null", "(", "header", "bytes", ")", ";", "if", "(", "webp", "support", "status", "is", "webp", "header", "(", "header", "bytes", ",", "0", ",", "header", "size", ")", ")", "{", "return", "get", "webp", "format", "(", "header", "bytes", ",", "header", "size", ")", ";", "}", "if", "(", "is", "jpeg", "header", "(", "header", "bytes", ",", "header", "size", ")", ")", "{", "return", "default", "image", "formats", "jpeg", ";", "}", "if", "(", "is", "png", "header", "(", "header", "bytes", ",", "header", "size", ")", ")", "{", "return", "default", "image", "formats", "png", ";", "}", "if", "(", "is", "gif", "header", "(", "header", "bytes", ",", "header", "size", ")", ")", "{", "return", "default", "image", "formats", "gif", ";", "}", "if", "(", "is", "bmp", "header", "(", "header", "bytes", ",", "header", "size", ")", ")", "{", "return", "default", "image", "formats", "bmp", ";", "}", "if", "(", "is", "ico", "header", "(", "header", "bytes", ",", "header", "size", ")", ")", "{", "return", "default", "image", "formats", "ico", ";", "}", "if", "(", "is", "heif", "header", "(", "header", "bytes", ",", "header", "size", ")", ")", "{", "return", "default", "image", "formats", "heif", ";", "}", "if", "(", "is", "dng", "header", "(", "header", "bytes", ",", "header", "size", ")", ")", "{", "return", "default", "image", "formats", "dng", ";", "}", "return", "image", "format", "unknown", ";", "}" ]
[ "return", "true", "if", "the", "node", "can", "accept", "the", "given", "data", "flavor", "and", "allow", "the", "drop", "action", ";", "called", "by", "the", "base", "class", "when", "a", "drag", "operation", "is", "in", "progress", ",", "and", "the", "drag", "did", "not", "initiate", "on", "this", "tree" ]
[ "protected", "boolean", "is", "drop", "site", "ok", "(", "program", "node", "node", ",", "drop", "target", "drag", "event", "e", ")", "{", "int", "drop", "action", "=", "e", "get", "drop", "action", "(", ")", ";", "data", "flavor", "chosen", "=", "drop", "tgt", "adapter", "get", "first", "matching", "flavor", "(", "e", ",", "acceptable", "flavors", ")", ";", "if", "(", "chosen", "equals", "(", "group", "transferable", "local", "group", "flavor", ")", ")", "{", "/", "/", "don", "'", "t", "allow", "drop", "if", "node", "is", "a", "fragment", "and", "the", "/", "/", "action", "is", "not", "a", "move", "if", "(", "node", "is", "fragment", "(", ")", "&", "&", "drop", "action", "!", "=", "dn", "d", "constants", "action", "move", ")", "{", "return", "false", ";", "}", "}", "else", "if", "(", "chosen", "equals", "(", "selection", "transferable", "local", "program", "selection", "flavor", ")", ")", "{", "if", "(", "(", "node", "is", "fragment", "(", ")", "&", "&", "drop", "action", "!", "=", "dn", "d", "constants", "action", "move", ")", "|", "|", "(", "node", "is", "module", "(", ")", "&", "&", "drop", "action", "!", "=", "dn", "d", "constants", "action", "move", ")", ")", "{", "return", "false", ";", "}", "try", "{", "object", "data", "=", "e", "get", "transferable", "(", ")", "get", "transfer", "data", "(", "selection", "transferable", "local", "program", "selection", "flavor", ")", ";", "selection", "transfer", "data", "transfer", "data", "=", "(", "selection", "transfer", "data", ")", "data", ";", "return", "program", "get", "domain", "file", "(", ")", "get", "pathname", "(", ")", "equals", "(", "transfer", "data", "get", "program", "path", "(", ")", ")", ";", "}", "catch", "(", "unsupported", "flavor", "exception", "e", "1", ")", "{", "return", "false", ";", "}", "catch", "(", "i", "o", "exception", "e", "1", ")", "{", "return", "false", ";", "}", "}", "else", "if", "(", "chosen", "equals", "(", "tree", "transferable", "local", "tree", "node", "flavor", ")", ")", "{", "/", "/", "from", "object", "is", "null", ",", "so", "we", "know", "this", "is", "/", "/", "from", "another", "tree", ",", "so", "don", "'", "t", "allow", "the", "drop", "return", "false", ";", "}", "return", "true", ";", "}" ]
[ "sets", "the", "function", "'", "s", "runtime", "context", "called", "by", "the", "framework", "when", "creating", "a", "parallel", "instance", "of", "the", "function" ]
[ "void", "set", "runtime", "context", "(", "runtime", "context", "t", ")", ";" ]
[ "match", "handlers", "declared", "under", "a", "base", "package", ",", "e", "g", "\"", "org", "example", "\"" ]
[ "public", "static", "handler", "type", "predicate", "for", "base", "package", "(", "string", "packages", ")", "{", "return", "new", "builder", "(", ")", "base", "package", "(", "packages", ")", "build", "(", ")", ";", "}" ]
[ "test", "the", "property", "'", "namespace", "number", "'" ]
[ "public", "void", "namespace", "number", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "namespace", "number", "}" ]
[ "request", "a", "voice", "verification", "code", "on", "success", ",", "the", "server", "will", "make", "a", "voice", "call", "to", "this", "signal", "user" ]
[ "public", "void", "request", "voice", "verification", "code", "(", "locale", "locale", ",", "optional", "<", "string", ">", "captcha", "token", ",", "optional", "<", "string", ">", "challenge", ")", "throws", "i", "o", "exception", "{", "this", "push", "service", "socket", "request", "voice", "verification", "code", "(", "locale", ",", "captcha", "token", ",", "challenge", ")", ";", "}" ]
[ "move", "a", "persisted", "replica", "from", "lazypersist", "directory", "to", "a", "subdirectory", "under", "finalized" ]
[ "replica", "info", "activate", "saved", "replica", "(", "replica", "info", "replica", "info", ",", "ram", "disk", "replica", "replica", "state", ")", "throws", "i", "o", "exception", "{", "file", "meta", "file", "=", "replica", "state", "get", "saved", "meta", "file", "(", ")", ";", "file", "block", "file", "=", "replica", "state", "get", "saved", "block", "file", "(", ")", ";", "final", "long", "block", "id", "=", "replica", "info", "get", "block", "id", "(", ")", ";", "final", "file", "block", "dir", "=", "datanode", "util", "id", "to", "block", "dir", "(", "finalized", "dir", ",", "block", "id", ")", ";", "final", "file", "target", "block", "file", "=", "new", "file", "(", "block", "dir", ",", "block", "file", "get", "name", "(", ")", ")", ";", "final", "file", "target", "meta", "file", "=", "new", "file", "(", "block", "dir", ",", "meta", "file", "get", "name", "(", ")", ")", ";", "file", "io", "provider", "move", "file", "(", "volume", ",", "block", "file", ",", "target", "block", "file", ")", ";", "fs", "dataset", "impl", "log", "info", "(", "\"", "moved", "\"", "+", "block", "file", "+", "\"", "to", "\"", "+", "target", "block", "file", ")", ";", "file", "io", "provider", "move", "file", "(", "volume", ",", "meta", "file", ",", "target", "meta", "file", ")", ";", "fs", "dataset", "impl", "log", "info", "(", "\"", "moved", "\"", "+", "meta", "file", "+", "\"", "to", "\"", "+", "target", "meta", "file", ")", ";", "replica", "info", "new", "replica", "info", "=", "new", "replica", "builder", "(", "replica", "state", "finalized", ")", "set", "block", "id", "(", "block", "id", ")", "set", "length", "(", "replica", "info", "get", "bytes", "on", "disk", "(", ")", ")", "set", "generation", "stamp", "(", "replica", "info", "get", "generation", "stamp", "(", ")", ")", "set", "fs", "volume", "(", "replica", "state", "get", "lazy", "persist", "volume", "(", ")", ")", "set", "directory", "to", "use", "(", "target", "block", "file", "get", "parent", "file", "(", ")", ")", "build", "(", ")", ";", "return", "new", "replica", "info", ";", "}" ]
[ "create", "a", "new", "group", "path", "object", "by", "adding", "the", "given", "child", "name", "to", "this", "group", "path" ]
[ "public", "group", "path", "path", "by", "adding", "child", "(", "string", "child", ")", "{", "string", "[", "]", "p", "=", "new", "string", "[", "group", "names", "length", "+", "1", "]", ";", "system", "arraycopy", "(", "group", "names", ",", "0", ",", "p", ",", "0", ",", "group", "names", "length", ")", ";", "p", "[", "p", "length", "-", "1", "]", "=", "child", ";", "return", "new", "group", "path", "(", "p", ")", ";", "}" ]
[ "get", "the", "mirror", "sets", "for", "this", "type", "mapping" ]
[ "mirror", "sets", "get", "mirror", "sets", "(", ")", "{", "return", "this", "mirror", "sets", ";", "}" ]
[ "allows", "to", "set", "the", "timeout" ]
[ "public", "void", "timeout", "(", "string", "timeout", ")", "{", "this", "timeout", "=", "time", "value", "parse", "time", "value", "(", "timeout", ",", "this", "timeout", ",", "get", "class", "(", ")", "get", "simple", "name", "(", ")", "+", "\"", "timeout", "\"", ")", ";", "}" ]
[ "create", "answer", "creates", "an", "answer", "for", "using", "with", "the", "client", "protocol", "mocks" ]
[ "private", "answer", "<", "long", "[", "]", ">", "create", "answer", "(", "final", "atomic", "integer", "counter", ",", "final", "long", "ret", "val", ")", "{", "return", "new", "answer", "<", "long", "[", "]", ">", "(", ")", "{", "@", "override", "public", "long", "[", "]", "answer", "(", "invocation", "on", "mock", "invocation", ")", "throws", "throwable", "{", "counter", "increment", "and", "get", "(", ")", ";", "return", "new", "long", "[", "]", "{", "ret", "val", "}", ";", "}", "}", ";", "}" ]
[ "don", "'", "t", "report", "the", "passed", "metric", "attributes", "for", "all", "metrics", "(", "e", "g", "\"", "p", "9", "9", "9", "\"", ",", "\"", "stddev", "\"", "or", "\"", "m", "1", "5", "\"", ")", "see", "{", "@", "link", "metric", "attribute", "}" ]
[ "public", "builder", "disabled", "metric", "attributes", "(", "set", "<", "metric", "attribute", ">", "disabled", "metric", "attributes", ")", "{", "this", "disabled", "metric", "attributes", "=", "disabled", "metric", "attributes", ";", "return", "this", ";", "}" ]
[ "get", "a", "reference", "to", "the", "wrapped", "output", "stream", "we", "always", "want", "to", "return", "the", "actual", "underlying", "input", "stream", ",", "even", "when", "we", "'", "re", "using", "a", "crypto", "stream", "e", "g", "in", "the", "delegated", "methods", "below" ]
[ "public", "input", "stream", "get", "wrapped", "stream", "(", ")", "{", "return", "in", ";", "}" ]
[ "return", "a", "{", "@", "link", "numeric", "doc", "values", "}", "instance", "that", "can", "be", "used", "to", "sort", "documents", "with", "this", "mode", "and", "the", "provided", "values", "when", "a", "document", "has", "no", "value", ",", "<", "code", ">", "missing", "value", "<", "code", ">", "is", "returned", "allowed", "modes", ":", "sum", ",", "avg", ",", "median", ",", "min", ",", "max" ]
[ "public", "numeric", "doc", "values", "select", "(", "final", "sorted", "numeric", "doc", "values", "values", ")", "{", "final", "numeric", "doc", "values", "singleton", "=", "doc", "values", "unwrap", "singleton", "(", "values", ")", ";", "if", "(", "singleton", "!", "=", "null", ")", "{", "return", "singleton", ";", "}", "else", "{", "return", "new", "abstract", "numeric", "doc", "values", "(", ")", "{", "private", "long", "value", ";", "@", "override", "public", "boolean", "advance", "exact", "(", "int", "target", ")", "throws", "i", "o", "exception", "{", "if", "(", "values", "advance", "exact", "(", "target", ")", ")", "{", "value", "=", "pick", "(", "values", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "@", "override", "public", "int", "doc", "i", "d", "(", ")", "{", "return", "values", "doc", "i", "d", "(", ")", ";", "}", "@", "override", "public", "long", "long", "value", "(", ")", "throws", "i", "o", "exception", "{", "return", "value", ";", "}", "}", ";", "}", "}" ]
[ "enable", "processing", "of", "forwarded", "headers", ",", "either", "extracting", "and", "removing", ",", "or", "remove", "only", "by", "default", "this", "is", "not", "set" ]
[ "public", "void", "set", "forwarded", "header", "transformer", "(", "forwarded", "header", "transformer", "transformer", ")", "{", "assert", "not", "null", "(", "transformer", ",", "\"", "forwarded", "header", "transformer", "is", "required", "\"", ")", ";", "this", "forwarded", "header", "transformer", "=", "transformer", ";", "}" ]
[ "get", "the", "code", "value", "for", "a", "particular", "integer", "error", "code" ]
[ "public", "static", "code", "get", "(", "int", "code", ")", "{", "return", "lookup", "get", "(", "code", ")", ";", "}" ]
[ "writes", "out", "the", "encoded", "form", "of", "the", "given", "constant" ]
[ "public", "void", "write", "constant", "(", "constant", "cst", ")", "{", "int", "type", "=", "constant", "to", "value", "type", "(", "cst", ")", ";", "int", "arg", ";", "switch", "(", "type", ")", "{", "case", "value", "byte", ":", "case", "value", "short", ":", "case", "value", "int", ":", "case", "value", "long", ":", "{", "long", "value", "=", "(", "(", "cst", "literal", "bits", ")", "cst", ")", "get", "long", "bits", "(", ")", ";", "encoded", "value", "codec", "write", "signed", "integral", "value", "(", "out", ",", "type", ",", "value", ")", ";", "break", ";", "}", "case", "value", "char", ":", "{", "long", "value", "=", "(", "(", "cst", "literal", "bits", ")", "cst", ")", "get", "long", "bits", "(", ")", ";", "encoded", "value", "codec", "write", "unsigned", "integral", "value", "(", "out", ",", "type", ",", "value", ")", ";", "break", ";", "}", "case", "value", "float", ":", "{", "/", "/", "shift", "value", "left", "32", "so", "that", "right", "-", "zero", "-", "extension", "works", "long", "value", "=", "(", "(", "cst", "float", ")", "cst", ")", "get", "long", "bits", "(", ")", "<", "<", "32", ";", "encoded", "value", "codec", "write", "right", "zero", "extended", "value", "(", "out", ",", "type", ",", "value", ")", ";", "break", ";", "}", "case", "value", "double", ":", "{", "long", "value", "=", "(", "(", "cst", "double", ")", "cst", ")", "get", "long", "bits", "(", ")", ";", "encoded", "value", "codec", "write", "right", "zero", "extended", "value", "(", "out", ",", "type", ",", "value", ")", ";", "break", ";", "}", "case", "value", "string", ":", "{", "int", "index", "=", "file", "get", "string", "ids", "(", ")", "index", "of", "(", "(", "cst", "string", ")", "cst", ")", ";", "encoded", "value", "codec", "write", "unsigned", "integral", "value", "(", "out", ",", "type", ",", "(", "long", ")", "index", ")", ";", "break", ";", "}", "case", "value", "type", ":", "{", "int", "index", "=", "file", "get", "type", "ids", "(", ")", "index", "of", "(", "(", "cst", "type", ")", "cst", ")", ";", "encoded", "value", "codec", "write", "unsigned", "integral", "value", "(", "out", ",", "type", ",", "(", "long", ")", "index", ")", ";", "break", ";", "}", "case", "value", "field", ":", "{", "int", "index", "=", "file", "get", "field", "ids", "(", ")", "index", "of", "(", "(", "cst", "field", "ref", ")", "cst", ")", ";", "encoded", "value", "codec", "write", "unsigned", "integral", "value", "(", "out", ",", "type", ",", "(", "long", ")", "index", ")", ";", "break", ";", "}", "case", "value", "method", ":", "{", "int", "index", "=", "file", "get", "method", "ids", "(", ")", "index", "of", "(", "(", "cst", "method", "ref", ")", "cst", ")", ";", "encoded", "value", "codec", "write", "unsigned", "integral", "value", "(", "out", ",", "type", ",", "(", "long", ")", "index", ")", ";", "break", ";", "}", "case", "value", "enum", ":", "{", "cst", "field", "ref", "field", "ref", "=", "(", "(", "cst", "enum", "ref", ")", "cst", ")", "get", "field", "ref", "(", ")", ";", "int", "index", "=", "file", "get", "field", "ids", "(", ")", "index", "of", "(", "field", "ref", ")", ";", "encoded", "value", "codec", "write", "unsigned", "integral", "value", "(", "out", ",", "type", ",", "(", "long", ")", "index", ")", ";", "break", ";", "}", "case", "value", "array", ":", "{", "out", "write", "byte", "(", "type", ")", ";", "write", "array", "(", "(", "cst", "array", ")", "cst", ",", "false", ")", ";", "break", ";", "}", "case", "value", "annotation", ":", "{", "out", "write", "byte", "(", "type", ")", ";", "write", "annotation", "(", "(", "(", "cst", "annotation", ")", "cst", ")", "get", "annotation", "(", ")", ",", "false", ")", ";", "break", ";", "}", "case", "value", "null", ":", "{", "out", "write", "byte", "(", "type", ")", ";", "break", ";", "}", "case", "value", "boolean", ":", "{", "int", "value", "=", "(", "(", "cst", "boolean", ")", "cst", ")", "get", "int", "bits", "(", ")", ";", "out", "write", "byte", "(", "type", "|", "(", "value", "<", "<", "5", ")", ")", ";", "break", ";", "}", "default", ":", "{", "throw", "new", "runtime", "exception", "(", "\"", "shouldn", "'", "t", "happen", "\"", ")", ";", "}", "}", "}" ]
[ "platform", "independent", "implementation", "for", "{", "@", "link", "file", "#", "set", "executable", "(", "boolean", ")", "}", "file", "#", "set", "executable", "does", "not", "work", "as", "expected", "on", "windows", "note", ":", "revoking", "execute", "permission", "on", "folders", "does", "not", "have", "the", "same", "behavior", "on", "windows", "as", "on", "unix", "platforms", "creating", ",", "deleting", "or", "renaming", "a", "file", "within", "that", "folder", "will", "still", "succeed", "on", "windows" ]
[ "public", "static", "boolean", "set", "executable", "(", "file", "f", ",", "boolean", "executable", ")", "{", "if", "(", "shell", "windows", ")", "{", "try", "{", "string", "permission", "=", "executable", "?", "\"", "u", "+", "x", "\"", ":", "\"", "u", "-", "x", "\"", ";", "file", "util", "chmod", "(", "f", "get", "canonical", "path", "(", ")", ",", "permission", ",", "false", ")", ";", "return", "true", ";", "}", "catch", "(", "i", "o", "exception", "ex", ")", "{", "return", "false", ";", "}", "}", "else", "{", "return", "f", "set", "executable", "(", "executable", ")", ";", "}", "}" ]
[ "gets", "the", "project", "name", "for", "the", "indicated", "project", "archive", "file" ]
[ "static", "string", "get", "project", "name", "(", "string", "archive", "path", "name", ")", "{", "if", "(", "archive", "path", "name", "=", "=", "null", ")", "{", "return", "null", ";", "}", "file", "archive", "file", "=", "new", "file", "(", "archive", "path", "name", ")", ";", "file", "input", "stream", "file", "in", "=", "null", ";", "jar", "input", "stream", "jar", "in", "=", "null", ";", "try", "{", "file", "in", "=", "new", "file", "input", "stream", "(", "archive", "file", ")", ";", "jar", "in", "=", "new", "jar", "input", "stream", "(", "file", "in", ")", ";", "while", "(", "true", ")", "{", "zip", "entry", "zip", "entry", "=", "jar", "in", "get", "next", "entry", "(", ")", ";", "if", "(", "zip", "entry", "=", "=", "null", ")", "{", "break", ";", "}", "string", "name", "=", "zip", "entry", "get", "name", "(", ")", ";", "jar", "in", "close", "entry", "(", ")", ";", "if", "(", "name", "ends", "with", "(", "project", "locator", "get", "project", "extension", "(", ")", ")", ")", "{", "int", "end", "index", "=", "name", "length", "(", ")", "-", "project", "locator", "get", "project", "extension", "(", ")", "length", "(", ")", ";", "string", "project", "name", "=", "name", "substring", "(", "0", ",", "end", "index", ")", ";", "return", "project", "name", ";", "}", "}", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "/", "/", "just", "return", "null", "below", "}", "finally", "{", "if", "(", "jar", "in", "!", "=", "null", ")", "{", "try", "{", "jar", "in", "close", "(", ")", ";", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "/", "/", "we", "tried", "}", "}", "if", "(", "file", "in", "!", "=", "null", ")", "{", "try", "{", "file", "in", "close", "(", ")", ";", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "/", "/", "we", "tried", "}", "}", "}", "return", "null", ";", "}" ]
[ "a", "builder", "that", "allows", "for", "presizing", "the", "partition", "data", "hashmap", ",", "and", "avoiding", "making", "a", "secondary", "copy", "of", "the", "session", "partitions", ",", "in", "cases", "where", "this", "is", "not", "necessarily", "this", "builder", "is", "primarily", "for", "use", "by", "the", "replica", "fetcher" ]
[ "public", "builder", "new", "builder", "(", "int", "size", ",", "boolean", "copy", "session", "partitions", ")", "{", "return", "new", "builder", "(", "size", ",", "copy", "session", "partitions", ")", ";", "}" ]
[ "refresh", "the", "rmi", "stub", "and", "retry", "the", "given", "invocation", "called", "by", "invoke", "on", "connect", "failure" ]
[ "protected", "object", "refresh", "and", "retry", "(", "method", "invocation", "invocation", ")", "throws", "throwable", "{", "remote", "fresh", "stub", "=", "null", ";", "synchronized", "(", "this", "stub", "monitor", ")", "{", "this", "cached", "stub", "=", "null", ";", "fresh", "stub", "=", "lookup", "stub", "(", ")", ";", "if", "(", "this", "cache", "stub", ")", "{", "this", "cached", "stub", "=", "fresh", "stub", ";", "}", "}", "return", "do", "invoke", "(", "invocation", ",", "fresh", "stub", ")", ";", "}" ]
[ "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", "the", "current", "composite", "state", "will", "reset", "to", "a", "non", "-", "edit", "mode", "the", "edit", "use", "enablement", "will", "remain", "unchanged" ]
[ "public", "void", "set", "composite", "(", "composite", "composite", ")", "{", "this", "composite", "=", "composite", ";", "if", "(", "composite", "!", "=", "null", ")", "{", "big", "endian", "=", "composite", "get", "data", "organization", "(", ")", "is", "big", "endian", "(", ")", ";", "}", "allocation", "byte", "offset", "=", "0", ";", "allocation", "byte", "size", "=", "1", ";", "if", "(", "!", "edit", "use", "enabled", ")", "{", "allocation", "byte", "size", "=", "composite", "get", "length", "(", ")", ";", "}", "init", "(", "null", ")", ";", "}" ]
[ "removes", "the", "last", "{", "@", "link", "channel", "handler", "}", "in", "this", "pipeline" ]
[ "channel", "handler", "remove", "last", "(", ")", ";" ]
[ "return", "the", "underlying", "native", "request", "object", ",", "if", "available" ]
[ "<", "t", ">", "t", "get", "native", "request", "(", "@", "nullable", "class", "<", "t", ">", "required", "type", ")", ";" ]
[ "splits", "{", "@", "code", "sequence", "}", "into", "string", "components", "and", "makes", "them", "available", "through", "an", "{", "@", "link", "iterator", "}", ",", "which", "may", "be", "lazily", "evaluated", "if", "you", "want", "an", "eagerly", "computed", "{", "@", "link", "list", "}", ",", "use", "{", "@", "link", "#", "split", "to", "list", "(", "char", "sequence", ")", "}" ]
[ "public", "iterable", "<", "string", ">", "split", "(", "final", "char", "sequence", "sequence", ")", "{", "check", "not", "null", "(", "sequence", ")", ";", "return", "new", "iterable", "<", "string", ">", "(", ")", "{", "@", "override", "public", "iterator", "<", "string", ">", "iterator", "(", ")", "{", "return", "splitting", "iterator", "(", "sequence", ")", ";", "}", "@", "override", "public", "string", "to", "string", "(", ")", "{", "return", "joiner", "on", "(", "\"", ",", "\"", ")", "append", "to", "(", "new", "string", "builder", "(", ")", "append", "(", "'", "[", "'", ")", ",", "this", ")", "append", "(", "'", "]", "'", ")", "to", "string", "(", ")", ";", "}", "}", ";", "}" ]
[ "add", "streams", "that", "are", "in", "included", "orc", "columns", "to", "the", "included", "streams", "map", ",", "and", "return", "whether", "there", "were", "any", "row", "group", "dictionaries" ]
[ "private", "boolean", "add", "included", "streams", "(", "map", "<", "integer", ",", "column", "encoding", ">", "column", "encodings", ",", "list", "<", "stream", ">", "streams", ",", "map", "<", "stream", "id", ",", "stream", ">", "included", "streams", ")", "{", "boolean", "has", "row", "group", "dictionary", "=", "false", ";", "for", "(", "stream", "stream", ":", "streams", ")", "{", "if", "(", "included", "orc", "columns", "contains", "(", "stream", "get", "column", "(", ")", ")", ")", "{", "included", "streams", "put", "(", "new", "stream", "id", "(", "stream", ")", ",", "stream", ")", ";", "if", "(", "stream", "get", "stream", "kind", "(", ")", "=", "=", "stream", "kind", "in", "dictionary", ")", "{", "column", "encoding", "column", "encoding", "=", "column", "encodings", "get", "(", "stream", "get", "column", "(", ")", ")", ";", "if", "(", "column", "encoding", "get", "column", "encoding", "kind", "(", ")", "=", "=", "dictionary", ")", "{", "has", "row", "group", "dictionary", "=", "true", ";", "}", "optional", "<", "sorted", "map", "<", "integer", ",", "dwrf", "sequence", "encoding", ">", ">", "additional", "sequence", "encodings", "=", "column", "encoding", "get", "additional", "sequence", "encodings", "(", ")", ";", "if", "(", "additional", "sequence", "encodings", "is", "present", "(", ")", "&", "&", "additional", "sequence", "encodings", "get", "(", ")", "values", "(", ")", "stream", "(", ")", "map", "(", "dwrf", "sequence", "encoding", ":", ":", "get", "value", "encoding", ")", "any", "match", "(", "encoding", "-", ">", "encoding", "get", "column", "encoding", "kind", "(", ")", "=", "=", "dictionary", ")", ")", "{", "has", "row", "group", "dictionary", "=", "true", ";", "}", "}", "}", "}", "return", "has", "row", "group", "dictionary", ";", "}" ]
[ "model", "tests", "for", "number", "only" ]
[ "public", "void", "test", "number", "only", "(", ")", "{", "/", "/", "todo", ":", "test", "number", "only", "}" ]
[ "sends", "a", "flick", "gesture", "to", "the", "current", "view" ]
[ "public", "touch", "actions", "flick", "(", "int", "x", "speed", ",", "int", "y", "speed", ")", "{", "if", "(", "touch", "screen", "!", "=", "null", ")", "{", "action", "add", "action", "(", "new", "flick", "action", "(", "touch", "screen", ",", "x", "speed", ",", "y", "speed", ")", ")", ";", "}", "return", "this", ";", "}" ]
[ "setup", "cluster", "with", "desired", "number", "of", "dn", ",", "racks", ",", "and", "specified", "number", "of", "rack", "that", "only", "has", "1", "dn", "other", "racks", "will", "be", "evenly", "setup", "with", "the", "number", "of", "d", "ns", "this", "is", "not", "done", "as", "a", "{", "@", "link", "before", "}", ",", "so", "test", "cases", "can", "setup", "differently" ]
[ "public", "void", "setup", "cluster", "(", "final", "int", "num", "datanodes", ",", "final", "int", "num", "racks", ",", "final", "int", "num", "single", "dn", "racks", ")", "throws", "exception", "{", "cluster", "=", "d", "f", "s", "test", "util", "setup", "cluster", "(", "conf", ",", "num", "datanodes", ",", "num", "racks", ",", "num", "single", "dn", "racks", ")", ";", "dfs", "=", "cluster", "get", "file", "system", "(", ")", ";", "dfs", "set", "erasure", "coding", "policy", "(", "new", "path", "(", "\"", "/", "\"", ")", ",", "ec", "policy", "get", "name", "(", ")", ")", ";", "}" ]
[ "compare", "two", "{", "@", "link", "match", "status", "}", "items", ",", "returning", "the", "most", "specific", "status" ]
[ "public", "static", "match", "status", "get", "most", "specific", "(", "match", "status", "a", ",", "match", "status", "b", ")", "{", "return", "(", "a", "ordinal", "(", ")", "<", "b", "ordinal", "(", ")", "?", "a", ":", "b", ")", ";", "}" ]