Anonymous2023/KGSum · Datasets at Hugging Face

docstring_tokens list	code_tokens list
[ "returns", "a", "view", "collection", "of", "all", "distinct", "keys", "contained", "in", "this", "multimap", "note", "that", "the", "key", "set", "contains", "a", "key", "if", "and", "only", "if", "this", "multimap", "maps", "that", "key", "to", "at", "least", "one", "value", "changes", "to", "the", "returned", "set", "will", "update", "the", "underlying", "multimap", ",", "and", "vice", "versa", "however", ",", "adding", "to", "the", "returned", "set", "is", "not", "possible" ]	[ "set", "<", "k", ">", "key", "set", "(", ")", ";" ]
[ "creates", "a", "g", "file", "for", "a", "filesystem", "using", "a", "string", "path", "(", "ie", "\"", "dirsubdirfilename", "\"", ")", ",", "with", "the", "path", "starting", "at", "the", "root", "of", "the", "filesystem", "the", "parents", "of", "this", "g", "file", "are", "created", "fresh", "from", "any", "directory", "names", "in", "the", "path", "string", "it", "is", "better", "to", "use", "the", "{", "@", "link", "#", "from", "filename", "(", "g", "file", "system", ",", "g", "file", ",", "string", ",", "boolean", ",", "long", ",", "fsrl", ")", "}", "method", "to", "create", "g", "file", "instances", "if", "you", "can", "supply", "the", "parent", "value", "as", "that", "will", "allow", "reuse", "of", "the", "parent", "objects", "instead", "of", "duplicates", "of", "them", "being", "created", "for", "each", "file", "with", "the", "same", "parent", "path" ]	[ "public", "static", "g", "file", "impl", "from", "path", "string", "(", "g", "file", "system", "file", "system", ",", "string", "path", ",", "fsrl", "fsrl", ",", "boolean", "is", "directory", ",", "long", "length", ")", "{", "return", "from", "path", "string", "(", "file", "system", ",", "null", ",", "path", ",", "fsrl", ",", "is", "directory", ",", "length", ")", ";", "}" ]
[ "rolling", "back", "to", "a", "snapshot", "in", "previous", "directory", "by", "moving", "it", "to", "current", "directory", "rollback", "procedure", ":", "<", "br", ">", "if", "previous", "directory", "exists", ":", "rename", "current", "to", "removed", "tmp", "rename", "previous", "to", "current", "remove", "removed", "tmp", "if", "previous", "directory", "does", "not", "exist", "and", "the", "current", "version", "supports", "federation", ",", "perform", "a", "simple", "rollback", "of", "layout", "version", "this", "does", "not", "involve", "savingrestoration", "of", "actual", "data" ]	[ "void", "do", "rollback", "(", "storage", "directory", "sd", ",", "namespace", "info", "ns", "info", ")", "throws", "i", "o", "exception", "{", "file", "prev", "dir", "=", "sd", "get", "previous", "dir", "(", ")", ";", "/", "/", "this", "is", "a", "regular", "startup", "or", "a", "post", "-", "federation", "rollback", "if", "(", "!", "prev", "dir", "exists", "(", ")", ")", "{", "if", "(", "data", "node", "layout", "version", "supports", "(", "layout", "version", "feature", "federation", ",", "data", "node", "layout", "version", "get", "current", "layout", "version", "(", ")", ")", ")", "{", "read", "properties", "(", "sd", ",", "data", "node", "layout", "version", "get", "current", "layout", "version", "(", ")", ")", ";", "write", "properties", "(", "sd", ")", ";", "log", "info", "(", "\"", "layout", "version", "rolled", "back", "to", "{", "}", "for", "storage", "{", "}", "\"", ",", "data", "node", "layout", "version", "get", "current", "layout", "version", "(", ")", ",", "sd", "get", "root", "(", ")", ")", ";", "}", "return", ";", "}", "data", "storage", "prev", "info", "=", "new", "data", "storage", "(", ")", ";", "prev", "info", "read", "previous", "version", "properties", "(", "sd", ")", ";", "/", "/", "we", "allow", "rollback", "to", "a", "state", ",", "which", "is", "either", "consistent", "with", "/", "/", "the", "namespace", "state", "or", "can", "be", "further", "upgraded", "to", "it", "if", "(", "!", "(", "prev", "info", "get", "layout", "version", "(", ")", ">", "=", "data", "node", "layout", "version", "get", "current", "layout", "version", "(", ")", "&", "&", "prev", "info", "get", "c", "time", "(", ")", "<", "=", "ns", "info", "get", "c", "time", "(", ")", ")", ")", "{", "/", "/", "cannot", "rollback", "throw", "new", "inconsistent", "f", "s", "state", "exception", "(", "sd", "get", "root", "(", ")", ",", "\"", "cannot", "rollback", "to", "a", "newer", "state", "\\", "n", "datanode", "previous", "state", ":", "lv", "=", "\"", "+", "prev", "info", "get", "layout", "version", "(", ")", "+", "\"", "c", "time", "=", "\"", "+", "prev", "info", "get", "c", "time", "(", ")", "+", "\"", "is", "newer", "than", "the", "namespace", "state", ":", "lv", "=", "\"", "+", "data", "node", "layout", "version", "get", "current", "layout", "version", "(", ")", "+", "\"", "c", "time", "=", "\"", "+", "ns", "info", "get", "c", "time", "(", ")", ")", ";", "}", "log", "info", "(", "\"", "rolling", "back", "storage", "directory", "{", "}", "\\", "n", "target", "lv", "=", "{", "}", ";", "target", "\"", "+", "\"", "c", "time", "=", "{", "}", "\"", ",", "sd", "get", "root", "(", ")", ",", "data", "node", "layout", "version", "get", "current", "layout", "version", "(", ")", ",", "ns", "info", "get", "c", "time", "(", ")", ")", ";", "file", "tmp", "dir", "=", "sd", "get", "removed", "tmp", "(", ")", ";", "assert", "!", "tmp", "dir", "exists", "(", ")", ":", "\"", "removed", "tmp", "directory", "must", "not", "exist", "\"", ";", "/", "/", "rename", "current", "to", "tmp", "file", "cur", "dir", "=", "sd", "get", "current", "dir", "(", ")", ";", "assert", "cur", "dir", "exists", "(", ")", ":", "\"", "current", "directory", "must", "exist", "\"", ";", "rename", "(", "cur", "dir", ",", "tmp", "dir", ")", ";", "/", "/", "rename", "previous", "to", "current", "rename", "(", "prev", "dir", ",", "cur", "dir", ")", ";", "/", "/", "delete", "tmp", "dir", "delete", "dir", "(", "tmp", "dir", ")", ";", "log", "info", "(", "\"", "rollback", "of", "{", "}", "is", "complete", "\"", ",", "sd", "get", "root", "(", ")", ")", ";", "}" ]
[ "{", "@", "inherit", "doc", "}" ]	[ "public", "char", "stream", "get", "input", "stream", "(", ")", "{", "if", "(", "i", "<", "tokens", "size", "(", ")", ")", "{", "return", "tokens", "get", "(", "i", ")", "get", "input", "stream", "(", ")", ";", "}", "else", "if", "(", "eof", "token", "!", "=", "null", ")", "{", "return", "eof", "token", "get", "input", "stream", "(", ")", ";", "}", "else", "if", "(", "tokens", "size", "(", ")", ">", "0", ")", "{", "return", "tokens", "get", "(", "tokens", "size", "(", ")", "-", "1", ")", "get", "input", "stream", "(", ")", ";", "}", "/", "/", "no", "input", "stream", "information", "is", "available", "return", "null", ";", "}" ]
[ "return", "the", "name", "of", "the", "one", "of", "schema", "this", "name", "is", "used", "to", "set", "the", "value", "of", "codegen", "property", "open", "api", "type", "if", "the", "'", "x", "-", "one", "-", "of", "-", "name", "'", "extension", "is", "specified", "in", "the", "oas", "document", ",", "return", "that", "value", "otherwise", ",", "a", "name", "is", "constructed", "by", "creating", "a", "comma", "-", "separated", "list", "of", "all", "the", "names", "of", "the", "one", "of", "schemas" ]	[ "public", "string", "to", "one", "of", "name", "(", "list", "<", "string", ">", "names", ",", "composed", "schema", "composed", "schema", ")", "{", "map", "<", "string", ",", "object", ">", "exts", "=", "composed", "schema", "get", "extensions", "(", ")", ";", "if", "(", "exts", "!", "=", "null", "&", "&", "exts", "contains", "key", "(", "\"", "x", "-", "one", "-", "of", "-", "name", "\"", ")", ")", "{", "return", "(", "string", ")", "exts", "get", "(", "\"", "x", "-", "one", "-", "of", "-", "name", "\"", ")", ";", "}", "return", "\"", "one", "of", "<", "\"", "+", "string", "join", "(", "\"", ",", "\"", ",", "names", ")", "+", "\"", ">", "\"", ";", "}" ]
[ "the", "name", "of", "the", "index", "template" ]	[ "public", "string", "name", "(", ")", "{", "return", "this", "name", ";", "}" ]
[ "returns", "a", "new", "{", "@", "code", "future", "}", "whose", "result", "is", "asynchronously", "derived", "from", "the", "result", "of", "this", "{", "@", "code", "future", "}", "if", "the", "input", "{", "@", "code", "future", "}", "fails", ",", "the", "returned", "{", "@", "code", "future", "}", "fails", "with", "the", "same", "exception", "(", "and", "the", "function", "is", "not", "invoked", ")", "more", "precisely", ",", "the", "returned", "{", "@", "code", "future", "}", "takes", "its", "result", "from", "a", "{", "@", "code", "future", "}", "produced", "by", "applying", "the", "given", "{", "@", "code", "async", "function", "}", "to", "the", "result", "of", "the", "original", "{", "@", "code", "future", "}", "example", "usage", ":", "{", "@", "code", "fluent", "future", "<", "row", "key", ">", "row", "key", "future", "=", "fluent", "future", "from", "(", "index", "service", "look", "up", "(", "query", ")", ")", ";", "listenable", "future", "<", "query", "result", ">", "query", "future", "=", "row", "key", "future", "transform", "async", "(", "data", "service", ":", ":", "read", "future", ",", "executor", ")", ";", "}", "when", "selecting", "an", "executor", ",", "note", "that", "{", "@", "code", "direct", "executor", "}", "is", "dangerous", "in", "some", "cases", "see", "the", "discussion", "in", "the", "{", "@", "link", "#", "add", "listener", "}", "documentation", "all", "its", "warnings", "about", "heavyweight", "listeners", "are", "also", "applicable", "to", "heavyweight", "functions", "passed", "to", "this", "method", "(", "specifically", ",", "{", "@", "code", "direct", "executor", "}", "functions", "should", "avoid", "heavyweight", "operations", "inside", "{", "@", "code", "async", "function", "apply", "}", "any", "heavyweight", "operations", "should", "occur", "in", "other", "threads", "responsible", "for", "completing", "the", "returned", "{", "@", "code", "future", "}", ")", "the", "returned", "{", "@", "code", "future", "}", "attempts", "to", "keep", "its", "cancellation", "state", "in", "sync", "with", "that", "of", "the", "input", "future", "and", "that", "of", "the", "future", "returned", "by", "the", "chain", "function", "that", "is", ",", "if", "the", "returned", "{", "@", "code", "future", "}", "is", "cancelled", ",", "it", "will", "attempt", "to", "cancel", "the", "other", "two", ",", "and", "if", "either", "of", "the", "other", "two", "is", "cancelled", ",", "the", "returned", "{", "@", "code", "future", "}", "will", "receive", "a", "callback", "in", "which", "it", "will", "attempt", "to", "cancel", "itself", "this", "method", "is", "similar", "to", "{", "@", "link", "java", "util", "concurrent", "completable", "future", "#", "then", "compose", "}", "and", "{", "@", "link", "java", "util", "concurrent", "completable", "future", "#", "then", "compose", "async", "}", "it", "can", "also", "serve", "some", "of", "the", "use", "cases", "of", "{", "@", "link", "java", "util", "concurrent", "completable", "future", "#", "handle", "}", "and", "{", "@", "link", "java", "util", "concurrent", "completable", "future", "#", "handle", "async", "}", "when", "used", "along", "with", "{", "@", "link", "#", "catching", "}" ]	[ "public", "final", "<", "t", ">", "fluent", "future", "<", "t", ">", "transform", "async", "(", "async", "function", "<", "?", "super", "v", ",", "t", ">", "function", ",", "executor", "executor", ")", "{", "return", "(", "fluent", "future", "<", "t", ">", ")", "futures", "transform", "async", "(", "this", ",", "function", ",", "executor", ")", ";", "}" ]
[ "see", "if", "the", "new", "build", "matches", "any", "of", "the", "peephole", "permalink" ]	[ "public", "void", "on", "completed", "(", "run", "<", "?", ",", "?", ">", "run", ",", "@", "non", "null", "task", "listener", "listener", ")", "{", "job", "<", "?", ",", "?", ">", "j", "=", "run", "get", "parent", "(", ")", ";", "for", "(", "peephole", "permalink", "pp", ":", "util", "filter", "(", "j", "get", "permalinks", "(", ")", ",", "peephole", "permalink", "class", ")", ")", "{", "if", "(", "pp", "apply", "(", "run", ")", ")", "{", "run", "<", "?", ",", "?", ">", "cur", "=", "pp", "resolve", "(", "j", ")", ";", "if", "(", "cur", "=", "=", "null", "\|", "\|", "cur", "get", "number", "(", ")", "<", "run", "get", "number", "(", ")", ")", "{", "logger", "fine", "(", "(", ")", "-", ">", "\"", "updating", "\"", "+", "pp", "get", "id", "(", ")", "+", "\"", "permalink", "to", "completed", "\"", "+", "run", ")", ";", "pp", "update", "cache", "(", "j", ",", "run", ")", ";", "}", "}", "}", "}" ]
[ "get", "array", "number" ]	[ "public", "list", "<", "big", "decimal", ">", "get", "array", "number", "(", ")", "{", "return", "array", "number", ";", "}" ]
[ "return", "whether", "dtd", "parsing", "is", "supported" ]	[ "public", "boolean", "is", "support", "dtd", "(", ")", "{", "return", "this", "support", "dtd", ";", "}" ]
[ "the", "name", "of", "the", "type", "this", "corresponds", "to", "the", "'", "type", "'", "part", "of", "a", "full", "resource", "name", "of", "the", "form", "package", ":", "typeentry", "the", "set", "of", "legal", "type", "names", "is", "listed", "in", "resource", "cpp", "<", "code", ">", "optional", "string", "name", "=", "2", ";", "<", "code", ">" ]	[ "public", "com", "google", "protobuf", "byte", "string", "get", "name", "bytes", "(", ")", "{", "return", "instance", "get", "name", "bytes", "(", ")", ";", "}" ]
[ "set", "ignore", "nulls", "indicator" ]	[ "public", "void", "set", "ignore", "nulls", "(", "boolean", "ignore", "nulls", ")", "{", "this", "ignore", "nulls", "=", "ignore", "nulls", ";", "}" ]
[ "returns", "the", "next", "state", "to", "transition", "to", "after", "the", "given", "state" ]	[ "private", "job", "state", "get", "next", "state", "(", "job", "state", "state", ")", "{", "switch", "(", "state", ")", "{", "case", "not", "running", ":", "return", "loading", ";", "case", "loading", ":", "return", "filtering", ";", "case", "filtering", ":", "return", "add", "removing", ";", "case", "add", "removing", ":", "return", "sorting", ";", "case", "sorting", ":", "return", "applying", ";", "case", "applying", ":", "default", ":", "return", "done", ";", "}", "}" ]
[ "stops", "the", "reporter", "and", "shuts", "down", "its", "thread", "of", "execution" ]	[ "public", "void", "close", "(", ")", "{", "stop", "(", ")", ";", "}" ]
[ "returns", "a", "recyclable", "m", "p", "point", "d", "instance", "returns", "the", "corresponding", "x", "pos", "for", "a", "given", "touch", "-", "position", "in", "pixels" ]	[ "protected", "m", "p", "point", "d", "get", "vals", "for", "touch", "(", "float", "x", ",", "float", "y", ")", "{", "/", "/", "take", "any", "transformer", "to", "determine", "the", "x", "-", "axis", "value", "m", "p", "point", "d", "pos", "=", "m", "chart", "get", "transformer", "(", "y", "axis", "axis", "dependency", "left", ")", "get", "values", "by", "touch", "point", "(", "x", ",", "y", ")", ";", "return", "pos", ";", "}" ]
[ "initiates", "a", "scan", "for", "all", "known", "barcode", "types", "with", "the", "default", "camera" ]	[ "public", "final", "alert", "dialog", "initiate", "scan", "(", ")", "{", "return", "initiate", "scan", "(", "all", "code", "types", ",", "-", "1", ")", ";", "}" ]
[ "{", "@", "inherit", "doc", "}" ]	[ "public", "int", "get", "height", "(", ")", "{", "return", "height", ";", "}" ]
[ "perform", "processing", "for", "the", "various", "hook", "points", "where", "breakpoints", "have", "been", "set" ]	[ "private", "void", "process", "breakpoint", "(", "address", "addr", ")", "throws", "exception", "{", "/", "/", "malloc", "hook", "if", "(", "addr", "equals", "(", "malloc", "entry", ")", ")", "{", "int", "size", "=", "emu", "helper", "read", "register", "(", "\"", "rdi", "\"", ")", "int", "value", "(", ")", ";", "address", "mem", "addr", "=", "malloc", "mgr", "malloc", "(", "size", ")", ";", "emu", "helper", "write", "register", "(", "\"", "rax", "\"", ",", "mem", "addr", "get", "offset", "(", ")", ")", ";", "}", "/", "/", "free", "hook", "else", "if", "(", "addr", "equals", "(", "free", "entry", ")", ")", "{", "address", "free", "addr", "=", "get", "address", "(", "emu", "helper", "read", "register", "(", "\"", "rdi", "\"", ")", "long", "value", "(", ")", ")", ";", "malloc", "mgr", "free", "(", "free", "addr", ")", ";", "}", "/", "/", "strlen", "hook", "else", "if", "(", "addr", "equals", "(", "strlen", "entry", ")", ")", "{", "address", "ptr", "=", "get", "address", "(", "emu", "helper", "read", "register", "(", "\"", "rdi", "\"", ")", "long", "value", "(", ")", ")", ";", "int", "len", "=", "0", ";", "while", "(", "emu", "helper", "read", "memory", "byte", "(", "ptr", ")", "!", "=", "0", ")", "{", "+", "+", "len", ";", "ptr", "=", "ptr", "next", "(", ")", ";", "}", "emu", "helper", "write", "register", "(", "\"", "rax", "\"", ",", "len", ")", ";", "}", "/", "/", "use", "string", "hook", "-", "print", "string", "else", "if", "(", "addr", "equals", "(", "use", "string", "entry", ")", ")", "{", "address", "string", "addr", "=", "get", "address", "(", "emu", "helper", "read", "register", "(", "\"", "rdi", "\"", ")", "long", "value", "(", ")", ")", ";", "string", "str", "=", "emu", "helper", "read", "null", "terminated", "string", "(", "string", "addr", ",", "32", ")", ";", "println", "(", "\"", "use", "string", ":", "\"", "+", "str", ")", ";", "/", "/", "output", "string", "argument", "to", "consoles", "}", "/", "/", "unexpected", "else", "{", "if", "(", "emu", "helper", "get", "emulate", "execution", "state", "(", ")", "!", "=", "emulate", "execution", "state", "breakpoint", ")", "{", "/", "/", "assume", "we", "are", "stepping", "and", "simply", "return", "return", ";", "}", "throw", "new", "not", "found", "exception", "(", "\"", "unhandled", "breakpoint", "at", "\"", "+", "addr", ")", ";", "}", "/", "/", "force", "early", "return", "long", "return", "offset", "=", "emu", "helper", "read", "stack", "value", "(", "0", ",", "8", ",", "false", ")", "long", "value", "(", ")", ";", "emu", "helper", "write", "register", "(", "emu", "helper", "get", "p", "c", "register", "(", ")", ",", "return", "offset", ")", ";", "}" ]
[ "returns", "the", "index", "of", "the", "type", "argument", "that", "the", "given", "step", "is", "stepping", "into", "this", "method", "should", "only", "be", "used", "for", "steps", "whose", "value", "is", "{", "@", "link", "#", "type", "argument", "}" ]	[ "public", "int", "get", "step", "argument", "(", "final", "int", "index", ")", "{", "/", "/", "returns", "the", "type", "argument", "index", "of", "the", "path", "element", "of", "the", "given", "index", "return", "type", "path", "container", "[", "type", "path", "offset", "+", "2", "*", "index", "+", "2", "]", ";", "}" ]
[ "executes", "the", "bootstrap", "checks", "if", "the", "node", "has", "the", "transport", "protocol", "bound", "to", "a", "non", "-", "loopback", "interface", "if", "the", "system", "property", "{", "@", "code", "es", "enforce", "bootstrap", "checks", "}", "is", "set", "to", "{", "@", "code", "true", "}", "then", "the", "bootstrap", "checks", "will", "be", "enforced", "regardless", "of", "whether", "or", "not", "the", "transport", "protocol", "is", "bound", "to", "a", "non", "-", "loopback", "interface" ]	[ "static", "void", "check", "(", "final", "bootstrap", "context", "context", ",", "final", "bound", "transport", "address", "bound", "transport", "address", ",", "list", "<", "bootstrap", "check", ">", "additional", "checks", ")", "throws", "node", "validation", "exception", "{", "final", "list", "<", "bootstrap", "check", ">", "built", "in", "checks", "=", "checks", "(", ")", ";", "final", "list", "<", "bootstrap", "check", ">", "combined", "checks", "=", "new", "array", "list", "<", ">", "(", "built", "in", "checks", ")", ";", "combined", "checks", "add", "all", "(", "additional", "checks", ")", ";", "check", "(", "context", ",", "enforce", "limits", "(", "bound", "transport", "address", ",", "discovery", "module", "discovery", "type", "setting", "get", "(", "context", "settings", "(", ")", ")", ")", ",", "collections", "unmodifiable", "list", "(", "combined", "checks", ")", ")", ";", "}" ]
[ "get", "string", "item" ]	[ "public", "string", "get", "string", "item", "(", ")", "{", "return", "string", "item", ";", "}" ]
[ "test", "the", "property", "'", "quantity", "'" ]	[ "public", "void", "quantity", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "quantity", "}" ]
[ "returns", "a", "substring", "of", "the", "input", "character", "sequence", "that", "omits", "all", "matching", "bmp", "characters", "from", "the", "end", "of", "the", "string", "for", "example", ":", "{", "@", "code", "char", "matcher", "any", "of", "(", "\"", "ab", "\"", ")", "trim", "trailing", "from", "(", "\"", "abacatbab", "\"", ")", "}", "returns", "{", "@", "code", "\"", "abacat", "\"", "}" ]	[ "public", "string", "trim", "trailing", "from", "(", "char", "sequence", "sequence", ")", "{", "int", "len", "=", "sequence", "length", "(", ")", ";", "for", "(", "int", "last", "=", "len", "-", "1", ";", "last", ">", "=", "0", ";", "last", "-", "-", ")", "{", "if", "(", "!", "matches", "(", "sequence", "char", "at", "(", "last", ")", ")", ")", "{", "return", "sequence", "sub", "sequence", "(", "0", ",", "last", "+", "1", ")", "to", "string", "(", ")", ";", "}", "}", "return", "\"", "\"", ";", "}" ]
[ "model", "tests", "for", "user" ]	[ "public", "void", "test", "user", "(", ")", "{", "/", "/", "todo", ":", "test", "user", "}" ]
[ "get", "the", "namesystem", "from", "the", "namenode" ]	[ "public", "static", "f", "s", "namesystem", "get", "namesystem", "(", "name", "node", "namenode", ")", "{", "return", "namenode", "get", "namesystem", "(", ")", ";", "}" ]
[ "combines", "predicates", "and", ",", "optimizes", ",", "and", "returns", "null", "if", "the", "result", "is", "always", "false", "the", "expression", "is", "simplified", "on", "the", "assumption", "that", "an", "unknown", "value", "is", "always", "treated", "as", "false", "therefore", "the", "simplified", "expression", "may", "sometimes", "evaluate", "to", "false", "where", "the", "original", "expression", "would", "evaluate", "to", "unknown" ]	[ "public", "rex", "node", "simplify", "filter", "predicates", "(", "iterable", "<", "?", "extends", "rex", "node", ">", "predicates", ")", "{", "final", "rex", "node", "simplified", "ands", "=", "with", "predicate", "elimination", "(", "bug", "calcite", "2401", "fixed", ")", "simplify", "unknown", "as", "false", "(", "rex", "util", "compose", "conjunction", "(", "rex", "builder", ",", "predicates", ")", ")", ";", "if", "(", "simplified", "ands", "is", "always", "false", "(", ")", ")", "{", "return", "null", ";", "}", "/", "/", "remove", "cast", "of", "boolean", "not", "null", "to", "boolean", "or", "vice", "versa", "filter", "accepts", "/", "/", "nullable", "and", "not", "-", "nullable", "conditions", ",", "but", "a", "cast", "might", "get", "in", "the", "way", "of", "/", "/", "other", "rewrites", "return", "remove", "nullability", "cast", "(", "simplified", "ands", ")", ";", "}" ]
[ "multiplies", "this", "vector", "by", "the", "first", "three", "columns", "of", "the", "matrix", ",", "essentially", "only", "applying", "rotation", "and", "scaling" ]	[ "public", "vector", "3", "rot", "(", "final", "matrix", "4", "matrix", ")", "{", "final", "float", "l", "mat", "[", "]", "=", "matrix", "val", ";", "return", "this", "set", "(", "x", "", "l", "mat", "[", "matrix", "4", "m00", "]", "+", "y", "", "l", "mat", "[", "matrix", "4", "m01", "]", "+", "z", "", "l", "mat", "[", "matrix", "4", "m02", "]", ",", "x", "", "l", "mat", "[", "matrix", "4", "m10", "]", "+", "y", "", "l", "mat", "[", "matrix", "4", "m11", "]", "+", "z", "", "l", "mat", "[", "matrix", "4", "m12", "]", ",", "x", "", "l", "mat", "[", "matrix", "4", "m20", "]", "+", "y", "", "l", "mat", "[", "matrix", "4", "m21", "]", "+", "z", "*", "l", "mat", "[", "matrix", "4", "m22", "]", ")", ";", "}" ]
[ "returns", "the", "length", "of", "the", "resource", "map" ]	[ "public", "int", "get", "resource", "map", "length", "(", ")", "{", "return", "resource", "map", "length", ";", "}" ]
[ "build", "a", "suitable", "variable", "or", "stack", "reference", "representation", "with", "optional", "scalar", "replacement" ]	[ "private", "object", "get", "variable", "reference", "representation", "(", "reference", "ref", ",", "variable", "var", ",", "scalar", "replaced", "scalar", ")", "{", "if", "(", "var", "!", "=", "null", ")", "{", "/", "/", "relies", "on", "reference", "-", "type", "to", "specify", "read", "/", "write", "access", "variable", "offset", "var", "offset", "=", "new", "variable", "offset", "(", "ref", ",", "var", ")", ";", "var", "offset", "set", "replaced", "element", "(", "replaced", "scalar", ",", "options", "include", "scalar", "reference", "adjustment", ")", ";", "return", "var", "offset", ";", "}", "if", "(", "ref", "is", "stack", "reference", "(", ")", ")", "{", "operand", "representation", "list", "compound", "list", "=", "new", "operand", "representation", "list", "(", ")", ";", "compound", "list", "add", "(", "\"", "stack", "\"", ")", ";", "compound", "list", "add", "(", "'", "[", "'", ")", ";", "compound", "list", "add", "(", "new", "scalar", "(", "32", ",", "(", "(", "stack", "reference", ")", "ref", ")", "get", "stack", "offset", "(", ")", ",", "true", ")", ")", ";", "compound", "list", "add", "(", "'", "]", "'", ")", ";", "return", "add", "scalar", "adjustment", "(", "compound", "list", ",", "ref", "get", "to", "address", "(", ")", ",", "replaced", "scalar", ",", "false", ")", ";", "}", "return", "null", ";", "}" ]
[ "reset", "timer", "for", "a", "session" ]	[ "synchronized", "public", "static", "void", "reset", "timer", "(", "string", "context", "path", ",", "string", "session", ")", "{", "if", "(", "session", "!", "=", "null", ")", "{", "string", "uri", "=", "concat", "(", "context", "path", ",", "session", ")", ";", "session", "timer", "task", "t", "=", "zk", "session", "timers", "remove", "(", "uri", ")", ";", "t", "cancel", "(", ")", ";", "zk", "session", "timers", "put", "(", "uri", ",", "new", "session", "timer", "task", "(", "t", ")", ")", ";", "}", "}" ]
[ "uses", "the", "given", "{", "@", "link", "executor", "service", "}" ]	[ "public", "jersey", "client", "builder", "using", "(", "executor", "service", "executor", "service", ")", "{", "this", "executor", "service", "=", "executor", "service", ";", "return", "this", ";", "}" ]
[ "test", "simplest", "case", "of", "recursion" ]	[ "public", "void", "test", "recursive", "resolve", "simple", "(", ")", "{", "type", "adapter", "<", "foo", "1", ">", "adapter", "=", "new", "gson", "(", ")", "get", "adapter", "(", "foo", "1", "class", ")", ";", "assert", "not", "null", "(", "adapter", ")", ";", "}" ]
[ "returns", "the", "path", "to", "a", "local", "copy", "of", "the", "file", "associated", "with", "the", "provided", "job", "id", "and", "blob", "key", "we", "will", "first", "attempt", "to", "serve", "the", "blob", "from", "the", "local", "storage", "if", "the", "blob", "is", "not", "in", "there", ",", "we", "will", "try", "to", "download", "it", "from", "the", "ha", "store", ",", "or", "directly", "from", "the", "{", "@", "link", "blob", "server", "}" ]	[ "public", "file", "get", "file", "(", "job", "i", "d", "job", "id", ",", "permanent", "blob", "key", "key", ")", "throws", "i", "o", "exception", "{", "check", "not", "null", "(", "job", "id", ")", ";", "return", "get", "file", "internal", "(", "job", "id", ",", "key", ")", ";", "}" ]
[ "default", "not", "null" ]	[ "public", "void", "set", "null", "at", "(", "int", "pos", ")", "{", "set", "null", "bit", "(", "pos", ")", ";", "segment", "put", "long", "(", "get", "field", "offset", "(", "pos", ")", ",", "0l", ")", ";", "}" ]
[ "the", "default", "implementation", "is", "empty", "can", "be", "overridden", "by", "subclasses", "as", "necessary" ]	[ "public", "void", "before", "test", "method", "(", "test", "context", "test", "context", ")", "throws", "exception", "{", "/", "", "no", "-", "op", "", "/", "}" ]
[ "<", "code", ">", "optional", "second", "msg", "blah", "=", "2", ";", "<", "code", ">" ]	[ "public", "boolean", "has", "blah", "(", ")", "{", "return", "(", "(", "bit", "field", "0", "&", "0x", "0", "0", "0", "0", "0", "0", "0", "2", ")", "=", "=", "0x", "0", "0", "0", "0", "0", "0", "0", "2", ")", ";", "}" ]
[ "called", "from", "within", "{", "@", "link", "#", "render", "frame", "}", "to", "let", "the", "caller", "know", "that", "while", "trying", "generate", "the", "requested", "frame", ",", "an", "earlier", "frame", "was", "generated", "this", "allows", "the", "caller", "to", "optionally", "cache", "the", "intermediate", "result", "the", "caller", "must", "copy", "the", "bitmap", "if", "it", "wishes", "to", "cache", "it", "as", "{", "@", "link", "#", "render", "frame", "}", "will", "continue", "using", "it", "generate", "the", "requested", "frame" ]	[ "void", "on", "intermediate", "result", "(", "int", "frame", "number", ",", "bitmap", "bitmap", ")", ";" ]
[ "retrieves", "a", "blob", "from", "the", "ha", "store", "to", "a", "{", "@", "link", "blob", "server", "}", "which", "cannot", "create", "incoming", "files", "file", "transfers", "should", "fail" ]	[ "public", "void", "test", "get", "fails", "incoming", "for", "job", "ha", "(", ")", "throws", "i", "o", "exception", "{", "assume", "true", "(", "!", "operating", "system", "is", "windows", "(", ")", ")", ";", "/", "/", "set", "writable", "doesn", "'", "t", "work", "on", "windows", "final", "job", "i", "d", "job", "id", "=", "new", "job", "i", "d", "(", ")", ";", "final", "configuration", "config", "=", "new", "configuration", "(", ")", ";", "config", "set", "string", "(", "high", "availability", "options", "ha", "mode", ",", "\"", "zookeeper", "\"", ")", ";", "config", "set", "string", "(", "blob", "server", "options", "storage", "directory", ",", "temporary", "folder", "new", "folder", "(", ")", "get", "absolute", "path", "(", ")", ")", ";", "config", "set", "string", "(", "high", "availability", "options", "ha", "storage", "path", ",", "temporary", "folder", "new", "folder", "(", ")", "get", "path", "(", ")", ")", ";", "blob", "store", "service", "blob", "store", "=", "null", ";", "try", "{", "blob", "store", "=", "blob", "utils", "create", "blob", "store", "from", "config", "(", "config", ")", ";", "file", "temp", "file", "dir", "=", "null", ";", "try", "(", "blob", "server", "server", "=", "new", "blob", "server", "(", "config", ",", "blob", "store", ")", ")", "{", "server", "start", "(", ")", ";", "/", "/", "store", "the", "data", "on", "the", "server", "(", "and", "blob", "store", ")", ",", "remove", "from", "local", "store", "byte", "[", "]", "data", "=", "new", "byte", "[", "2000000", "]", ";", "rnd", "next", "bytes", "(", "data", ")", ";", "blob", "key", "blob", "key", "=", "put", "(", "server", ",", "job", "id", ",", "data", ",", "permanent", "blob", ")", ";", "assert", "true", "(", "server", "get", "storage", "location", "(", "job", "id", ",", "blob", "key", ")", "delete", "(", ")", ")", ";", "/", "/", "make", "sure", "the", "blob", "server", "cannot", "create", "any", "files", "in", "its", "storage", "dir", "temp", "file", "dir", "=", "server", "create", "temporary", "filename", "(", ")", "get", "parent", "file", "(", ")", ";", "assert", "true", "(", "temp", "file", "dir", "set", "executable", "(", "true", ",", "false", ")", ")", ";", "assert", "true", "(", "temp", "file", "dir", "set", "readable", "(", "true", ",", "false", ")", ")", ";", "assert", "true", "(", "temp", "file", "dir", "set", "writable", "(", "false", ",", "false", ")", ")", ";", "/", "/", "request", "the", "file", "from", "the", "blob", "store", "exception", "expect", "(", "i", "o", "exception", "class", ")", ";", "exception", "expect", "message", "(", "\"", "permission", "denied", "\"", ")", ";", "try", "{", "get", "(", "server", ",", "job", "id", ",", "blob", "key", ")", ";", "}", "finally", "{", "hash", "set", "<", "string", ">", "expected", "dirs", "=", "new", "hash", "set", "<", ">", "(", ")", ";", "expected", "dirs", "add", "(", "\"", "incoming", "\"", ")", ";", "expected", "dirs", "add", "(", "job", "dir", "prefix", "+", "job", "id", ")", ";", "/", "/", "only", "the", "incoming", "and", "job", "directory", "should", "exist", "(", "no", "job", "directory", "!", ")", "file", "storage", "dir", "=", "temp", "file", "dir", "get", "parent", "file", "(", ")", ";", "string", "[", "]", "actual", "dirs", "=", "storage", "dir", "list", "(", ")", ";", "assert", "not", "null", "(", "actual", "dirs", ")", ";", "assert", "equals", "(", "expected", "dirs", ",", "new", "hash", "set", "<", ">", "(", "arrays", "as", "list", "(", "actual", "dirs", ")", ")", ")", ";", "/", "/", "job", "directory", "should", "be", "empty", "file", "job", "dir", "=", "new", "file", "(", "temp", "file", "dir", "get", "parent", "file", "(", ")", ",", "job", "dir", "prefix", "+", "job", "id", ")", ";", "assert", "array", "equals", "(", "new", "string", "[", "]", "{", "}", ",", "job", "dir", "list", "(", ")", ")", ";", "}", "}", "finally", "{", "/", "/", "set", "writable", "again", "to", "make", "sure", "we", "can", "remove", "the", "directory", "if", "(", "temp", "file", "dir", "!", "=", "null", ")", "{", "/", "/", "noinspection", "result", "of", "method", "call", "ignored", "temp", "file", "dir", "set", "writable", "(", "true", ",", "false", ")", ";", "}", "}", "}", "finally", "{", "if", "(", "blob", "store", "!", "=", "null", ")", "{", "blob", "store", "close", "and", "cleanup", "all", "data", "(", ")", ";", "}", "}", "}" ]
[ "active", "the", "selected", "profile", "task", "to", "execution", "task", ",", "and", "start", "a", "removal", "task", "for", "it" ]	[ "private", "synchronized", "void", "process", "profile", "task", "(", "profile", "task", "task", ")", "{", "/", "/", "make", "sure", "prev", "profile", "task", "already", "stopped", "stop", "current", "profile", "task", "(", "task", "execution", "context", "get", "(", ")", ")", ";", "/", "/", "make", "stop", "task", "schedule", "and", "task", "context", "final", "profile", "task", "execution", "context", "current", "started", "task", "context", "=", "new", "profile", "task", "execution", "context", "(", "task", ")", ";", "task", "execution", "context", "set", "(", "current", "started", "task", "context", ")", ";", "/", "/", "start", "profiling", "this", "task", "current", "started", "task", "context", "start", "profiling", "(", "profile", "executor", ")", ";", "profile", "task", "schedule", "schedule", "(", "(", ")", "-", ">", "stop", "current", "profile", "task", "(", "current", "started", "task", "context", ")", ",", "task", "get", "duration", "(", ")", ",", "time", "unit", "minutes", ")", ";", "}" ]
[ "increase", "the", "size", "of", "this", "d", "b", "buffer", "object" ]	[ "private", "void", "grow", "(", "int", "new", "size", ",", "boolean", "preserve", "data", ")", "throws", "i", "o", "exception", "{", "int", "old", "size", "=", "this", "size", ";", "this", "size", "=", "new", "size", ";", "/", "/", "currently", "using", "a", "single", "data", "buffer", "if", "(", "data", "buffer", "id", "table", "length", "=", "=", "1", ")", "{", "/", "/", "transition", "to", "an", "indexed", "chained", "buffer", "if", "(", "new", "size", ">", "data", "space", ")", "{", "data", "buffer", "first", "buffer", "=", "buffer", "mgr", "get", "buffer", "(", "first", "buffer", "id", ")", ";", "data", "buffer", "new", "first", "data", "buf", "=", "null", ";", "try", "{", "/", "/", "save", "data", "in", "new", "data", "buffer", "if", "(", "preserve", "data", ")", "{", "new", "first", "data", "buf", "=", "buffer", "mgr", "create", "buffer", "(", ")", ";", "new", "first", "data", "buf", "copy", "(", "data", "base", "offset", "indexed", ",", "first", "buffer", ",", "data", "base", "offset", "nonindexed", ",", "old", "size", ")", ";", "int", "indexed", "data", "space", "=", "new", "first", "data", "buf", "length", "(", ")", "-", "data", "base", "offset", "indexed", ";", "byte", "[", "]", "zero", "bytes", "=", "new", "byte", "[", "indexed", "data", "space", "-", "old", "size", "]", ";", "if", "(", "use", "x", "o", "r", "mask", ")", "{", "int", "offset", "=", "old", "size", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "zero", "bytes", "length", ";", "i", "+", "+", ",", "offset", "+", "+", ")", "{", "zero", "bytes", "[", "i", "]", "=", "xor", "mask", "byte", "(", "offset", ",", "zero", "bytes", "[", "i", "]", ")", ";", "}", "}", "new", "first", "data", "buf", "put", "(", "data", "base", "offset", "indexed", "+", "old", "size", ",", "zero", "bytes", ")", ";", "}", "/", "/", "establish", "index", "for", "d", "b", "buffer", "create", "index", "(", "first", "buffer", ")", ";", "first", "buffer", "=", "null", ";", "/", "/", "establish", "first", "data", "buffer", "if", "(", "preserve", "data", ")", "{", "add", "buffer", "(", "0", ",", "new", "first", "data", "buf", ")", ";", "}", "}", "finally", "{", "if", "(", "first", "buffer", "!", "=", "null", ")", "{", "buffer", "mgr", "release", "buffer", "(", "first", "buffer", ")", ";", "}", "if", "(", "new", "first", "data", "buf", "!", "=", "null", ")", "{", "buffer", "mgr", "release", "buffer", "(", "new", "first", "data", "buf", ")", ";", "}", "}", "return", ";", "}", "/", "/", "adjust", "stored", "buffer", "size", "data", "buffer", "buffer", "=", "buffer", "mgr", "get", "buffer", "(", "first", "buffer", "id", ")", ";", "buffer", "put", "int", "(", "data", "length", "offset", ",", "get", "obfuscation", "data", "length", "field", "value", "(", ")", ")", ";", "buffer", "mgr", "release", "buffer", "(", "buffer", ")", ";", "}", "/", "/", "already", "using", "an", "index", "-", "existing", "data", "is", "always", "preserved", "else", "{", "byte", "[", "]", "empty", "index", "data", "=", "new", "byte", "[", "indexes", "per", "buffer", "*", "id", "size", "]", ";", "arrays", "fill", "(", "empty", "index", "data", ",", "(", "byte", ")", "0xff", ")", ";", "/", "/", "compute", "index", "counts", "int", "new", "index", "count", "=", "(", "(", "new", "size", "-", "1", ")", "/", "data", "space", ")", "+", "1", ";", "int", "new", "index", "buffer", "count", "=", "(", "(", "new", "index", "count", "-", "1", ")", "/", "indexes", "per", "buffer", ")", "+", "1", ";", "/", "/", "grow", "data", "buffer", "id", "table", "int", "[", "]", "new", "data", "buffer", "id", "table", "=", "new", "int", "[", "new", "index", "count", "]", ";", "system", "arraycopy", "(", "data", "buffer", "id", "table", ",", "0", ",", "new", "data", "buffer", "id", "table", ",", "0", ",", "data", "buffer", "id", "table", "length", ")", ";", "arrays", "fill", "(", "new", "data", "buffer", "id", "table", ",", "data", "buffer", "id", "table", "length", ",", "new", "index", "count", ",", "-", "1", ")", ";", "data", "buffer", "id", "table", "=", "new", "data", "buffer", "id", "table", ";", "/", "/", "grow", "index", "buffer", "id", "table", "int", "old", "index", "buffer", "count", "=", "index", "buffer", "id", "table", "length", ";", "if", "(", "old", "index", "buffer", "count", "<", "new", "index", "buffer", "count", ")", "{", "int", "[", "]", "new", "index", "buffer", "id", "table", "=", "new", "int", "[", "new", "index", "buffer", "count", "]", ";", "system", "arraycopy", "(", "index", "buffer", "id", "table", ",", "0", ",", "new", "index", "buffer", "id", "table", ",", "0", ",", "old", "index", "buffer", "count", ")", ";", "arrays", "fill", "(", "new", "index", "buffer", "id", "table", ",", "old", "index", "buffer", "count", ",", "new", "index", "buffer", "count", ",", "-", "1", ")", ";", "index", "buffer", "id", "table", "=", "new", "index", "buffer", "id", "table", ";", "/", "/", "allocate", "additional", "index", "buffers", "data", "buffer", "index", "buffer", "=", "buffer", "mgr", "get", "buffer", "(", "index", "buffer", "id", "table", "[", "old", "index", "buffer", "count", "-", "1", "]", ")", ";", "for", "(", "int", "i", "=", "old", "index", "buffer", "count", ";", "i", "<", "new", "index", "buffer", "count", ";", "i", "+", "+", ")", "{", "index", "buffer", "=", "append", "index", "buffer", "(", "index", "buffer", ")", ";", "index", "buffer", "put", "(", "index", "base", "offset", ",", "empty", "index", "data", ")", ";", "/", "/", "initialize", "to", "all", "-", "1", "'", "s", "index", "buffer", "id", "table", "[", "i", "]", "=", "index", "buffer", "get", "id", "(", ")", ";", "}", "buffer", "mgr", "release", "buffer", "(", "index", "buffer", ")", ";", "}", "/", "/", "adjust", "stored", "buffer", "size", "data", "buffer", "buffer", "=", "buffer", "mgr", "get", "buffer", "(", "first", "buffer", "id", ")", ";", "buffer", "put", "int", "(", "data", "length", "offset", ",", "get", "obfuscation", "data", "length", "field", "value", "(", ")", ")", ";", "buffer", "mgr", "release", "buffer", "(", "buffer", ")", ";", "}", "}" ]
[ "reads", "restore", "status", "from", "stream", "input" ]	[ "public", "static", "shard", "restore", "status", "read", "shard", "restore", "status", "(", "stream", "input", "in", ")", "throws", "i", "o", "exception", "{", "shard", "restore", "status", "shard", "snapshot", "status", "=", "new", "shard", "restore", "status", "(", ")", ";", "shard", "snapshot", "status", "read", "from", "(", "in", ")", ";", "return", "shard", "snapshot", "status", ";", "}" ]
[ "get", "name", "wrapped", "array" ]	[ "public", "list", "<", "integer", ">", "get", "name", "wrapped", "array", "(", ")", "{", "return", "name", "wrapped", "array", ";", "}" ]
[ "the", "sink", "node", "making", "the", "request", "<", "code", ">", "istio", "mcp", "v", "1alpha", "1", "sink", "node", "sink", "node", "=", "1", ";", "<", "code", ">" ]	[ "public", "com", "alibaba", "nacos", "istio", "model", "mcp", "sink", "node", "or", "builder", "get", "sink", "node", "or", "builder", "(", ")", "{", "if", "(", "sink", "node", "builder", "!", "=", "null", ")", "{", "return", "sink", "node", "builder", "get", "message", "or", "builder", "(", ")", ";", "}", "else", "{", "return", "sink", "node", "=", "=", "null", "?", "com", "alibaba", "nacos", "istio", "model", "mcp", "sink", "node", "get", "default", "instance", "(", ")", ":", "sink", "node", ";", "}", "}" ]
[ "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", "\"", ")", ";", "}" ]
[ "test", "the", "property", "'", "password", "'" ]	[ "public", "void", "password", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "password", "}" ]
[ "get", "user", "by", "user", "name" ]	[ "public", "void", "get", "user", "by", "name", "test", "(", ")", "{", "string", "username", "=", "null", ";", "user", "response", "=", "api", "get", "user", "by", "name", "(", "username", ")", "block", "(", ")", ";", "/", "/", "todo", ":", "test", "validations", "}" ]
[ "required", "one", "or", "more", "hosts", "exposed", "by", "this", "gateway", "while", "typically", "applicable", "to", "http", "services", ",", "it", "can", "also", "be", "used", "for", "tcp", "services", "using", "tls", "with", "sni", "a", "host", "is", "specified", "as", "a", "`", "dns", "name", "`", "with", "an", "optional", "`", "namespace", "`", "prefix", "the", "`", "dns", "name", "`", "should", "be", "specified", "using", "fqdn", "format", ",", "optionally", "including", "a", "wildcard", "character", "in", "the", "left", "-", "most", "component", "(", "e", "g", ",", "`", "prod", "&", "#", "42", ";", "example", "com", "`", ")", "set", "the", "`", "dns", "name", "`", "to", "`", "`", "to", "select", "all", "`", "virtual", "service", "`", "hosts", "from", "the", "specified", "namespace", "(", "e", "g", ",", "`", "prod", "&", "#", "42", ";", "`", ")", "the", "`", "namespace", "`", "can", "be", "set", "to", "`", "`", "or", "`", "`", ",", "representing", "any", "or", "the", "current", "namespace", ",", "respectively", "for", "example", ",", "`", "&", "#", "47", ";", "foo", "example", "com", "`", "selects", "the", "service", "from", "any", "available", "namespace", "while", "`", "foo", "example", "com", "`", "only", "selects", "the", "service", "from", "the", "namespace", "of", "the", "sidecar", "the", "default", ",", "if", "no", "`", "namespace", "`", "is", "specified", ",", "is", "`", "&", "#", "47", ";", "`", ",", "that", "is", ",", "select", "services", "from", "any", "namespace", "any", "associated", "`", "destination", "rule", "`", "in", "the", "selected", "namespace", "will", "also", "be", "used", "a", "`", "virtual", "service", "`", "must", "be", "bound", "to", "the", "gateway", "and", "must", "have", "one", "or", "more", "hosts", "that", "match", "the", "hosts", "specified", "in", "a", "server", "the", "match", "could", "be", "an", "exact", "match", "or", "a", "suffix", "match", "with", "the", "server", "'", "s", "hosts", "for", "example", ",", "if", "the", "server", "'", "s", "hosts", "specifies", "`", "example", "com", "`", ",", "a", "`", "virtual", "service", "`", "with", "hosts", "`", "dev", "example", "com", "`", "or", "`", "prod", "example", "com", "`", "will", "match", "however", ",", "a", "`", "virtual", "service", "`", "with", "host", "`", "example", "com", "`", "or", "`", "newexample", "com", "`", "will", "not", "match", "note", ":", "only", "virtual", "services", "exported", "to", "the", "gateway", "'", "s", "namespace", "(", "e", "g", ",", "`", "export", "to", "`", "value", "of", "`", "`", ")", "can", "be", "referenced", "private", "configurations", "(", "e", "g", ",", "`", "export", "to", "`", "set", "to", "`", "`", ")", "will", "not", "be", "available", "refer", "to", "the", "`", "export", "to", "`", "setting", "in", "`", "virtual", "service", "`", ",", "`", "destination", "rule", "`", ",", "and", "`", "service", "entry", "`", "configurations", "for", "details", "<", "code", ">", "repeated", "string", "hosts", "=", "2", ";", "<", "code", ">" ]	[ "public", "com", "google", "protobuf", "protocol", "string", "list", "get", "hosts", "list", "(", ")", "{", "return", "hosts", ";", "}" ]
[ "gets", "root", "element", "from", "resource" ]	[ "public", "static", "element", "get", "root", "element", "from", "(", "final", "input", "stream", "metadata", "resource", ",", "final", "open", "saml", "config", "bean", "config", "bean", ")", "{", "val", "document", "=", "config", "bean", "get", "parser", "pool", "(", ")", "parse", "(", "metadata", "resource", ")", ";", "return", "document", "get", "document", "element", "(", ")", ";", "}" ]
[ "set", "the", "{", "@", "link", "player", "control", "view", "visibility", "listener", "}" ]	[ "public", "void", "set", "controller", "visibility", "listener", "(", "@", "nullable", "player", "control", "view", "visibility", "listener", "listener", ")", "{", "assertions", "check", "state", "not", "null", "(", "controller", ")", ";", "if", "(", "this", "controller", "visibility", "listener", "=", "=", "listener", ")", "{", "return", ";", "}", "if", "(", "this", "controller", "visibility", "listener", "!", "=", "null", ")", "{", "controller", "remove", "visibility", "listener", "(", "this", "controller", "visibility", "listener", ")", ";", "}", "this", "controller", "visibility", "listener", "=", "listener", ";", "if", "(", "listener", "!", "=", "null", ")", "{", "controller", "add", "visibility", "listener", "(", "listener", ")", ";", "}", "}" ]
[ "call", "this", "from", "your", "{", "@", "link", "activity", "}", "'", "s", "{", "@", "link", "activity", "#", "on", "activity", "result", "(", "int", ",", "int", ",", "intent", ")", "}", "method" ]	[ "public", "static", "intent", "result", "parse", "activity", "result", "(", "int", "request", "code", ",", "int", "result", "code", ",", "intent", "intent", ")", "{", "if", "(", "request", "code", "=", "=", "request", "code", ")", "{", "if", "(", "result", "code", "=", "=", "activity", "result", "ok", ")", "{", "string", "contents", "=", "intent", "get", "string", "extra", "(", "\"", "scan", "result", "\"", ")", ";", "string", "format", "name", "=", "intent", "get", "string", "extra", "(", "\"", "scan", "result", "format", "\"", ")", ";", "byte", "[", "]", "raw", "bytes", "=", "intent", "get", "byte", "array", "extra", "(", "\"", "scan", "result", "bytes", "\"", ")", ";", "int", "intent", "orientation", "=", "intent", "get", "int", "extra", "(", "\"", "scan", "result", "orientation", "\"", ",", "integer", "min", "value", ")", ";", "integer", "orientation", "=", "intent", "orientation", "=", "=", "integer", "min", "value", "?", "null", ":", "intent", "orientation", ";", "string", "error", "correction", "level", "=", "intent", "get", "string", "extra", "(", "\"", "scan", "result", "error", "correction", "level", "\"", ")", ";", "return", "new", "intent", "result", "(", "contents", ",", "format", "name", ",", "raw", "bytes", ",", "orientation", ",", "error", "correction", "level", ")", ";", "}", "return", "new", "intent", "result", "(", ")", ";", "}", "return", "null", ";", "}" ]
[ "returns", "an", "immutable", "list", "containing", "the", "given", "elements", ",", "in", "order" ]	[ "public", "static", "<", "e", ">", "immutable", "list", "<", "e", ">", "of", "(", "e", "e", "1", ",", "e", "e", "2", ",", "e", "e", "3", ",", "e", "e", "4", ",", "e", "e", "5", ",", "e", "e", "6", ",", "e", "e", "7", ",", "e", "e", "8", ",", "e", "e", "9", ",", "e", "e", "1", "0", ")", "{", "return", "construct", "(", "e", "1", ",", "e", "2", ",", "e", "3", ",", "e", "4", ",", "e", "5", ",", "e", "6", ",", "e", "7", ",", "e", "8", ",", "e", "9", ",", "e", "1", "0", ")", ";", "}" ]
[ "translate", "an", "exception", "raised", "in", "an", "operation", "into", "an", "i", "o", "exception", "the", "specific", "type", "of", "i", "o", "exception", "depends", "on", "the", "class", "of", "{", "@", "link", "obs", "exception", "}", "passed", "in", ",", "and", "any", "status", "codes", "included", "in", "the", "operation", "that", "is", ":", "http", "error", "codes", "are", "examined", "and", "can", "be", "used", "to", "build", "a", "more", "specific", "response" ]	[ "static", "i", "o", "exception", "translate", "exception", "(", "final", "string", "operation", ",", "final", "path", "path", ",", "final", "obs", "exception", "exception", ")", "{", "return", "translate", "exception", "(", "operation", ",", "path", "to", "string", "(", ")", ",", "exception", ")", ";", "}" ]
[ "get", "the", "maximum", "memory", "size", "am", "can", "use", "in", "mb" ]	[ "public", "long", "get", "max", "a", "m", "share", "m", "b", "(", ")", "{", "return", "max", "a", "m", "share", "m", "b", "value", "(", ")", ";", "}" ]
[ "sets", "the", "configurations", "not", "thread", "-", "safe", "do", "not", "call", "except", "from", "tests", "!" ]	[ "public", "void", "set", "configurations", "for", "testing", "(", "event", "handler", "event", "handler", ",", "build", "configuration", "collection", "configurations", ")", "{", "skyframe", "build", "view", "set", "configurations", "(", "event", "handler", ",", "configurations", ",", "/", "", "max", "differences", "to", "show", "", "/", "-", "1", ")", ";", "}" ]
[ "computes", "a", "data", "move", "from", "the", "largest", "disk", "we", "have", "to", "smallest", "disk" ]	[ "private", "step", "compute", "move", "(", "disk", "balancer", "volume", "set", "current", "set", ",", "disk", "balancer", "volume", "low", "volume", ",", "disk", "balancer", "volume", "high", "volume", ")", "{", "/", "/", "compute", "how", "many", "bytes", "we", "can", "move", "first", "compute", "the", "maximum", "that", "/", "/", "low", "volume", "can", "receive", ",", "then", "compute", "maximum", "high", "volume", "can", "give", "/", "/", "then", "take", "the", "minimum", "of", "those", "two", "numbers", "that", "is", "the", "bytes", "to", "move", "long", "max", "low", "volume", "can", "receive", "=", "(", "long", ")", "(", "(", "current", "set", "get", "ideal", "used", "(", ")", "", "low", "volume", "compute", "effective", "capacity", "(", ")", ")", "-", "low", "volume", "get", "used", "(", ")", ")", ";", "/", "/", "this", "disk", "cannot", "take", "any", "more", "data", "from", "any", "disk", "/", "/", "remove", "it", "from", "our", "computation", "matrix", "if", "(", "max", "low", "volume", "can", "receive", "<", "=", "0", ")", "{", "log", "debug", "(", "\"", "{", "}", "skipping", "disk", "from", "computation", "maximum", "data", "size", "\"", "+", "\"", "achieved", "\"", ",", "low", "volume", "get", "path", "(", ")", ")", ";", "skip", "volume", "(", "current", "set", ",", "low", "volume", ")", ";", "}", "long", "max", "high", "volume", "can", "give", "=", "high", "volume", "get", "used", "(", ")", "-", "(", "long", ")", "(", "current", "set", "get", "ideal", "used", "(", ")", "", "high", "volume", "compute", "effective", "capacity", "(", ")", ")", ";", "/", "/", "this", "volume", "cannot", "give", "any", "more", "data", ",", "remove", "it", "from", "the", "/", "/", "computation", "matrix", "if", "(", "max", "high", "volume", "can", "give", "<", "=", "0", ")", "{", "log", "debug", "(", "\"", "{", "}", "skipping", "disk", "from", "computation", "minimum", "data", "size", "\"", "+", "\"", "achieved", "\"", ",", "high", "volume", "get", "path", "(", ")", ")", ";", "skip", "volume", "(", "current", "set", ",", "high", "volume", ")", ";", "}", "long", "bytes", "to", "move", "=", "math", "min", "(", "max", "low", "volume", "can", "receive", ",", "max", "high", "volume", "can", "give", ")", ";", "step", "next", "step", "=", "null", ";", "if", "(", "bytes", "to", "move", ">", "0", ")", "{", "/", "/", "create", "a", "new", "step", "next", "step", "=", "new", "move", "step", "(", "high", "volume", ",", "current", "set", "get", "ideal", "used", "(", ")", ",", "low", "volume", ",", "bytes", "to", "move", ",", "current", "set", "get", "set", "i", "d", "(", ")", ")", ";", "log", "debug", "(", "\"", "next", "step", ":", "{", "}", "\"", ",", "next", "step", ")", ";", "}", "return", "next", "step", ";", "}" ]
[ "guaranteed", "to", "throw", "an", "exception", "and", "leave", "the", "map", "unmodified" ]	[ "public", "final", "v", "put", "(", "k", "k", ",", "v", "v", ")", "{", "throw", "new", "unsupported", "operation", "exception", "(", ")", ";", "}" ]
[ "get", "the", "source", "of", "the", "mapping", "or", "{", "@", "code", "null", "}" ]	[ "annotation", "type", "mapping", "get", "source", "(", ")", "{", "return", "this", "source", ";", "}" ]
[ "sets", "the", "operator", "to", "use", "when", "using", "a", "boolean", "query", "defaults", "to", "{", "@", "code", "or", "}" ]	[ "public", "match", "bool", "prefix", "query", "builder", "operator", "(", "operator", "operator", ")", "{", "if", "(", "operator", "=", "=", "null", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "[", "\"", "+", "name", "+", "\"", "]", "requires", "operator", "to", "be", "non", "-", "null", "\"", ")", ";", "}", "this", "operator", "=", "operator", ";", "return", "this", ";", "}" ]
[ "add", "a", "new", "value", "to", "the", "histogram", "note", "that", "the", "value", "will", "be", "clipped", "to", "the", "maximum", "value", "available", "in", "the", "histogram", "instance", "this", "method", "is", "provided", "for", "convenience", ",", "but", "handles", "the", "same", "numeric", "range", "as", "the", "method", "which", "takes", "an", "int" ]	[ "public", "void", "add", "(", "long", "value", ")", "{", "if", "(", "value", ">", "integer", "max", "value", ")", "{", "add", "(", "integer", "max", "value", ")", ";", "}", "else", "if", "(", "value", "<", "integer", "min", "value", ")", "{", "add", "(", "integer", "min", "value", ")", ";", "}", "else", "{", "add", "(", "(", "int", ")", "value", ")", ";", "}", "}" ]
[ "computes", "the", "set", "of", "conflicting", "or", "ambiguous", "alternatives", "from", "a", "configuration", "set", ",", "if", "that", "information", "was", "not", "already", "provided", "by", "the", "parser" ]	[ "protected", "bit", "set", "get", "conflicting", "alts", "(", "bit", "set", "reported", "alts", ",", "a", "t", "n", "config", "set", "configs", ")", "{", "if", "(", "reported", "alts", "!", "=", "null", ")", "{", "return", "reported", "alts", ";", "}", "bit", "set", "result", "=", "new", "bit", "set", "(", ")", ";", "for", "(", "a", "t", "n", "config", "config", ":", "configs", ")", "{", "result", "set", "(", "config", "alt", ")", ";", "}", "return", "result", ";", "}" ]
[ "get", "name", "boolean" ]	[ "public", "boolean", "get", "name", "boolean", "(", ")", "{", "return", "name", "boolean", ";", "}" ]
[ "if", "this", "future", "has", "been", "cancelled", "(", "and", "possibly", "interrupted", ")", ",", "cancels", "(", "and", "possibly", "interrupts", ")", "the", "given", "future", "(", "if", "available", ")" ]	[ "final", "void", "maybe", "propagate", "cancellation", "to", "(", "@", "nullable", "future", "<", "?", ">", "related", ")", "{", "if", "(", "related", "!", "=", "null", "&", "is", "cancelled", "(", ")", ")", "{", "related", "cancel", "(", "was", "interrupted", "(", ")", ")", ";", "}", "}" ]
[ "initializes", "the", "filter", "this", "implementation", "is", "a", "nop" ]	[ "public", "void", "init", "(", "filter", "config", "filter", "config", ")", "throws", "servlet", "exception", "{", "}" ]
[ "{", "@", "inherit", "doc", "}" ]	[ "public", "string", "get", "id", "(", ")", "{", "return", "this", "id", ";", "}" ]
[ "return", "the", "{", "@", "link", "min", "and", "max", "}", "indexed", "value", "from", "the", "provided", "{", "@", "link", "field", "sort", "builder", "}", "or", "<", "code", ">", "null", "<", "code", ">", "if", "unknown", "the", "value", "can", "be", "extracted", "on", "non", "-", "nested", "indexed", "mapped", "fields", "of", "type", "keyword", ",", "numeric", "or", "date", ",", "other", "fields", "and", "configurations", "return", "<", "code", ">", "null", "<", "code", ">" ]	[ "public", "static", "min", "and", "max", "<", "?", ">", "get", "min", "max", "or", "null", "(", "query", "shard", "context", "context", ",", "field", "sort", "builder", "sort", "builder", ")", "throws", "i", "o", "exception", "{", "sort", "and", "formats", "sort", "=", "sort", "builder", "build", "sort", "(", "collections", "singleton", "list", "(", "sort", "builder", ")", ",", "context", ")", "get", "(", ")", ";", "sort", "field", "sort", "field", "=", "sort", "sort", "get", "sort", "(", ")", "[", "0", "]", ";", "if", "(", "sort", "field", "get", "field", "(", ")", "=", "=", "null", ")", "{", "return", "null", ";", "}", "index", "reader", "reader", "=", "context", "get", "index", "reader", "(", ")", ";", "mapped", "field", "type", "field", "type", "=", "context", "get", "field", "type", "(", "sort", "field", "get", "field", "(", ")", ")", ";", "if", "(", "reader", "=", "=", "null", "\|", "\|", "(", "field", "type", "=", "=", "null", "\|", "\|", "field", "type", "is", "searchable", "(", ")", "=", "=", "false", ")", ")", "{", "return", "null", ";", "}", "switch", "(", "index", "sort", "config", "get", "sort", "field", "type", "(", "sort", "field", ")", ")", "{", "case", "long", ":", "case", "int", ":", "case", "double", ":", "case", "float", ":", "return", "extract", "numeric", "min", "and", "max", "(", "reader", ",", "sort", "field", ",", "field", "type", ",", "sort", "builder", ")", ";", "case", "string", ":", "case", "string", "val", ":", "if", "(", "field", "type", "instanceof", "keyword", "field", "mapper", "keyword", "field", "type", ")", "{", "terms", "terms", "=", "multi", "terms", "get", "terms", "(", "reader", ",", "field", "type", "name", "(", ")", ")", ";", "if", "(", "terms", "=", "=", "null", ")", "{", "return", "null", ";", "}", "return", "terms", "get", "min", "(", ")", "!", "=", "null", "?", "new", "min", "and", "max", "<", ">", "(", "terms", "get", "min", "(", ")", ",", "terms", "get", "max", "(", ")", ")", ":", "null", ";", "}", "break", ";", "}", "return", "null", ";", "}" ]
[ "returns", "the", "text", "direction", "of", "the", "legend" ]	[ "public", "legend", "direction", "get", "direction", "(", ")", "{", "return", "m", "direction", ";", "}" ]
[ "asynchronously", "puts", "an", "stored", "script", "using", "the", "scripting", "api", "see", "<", "a", "href", "=", "\"", "https", ":", "www", "elastic", "coguideenelasticsearchreferencecurrentmodules", "-", "scripting", "-", "using", "html", "\"", ">", "scripting", "api", "on", "elastic", "co" ]	[ "public", "cancellable", "put", "script", "async", "(", "put", "stored", "script", "request", "put", "stored", "script", "request", ",", "request", "options", "options", ",", "action", "listener", "<", "acknowledged", "response", ">", "listener", ")", "{", "return", "perform", "request", "async", "and", "parse", "entity", "(", "put", "stored", "script", "request", ",", "request", "converters", ":", ":", "put", "script", ",", "options", ",", "acknowledged", "response", ":", ":", "from", "x", "content", ",", "listener", ",", "empty", "set", "(", ")", ")", ";", "}" ]
[ "returns", "the", "node", "with", "the", "specified", "value", ",", "or", "null" ]	[ "public", "@", "null", "n", "find", "node", "(", "v", "value", ")", "{", "if", "(", "value", "=", "=", "null", ")", "throw", "new", "illegal", "argument", "exception", "(", "\"", "value", "cannot", "be", "null", "\"", ")", ";", "return", "(", "n", ")", "find", "node", "(", "root", "nodes", ",", "value", ")", ";", "}" ]
[ "is", "this", "executor", "ready", "to", "accept", "some", "tasks", "?" ]	[ "public", "boolean", "is", "available", "(", ")", "{", "return", "work", "unit", "=", "=", "null", "&", "&", "!", "executor", "get", "owner", "(", ")", "is", "offline", "(", ")", "&", "&", "executor", "get", "owner", "(", ")", "is", "accepting", "tasks", "(", ")", ";", "}" ]
[ "returns", "the", "{", "@", "link", "cause", "}", "s", "that", "triggered", "a", "build", "if", "a", "build", "sits", "in", "the", "queue", "for", "a", "long", "time", ",", "multiple", "build", "requests", "made", "during", "this", "period", "are", "all", "rolled", "up", "into", "one", "build", ",", "hence", "this", "method", "may", "return", "a", "list" ]	[ "public", "@", "non", "null", "list", "<", "cause", ">", "get", "causes", "(", ")", "{", "cause", "action", "a", "=", "get", "action", "(", "cause", "action", "class", ")", ";", "if", "(", "a", "=", "=", "null", ")", "return", "collections", "empty", "list", "(", ")", ";", "return", "collections", "unmodifiable", "list", "(", "a", "get", "causes", "(", ")", ")", ";", "}" ]
[ "returns", "the", "library", "family", "name" ]	[ "public", "string", "get", "library", "family", "name", "(", ")", "{", "return", "record", "get", "string", "(", "library", "family", "name", "col", ")", ";", "}" ]
[ "get", "photo", "urls" ]	[ "public", "set", "<", "string", ">", "get", "photo", "urls", "(", ")", "{", "return", "photo", "urls", ";", "}" ]
[ "test", "the", "netgroups", "(", "groups", "in", "acl", "rules", "that", "start", "with", "@", ")", "this", "is", "a", "manual", "test", "because", "it", "requires", ":", "-", "host", "setup", "-", "native", "code", "compiled", "-", "specify", "the", "group", "mapping", "class", "host", "setup", ":", "etcnsswitch", "conf", "should", "have", "a", "line", "like", "this", ":", "netgroup", ":", "files", "etcnetgroup", "should", "be", "(", "the", "whole", "file", ")", ":", "foo", "group", "(", ",", "proxied", "user", ",", ")", "to", "run", "this", "test", ":", "export", "java", "home", "=", "'", "pathtojava", "'", "mvn", "test", "\\", "-", "dtest", "=", "test", "proxy", "users", "\\", "-", "d", "test", "proxy", "users", "group", "mapping", "=", "$", "class", "name", "\\", "where", "$", "class", "name", "is", "one", "of", "the", "classes", "that", "provide", "group", "mapping", "services", ",", "i", "e", "classes", "that", "implement", "group", "mapping", "service", "provider", "interface", ",", "at", "this", "time", ":", "-", "org", "apache", "hadoop", "security", "jni", "based", "unix", "groups", "netgroup", "mapping", "-", "org", "apache", "hadoop", "security", "shell", "based", "unix", "groups", "netgroup", "mapping" ]	[ "public", "void", "test", "netgroups", "(", ")", "throws", "i", "o", "exception", "{", "if", "(", "!", "native", "code", "loader", "is", "native", "code", "loaded", "(", ")", ")", "{", "log", "info", "(", "\"", "not", "testing", "netgroups", ",", "\"", "+", "\"", "this", "test", "only", "runs", "when", "native", "code", "is", "compiled", "\"", ")", ";", "return", ";", "}", "string", "group", "mapping", "class", "name", "=", "system", "get", "property", "(", "\"", "test", "proxy", "users", "group", "mapping", "\"", ")", ";", "if", "(", "group", "mapping", "class", "name", "=", "=", "null", ")", "{", "log", "info", "(", "\"", "not", "testing", "netgroups", ",", "no", "group", "mapping", "class", "specified", ",", "\"", "+", "\"", "use", "-", "d", "test", "proxy", "users", "group", "mapping", "=", "$", "class", "name", "to", "specify", "\"", "+", "\"", "group", "mapping", "class", "(", "must", "implement", "group", "mapping", "service", "provider", "\"", "+", "\"", "interface", "and", "support", "netgroups", ")", "\"", ")", ";", "return", ";", "}", "log", "info", "(", "\"", "testing", "netgroups", "using", ":", "\"", "+", "group", "mapping", "class", "name", ")", ";", "configuration", "conf", "=", "new", "configuration", "(", ")", ";", "conf", "set", "(", "common", "configuration", "keys", "public", "hadoop", "security", "group", "mapping", ",", "group", "mapping", "class", "name", ")", ";", "conf", "set", "(", "default", "impersonation", "provider", "get", "test", "provider", "(", ")", "get", "proxy", "superuser", "group", "conf", "key", "(", "real", "user", "name", ")", ",", "string", "utils", "join", "(", "\"", ",", "\"", ",", "arrays", "as", "list", "(", "netgroup", "names", ")", ")", ")", ";", "conf", "set", "(", "default", "impersonation", "provider", "get", "test", "provider", "(", ")", "get", "proxy", "superuser", "ip", "conf", "key", "(", "real", "user", "name", ")", ",", "proxy", "ip", ")", ";", "proxy", "users", "refresh", "super", "user", "groups", "configuration", "(", "conf", ")", ";", "groups", "groups", "=", "groups", "get", "user", "to", "groups", "mapping", "service", "(", "conf", ")", ";", "/", "/", "try", "proxying", "a", "group", "that", "'", "s", "allowed", "user", "group", "information", "real", "user", "ugi", "=", "user", "group", "information", "create", "remote", "user", "(", "real", "user", "name", ")", ";", "user", "group", "information", "proxy", "user", "ugi", "=", "user", "group", "information", "create", "proxy", "user", "for", "testing", "(", "proxy", "user", "name", ",", "real", "user", "ugi", ",", "groups", "get", "groups", "(", "proxy", "user", "name", ")", "to", "array", "(", "new", "string", "[", "groups", "get", "groups", "(", "proxy", "user", "name", ")", "size", "(", ")", "]", ")", ")", ";", "assert", "authorized", "(", "proxy", "user", "ugi", ",", "proxy", "ip", ")", ";", "}" ]
[ "notification", "that", "a", "domain", "file", "previously", "open", "for", "update", "is", "in", "the", "process", "of", "closing" ]	[ "public", "void", "domain", "file", "object", "closed", "(", "domain", "file", "file", ",", "domain", "object", "object", ")", ";" ]
[ "how", "many", "captured", "groups", "are", "in", "this", "subtext" ]	[ "public", "int", "group", "count", "(", ")", "{", "return", "groups", "length", "/", "2", ";", "}" ]
[ "get", "the", "{", "@", "link", "#", "size", "(", ")", "}", "parameter" ]	[ "public", "integer", "size", "(", ")", "{", "return", "this", "size", ";", "}" ]
[ "optional", "list", "of", "installers", "to", "be", "configured", "by", "default", "for", "new", "tools", "of", "this", "type", "if", "there", "are", "popular", "versions", "of", "the", "tool", "available", "using", "generic", "installation", "techniques", ",", "they", "can", "be", "returned", "here", "for", "the", "user", "'", "s", "convenience" ]	[ "public", "list", "<", "?", "extends", "tool", "installer", ">", "get", "default", "installers", "(", ")", "{", "return", "collections", "empty", "list", "(", ")", ";", "}" ]
[ "the", "block", "location", "of", "returned", "located", "file", "status", "will", "have", "different", "formats", "for", "replicated", "and", "erasure", "coded", "file", "please", "refer", "to", "{", "@", "link", "file", "context", "#", "get", "file", "block", "locations", "(", "path", ",", "long", ",", "long", ")", "}", "for", "more", "details" ]	[ "public", "remote", "iterator", "<", "located", "file", "status", ">", "list", "located", "status", "(", "final", "path", "p", ")", "throws", "file", "not", "found", "exception", ",", "i", "o", "exception", "{", "return", "new", "dir", "listing", "iterator", "<", "located", "file", "status", ">", "(", "p", ",", "true", ")", "{", "@", "override", "public", "located", "file", "status", "next", "(", ")", "throws", "i", "o", "exception", "{", "return", "(", "(", "hdfs", "located", "file", "status", ")", "get", "next", "(", ")", ")", "make", "qualified", "located", "(", "get", "uri", "(", ")", ",", "p", ")", ";", "}", "}", ";", "}" ]
[ "type", "of", "the", "resource", "that", "is", "being", "requested", ",", "e", "g", "\"", "type", "googleapis", "comistio", "io", "networking", "v", "1alpha", "3", "virtual", "service", "\"", "<", "code", ">", "string", "type", "url", "=", "3", ";", "<", "code", ">" ]	[ "public", "com", "google", "protobuf", "byte", "string", "get", "type", "url", "bytes", "(", ")", "{", "java", "lang", "object", "ref", "=", "type", "url", ";", "if", "(", "ref", "instanceof", "string", ")", "{", "com", "google", "protobuf", "byte", "string", "b", "=", "com", "google", "protobuf", "byte", "string", "copy", "from", "utf", "8", "(", "(", "java", "lang", "string", ")", "ref", ")", ";", "type", "url", "=", "b", ";", "return", "b", ";", "}", "else", "{", "return", "(", "com", "google", "protobuf", "byte", "string", ")", "ref", ";", "}", "}" ]
[ "retrieve", "the", "data", "source", "identified", "by", "the", "given", "name" ]	[ "data", "source", "get", "data", "source", "(", "string", "data", "source", "name", ")", "throws", "data", "source", "lookup", "failure", "exception", ";" ]
[ "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", "\"", ")", ";", "}" ]
[ "new", "saml", "object" ]	[ "protected", "<", "t", "extends", "s", "a", "m", "l", "object", ">", "t", "new", "saml", "object", "(", "final", "class", "<", "t", ">", "object", "type", ")", "{", "val", "q", "name", "=", "get", "saml", "object", "q", "name", "(", "object", "type", ")", ";", "return", "saml", "utils", "new", "saml", "object", "(", "object", "type", ",", "q", "name", ")", ";", "}" ]
[ "verifies", "that", "we", "can", "install", "an", "extension", "from", "a", "folder" ]	[ "public", "void", "test", "install", "extension", "from", "folder", "(", ")", "throws", "extension", "exception", ",", "i", "o", "exception", "{", "/", "/", "create", "an", "extension", "and", "install", "it", "resource", "file", "r", "file", "=", "create", "extension", "folder", "(", ")", ";", "extension", "utils", "install", "(", "r", "file", ")", ";", "/", "/", "verify", "the", "extension", "is", "in", "the", "install", "folder", "and", "has", "the", "correct", "name", "check", "dirty", "install", "(", "default", "ext", "name", ")", ";", "}" ]
[ "adds", "the", "header", "search", "paths", "provided", "by", "the", "protobuf", "library" ]	[ "public", "builder", "add", "protobuf", "header", "search", "paths", "(", "nested", "set", "<", "path", "fragment", ">", "protobuf", "header", "search", "paths", ")", "{", "this", "protobuf", "header", "search", "paths", "add", "transitive", "(", "protobuf", "header", "search", "paths", ")", ";", "return", "this", ";", "}" ]
[ "adds", "the", "given", "list", "of", "items", "to", "the", "statistics" ]	[ "public", "void", "add", "all", "(", "section", "list", ")", "{", "collection", "<", "?", "extends", "item", ">", "items", "=", "list", "items", "(", ")", ";", "for", "(", "item", "item", ":", "items", ")", "{", "add", "(", "item", ")", ";", "}", "}" ]
[ "retrieve", "the", "given", "column", "as", "character", "stream", "from", "the", "given", "result", "set", "might", "simply", "invoke", "{", "@", "code", "result", "set", "get", "character", "stream", "}", "or", "work", "with", "{", "@", "code", "result", "set", "get", "clob", "}", ",", "depending", "on", "the", "database", "and", "driver" ]	[ "reader", "get", "clob", "as", "character", "stream", "(", "result", "set", "rs", ",", "string", "column", "name", ")", "throws", "s", "q", "l", "exception", ";" ]
[ "test", "to", "verify", "listeners", "defined", "in", "the", "bpmn", "xml", "with", "invalid", "classdelegate", "expression", "values", "cause", "an", "exception", "when", "process", "is", "started" ]	[ "public", "void", "test", "process", "definition", "listener", "definition", "error", "(", ")", "throws", "exception", "{", "/", "/", "deploy", "process", "with", "expression", "which", "references", "an", "unexisting", "bean", "org", "activiti", "engine", "repository", "deployment", "deployment", "=", "repository", "service", "create", "deployment", "(", ")", "add", "classpath", "resource", "(", "\"", "org", "/", "activiti", "/", "standalone", "/", "event", "/", "invalid", "event", "listener", "expression", "bpmn", "2", "0", "xml", "\"", ")", "deploy", "(", ")", ";", "process", "instance", "process", "instance", "=", "runtime", "service", "start", "process", "instance", "by", "key", "(", "\"", "test", "invalid", "event", "expression", "\"", ")", ";", "assert", "that", "(", "process", "instance", ")", "is", "not", "null", "(", ")", ";", "repository", "service", "delete", "deployment", "(", "deployment", "get", "id", "(", ")", ",", "true", ")", ";", "/", "/", "deploy", "process", "with", "listener", "which", "references", "an", "unexisting", "class", "deployment", "=", "repository", "service", "create", "deployment", "(", ")", "add", "classpath", "resource", "(", "\"", "org", "/", "activiti", "/", "standalone", "/", "event", "/", "invalid", "event", "listener", "class", "bpmn", "2", "0", "xml", "\"", ")", "deploy", "(", ")", ";", "process", "instance", "=", "runtime", "service", "start", "process", "instance", "by", "key", "(", "\"", "test", "invalid", "event", "class", "\"", ")", ";", "repository", "service", "delete", "deployment", "(", "deployment", "get", "id", "(", ")", ",", "true", ")", ";", "}" ]
[ "return", "base", "6", "4", "-", "encode", "bytes" ]	[ "public", "static", "byte", "[", "]", "base", "6", "4", "encode", "(", "final", "string", "input", ")", "{", "return", "base", "6", "4", "encode", "(", "input", "get", "bytes", "(", ")", ")", ";", "}" ]
[ "{", "@", "inherit", "doc", "}" ]	[ "public", "void", "update", "binary", "stream", "(", "int", "column", "index", ",", "input", "stream", "x", ",", "long", "length", ")", "throws", "s", "q", "l", "exception", "{", "}" ]
[ "compare", "the", "given", "{", "@", "code", "property", "descriptors", "}", "and", "return", "{", "@", "code", "true", "}", "if", "they", "are", "equivalent", ",", "i", "e", "their", "read", "method", ",", "write", "method", ",", "property", "type", ",", "property", "editor", "and", "flags", "are", "equivalent" ]	[ "public", "static", "boolean", "equals", "(", "property", "descriptor", "pd", ",", "property", "descriptor", "other", "pd", ")", "{", "return", "(", "object", "utils", "null", "safe", "equals", "(", "pd", "get", "read", "method", "(", ")", ",", "other", "pd", "get", "read", "method", "(", ")", ")", "&", "&", "object", "utils", "null", "safe", "equals", "(", "pd", "get", "write", "method", "(", ")", ",", "other", "pd", "get", "write", "method", "(", ")", ")", "&", "&", "object", "utils", "null", "safe", "equals", "(", "pd", "get", "property", "type", "(", ")", ",", "other", "pd", "get", "property", "type", "(", ")", ")", "&", "&", "object", "utils", "null", "safe", "equals", "(", "pd", "get", "property", "editor", "class", "(", ")", ",", "other", "pd", "get", "property", "editor", "class", "(", ")", ")", "&", "&", "pd", "is", "bound", "(", ")", "=", "=", "other", "pd", "is", "bound", "(", ")", "&", "&", "pd", "is", "constrained", "(", ")", "=", "=", "other", "pd", "is", "constrained", "(", ")", ")", ";", "}" ]
[ "perform", "a", "psuedo", "-", "disassembly", "of", "an", "single", "instruction", "block", "only", "following", "fall", "-", "throughs", "warning", "!", "this", "method", "should", "not", "be", "used", "in", "conjunction", "with", "other", "disassembly", "methods", "on", "the", "this", "disassembler", "instance", "disassembler", "must", "be", "instantiated", "with", "a", "program", "object" ]	[ "public", "instruction", "block", "pseudo", "disassemble", "block", "(", "address", "addr", ",", "register", "value", "default", "context", "value", ",", "int", "limit", ")", "{", "if", "(", "program", "=", "=", "null", ")", "{", "throw", "new", "unsupported", "operation", "exception", "(", "\"", "method", "requires", "instantiation", "with", "a", "program", "object", "\"", ")", ";", "}", "return", "pseudo", "disassemble", "block", "(", "new", "dumb", "mem", "buffer", "impl", "(", "program", "get", "memory", "(", ")", ",", "addr", ")", ",", "default", "context", "value", ",", "limit", ")", ";", "}" ]
[ "define", "a", "factory", "for", "a", "class" ]	[ "public", "static", "void", "set", "factory", "(", "class", "c", ",", "writable", "factory", "factory", ")", "{", "class", "to", "factory", "put", "(", "c", ",", "factory", ")", ";", "}" ]
[ "determine", "the", "target", "type", "for", "the", "given", "generic", "parameter", "type" ]	[ "public", "static", "class", "<", "?", ">", "resolve", "parameter", "type", "(", "method", "parameter", "method", "parameter", ",", "class", "<", "?", ">", "implementation", "class", ")", "{", "assert", "not", "null", "(", "method", "parameter", ",", "\"", "method", "parameter", "must", "not", "be", "null", "\"", ")", ";", "assert", "not", "null", "(", "implementation", "class", ",", "\"", "class", "must", "not", "be", "null", "\"", ")", ";", "method", "parameter", "set", "containing", "class", "(", "implementation", "class", ")", ";", "return", "method", "parameter", "get", "parameter", "type", "(", ")", ";", "}" ]
[ "wait", "for", "the", "given", "job", "to", "complete" ]	[ "public", "void", "wait", "for", "job", "completion", "(", "job", "job", ")", "throws", "exception", "{", "assert", "job", "!", "=", "null", ";", "if", "(", "!", "job", "wait", "for", "completion", "(", "true", ")", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "dist", "cp", "failure", ":", "job", "\"", "+", "job", "get", "job", "i", "d", "(", ")", "+", "\"", "has", "failed", ":", "\"", "+", "job", "get", "status", "(", ")", "get", "failure", "info", "(", ")", ")", ";", "}", "}" ]
[ "looks", "up", "finalizer", "start", "finalizer", "(", ")" ]	[ "static", "method", "get", "start", "finalizer", "(", "class", "<", "?", ">", "finalizer", ")", "{", "try", "{", "return", "finalizer", "get", "method", "(", "\"", "start", "finalizer", "\"", ",", "class", "class", ",", "reference", "queue", "class", ",", "phantom", "reference", "class", ")", ";", "}", "catch", "(", "no", "such", "method", "exception", "e", ")", "{", "throw", "new", "assertion", "error", "(", "e", ")", ";", "}", "}" ]
[ "update", "the", "frontier", "for", "a", "path", "pathfinding", "thread", "only" ]	[ "private", "void", "update", "frontier", "(", "flowfield", "path", ",", "long", "ns", "to", "run", ")", "{", "long", "start", "=", "time", "nanos", "(", ")", ";", "while", "(", "path", "frontier", "size", ">", "0", "&", "&", "(", "ns", "to", "run", "<", "0", "\|", "\|", "time", "time", "since", "nanos", "(", "start", ")", "<", "=", "ns", "to", "run", ")", ")", "{", "tile", "tile", "=", "world", "tile", "(", "path", "frontier", "remove", "last", "(", ")", ")", ";", "if", "(", "tile", "=", "=", "null", "\|", "\|", "path", "weights", "=", "=", "null", ")", "return", ";", "/", "/", "something", "went", "horribly", "wrong", ",", "bail", "int", "cost", "=", "path", "weights", "[", "tile", "x", "]", "[", "tile", "y", "]", ";", "/", "/", "pathfinding", "overflowed", "for", "some", "reason", ",", "time", "to", "bail", "the", "next", "block", "update", "will", "handle", "this", ",", "hopefully", "if", "(", "path", "frontier", "size", ">", "=", "world", "width", "(", ")", "*", "world", "height", "(", ")", ")", "{", "path", "frontier", "clear", "(", ")", ";", "return", ";", "}", "if", "(", "cost", "!", "=", "impassable", ")", "{", "for", "(", "point", "2", "point", ":", "geometry", "d", "4", ")", "{", "int", "dx", "=", "tile", "x", "+", "point", "x", ",", "dy", "=", "tile", "y", "+", "point", "y", ";", "if", "(", "dx", "<", "0", "\|", "\|", "dy", "<", "0", "\|", "\|", "dx", ">", "=", "tiles", "length", "\|", "\|", "dy", ">", "=", "tiles", "[", "0", "]", "length", ")", "continue", ";", "int", "other", "cost", "=", "path", "cost", "get", "cost", "(", "path", "team", ",", "tiles", "[", "dx", "]", "[", "dy", "]", ")", ";", "if", "(", "(", "path", "weights", "[", "dx", "]", "[", "dy", "]", ">", "cost", "+", "other", "cost", "\|", "\|", "path", "searches", "[", "dx", "]", "[", "dy", "]", "<", "path", "search", ")", "&", "&", "other", "cost", "!", "=", "impassable", ")", "{", "path", "frontier", "add", "first", "(", "point", "2", "pack", "(", "dx", ",", "dy", ")", ")", ";", "path", "weights", "[", "dx", "]", "[", "dy", "]", "=", "cost", "+", "other", "cost", ";", "path", "searches", "[", "dx", "]", "[", "dy", "]", "=", "(", "short", ")", "path", "search", ";", "}", "}", "}", "}", "}" ]
[ "notifies", "consumer", "of", "new", "result", "and", "finishes", "if", "the", "result", "is", "final" ]	[ "private", "void", "handle", "result", "(", "final", "closeable", "image", "decoded", "image", ",", "final", "@", "status", "int", "status", ")", "{", "closeable", "reference", "<", "closeable", "image", ">", "decoded", "image", "ref", "=", "m", "closeable", "reference", "factory", "create", "(", "decoded", "image", ")", ";", "try", "{", "maybe", "finish", "(", "is", "last", "(", "status", ")", ")", ";", "get", "consumer", "(", ")", "on", "new", "result", "(", "decoded", "image", "ref", ",", "status", ")", ";", "}", "finally", "{", "closeable", "reference", "close", "safely", "(", "decoded", "image", "ref", ")", ";", "}", "}" ]
[ "build", "the", "{", "@", "code", "mock", "rest", "service", "server", "}", "and", "set", "up", "the", "underlying", "{", "@", "code", "rest", "template", "}", "or", "{", "@", "code", "async", "rest", "template", "}", "with", "a", "{", "@", "link", "client", "http", "request", "factory", "}", "that", "creates", "mock", "requests" ]	[ "mock", "rest", "service", "server", "build", "(", ")", ";" ]
[ "if", "the", "file", "created", "by", "{", "@", "link", "#", "write", "temp", "cache", "file", "(", "input", "stream", ",", "file", "extension", ")", "}", "was", "successfully", "parsed", ",", "this", "should", "be", "called", "to", "remove", "the", "temporary", "part", "of", "its", "name", "which", "will", "allow", "it", "to", "be", "a", "cache", "hit", "in", "the", "future" ]	[ "void", "rename", "temp", "file", "(", "string", "url", ",", "file", "extension", "extension", ")", "{", "string", "file", "name", "=", "filename", "for", "url", "(", "url", ",", "extension", ",", "true", ")", ";", "file", "file", "=", "new", "file", "(", "parent", "dir", "(", ")", ",", "file", "name", ")", ";", "string", "new", "file", "name", "=", "file", "get", "absolute", "path", "(", ")", "replace", "(", "\"", "temp", "\"", ",", "\"", "\"", ")", ";", "file", "new", "file", "=", "new", "file", "(", "new", "file", "name", ")", ";", "boolean", "renamed", "=", "file", "rename", "to", "(", "new", "file", ")", ";", "logger", "debug", "(", "\"", "copying", "temp", "file", "to", "real", "file", "(", "\"", "+", "new", "file", "+", "\"", ")", "\"", ")", ";", "if", "(", "!", "renamed", ")", "{", "logger", "warning", "(", "\"", "unable", "to", "rename", "cache", "file", "\"", "+", "file", "get", "absolute", "path", "(", ")", "+", "\"", "to", "\"", "+", "new", "file", "get", "absolute", "path", "(", ")", "+", "\"", "\"", ")", ";", "}", "}" ]
[ "makes", "sure", "the", "aspect", "will", "propagate", "to", "its", "implicit", "attributes", "if", "there", "is", "a", "\"", "regular", "\"", "dependency", "path", "to", "it", "(", "i", "e", "not", "through", "its", "own", "implicit", "attributes", ")" ]	[ "public", "void", "aspect", "with", "all", "attributes", "propagates", "to", "its", "tool", "if", "there", "is", "path", "(", ")", "throws", "exception", "{", "set", "rules", "available", "in", "tests", "(", "test", "aspects", "base", "rule", ",", "test", "aspects", "simple", "rule", ",", "test", "aspects", "all", "attributes", "with", "tool", "aspect", "rule", ")", ";", "pkg", "(", "\"", "a", "\"", ",", "\"", "simple", "(", "name", "=", "'", "tool", "'", ")", "\"", ",", "\"", "simple", "(", "name", "=", "'", "a", "'", ",", "foo", "=", "[", "'", ":", "b", "'", "]", ",", "foo", "1", "=", "'", ":", "c", "'", ",", "txt", "=", "'", "some", "text", "'", ")", "\"", ",", "\"", "simple", "(", "name", "=", "'", "b", "'", ",", "foo", "=", "[", "]", ",", "txt", "=", "'", "some", "text", "'", ")", "\"", ",", "\"", "simple", "(", "name", "=", "'", "c", "'", ",", "foo", "=", "[", "'", ":", "tool", "'", "]", ",", "txt", "=", "'", "more", "text", "'", ")", "\"", ",", "\"", "all", "attributes", "with", "tool", "aspect", "(", "name", "=", "'", "x", "'", ",", "foo", "=", "[", "'", ":", "a", "'", "]", ")", "\"", ")", ";", "configured", "target", "a", "=", "get", "configured", "target", "(", "\"", "/", "/", "a", ":", "x", "\"", ")", ";", "assert", "that", "(", "a", "get", "provider", "(", "rule", "info", "class", ")", "get", "data", "(", ")", "to", "list", "(", ")", ")", "contains", "exactly", "(", "\"", "aspect", "/", "/", "a", ":", "a", "\"", ",", "\"", "aspect", "/", "/", "a", ":", "b", "\"", ",", "\"", "aspect", "/", "/", "a", ":", "c", "\"", ",", "\"", "aspect", "/", "/", "a", ":", "tool", "\"", ",", "\"", "rule", "/", "/", "a", ":", "x", "\"", ")", ";", "}" ]

[ "returns", "a", "view", "collection", "of", "all", "distinct", "keys", "contained", "in", "this", "multimap", "note", "that", "the", "key", "set", "contains", "a", "key", "if", "and", "only", "if", "this", "multimap", "maps", "that", "key", "to", "at", "least", "one", "value", "changes", "to", "the", "returned", "set", "will", "update", "the", "underlying", "multimap", ",", "and", "vice", "versa", "however", ",", "adding", "to", "the", "returned", "set", "is", "not", "possible" ]

[ "set", "<", "k", ">", "key", "set", "(", ")", ";" ]

[ "creates", "a", "g", "file", "for", "a", "filesystem", "using", "a", "string", "path", "(", "ie", "\"", "dirsubdirfilename", "\"", ")", ",", "with", "the", "path", "starting", "at", "the", "root", "of", "the", "filesystem", "the", "parents", "of", "this", "g", "file", "are", "created", "fresh", "from", "any", "directory", "names", "in", "the", "path", "string", "it", "is", "better", "to", "use", "the", "{", "@", "link", "#", "from", "filename", "(", "g", "file", "system", ",", "g", "file", ",", "string", ",", "boolean", ",", "long", ",", "fsrl", ")", "}", "method", "to", "create", "g", "file", "instances", "if", "you", "can", "supply", "the", "parent", "value", "as", "that", "will", "allow", "reuse", "of", "the", "parent", "objects", "instead", "of", "duplicates", "of", "them", "being", "created", "for", "each", "file", "with", "the", "same", "parent", "path" ]

[ "public", "static", "g", "file", "impl", "from", "path", "string", "(", "g", "file", "system", "file", "system", ",", "string", "path", ",", "fsrl", "fsrl", ",", "boolean", "is", "directory", ",", "long", "length", ")", "{", "return", "from", "path", "string", "(", "file", "system", ",", "null", ",", "path", ",", "fsrl", ",", "is", "directory", ",", "length", ")", ";", "}" ]

[ "rolling", "back", "to", "a", "snapshot", "in", "previous", "directory", "by", "moving", "it", "to", "current", "directory", "rollback", "procedure", ":", "<", "br", ">", "if", "previous", "directory", "exists", ":", "rename", "current", "to", "removed", "tmp", "rename", "previous", "to", "current", "remove", "removed", "tmp", "if", "previous", "directory", "does", "not", "exist", "and", "the", "current", "version", "supports", "federation", ",", "perform", "a", "simple", "rollback", "of", "layout", "version", "this", "does", "not", "involve", "savingrestoration", "of", "actual", "data" ]

[ "void", "do", "rollback", "(", "storage", "directory", "sd", ",", "namespace", "info", "ns", "info", ")", "throws", "i", "o", "exception", "{", "file", "prev", "dir", "=", "sd", "get", "previous", "dir", "(", ")", ";", "/", "/", "this", "is", "a", "regular", "startup", "or", "a", "post", "-", "federation", "rollback", "if", "(", "!", "prev", "dir", "exists", "(", ")", ")", "{", "if", "(", "data", "node", "layout", "version", "supports", "(", "layout", "version", "feature", "federation", ",", "data", "node", "layout", "version", "get", "current", "layout", "version", "(", ")", ")", ")", "{", "read", "properties", "(", "sd", ",", "data", "node", "layout", "version", "get", "current", "layout", "version", "(", ")", ")", ";", "write", "properties", "(", "sd", ")", ";", "log", "info", "(", "\"", "layout", "version", "rolled", "back", "to", "{", "}", "for", "storage", "{", "}", "\"", ",", "data", "node", "layout", "version", "get", "current", "layout", "version", "(", ")", ",", "sd", "get", "root", "(", ")", ")", ";", "}", "return", ";", "}", "data", "storage", "prev", "info", "=", "new", "data", "storage", "(", ")", ";", "prev", "info", "read", "previous", "version", "properties", "(", "sd", ")", ";", "/", "/", "we", "allow", "rollback", "to", "a", "state", ",", "which", "is", "either", "consistent", "with", "/", "/", "the", "namespace", "state", "or", "can", "be", "further", "upgraded", "to", "it", "if", "(", "!", "(", "prev", "info", "get", "layout", "version", "(", ")", ">", "=", "data", "node", "layout", "version", "get", "current", "layout", "version", "(", ")", "&", "&", "prev", "info", "get", "c", "time", "(", ")", "<", "=", "ns", "info", "get", "c", "time", "(", ")", ")", ")", "{", "/", "/", "cannot", "rollback", "throw", "new", "inconsistent", "f", "s", "state", "exception", "(", "sd", "get", "root", "(", ")", ",", "\"", "cannot", "rollback", "to", "a", "newer", "state", "\\", "n", "datanode", "previous", "state", ":", "lv", "=", "\"", "+", "prev", "info", "get", "layout", "version", "(", ")", "+", "\"", "c", "time", "=", "\"", "+", "prev", "info", "get", "c", "time", "(", ")", "+", "\"", "is", "newer", "than", "the", "namespace", "state", ":", "lv", "=", "\"", "+", "data", "node", "layout", "version", "get", "current", "layout", "version", "(", ")", "+", "\"", "c", "time", "=", "\"", "+", "ns", "info", "get", "c", "time", "(", ")", ")", ";", "}", "log", "info", "(", "\"", "rolling", "back", "storage", "directory", "{", "}", "\\", "n", "target", "lv", "=", "{", "}", ";", "target", "\"", "+", "\"", "c", "time", "=", "{", "}", "\"", ",", "sd", "get", "root", "(", ")", ",", "data", "node", "layout", "version", "get", "current", "layout", "version", "(", ")", ",", "ns", "info", "get", "c", "time", "(", ")", ")", ";", "file", "tmp", "dir", "=", "sd", "get", "removed", "tmp", "(", ")", ";", "assert", "!", "tmp", "dir", "exists", "(", ")", ":", "\"", "removed", "tmp", "directory", "must", "not", "exist", "\"", ";", "/", "/", "rename", "current", "to", "tmp", "file", "cur", "dir", "=", "sd", "get", "current", "dir", "(", ")", ";", "assert", "cur", "dir", "exists", "(", ")", ":", "\"", "current", "directory", "must", "exist", "\"", ";", "rename", "(", "cur", "dir", ",", "tmp", "dir", ")", ";", "/", "/", "rename", "previous", "to", "current", "rename", "(", "prev", "dir", ",", "cur", "dir", ")", ";", "/", "/", "delete", "tmp", "dir", "delete", "dir", "(", "tmp", "dir", ")", ";", "log", "info", "(", "\"", "rollback", "of", "{", "}", "is", "complete", "\"", ",", "sd", "get", "root", "(", ")", ")", ";", "}" ]

[ "{", "@", "inherit", "doc", "}" ]

[ "public", "char", "stream", "get", "input", "stream", "(", ")", "{", "if", "(", "i", "<", "tokens", "size", "(", ")", ")", "{", "return", "tokens", "get", "(", "i", ")", "get", "input", "stream", "(", ")", ";", "}", "else", "if", "(", "eof", "token", "!", "=", "null", ")", "{", "return", "eof", "token", "get", "input", "stream", "(", ")", ";", "}", "else", "if", "(", "tokens", "size", "(", ")", ">", "0", ")", "{", "return", "tokens", "get", "(", "tokens", "size", "(", ")", "-", "1", ")", "get", "input", "stream", "(", ")", ";", "}", "/", "/", "no", "input", "stream", "information", "is", "available", "return", "null", ";", "}" ]

[ "return", "the", "name", "of", "the", "one", "of", "schema", "this", "name", "is", "used", "to", "set", "the", "value", "of", "codegen", "property", "open", "api", "type", "if", "the", "'", "x", "-", "one", "-", "of", "-", "name", "'", "extension", "is", "specified", "in", "the", "oas", "document", ",", "return", "that", "value", "otherwise", ",", "a", "name", "is", "constructed", "by", "creating", "a", "comma", "-", "separated", "list", "of", "all", "the", "names", "of", "the", "one", "of", "schemas" ]

[ "public", "string", "to", "one", "of", "name", "(", "list", "<", "string", ">", "names", ",", "composed", "schema", "composed", "schema", ")", "{", "map", "<", "string", ",", "object", ">", "exts", "=", "composed", "schema", "get", "extensions", "(", ")", ";", "if", "(", "exts", "!", "=", "null", "&", "&", "exts", "contains", "key", "(", "\"", "x", "-", "one", "-", "of", "-", "name", "\"", ")", ")", "{", "return", "(", "string", ")", "exts", "get", "(", "\"", "x", "-", "one", "-", "of", "-", "name", "\"", ")", ";", "}", "return", "\"", "one", "of", "<", "\"", "+", "string", "join", "(", "\"", ",", "\"", ",", "names", ")", "+", "\"", ">", "\"", ";", "}" ]

[ "the", "name", "of", "the", "index", "template" ]

[ "public", "string", "name", "(", ")", "{", "return", "this", "name", ";", "}" ]

[ "returns", "a", "new", "{", "@", "code", "future", "}", "whose", "result", "is", "asynchronously", "derived", "from", "the", "result", "of", "this", "{", "@", "code", "future", "}", "if", "the", "input", "{", "@", "code", "future", "}", "fails", ",", "the", "returned", "{", "@", "code", "future", "}", "fails", "with", "the", "same", "exception", "(", "and", "the", "function", "is", "not", "invoked", ")", "more", "precisely", ",", "the", "returned", "{", "@", "code", "future", "}", "takes", "its", "result", "from", "a", "{", "@", "code", "future", "}", "produced", "by", "applying", "the", "given", "{", "@", "code", "async", "function", "}", "to", "the", "result", "of", "the", "original", "{", "@", "code", "future", "}", "example", "usage", ":", "{", "@", "code", "fluent", "future", "<", "row", "key", ">", "row", "key", "future", "=", "fluent", "future", "from", "(", "index", "service", "look", "up", "(", "query", ")", ")", ";", "listenable", "future", "<", "query", "result", ">", "query", "future", "=", "row", "key", "future", "transform", "async", "(", "data", "service", ":", ":", "read", "future", ",", "executor", ")", ";", "}", "when", "selecting", "an", "executor", ",", "note", "that", "{", "@", "code", "direct", "executor", "}", "is", "dangerous", "in", "some", "cases", "see", "the", "discussion", "in", "the", "{", "@", "link", "#", "add", "listener", "}", "documentation", "all", "its", "warnings", "about", "heavyweight", "listeners", "are", "also", "applicable", "to", "heavyweight", "functions", "passed", "to", "this", "method", "(", "specifically", ",", "{", "@", "code", "direct", "executor", "}", "functions", "should", "avoid", "heavyweight", "operations", "inside", "{", "@", "code", "async", "function", "apply", "}", "any", "heavyweight", "operations", "should", "occur", "in", "other", "threads", "responsible", "for", "completing", "the", "returned", "{", "@", "code", "future", "}", ")", "the", "returned", "{", "@", "code", "future", "}", "attempts", "to", "keep", "its", "cancellation", "state", "in", "sync", "with", "that", "of", "the", "input", "future", "and", "that", "of", "the", "future", "returned", "by", "the", "chain", "function", "that", "is", ",", "if", "the", "returned", "{", "@", "code", "future", "}", "is", "cancelled", ",", "it", "will", "attempt", "to", "cancel", "the", "other", "two", ",", "and", "if", "either", "of", "the", "other", "two", "is", "cancelled", ",", "the", "returned", "{", "@", "code", "future", "}", "will", "receive", "a", "callback", "in", "which", "it", "will", "attempt", "to", "cancel", "itself", "this", "method", "is", "similar", "to", "{", "@", "link", "java", "util", "concurrent", "completable", "future", "#", "then", "compose", "}", "and", "{", "@", "link", "java", "util", "concurrent", "completable", "future", "#", "then", "compose", "async", "}", "it", "can", "also", "serve", "some", "of", "the", "use", "cases", "of", "{", "@", "link", "java", "util", "concurrent", "completable", "future", "#", "handle", "}", "and", "{", "@", "link", "java", "util", "concurrent", "completable", "future", "#", "handle", "async", "}", "when", "used", "along", "with", "{", "@", "link", "#", "catching", "}" ]

[ "public", "final", "<", "t", ">", "fluent", "future", "<", "t", ">", "transform", "async", "(", "async", "function", "<", "?", "super", "v", ",", "t", ">", "function", ",", "executor", "executor", ")", "{", "return", "(", "fluent", "future", "<", "t", ">", ")", "futures", "transform", "async", "(", "this", ",", "function", ",", "executor", ")", ";", "}" ]

[ "see", "if", "the", "new", "build", "matches", "any", "of", "the", "peephole", "permalink" ]

[ "public", "void", "on", "completed", "(", "run", "<", "?", ",", "?", ">", "run", ",", "@", "non", "null", "task", "listener", "listener", ")", "{", "job", "<", "?", ",", "?", ">", "j", "=", "run", "get", "parent", "(", ")", ";", "for", "(", "peephole", "permalink", "pp", ":", "util", "filter", "(", "j", "get", "permalinks", "(", ")", ",", "peephole", "permalink", "class", ")", ")", "{", "if", "(", "pp", "apply", "(", "run", ")", ")", "{", "run", "<", "?", ",", "?", ">", "cur", "=", "pp", "resolve", "(", "j", ")", ";", "if", "(", "cur", "=", "=", "null", "|", "|", "cur", "get", "number", "(", ")", "<", "run", "get", "number", "(", ")", ")", "{", "logger", "fine", "(", "(", ")", "-", ">", "\"", "updating", "\"", "+", "pp", "get", "id", "(", ")", "+", "\"", "permalink", "to", "completed", "\"", "+", "run", ")", ";", "pp", "update", "cache", "(", "j", ",", "run", ")", ";", "}", "}", "}", "}" ]

[ "get", "array", "number" ]

[ "public", "list", "<", "big", "decimal", ">", "get", "array", "number", "(", ")", "{", "return", "array", "number", ";", "}" ]

[ "return", "whether", "dtd", "parsing", "is", "supported" ]

[ "public", "boolean", "is", "support", "dtd", "(", ")", "{", "return", "this", "support", "dtd", ";", "}" ]

[ "the", "name", "of", "the", "type", "this", "corresponds", "to", "the", "'", "type", "'", "part", "of", "a", "full", "resource", "name", "of", "the", "form", "package", ":", "typeentry", "the", "set", "of", "legal", "type", "names", "is", "listed", "in", "resource", "cpp", "<", "code", ">", "optional", "string", "name", "=", "2", ";", "<", "code", ">" ]

[ "public", "com", "google", "protobuf", "byte", "string", "get", "name", "bytes", "(", ")", "{", "return", "instance", "get", "name", "bytes", "(", ")", ";", "}" ]

[ "set", "ignore", "nulls", "indicator" ]

[ "public", "void", "set", "ignore", "nulls", "(", "boolean", "ignore", "nulls", ")", "{", "this", "ignore", "nulls", "=", "ignore", "nulls", ";", "}" ]

[ "returns", "the", "next", "state", "to", "transition", "to", "after", "the", "given", "state" ]

[ "private", "job", "state", "get", "next", "state", "(", "job", "state", "state", ")", "{", "switch", "(", "state", ")", "{", "case", "not", "running", ":", "return", "loading", ";", "case", "loading", ":", "return", "filtering", ";", "case", "filtering", ":", "return", "add", "removing", ";", "case", "add", "removing", ":", "return", "sorting", ";", "case", "sorting", ":", "return", "applying", ";", "case", "applying", ":", "default", ":", "return", "done", ";", "}", "}" ]

[ "stops", "the", "reporter", "and", "shuts", "down", "its", "thread", "of", "execution" ]

[ "public", "void", "close", "(", ")", "{", "stop", "(", ")", ";", "}" ]

[ "returns", "a", "recyclable", "m", "p", "point", "d", "instance", "returns", "the", "corresponding", "x", "pos", "for", "a", "given", "touch", "-", "position", "in", "pixels" ]

[ "protected", "m", "p", "point", "d", "get", "vals", "for", "touch", "(", "float", "x", ",", "float", "y", ")", "{", "/", "/", "take", "any", "transformer", "to", "determine", "the", "x", "-", "axis", "value", "m", "p", "point", "d", "pos", "=", "m", "chart", "get", "transformer", "(", "y", "axis", "axis", "dependency", "left", ")", "get", "values", "by", "touch", "point", "(", "x", ",", "y", ")", ";", "return", "pos", ";", "}" ]

[ "initiates", "a", "scan", "for", "all", "known", "barcode", "types", "with", "the", "default", "camera" ]

[ "public", "final", "alert", "dialog", "initiate", "scan", "(", ")", "{", "return", "initiate", "scan", "(", "all", "code", "types", ",", "-", "1", ")", ";", "}" ]

[ "{", "@", "inherit", "doc", "}" ]

[ "public", "int", "get", "height", "(", ")", "{", "return", "height", ";", "}" ]

[ "perform", "processing", "for", "the", "various", "hook", "points", "where", "breakpoints", "have", "been", "set" ]

[ "private", "void", "process", "breakpoint", "(", "address", "addr", ")", "throws", "exception", "{", "/", "/", "malloc", "hook", "if", "(", "addr", "equals", "(", "malloc", "entry", ")", ")", "{", "int", "size", "=", "emu", "helper", "read", "register", "(", "\"", "rdi", "\"", ")", "int", "value", "(", ")", ";", "address", "mem", "addr", "=", "malloc", "mgr", "malloc", "(", "size", ")", ";", "emu", "helper", "write", "register", "(", "\"", "rax", "\"", ",", "mem", "addr", "get", "offset", "(", ")", ")", ";", "}", "/", "/", "free", "hook", "else", "if", "(", "addr", "equals", "(", "free", "entry", ")", ")", "{", "address", "free", "addr", "=", "get", "address", "(", "emu", "helper", "read", "register", "(", "\"", "rdi", "\"", ")", "long", "value", "(", ")", ")", ";", "malloc", "mgr", "free", "(", "free", "addr", ")", ";", "}", "/", "/", "strlen", "hook", "else", "if", "(", "addr", "equals", "(", "strlen", "entry", ")", ")", "{", "address", "ptr", "=", "get", "address", "(", "emu", "helper", "read", "register", "(", "\"", "rdi", "\"", ")", "long", "value", "(", ")", ")", ";", "int", "len", "=", "0", ";", "while", "(", "emu", "helper", "read", "memory", "byte", "(", "ptr", ")", "!", "=", "0", ")", "{", "+", "+", "len", ";", "ptr", "=", "ptr", "next", "(", ")", ";", "}", "emu", "helper", "write", "register", "(", "\"", "rax", "\"", ",", "len", ")", ";", "}", "/", "/", "use", "string", "hook", "-", "print", "string", "else", "if", "(", "addr", "equals", "(", "use", "string", "entry", ")", ")", "{", "address", "string", "addr", "=", "get", "address", "(", "emu", "helper", "read", "register", "(", "\"", "rdi", "\"", ")", "long", "value", "(", ")", ")", ";", "string", "str", "=", "emu", "helper", "read", "null", "terminated", "string", "(", "string", "addr", ",", "32", ")", ";", "println", "(", "\"", "use", "string", ":", "\"", "+", "str", ")", ";", "/", "/", "output", "string", "argument", "to", "consoles", "}", "/", "/", "unexpected", "else", "{", "if", "(", "emu", "helper", "get", "emulate", "execution", "state", "(", ")", "!", "=", "emulate", "execution", "state", "breakpoint", ")", "{", "/", "/", "assume", "we", "are", "stepping", "and", "simply", "return", "return", ";", "}", "throw", "new", "not", "found", "exception", "(", "\"", "unhandled", "breakpoint", "at", "\"", "+", "addr", ")", ";", "}", "/", "/", "force", "early", "return", "long", "return", "offset", "=", "emu", "helper", "read", "stack", "value", "(", "0", ",", "8", ",", "false", ")", "long", "value", "(", ")", ";", "emu", "helper", "write", "register", "(", "emu", "helper", "get", "p", "c", "register", "(", ")", ",", "return", "offset", ")", ";", "}" ]

[ "returns", "the", "index", "of", "the", "type", "argument", "that", "the", "given", "step", "is", "stepping", "into", "this", "method", "should", "only", "be", "used", "for", "steps", "whose", "value", "is", "{", "@", "link", "#", "type", "argument", "}" ]

[ "public", "int", "get", "step", "argument", "(", "final", "int", "index", ")", "{", "/", "/", "returns", "the", "type", "argument", "index", "of", "the", "path", "element", "of", "the", "given", "index", "return", "type", "path", "container", "[", "type", "path", "offset", "+", "2", "*", "index", "+", "2", "]", ";", "}" ]

[ "executes", "the", "bootstrap", "checks", "if", "the", "node", "has", "the", "transport", "protocol", "bound", "to", "a", "non", "-", "loopback", "interface", "if", "the", "system", "property", "{", "@", "code", "es", "enforce", "bootstrap", "checks", "}", "is", "set", "to", "{", "@", "code", "true", "}", "then", "the", "bootstrap", "checks", "will", "be", "enforced", "regardless", "of", "whether", "or", "not", "the", "transport", "protocol", "is", "bound", "to", "a", "non", "-", "loopback", "interface" ]

[ "static", "void", "check", "(", "final", "bootstrap", "context", "context", ",", "final", "bound", "transport", "address", "bound", "transport", "address", ",", "list", "<", "bootstrap", "check", ">", "additional", "checks", ")", "throws", "node", "validation", "exception", "{", "final", "list", "<", "bootstrap", "check", ">", "built", "in", "checks", "=", "checks", "(", ")", ";", "final", "list", "<", "bootstrap", "check", ">", "combined", "checks", "=", "new", "array", "list", "<", ">", "(", "built", "in", "checks", ")", ";", "combined", "checks", "add", "all", "(", "additional", "checks", ")", ";", "check", "(", "context", ",", "enforce", "limits", "(", "bound", "transport", "address", ",", "discovery", "module", "discovery", "type", "setting", "get", "(", "context", "settings", "(", ")", ")", ")", ",", "collections", "unmodifiable", "list", "(", "combined", "checks", ")", ")", ";", "}" ]

[ "get", "string", "item" ]

[ "public", "string", "get", "string", "item", "(", ")", "{", "return", "string", "item", ";", "}" ]

[ "test", "the", "property", "'", "quantity", "'" ]

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

[ "returns", "a", "substring", "of", "the", "input", "character", "sequence", "that", "omits", "all", "matching", "bmp", "characters", "from", "the", "end", "of", "the", "string", "for", "example", ":", "{", "@", "code", "char", "matcher", "any", "of", "(", "\"", "ab", "\"", ")", "trim", "trailing", "from", "(", "\"", "abacatbab", "\"", ")", "}", "returns", "{", "@", "code", "\"", "abacat", "\"", "}" ]

[ "public", "string", "trim", "trailing", "from", "(", "char", "sequence", "sequence", ")", "{", "int", "len", "=", "sequence", "length", "(", ")", ";", "for", "(", "int", "last", "=", "len", "-", "1", ";", "last", ">", "=", "0", ";", "last", "-", "-", ")", "{", "if", "(", "!", "matches", "(", "sequence", "char", "at", "(", "last", ")", ")", ")", "{", "return", "sequence", "sub", "sequence", "(", "0", ",", "last", "+", "1", ")", "to", "string", "(", ")", ";", "}", "}", "return", "\"", "\"", ";", "}" ]

[ "model", "tests", "for", "user" ]

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

[ "get", "the", "namesystem", "from", "the", "namenode" ]

[ "public", "static", "f", "s", "namesystem", "get", "namesystem", "(", "name", "node", "namenode", ")", "{", "return", "namenode", "get", "namesystem", "(", ")", ";", "}" ]

[ "combines", "predicates", "and", ",", "optimizes", ",", "and", "returns", "null", "if", "the", "result", "is", "always", "false", "the", "expression", "is", "simplified", "on", "the", "assumption", "that", "an", "unknown", "value", "is", "always", "treated", "as", "false", "therefore", "the", "simplified", "expression", "may", "sometimes", "evaluate", "to", "false", "where", "the", "original", "expression", "would", "evaluate", "to", "unknown" ]

[ "public", "rex", "node", "simplify", "filter", "predicates", "(", "iterable", "<", "?", "extends", "rex", "node", ">", "predicates", ")", "{", "final", "rex", "node", "simplified", "ands", "=", "with", "predicate", "elimination", "(", "bug", "calcite", "2401", "fixed", ")", "simplify", "unknown", "as", "false", "(", "rex", "util", "compose", "conjunction", "(", "rex", "builder", ",", "predicates", ")", ")", ";", "if", "(", "simplified", "ands", "is", "always", "false", "(", ")", ")", "{", "return", "null", ";", "}", "/", "/", "remove", "cast", "of", "boolean", "not", "null", "to", "boolean", "or", "vice", "versa", "filter", "accepts", "/", "/", "nullable", "and", "not", "-", "nullable", "conditions", ",", "but", "a", "cast", "might", "get", "in", "the", "way", "of", "/", "/", "other", "rewrites", "return", "remove", "nullability", "cast", "(", "simplified", "ands", ")", ";", "}" ]

[ "multiplies", "this", "vector", "by", "the", "first", "three", "columns", "of", "the", "matrix", ",", "essentially", "only", "applying", "rotation", "and", "scaling" ]

[ "public", "vector", "3", "rot", "(", "final", "matrix", "4", "matrix", ")", "{", "final", "float", "l", "mat", "[", "]", "=", "matrix", "val", ";", "return", "this", "set", "(", "x", "*", "l", "mat", "[", "matrix", "4", "m00", "]", "+", "y", "*", "l", "mat", "[", "matrix", "4", "m01", "]", "+", "z", "*", "l", "mat", "[", "matrix", "4", "m02", "]", ",", "x", "*", "l", "mat", "[", "matrix", "4", "m10", "]", "+", "y", "*", "l", "mat", "[", "matrix", "4", "m11", "]", "+", "z", "*", "l", "mat", "[", "matrix", "4", "m12", "]", ",", "x", "*", "l", "mat", "[", "matrix", "4", "m20", "]", "+", "y", "*", "l", "mat", "[", "matrix", "4", "m21", "]", "+", "z", "*", "l", "mat", "[", "matrix", "4", "m22", "]", ")", ";", "}" ]

[ "returns", "the", "length", "of", "the", "resource", "map" ]

[ "public", "int", "get", "resource", "map", "length", "(", ")", "{", "return", "resource", "map", "length", ";", "}" ]

[ "build", "a", "suitable", "variable", "or", "stack", "reference", "representation", "with", "optional", "scalar", "replacement" ]

[ "private", "object", "get", "variable", "reference", "representation", "(", "reference", "ref", ",", "variable", "var", ",", "scalar", "replaced", "scalar", ")", "{", "if", "(", "var", "!", "=", "null", ")", "{", "/", "/", "relies", "on", "reference", "-", "type", "to", "specify", "read", "/", "write", "access", "variable", "offset", "var", "offset", "=", "new", "variable", "offset", "(", "ref", ",", "var", ")", ";", "var", "offset", "set", "replaced", "element", "(", "replaced", "scalar", ",", "options", "include", "scalar", "reference", "adjustment", ")", ";", "return", "var", "offset", ";", "}", "if", "(", "ref", "is", "stack", "reference", "(", ")", ")", "{", "operand", "representation", "list", "compound", "list", "=", "new", "operand", "representation", "list", "(", ")", ";", "compound", "list", "add", "(", "\"", "stack", "\"", ")", ";", "compound", "list", "add", "(", "'", "[", "'", ")", ";", "compound", "list", "add", "(", "new", "scalar", "(", "32", ",", "(", "(", "stack", "reference", ")", "ref", ")", "get", "stack", "offset", "(", ")", ",", "true", ")", ")", ";", "compound", "list", "add", "(", "'", "]", "'", ")", ";", "return", "add", "scalar", "adjustment", "(", "compound", "list", ",", "ref", "get", "to", "address", "(", ")", ",", "replaced", "scalar", ",", "false", ")", ";", "}", "return", "null", ";", "}" ]

[ "reset", "timer", "for", "a", "session" ]

[ "synchronized", "public", "static", "void", "reset", "timer", "(", "string", "context", "path", ",", "string", "session", ")", "{", "if", "(", "session", "!", "=", "null", ")", "{", "string", "uri", "=", "concat", "(", "context", "path", ",", "session", ")", ";", "session", "timer", "task", "t", "=", "zk", "session", "timers", "remove", "(", "uri", ")", ";", "t", "cancel", "(", ")", ";", "zk", "session", "timers", "put", "(", "uri", ",", "new", "session", "timer", "task", "(", "t", ")", ")", ";", "}", "}" ]

[ "uses", "the", "given", "{", "@", "link", "executor", "service", "}" ]

[ "public", "jersey", "client", "builder", "using", "(", "executor", "service", "executor", "service", ")", "{", "this", "executor", "service", "=", "executor", "service", ";", "return", "this", ";", "}" ]

[ "test", "simplest", "case", "of", "recursion" ]

[ "public", "void", "test", "recursive", "resolve", "simple", "(", ")", "{", "type", "adapter", "<", "foo", "1", ">", "adapter", "=", "new", "gson", "(", ")", "get", "adapter", "(", "foo", "1", "class", ")", ";", "assert", "not", "null", "(", "adapter", ")", ";", "}" ]

[ "returns", "the", "path", "to", "a", "local", "copy", "of", "the", "file", "associated", "with", "the", "provided", "job", "id", "and", "blob", "key", "we", "will", "first", "attempt", "to", "serve", "the", "blob", "from", "the", "local", "storage", "if", "the", "blob", "is", "not", "in", "there", ",", "we", "will", "try", "to", "download", "it", "from", "the", "ha", "store", ",", "or", "directly", "from", "the", "{", "@", "link", "blob", "server", "}" ]

[ "public", "file", "get", "file", "(", "job", "i", "d", "job", "id", ",", "permanent", "blob", "key", "key", ")", "throws", "i", "o", "exception", "{", "check", "not", "null", "(", "job", "id", ")", ";", "return", "get", "file", "internal", "(", "job", "id", ",", "key", ")", ";", "}" ]

[ "default", "not", "null" ]

[ "public", "void", "set", "null", "at", "(", "int", "pos", ")", "{", "set", "null", "bit", "(", "pos", ")", ";", "segment", "put", "long", "(", "get", "field", "offset", "(", "pos", ")", ",", "0l", ")", ";", "}" ]

[ "the", "default", "implementation", "is", "empty", "can", "be", "overridden", "by", "subclasses", "as", "necessary" ]

[ "public", "void", "before", "test", "method", "(", "test", "context", "test", "context", ")", "throws", "exception", "{", "/", "*", "no", "-", "op", "*", "/", "}" ]

[ "<", "code", ">", "optional", "second", "msg", "blah", "=", "2", ";", "<", "code", ">" ]

[ "public", "boolean", "has", "blah", "(", ")", "{", "return", "(", "(", "bit", "field", "0", "&", "0x", "0", "0", "0", "0", "0", "0", "0", "2", ")", "=", "=", "0x", "0", "0", "0", "0", "0", "0", "0", "2", ")", ";", "}" ]

[ "called", "from", "within", "{", "@", "link", "#", "render", "frame", "}", "to", "let", "the", "caller", "know", "that", "while", "trying", "generate", "the", "requested", "frame", ",", "an", "earlier", "frame", "was", "generated", "this", "allows", "the", "caller", "to", "optionally", "cache", "the", "intermediate", "result", "the", "caller", "must", "copy", "the", "bitmap", "if", "it", "wishes", "to", "cache", "it", "as", "{", "@", "link", "#", "render", "frame", "}", "will", "continue", "using", "it", "generate", "the", "requested", "frame" ]

[ "void", "on", "intermediate", "result", "(", "int", "frame", "number", ",", "bitmap", "bitmap", ")", ";" ]

[ "retrieves", "a", "blob", "from", "the", "ha", "store", "to", "a", "{", "@", "link", "blob", "server", "}", "which", "cannot", "create", "incoming", "files", "file", "transfers", "should", "fail" ]

[ "public", "void", "test", "get", "fails", "incoming", "for", "job", "ha", "(", ")", "throws", "i", "o", "exception", "{", "assume", "true", "(", "!", "operating", "system", "is", "windows", "(", ")", ")", ";", "/", "/", "set", "writable", "doesn", "'", "t", "work", "on", "windows", "final", "job", "i", "d", "job", "id", "=", "new", "job", "i", "d", "(", ")", ";", "final", "configuration", "config", "=", "new", "configuration", "(", ")", ";", "config", "set", "string", "(", "high", "availability", "options", "ha", "mode", ",", "\"", "zookeeper", "\"", ")", ";", "config", "set", "string", "(", "blob", "server", "options", "storage", "directory", ",", "temporary", "folder", "new", "folder", "(", ")", "get", "absolute", "path", "(", ")", ")", ";", "config", "set", "string", "(", "high", "availability", "options", "ha", "storage", "path", ",", "temporary", "folder", "new", "folder", "(", ")", "get", "path", "(", ")", ")", ";", "blob", "store", "service", "blob", "store", "=", "null", ";", "try", "{", "blob", "store", "=", "blob", "utils", "create", "blob", "store", "from", "config", "(", "config", ")", ";", "file", "temp", "file", "dir", "=", "null", ";", "try", "(", "blob", "server", "server", "=", "new", "blob", "server", "(", "config", ",", "blob", "store", ")", ")", "{", "server", "start", "(", ")", ";", "/", "/", "store", "the", "data", "on", "the", "server", "(", "and", "blob", "store", ")", ",", "remove", "from", "local", "store", "byte", "[", "]", "data", "=", "new", "byte", "[", "2000000", "]", ";", "rnd", "next", "bytes", "(", "data", ")", ";", "blob", "key", "blob", "key", "=", "put", "(", "server", ",", "job", "id", ",", "data", ",", "permanent", "blob", ")", ";", "assert", "true", "(", "server", "get", "storage", "location", "(", "job", "id", ",", "blob", "key", ")", "delete", "(", ")", ")", ";", "/", "/", "make", "sure", "the", "blob", "server", "cannot", "create", "any", "files", "in", "its", "storage", "dir", "temp", "file", "dir", "=", "server", "create", "temporary", "filename", "(", ")", "get", "parent", "file", "(", ")", ";", "assert", "true", "(", "temp", "file", "dir", "set", "executable", "(", "true", ",", "false", ")", ")", ";", "assert", "true", "(", "temp", "file", "dir", "set", "readable", "(", "true", ",", "false", ")", ")", ";", "assert", "true", "(", "temp", "file", "dir", "set", "writable", "(", "false", ",", "false", ")", ")", ";", "/", "/", "request", "the", "file", "from", "the", "blob", "store", "exception", "expect", "(", "i", "o", "exception", "class", ")", ";", "exception", "expect", "message", "(", "\"", "permission", "denied", "\"", ")", ";", "try", "{", "get", "(", "server", ",", "job", "id", ",", "blob", "key", ")", ";", "}", "finally", "{", "hash", "set", "<", "string", ">", "expected", "dirs", "=", "new", "hash", "set", "<", ">", "(", ")", ";", "expected", "dirs", "add", "(", "\"", "incoming", "\"", ")", ";", "expected", "dirs", "add", "(", "job", "dir", "prefix", "+", "job", "id", ")", ";", "/", "/", "only", "the", "incoming", "and", "job", "directory", "should", "exist", "(", "no", "job", "directory", "!", ")", "file", "storage", "dir", "=", "temp", "file", "dir", "get", "parent", "file", "(", ")", ";", "string", "[", "]", "actual", "dirs", "=", "storage", "dir", "list", "(", ")", ";", "assert", "not", "null", "(", "actual", "dirs", ")", ";", "assert", "equals", "(", "expected", "dirs", ",", "new", "hash", "set", "<", ">", "(", "arrays", "as", "list", "(", "actual", "dirs", ")", ")", ")", ";", "/", "/", "job", "directory", "should", "be", "empty", "file", "job", "dir", "=", "new", "file", "(", "temp", "file", "dir", "get", "parent", "file", "(", ")", ",", "job", "dir", "prefix", "+", "job", "id", ")", ";", "assert", "array", "equals", "(", "new", "string", "[", "]", "{", "}", ",", "job", "dir", "list", "(", ")", ")", ";", "}", "}", "finally", "{", "/", "/", "set", "writable", "again", "to", "make", "sure", "we", "can", "remove", "the", "directory", "if", "(", "temp", "file", "dir", "!", "=", "null", ")", "{", "/", "/", "noinspection", "result", "of", "method", "call", "ignored", "temp", "file", "dir", "set", "writable", "(", "true", ",", "false", ")", ";", "}", "}", "}", "finally", "{", "if", "(", "blob", "store", "!", "=", "null", ")", "{", "blob", "store", "close", "and", "cleanup", "all", "data", "(", ")", ";", "}", "}", "}" ]

[ "active", "the", "selected", "profile", "task", "to", "execution", "task", ",", "and", "start", "a", "removal", "task", "for", "it" ]

[ "private", "synchronized", "void", "process", "profile", "task", "(", "profile", "task", "task", ")", "{", "/", "/", "make", "sure", "prev", "profile", "task", "already", "stopped", "stop", "current", "profile", "task", "(", "task", "execution", "context", "get", "(", ")", ")", ";", "/", "/", "make", "stop", "task", "schedule", "and", "task", "context", "final", "profile", "task", "execution", "context", "current", "started", "task", "context", "=", "new", "profile", "task", "execution", "context", "(", "task", ")", ";", "task", "execution", "context", "set", "(", "current", "started", "task", "context", ")", ";", "/", "/", "start", "profiling", "this", "task", "current", "started", "task", "context", "start", "profiling", "(", "profile", "executor", ")", ";", "profile", "task", "schedule", "schedule", "(", "(", ")", "-", ">", "stop", "current", "profile", "task", "(", "current", "started", "task", "context", ")", ",", "task", "get", "duration", "(", ")", ",", "time", "unit", "minutes", ")", ";", "}" ]

[ "increase", "the", "size", "of", "this", "d", "b", "buffer", "object" ]

[ "private", "void", "grow", "(", "int", "new", "size", ",", "boolean", "preserve", "data", ")", "throws", "i", "o", "exception", "{", "int", "old", "size", "=", "this", "size", ";", "this", "size", "=", "new", "size", ";", "/", "/", "currently", "using", "a", "single", "data", "buffer", "if", "(", "data", "buffer", "id", "table", "length", "=", "=", "1", ")", "{", "/", "/", "transition", "to", "an", "indexed", "chained", "buffer", "if", "(", "new", "size", ">", "data", "space", ")", "{", "data", "buffer", "first", "buffer", "=", "buffer", "mgr", "get", "buffer", "(", "first", "buffer", "id", ")", ";", "data", "buffer", "new", "first", "data", "buf", "=", "null", ";", "try", "{", "/", "/", "save", "data", "in", "new", "data", "buffer", "if", "(", "preserve", "data", ")", "{", "new", "first", "data", "buf", "=", "buffer", "mgr", "create", "buffer", "(", ")", ";", "new", "first", "data", "buf", "copy", "(", "data", "base", "offset", "indexed", ",", "first", "buffer", ",", "data", "base", "offset", "nonindexed", ",", "old", "size", ")", ";", "int", "indexed", "data", "space", "=", "new", "first", "data", "buf", "length", "(", ")", "-", "data", "base", "offset", "indexed", ";", "byte", "[", "]", "zero", "bytes", "=", "new", "byte", "[", "indexed", "data", "space", "-", "old", "size", "]", ";", "if", "(", "use", "x", "o", "r", "mask", ")", "{", "int", "offset", "=", "old", "size", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "zero", "bytes", "length", ";", "i", "+", "+", ",", "offset", "+", "+", ")", "{", "zero", "bytes", "[", "i", "]", "=", "xor", "mask", "byte", "(", "offset", ",", "zero", "bytes", "[", "i", "]", ")", ";", "}", "}", "new", "first", "data", "buf", "put", "(", "data", "base", "offset", "indexed", "+", "old", "size", ",", "zero", "bytes", ")", ";", "}", "/", "/", "establish", "index", "for", "d", "b", "buffer", "create", "index", "(", "first", "buffer", ")", ";", "first", "buffer", "=", "null", ";", "/", "/", "establish", "first", "data", "buffer", "if", "(", "preserve", "data", ")", "{", "add", "buffer", "(", "0", ",", "new", "first", "data", "buf", ")", ";", "}", "}", "finally", "{", "if", "(", "first", "buffer", "!", "=", "null", ")", "{", "buffer", "mgr", "release", "buffer", "(", "first", "buffer", ")", ";", "}", "if", "(", "new", "first", "data", "buf", "!", "=", "null", ")", "{", "buffer", "mgr", "release", "buffer", "(", "new", "first", "data", "buf", ")", ";", "}", "}", "return", ";", "}", "/", "/", "adjust", "stored", "buffer", "size", "data", "buffer", "buffer", "=", "buffer", "mgr", "get", "buffer", "(", "first", "buffer", "id", ")", ";", "buffer", "put", "int", "(", "data", "length", "offset", ",", "get", "obfuscation", "data", "length", "field", "value", "(", ")", ")", ";", "buffer", "mgr", "release", "buffer", "(", "buffer", ")", ";", "}", "/", "/", "already", "using", "an", "index", "-", "existing", "data", "is", "always", "preserved", "else", "{", "byte", "[", "]", "empty", "index", "data", "=", "new", "byte", "[", "indexes", "per", "buffer", "*", "id", "size", "]", ";", "arrays", "fill", "(", "empty", "index", "data", ",", "(", "byte", ")", "0xff", ")", ";", "/", "/", "compute", "index", "counts", "int", "new", "index", "count", "=", "(", "(", "new", "size", "-", "1", ")", "/", "data", "space", ")", "+", "1", ";", "int", "new", "index", "buffer", "count", "=", "(", "(", "new", "index", "count", "-", "1", ")", "/", "indexes", "per", "buffer", ")", "+", "1", ";", "/", "/", "grow", "data", "buffer", "id", "table", "int", "[", "]", "new", "data", "buffer", "id", "table", "=", "new", "int", "[", "new", "index", "count", "]", ";", "system", "arraycopy", "(", "data", "buffer", "id", "table", ",", "0", ",", "new", "data", "buffer", "id", "table", ",", "0", ",", "data", "buffer", "id", "table", "length", ")", ";", "arrays", "fill", "(", "new", "data", "buffer", "id", "table", ",", "data", "buffer", "id", "table", "length", ",", "new", "index", "count", ",", "-", "1", ")", ";", "data", "buffer", "id", "table", "=", "new", "data", "buffer", "id", "table", ";", "/", "/", "grow", "index", "buffer", "id", "table", "int", "old", "index", "buffer", "count", "=", "index", "buffer", "id", "table", "length", ";", "if", "(", "old", "index", "buffer", "count", "<", "new", "index", "buffer", "count", ")", "{", "int", "[", "]", "new", "index", "buffer", "id", "table", "=", "new", "int", "[", "new", "index", "buffer", "count", "]", ";", "system", "arraycopy", "(", "index", "buffer", "id", "table", ",", "0", ",", "new", "index", "buffer", "id", "table", ",", "0", ",", "old", "index", "buffer", "count", ")", ";", "arrays", "fill", "(", "new", "index", "buffer", "id", "table", ",", "old", "index", "buffer", "count", ",", "new", "index", "buffer", "count", ",", "-", "1", ")", ";", "index", "buffer", "id", "table", "=", "new", "index", "buffer", "id", "table", ";", "/", "/", "allocate", "additional", "index", "buffers", "data", "buffer", "index", "buffer", "=", "buffer", "mgr", "get", "buffer", "(", "index", "buffer", "id", "table", "[", "old", "index", "buffer", "count", "-", "1", "]", ")", ";", "for", "(", "int", "i", "=", "old", "index", "buffer", "count", ";", "i", "<", "new", "index", "buffer", "count", ";", "i", "+", "+", ")", "{", "index", "buffer", "=", "append", "index", "buffer", "(", "index", "buffer", ")", ";", "index", "buffer", "put", "(", "index", "base", "offset", ",", "empty", "index", "data", ")", ";", "/", "/", "initialize", "to", "all", "-", "1", "'", "s", "index", "buffer", "id", "table", "[", "i", "]", "=", "index", "buffer", "get", "id", "(", ")", ";", "}", "buffer", "mgr", "release", "buffer", "(", "index", "buffer", ")", ";", "}", "/", "/", "adjust", "stored", "buffer", "size", "data", "buffer", "buffer", "=", "buffer", "mgr", "get", "buffer", "(", "first", "buffer", "id", ")", ";", "buffer", "put", "int", "(", "data", "length", "offset", ",", "get", "obfuscation", "data", "length", "field", "value", "(", ")", ")", ";", "buffer", "mgr", "release", "buffer", "(", "buffer", ")", ";", "}", "}" ]

[ "reads", "restore", "status", "from", "stream", "input" ]

[ "public", "static", "shard", "restore", "status", "read", "shard", "restore", "status", "(", "stream", "input", "in", ")", "throws", "i", "o", "exception", "{", "shard", "restore", "status", "shard", "snapshot", "status", "=", "new", "shard", "restore", "status", "(", ")", ";", "shard", "snapshot", "status", "read", "from", "(", "in", ")", ";", "return", "shard", "snapshot", "status", ";", "}" ]

[ "get", "name", "wrapped", "array" ]

[ "public", "list", "<", "integer", ">", "get", "name", "wrapped", "array", "(", ")", "{", "return", "name", "wrapped", "array", ";", "}" ]

[ "the", "sink", "node", "making", "the", "request", "<", "code", ">", "istio", "mcp", "v", "1alpha", "1", "sink", "node", "sink", "node", "=", "1", ";", "<", "code", ">" ]

[ "public", "com", "alibaba", "nacos", "istio", "model", "mcp", "sink", "node", "or", "builder", "get", "sink", "node", "or", "builder", "(", ")", "{", "if", "(", "sink", "node", "builder", "!", "=", "null", ")", "{", "return", "sink", "node", "builder", "get", "message", "or", "builder", "(", ")", ";", "}", "else", "{", "return", "sink", "node", "=", "=", "null", "?", "com", "alibaba", "nacos", "istio", "model", "mcp", "sink", "node", "get", "default", "instance", "(", ")", ":", "sink", "node", ";", "}", "}" ]

[ "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", "\"", ")", ";", "}" ]

[ "test", "the", "property", "'", "password", "'" ]

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

[ "get", "user", "by", "user", "name" ]

[ "public", "void", "get", "user", "by", "name", "test", "(", ")", "{", "string", "username", "=", "null", ";", "user", "response", "=", "api", "get", "user", "by", "name", "(", "username", ")", "block", "(", ")", ";", "/", "/", "todo", ":", "test", "validations", "}" ]

[ "required", "one", "or", "more", "hosts", "exposed", "by", "this", "gateway", "while", "typically", "applicable", "to", "http", "services", ",", "it", "can", "also", "be", "used", "for", "tcp", "services", "using", "tls", "with", "sni", "a", "host", "is", "specified", "as", "a", "`", "dns", "name", "`", "with", "an", "optional", "`", "namespace", "`", "prefix", "the", "`", "dns", "name", "`", "should", "be", "specified", "using", "fqdn", "format", ",", "optionally", "including", "a", "wildcard", "character", "in", "the", "left", "-", "most", "component", "(", "e", "g", ",", "`", "prod", "&", "#", "42", ";", "example", "com", "`", ")", "set", "the", "`", "dns", "name", "`", "to", "`", "`", "to", "select", "all", "`", "virtual", "service", "`", "hosts", "from", "the", "specified", "namespace", "(", "e", "g", ",", "`", "prod", "&", "#", "42", ";", "`", ")", "the", "`", "namespace", "`", "can", "be", "set", "to", "`", "`", "or", "`", "`", ",", "representing", "any", "or", "the", "current", "namespace", ",", "respectively", "for", "example", ",", "`", "&", "#", "47", ";", "foo", "example", "com", "`", "selects", "the", "service", "from", "any", "available", "namespace", "while", "`", "foo", "example", "com", "`", "only", "selects", "the", "service", "from", "the", "namespace", "of", "the", "sidecar", "the", "default", ",", "if", "no", "`", "namespace", "`", "is", "specified", ",", "is", "`", "&", "#", "47", ";", "`", ",", "that", "is", ",", "select", "services", "from", "any", "namespace", "any", "associated", "`", "destination", "rule", "`", "in", "the", "selected", "namespace", "will", "also", "be", "used", "a", "`", "virtual", "service", "`", "must", "be", "bound", "to", "the", "gateway", "and", "must", "have", "one", "or", "more", "hosts", "that", "match", "the", "hosts", "specified", "in", "a", "server", "the", "match", "could", "be", "an", "exact", "match", "or", "a", "suffix", "match", "with", "the", "server", "'", "s", "hosts", "for", "example", ",", "if", "the", "server", "'", "s", "hosts", "specifies", "`", "example", "com", "`", ",", "a", "`", "virtual", "service", "`", "with", "hosts", "`", "dev", "example", "com", "`", "or", "`", "prod", "example", "com", "`", "will", "match", "however", ",", "a", "`", "virtual", "service", "`", "with", "host", "`", "example", "com", "`", "or", "`", "newexample", "com", "`", "will", "not", "match", "note", ":", "only", "virtual", "services", "exported", "to", "the", "gateway", "'", "s", "namespace", "(", "e", "g", ",", "`", "export", "to", "`", "value", "of", "`", "`", ")", "can", "be", "referenced", "private", "configurations", "(", "e", "g", ",", "`", "export", "to", "`", "set", "to", "`", "`", ")", "will", "not", "be", "available", "refer", "to", "the", "`", "export", "to", "`", "setting", "in", "`", "virtual", "service", "`", ",", "`", "destination", "rule", "`", ",", "and", "`", "service", "entry", "`", "configurations", "for", "details", "<", "code", ">", "repeated", "string", "hosts", "=", "2", ";", "<", "code", ">" ]

[ "public", "com", "google", "protobuf", "protocol", "string", "list", "get", "hosts", "list", "(", ")", "{", "return", "hosts", ";", "}" ]

[ "gets", "root", "element", "from", "resource" ]

[ "public", "static", "element", "get", "root", "element", "from", "(", "final", "input", "stream", "metadata", "resource", ",", "final", "open", "saml", "config", "bean", "config", "bean", ")", "{", "val", "document", "=", "config", "bean", "get", "parser", "pool", "(", ")", "parse", "(", "metadata", "resource", ")", ";", "return", "document", "get", "document", "element", "(", ")", ";", "}" ]

[ "set", "the", "{", "@", "link", "player", "control", "view", "visibility", "listener", "}" ]

[ "public", "void", "set", "controller", "visibility", "listener", "(", "@", "nullable", "player", "control", "view", "visibility", "listener", "listener", ")", "{", "assertions", "check", "state", "not", "null", "(", "controller", ")", ";", "if", "(", "this", "controller", "visibility", "listener", "=", "=", "listener", ")", "{", "return", ";", "}", "if", "(", "this", "controller", "visibility", "listener", "!", "=", "null", ")", "{", "controller", "remove", "visibility", "listener", "(", "this", "controller", "visibility", "listener", ")", ";", "}", "this", "controller", "visibility", "listener", "=", "listener", ";", "if", "(", "listener", "!", "=", "null", ")", "{", "controller", "add", "visibility", "listener", "(", "listener", ")", ";", "}", "}" ]

[ "call", "this", "from", "your", "{", "@", "link", "activity", "}", "'", "s", "{", "@", "link", "activity", "#", "on", "activity", "result", "(", "int", ",", "int", ",", "intent", ")", "}", "method" ]

[ "public", "static", "intent", "result", "parse", "activity", "result", "(", "int", "request", "code", ",", "int", "result", "code", ",", "intent", "intent", ")", "{", "if", "(", "request", "code", "=", "=", "request", "code", ")", "{", "if", "(", "result", "code", "=", "=", "activity", "result", "ok", ")", "{", "string", "contents", "=", "intent", "get", "string", "extra", "(", "\"", "scan", "result", "\"", ")", ";", "string", "format", "name", "=", "intent", "get", "string", "extra", "(", "\"", "scan", "result", "format", "\"", ")", ";", "byte", "[", "]", "raw", "bytes", "=", "intent", "get", "byte", "array", "extra", "(", "\"", "scan", "result", "bytes", "\"", ")", ";", "int", "intent", "orientation", "=", "intent", "get", "int", "extra", "(", "\"", "scan", "result", "orientation", "\"", ",", "integer", "min", "value", ")", ";", "integer", "orientation", "=", "intent", "orientation", "=", "=", "integer", "min", "value", "?", "null", ":", "intent", "orientation", ";", "string", "error", "correction", "level", "=", "intent", "get", "string", "extra", "(", "\"", "scan", "result", "error", "correction", "level", "\"", ")", ";", "return", "new", "intent", "result", "(", "contents", ",", "format", "name", ",", "raw", "bytes", ",", "orientation", ",", "error", "correction", "level", ")", ";", "}", "return", "new", "intent", "result", "(", ")", ";", "}", "return", "null", ";", "}" ]

[ "returns", "an", "immutable", "list", "containing", "the", "given", "elements", ",", "in", "order" ]

[ "public", "static", "<", "e", ">", "immutable", "list", "<", "e", ">", "of", "(", "e", "e", "1", ",", "e", "e", "2", ",", "e", "e", "3", ",", "e", "e", "4", ",", "e", "e", "5", ",", "e", "e", "6", ",", "e", "e", "7", ",", "e", "e", "8", ",", "e", "e", "9", ",", "e", "e", "1", "0", ")", "{", "return", "construct", "(", "e", "1", ",", "e", "2", ",", "e", "3", ",", "e", "4", ",", "e", "5", ",", "e", "6", ",", "e", "7", ",", "e", "8", ",", "e", "9", ",", "e", "1", "0", ")", ";", "}" ]

[ "translate", "an", "exception", "raised", "in", "an", "operation", "into", "an", "i", "o", "exception", "the", "specific", "type", "of", "i", "o", "exception", "depends", "on", "the", "class", "of", "{", "@", "link", "obs", "exception", "}", "passed", "in", ",", "and", "any", "status", "codes", "included", "in", "the", "operation", "that", "is", ":", "http", "error", "codes", "are", "examined", "and", "can", "be", "used", "to", "build", "a", "more", "specific", "response" ]

[ "static", "i", "o", "exception", "translate", "exception", "(", "final", "string", "operation", ",", "final", "path", "path", ",", "final", "obs", "exception", "exception", ")", "{", "return", "translate", "exception", "(", "operation", ",", "path", "to", "string", "(", ")", ",", "exception", ")", ";", "}" ]

[ "get", "the", "maximum", "memory", "size", "am", "can", "use", "in", "mb" ]

[ "public", "long", "get", "max", "a", "m", "share", "m", "b", "(", ")", "{", "return", "max", "a", "m", "share", "m", "b", "value", "(", ")", ";", "}" ]

[ "sets", "the", "configurations", "not", "thread", "-", "safe", "do", "not", "call", "except", "from", "tests", "!" ]

[ "public", "void", "set", "configurations", "for", "testing", "(", "event", "handler", "event", "handler", ",", "build", "configuration", "collection", "configurations", ")", "{", "skyframe", "build", "view", "set", "configurations", "(", "event", "handler", ",", "configurations", ",", "/", "*", "max", "differences", "to", "show", "*", "/", "-", "1", ")", ";", "}" ]

[ "computes", "a", "data", "move", "from", "the", "largest", "disk", "we", "have", "to", "smallest", "disk" ]

[ "private", "step", "compute", "move", "(", "disk", "balancer", "volume", "set", "current", "set", ",", "disk", "balancer", "volume", "low", "volume", ",", "disk", "balancer", "volume", "high", "volume", ")", "{", "/", "/", "compute", "how", "many", "bytes", "we", "can", "move", "first", "compute", "the", "maximum", "that", "/", "/", "low", "volume", "can", "receive", ",", "then", "compute", "maximum", "high", "volume", "can", "give", "/", "/", "then", "take", "the", "minimum", "of", "those", "two", "numbers", "that", "is", "the", "bytes", "to", "move", "long", "max", "low", "volume", "can", "receive", "=", "(", "long", ")", "(", "(", "current", "set", "get", "ideal", "used", "(", ")", "*", "low", "volume", "compute", "effective", "capacity", "(", ")", ")", "-", "low", "volume", "get", "used", "(", ")", ")", ";", "/", "/", "this", "disk", "cannot", "take", "any", "more", "data", "from", "any", "disk", "/", "/", "remove", "it", "from", "our", "computation", "matrix", "if", "(", "max", "low", "volume", "can", "receive", "<", "=", "0", ")", "{", "log", "debug", "(", "\"", "{", "}", "skipping", "disk", "from", "computation", "maximum", "data", "size", "\"", "+", "\"", "achieved", "\"", ",", "low", "volume", "get", "path", "(", ")", ")", ";", "skip", "volume", "(", "current", "set", ",", "low", "volume", ")", ";", "}", "long", "max", "high", "volume", "can", "give", "=", "high", "volume", "get", "used", "(", ")", "-", "(", "long", ")", "(", "current", "set", "get", "ideal", "used", "(", ")", "*", "high", "volume", "compute", "effective", "capacity", "(", ")", ")", ";", "/", "/", "this", "volume", "cannot", "give", "any", "more", "data", ",", "remove", "it", "from", "the", "/", "/", "computation", "matrix", "if", "(", "max", "high", "volume", "can", "give", "<", "=", "0", ")", "{", "log", "debug", "(", "\"", "{", "}", "skipping", "disk", "from", "computation", "minimum", "data", "size", "\"", "+", "\"", "achieved", "\"", ",", "high", "volume", "get", "path", "(", ")", ")", ";", "skip", "volume", "(", "current", "set", ",", "high", "volume", ")", ";", "}", "long", "bytes", "to", "move", "=", "math", "min", "(", "max", "low", "volume", "can", "receive", ",", "max", "high", "volume", "can", "give", ")", ";", "step", "next", "step", "=", "null", ";", "if", "(", "bytes", "to", "move", ">", "0", ")", "{", "/", "/", "create", "a", "new", "step", "next", "step", "=", "new", "move", "step", "(", "high", "volume", ",", "current", "set", "get", "ideal", "used", "(", ")", ",", "low", "volume", ",", "bytes", "to", "move", ",", "current", "set", "get", "set", "i", "d", "(", ")", ")", ";", "log", "debug", "(", "\"", "next", "step", ":", "{", "}", "\"", ",", "next", "step", ")", ";", "}", "return", "next", "step", ";", "}" ]

[ "guaranteed", "to", "throw", "an", "exception", "and", "leave", "the", "map", "unmodified" ]

[ "public", "final", "v", "put", "(", "k", "k", ",", "v", "v", ")", "{", "throw", "new", "unsupported", "operation", "exception", "(", ")", ";", "}" ]

[ "get", "the", "source", "of", "the", "mapping", "or", "{", "@", "code", "null", "}" ]

[ "annotation", "type", "mapping", "get", "source", "(", ")", "{", "return", "this", "source", ";", "}" ]

[ "sets", "the", "operator", "to", "use", "when", "using", "a", "boolean", "query", "defaults", "to", "{", "@", "code", "or", "}" ]

[ "public", "match", "bool", "prefix", "query", "builder", "operator", "(", "operator", "operator", ")", "{", "if", "(", "operator", "=", "=", "null", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "[", "\"", "+", "name", "+", "\"", "]", "requires", "operator", "to", "be", "non", "-", "null", "\"", ")", ";", "}", "this", "operator", "=", "operator", ";", "return", "this", ";", "}" ]

[ "add", "a", "new", "value", "to", "the", "histogram", "note", "that", "the", "value", "will", "be", "clipped", "to", "the", "maximum", "value", "available", "in", "the", "histogram", "instance", "this", "method", "is", "provided", "for", "convenience", ",", "but", "handles", "the", "same", "numeric", "range", "as", "the", "method", "which", "takes", "an", "int" ]

[ "public", "void", "add", "(", "long", "value", ")", "{", "if", "(", "value", ">", "integer", "max", "value", ")", "{", "add", "(", "integer", "max", "value", ")", ";", "}", "else", "if", "(", "value", "<", "integer", "min", "value", ")", "{", "add", "(", "integer", "min", "value", ")", ";", "}", "else", "{", "add", "(", "(", "int", ")", "value", ")", ";", "}", "}" ]

[ "computes", "the", "set", "of", "conflicting", "or", "ambiguous", "alternatives", "from", "a", "configuration", "set", ",", "if", "that", "information", "was", "not", "already", "provided", "by", "the", "parser" ]

[ "protected", "bit", "set", "get", "conflicting", "alts", "(", "bit", "set", "reported", "alts", ",", "a", "t", "n", "config", "set", "configs", ")", "{", "if", "(", "reported", "alts", "!", "=", "null", ")", "{", "return", "reported", "alts", ";", "}", "bit", "set", "result", "=", "new", "bit", "set", "(", ")", ";", "for", "(", "a", "t", "n", "config", "config", ":", "configs", ")", "{", "result", "set", "(", "config", "alt", ")", ";", "}", "return", "result", ";", "}" ]

[ "get", "name", "boolean" ]

[ "public", "boolean", "get", "name", "boolean", "(", ")", "{", "return", "name", "boolean", ";", "}" ]

[ "if", "this", "future", "has", "been", "cancelled", "(", "and", "possibly", "interrupted", ")", ",", "cancels", "(", "and", "possibly", "interrupts", ")", "the", "given", "future", "(", "if", "available", ")" ]

[ "final", "void", "maybe", "propagate", "cancellation", "to", "(", "@", "nullable", "future", "<", "?", ">", "related", ")", "{", "if", "(", "related", "!", "=", "null", "&", "is", "cancelled", "(", ")", ")", "{", "related", "cancel", "(", "was", "interrupted", "(", ")", ")", ";", "}", "}" ]

[ "initializes", "the", "filter", "this", "implementation", "is", "a", "nop" ]

[ "public", "void", "init", "(", "filter", "config", "filter", "config", ")", "throws", "servlet", "exception", "{", "}" ]

[ "{", "@", "inherit", "doc", "}" ]

[ "public", "string", "get", "id", "(", ")", "{", "return", "this", "id", ";", "}" ]

[ "return", "the", "{", "@", "link", "min", "and", "max", "}", "indexed", "value", "from", "the", "provided", "{", "@", "link", "field", "sort", "builder", "}", "or", "<", "code", ">", "null", "<", "code", ">", "if", "unknown", "the", "value", "can", "be", "extracted", "on", "non", "-", "nested", "indexed", "mapped", "fields", "of", "type", "keyword", ",", "numeric", "or", "date", ",", "other", "fields", "and", "configurations", "return", "<", "code", ">", "null", "<", "code", ">" ]

[ "public", "static", "min", "and", "max", "<", "?", ">", "get", "min", "max", "or", "null", "(", "query", "shard", "context", "context", ",", "field", "sort", "builder", "sort", "builder", ")", "throws", "i", "o", "exception", "{", "sort", "and", "formats", "sort", "=", "sort", "builder", "build", "sort", "(", "collections", "singleton", "list", "(", "sort", "builder", ")", ",", "context", ")", "get", "(", ")", ";", "sort", "field", "sort", "field", "=", "sort", "sort", "get", "sort", "(", ")", "[", "0", "]", ";", "if", "(", "sort", "field", "get", "field", "(", ")", "=", "=", "null", ")", "{", "return", "null", ";", "}", "index", "reader", "reader", "=", "context", "get", "index", "reader", "(", ")", ";", "mapped", "field", "type", "field", "type", "=", "context", "get", "field", "type", "(", "sort", "field", "get", "field", "(", ")", ")", ";", "if", "(", "reader", "=", "=", "null", "|", "|", "(", "field", "type", "=", "=", "null", "|", "|", "field", "type", "is", "searchable", "(", ")", "=", "=", "false", ")", ")", "{", "return", "null", ";", "}", "switch", "(", "index", "sort", "config", "get", "sort", "field", "type", "(", "sort", "field", ")", ")", "{", "case", "long", ":", "case", "int", ":", "case", "double", ":", "case", "float", ":", "return", "extract", "numeric", "min", "and", "max", "(", "reader", ",", "sort", "field", ",", "field", "type", ",", "sort", "builder", ")", ";", "case", "string", ":", "case", "string", "val", ":", "if", "(", "field", "type", "instanceof", "keyword", "field", "mapper", "keyword", "field", "type", ")", "{", "terms", "terms", "=", "multi", "terms", "get", "terms", "(", "reader", ",", "field", "type", "name", "(", ")", ")", ";", "if", "(", "terms", "=", "=", "null", ")", "{", "return", "null", ";", "}", "return", "terms", "get", "min", "(", ")", "!", "=", "null", "?", "new", "min", "and", "max", "<", ">", "(", "terms", "get", "min", "(", ")", ",", "terms", "get", "max", "(", ")", ")", ":", "null", ";", "}", "break", ";", "}", "return", "null", ";", "}" ]

[ "returns", "the", "text", "direction", "of", "the", "legend" ]

[ "public", "legend", "direction", "get", "direction", "(", ")", "{", "return", "m", "direction", ";", "}" ]

[ "asynchronously", "puts", "an", "stored", "script", "using", "the", "scripting", "api", "see", "<", "a", "href", "=", "\"", "https", ":", "www", "elastic", "coguideenelasticsearchreferencecurrentmodules", "-", "scripting", "-", "using", "html", "\"", ">", "scripting", "api", "on", "elastic", "co" ]

[ "public", "cancellable", "put", "script", "async", "(", "put", "stored", "script", "request", "put", "stored", "script", "request", ",", "request", "options", "options", ",", "action", "listener", "<", "acknowledged", "response", ">", "listener", ")", "{", "return", "perform", "request", "async", "and", "parse", "entity", "(", "put", "stored", "script", "request", ",", "request", "converters", ":", ":", "put", "script", ",", "options", ",", "acknowledged", "response", ":", ":", "from", "x", "content", ",", "listener", ",", "empty", "set", "(", ")", ")", ";", "}" ]

[ "returns", "the", "node", "with", "the", "specified", "value", ",", "or", "null" ]

[ "public", "@", "null", "n", "find", "node", "(", "v", "value", ")", "{", "if", "(", "value", "=", "=", "null", ")", "throw", "new", "illegal", "argument", "exception", "(", "\"", "value", "cannot", "be", "null", "\"", ")", ";", "return", "(", "n", ")", "find", "node", "(", "root", "nodes", ",", "value", ")", ";", "}" ]

[ "is", "this", "executor", "ready", "to", "accept", "some", "tasks", "?" ]

[ "public", "boolean", "is", "available", "(", ")", "{", "return", "work", "unit", "=", "=", "null", "&", "&", "!", "executor", "get", "owner", "(", ")", "is", "offline", "(", ")", "&", "&", "executor", "get", "owner", "(", ")", "is", "accepting", "tasks", "(", ")", ";", "}" ]

[ "returns", "the", "{", "@", "link", "cause", "}", "s", "that", "triggered", "a", "build", "if", "a", "build", "sits", "in", "the", "queue", "for", "a", "long", "time", ",", "multiple", "build", "requests", "made", "during", "this", "period", "are", "all", "rolled", "up", "into", "one", "build", ",", "hence", "this", "method", "may", "return", "a", "list" ]

[ "public", "@", "non", "null", "list", "<", "cause", ">", "get", "causes", "(", ")", "{", "cause", "action", "a", "=", "get", "action", "(", "cause", "action", "class", ")", ";", "if", "(", "a", "=", "=", "null", ")", "return", "collections", "empty", "list", "(", ")", ";", "return", "collections", "unmodifiable", "list", "(", "a", "get", "causes", "(", ")", ")", ";", "}" ]

[ "returns", "the", "library", "family", "name" ]

[ "public", "string", "get", "library", "family", "name", "(", ")", "{", "return", "record", "get", "string", "(", "library", "family", "name", "col", ")", ";", "}" ]

[ "get", "photo", "urls" ]

[ "public", "set", "<", "string", ">", "get", "photo", "urls", "(", ")", "{", "return", "photo", "urls", ";", "}" ]

[ "test", "the", "netgroups", "(", "groups", "in", "acl", "rules", "that", "start", "with", "@", ")", "this", "is", "a", "manual", "test", "because", "it", "requires", ":", "-", "host", "setup", "-", "native", "code", "compiled", "-", "specify", "the", "group", "mapping", "class", "host", "setup", ":", "etcnsswitch", "conf", "should", "have", "a", "line", "like", "this", ":", "netgroup", ":", "files", "etcnetgroup", "should", "be", "(", "the", "whole", "file", ")", ":", "foo", "group", "(", ",", "proxied", "user", ",", ")", "to", "run", "this", "test", ":", "export", "java", "home", "=", "'", "pathtojava", "'", "mvn", "test", "\\", "-", "dtest", "=", "test", "proxy", "users", "\\", "-", "d", "test", "proxy", "users", "group", "mapping", "=", "$", "class", "name", "\\", "where", "$", "class", "name", "is", "one", "of", "the", "classes", "that", "provide", "group", "mapping", "services", ",", "i", "e", "classes", "that", "implement", "group", "mapping", "service", "provider", "interface", ",", "at", "this", "time", ":", "-", "org", "apache", "hadoop", "security", "jni", "based", "unix", "groups", "netgroup", "mapping", "-", "org", "apache", "hadoop", "security", "shell", "based", "unix", "groups", "netgroup", "mapping" ]

[ "public", "void", "test", "netgroups", "(", ")", "throws", "i", "o", "exception", "{", "if", "(", "!", "native", "code", "loader", "is", "native", "code", "loaded", "(", ")", ")", "{", "log", "info", "(", "\"", "not", "testing", "netgroups", ",", "\"", "+", "\"", "this", "test", "only", "runs", "when", "native", "code", "is", "compiled", "\"", ")", ";", "return", ";", "}", "string", "group", "mapping", "class", "name", "=", "system", "get", "property", "(", "\"", "test", "proxy", "users", "group", "mapping", "\"", ")", ";", "if", "(", "group", "mapping", "class", "name", "=", "=", "null", ")", "{", "log", "info", "(", "\"", "not", "testing", "netgroups", ",", "no", "group", "mapping", "class", "specified", ",", "\"", "+", "\"", "use", "-", "d", "test", "proxy", "users", "group", "mapping", "=", "$", "class", "name", "to", "specify", "\"", "+", "\"", "group", "mapping", "class", "(", "must", "implement", "group", "mapping", "service", "provider", "\"", "+", "\"", "interface", "and", "support", "netgroups", ")", "\"", ")", ";", "return", ";", "}", "log", "info", "(", "\"", "testing", "netgroups", "using", ":", "\"", "+", "group", "mapping", "class", "name", ")", ";", "configuration", "conf", "=", "new", "configuration", "(", ")", ";", "conf", "set", "(", "common", "configuration", "keys", "public", "hadoop", "security", "group", "mapping", ",", "group", "mapping", "class", "name", ")", ";", "conf", "set", "(", "default", "impersonation", "provider", "get", "test", "provider", "(", ")", "get", "proxy", "superuser", "group", "conf", "key", "(", "real", "user", "name", ")", ",", "string", "utils", "join", "(", "\"", ",", "\"", ",", "arrays", "as", "list", "(", "netgroup", "names", ")", ")", ")", ";", "conf", "set", "(", "default", "impersonation", "provider", "get", "test", "provider", "(", ")", "get", "proxy", "superuser", "ip", "conf", "key", "(", "real", "user", "name", ")", ",", "proxy", "ip", ")", ";", "proxy", "users", "refresh", "super", "user", "groups", "configuration", "(", "conf", ")", ";", "groups", "groups", "=", "groups", "get", "user", "to", "groups", "mapping", "service", "(", "conf", ")", ";", "/", "/", "try", "proxying", "a", "group", "that", "'", "s", "allowed", "user", "group", "information", "real", "user", "ugi", "=", "user", "group", "information", "create", "remote", "user", "(", "real", "user", "name", ")", ";", "user", "group", "information", "proxy", "user", "ugi", "=", "user", "group", "information", "create", "proxy", "user", "for", "testing", "(", "proxy", "user", "name", ",", "real", "user", "ugi", ",", "groups", "get", "groups", "(", "proxy", "user", "name", ")", "to", "array", "(", "new", "string", "[", "groups", "get", "groups", "(", "proxy", "user", "name", ")", "size", "(", ")", "]", ")", ")", ";", "assert", "authorized", "(", "proxy", "user", "ugi", ",", "proxy", "ip", ")", ";", "}" ]

[ "notification", "that", "a", "domain", "file", "previously", "open", "for", "update", "is", "in", "the", "process", "of", "closing" ]

[ "public", "void", "domain", "file", "object", "closed", "(", "domain", "file", "file", ",", "domain", "object", "object", ")", ";" ]

[ "how", "many", "captured", "groups", "are", "in", "this", "subtext" ]

[ "public", "int", "group", "count", "(", ")", "{", "return", "groups", "length", "/", "2", ";", "}" ]

[ "get", "the", "{", "@", "link", "#", "size", "(", ")", "}", "parameter" ]

[ "public", "integer", "size", "(", ")", "{", "return", "this", "size", ";", "}" ]

[ "optional", "list", "of", "installers", "to", "be", "configured", "by", "default", "for", "new", "tools", "of", "this", "type", "if", "there", "are", "popular", "versions", "of", "the", "tool", "available", "using", "generic", "installation", "techniques", ",", "they", "can", "be", "returned", "here", "for", "the", "user", "'", "s", "convenience" ]

[ "public", "list", "<", "?", "extends", "tool", "installer", ">", "get", "default", "installers", "(", ")", "{", "return", "collections", "empty", "list", "(", ")", ";", "}" ]

[ "the", "block", "location", "of", "returned", "located", "file", "status", "will", "have", "different", "formats", "for", "replicated", "and", "erasure", "coded", "file", "please", "refer", "to", "{", "@", "link", "file", "context", "#", "get", "file", "block", "locations", "(", "path", ",", "long", ",", "long", ")", "}", "for", "more", "details" ]

[ "public", "remote", "iterator", "<", "located", "file", "status", ">", "list", "located", "status", "(", "final", "path", "p", ")", "throws", "file", "not", "found", "exception", ",", "i", "o", "exception", "{", "return", "new", "dir", "listing", "iterator", "<", "located", "file", "status", ">", "(", "p", ",", "true", ")", "{", "@", "override", "public", "located", "file", "status", "next", "(", ")", "throws", "i", "o", "exception", "{", "return", "(", "(", "hdfs", "located", "file", "status", ")", "get", "next", "(", ")", ")", "make", "qualified", "located", "(", "get", "uri", "(", ")", ",", "p", ")", ";", "}", "}", ";", "}" ]

[ "type", "of", "the", "resource", "that", "is", "being", "requested", ",", "e", "g", "\"", "type", "googleapis", "comistio", "io", "networking", "v", "1alpha", "3", "virtual", "service", "\"", "<", "code", ">", "string", "type", "url", "=", "3", ";", "<", "code", ">" ]

[ "public", "com", "google", "protobuf", "byte", "string", "get", "type", "url", "bytes", "(", ")", "{", "java", "lang", "object", "ref", "=", "type", "url", ";", "if", "(", "ref", "instanceof", "string", ")", "{", "com", "google", "protobuf", "byte", "string", "b", "=", "com", "google", "protobuf", "byte", "string", "copy", "from", "utf", "8", "(", "(", "java", "lang", "string", ")", "ref", ")", ";", "type", "url", "=", "b", ";", "return", "b", ";", "}", "else", "{", "return", "(", "com", "google", "protobuf", "byte", "string", ")", "ref", ";", "}", "}" ]

[ "retrieve", "the", "data", "source", "identified", "by", "the", "given", "name" ]

[ "data", "source", "get", "data", "source", "(", "string", "data", "source", "name", ")", "throws", "data", "source", "lookup", "failure", "exception", ";" ]

[ "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", "\"", ")", ";", "}" ]

[ "new", "saml", "object" ]

[ "protected", "<", "t", "extends", "s", "a", "m", "l", "object", ">", "t", "new", "saml", "object", "(", "final", "class", "<", "t", ">", "object", "type", ")", "{", "val", "q", "name", "=", "get", "saml", "object", "q", "name", "(", "object", "type", ")", ";", "return", "saml", "utils", "new", "saml", "object", "(", "object", "type", ",", "q", "name", ")", ";", "}" ]

[ "verifies", "that", "we", "can", "install", "an", "extension", "from", "a", "folder" ]

[ "public", "void", "test", "install", "extension", "from", "folder", "(", ")", "throws", "extension", "exception", ",", "i", "o", "exception", "{", "/", "/", "create", "an", "extension", "and", "install", "it", "resource", "file", "r", "file", "=", "create", "extension", "folder", "(", ")", ";", "extension", "utils", "install", "(", "r", "file", ")", ";", "/", "/", "verify", "the", "extension", "is", "in", "the", "install", "folder", "and", "has", "the", "correct", "name", "check", "dirty", "install", "(", "default", "ext", "name", ")", ";", "}" ]

[ "adds", "the", "header", "search", "paths", "provided", "by", "the", "protobuf", "library" ]

[ "public", "builder", "add", "protobuf", "header", "search", "paths", "(", "nested", "set", "<", "path", "fragment", ">", "protobuf", "header", "search", "paths", ")", "{", "this", "protobuf", "header", "search", "paths", "add", "transitive", "(", "protobuf", "header", "search", "paths", ")", ";", "return", "this", ";", "}" ]

[ "adds", "the", "given", "list", "of", "items", "to", "the", "statistics" ]

[ "public", "void", "add", "all", "(", "section", "list", ")", "{", "collection", "<", "?", "extends", "item", ">", "items", "=", "list", "items", "(", ")", ";", "for", "(", "item", "item", ":", "items", ")", "{", "add", "(", "item", ")", ";", "}", "}" ]

[ "retrieve", "the", "given", "column", "as", "character", "stream", "from", "the", "given", "result", "set", "might", "simply", "invoke", "{", "@", "code", "result", "set", "get", "character", "stream", "}", "or", "work", "with", "{", "@", "code", "result", "set", "get", "clob", "}", ",", "depending", "on", "the", "database", "and", "driver" ]

[ "reader", "get", "clob", "as", "character", "stream", "(", "result", "set", "rs", ",", "string", "column", "name", ")", "throws", "s", "q", "l", "exception", ";" ]

[ "test", "to", "verify", "listeners", "defined", "in", "the", "bpmn", "xml", "with", "invalid", "classdelegate", "expression", "values", "cause", "an", "exception", "when", "process", "is", "started" ]

[ "public", "void", "test", "process", "definition", "listener", "definition", "error", "(", ")", "throws", "exception", "{", "/", "/", "deploy", "process", "with", "expression", "which", "references", "an", "unexisting", "bean", "org", "activiti", "engine", "repository", "deployment", "deployment", "=", "repository", "service", "create", "deployment", "(", ")", "add", "classpath", "resource", "(", "\"", "org", "/", "activiti", "/", "standalone", "/", "event", "/", "invalid", "event", "listener", "expression", "bpmn", "2", "0", "xml", "\"", ")", "deploy", "(", ")", ";", "process", "instance", "process", "instance", "=", "runtime", "service", "start", "process", "instance", "by", "key", "(", "\"", "test", "invalid", "event", "expression", "\"", ")", ";", "assert", "that", "(", "process", "instance", ")", "is", "not", "null", "(", ")", ";", "repository", "service", "delete", "deployment", "(", "deployment", "get", "id", "(", ")", ",", "true", ")", ";", "/", "/", "deploy", "process", "with", "listener", "which", "references", "an", "unexisting", "class", "deployment", "=", "repository", "service", "create", "deployment", "(", ")", "add", "classpath", "resource", "(", "\"", "org", "/", "activiti", "/", "standalone", "/", "event", "/", "invalid", "event", "listener", "class", "bpmn", "2", "0", "xml", "\"", ")", "deploy", "(", ")", ";", "process", "instance", "=", "runtime", "service", "start", "process", "instance", "by", "key", "(", "\"", "test", "invalid", "event", "class", "\"", ")", ";", "repository", "service", "delete", "deployment", "(", "deployment", "get", "id", "(", ")", ",", "true", ")", ";", "}" ]

[ "return", "base", "6", "4", "-", "encode", "bytes" ]

[ "public", "static", "byte", "[", "]", "base", "6", "4", "encode", "(", "final", "string", "input", ")", "{", "return", "base", "6", "4", "encode", "(", "input", "get", "bytes", "(", ")", ")", ";", "}" ]

[ "{", "@", "inherit", "doc", "}" ]

[ "public", "void", "update", "binary", "stream", "(", "int", "column", "index", ",", "input", "stream", "x", ",", "long", "length", ")", "throws", "s", "q", "l", "exception", "{", "}" ]

[ "compare", "the", "given", "{", "@", "code", "property", "descriptors", "}", "and", "return", "{", "@", "code", "true", "}", "if", "they", "are", "equivalent", ",", "i", "e", "their", "read", "method", ",", "write", "method", ",", "property", "type", ",", "property", "editor", "and", "flags", "are", "equivalent" ]

[ "public", "static", "boolean", "equals", "(", "property", "descriptor", "pd", ",", "property", "descriptor", "other", "pd", ")", "{", "return", "(", "object", "utils", "null", "safe", "equals", "(", "pd", "get", "read", "method", "(", ")", ",", "other", "pd", "get", "read", "method", "(", ")", ")", "&", "&", "object", "utils", "null", "safe", "equals", "(", "pd", "get", "write", "method", "(", ")", ",", "other", "pd", "get", "write", "method", "(", ")", ")", "&", "&", "object", "utils", "null", "safe", "equals", "(", "pd", "get", "property", "type", "(", ")", ",", "other", "pd", "get", "property", "type", "(", ")", ")", "&", "&", "object", "utils", "null", "safe", "equals", "(", "pd", "get", "property", "editor", "class", "(", ")", ",", "other", "pd", "get", "property", "editor", "class", "(", ")", ")", "&", "&", "pd", "is", "bound", "(", ")", "=", "=", "other", "pd", "is", "bound", "(", ")", "&", "&", "pd", "is", "constrained", "(", ")", "=", "=", "other", "pd", "is", "constrained", "(", ")", ")", ";", "}" ]

[ "perform", "a", "psuedo", "-", "disassembly", "of", "an", "single", "instruction", "block", "only", "following", "fall", "-", "throughs", "warning", "!", "this", "method", "should", "not", "be", "used", "in", "conjunction", "with", "other", "disassembly", "methods", "on", "the", "this", "disassembler", "instance", "disassembler", "must", "be", "instantiated", "with", "a", "program", "object" ]

[ "public", "instruction", "block", "pseudo", "disassemble", "block", "(", "address", "addr", ",", "register", "value", "default", "context", "value", ",", "int", "limit", ")", "{", "if", "(", "program", "=", "=", "null", ")", "{", "throw", "new", "unsupported", "operation", "exception", "(", "\"", "method", "requires", "instantiation", "with", "a", "program", "object", "\"", ")", ";", "}", "return", "pseudo", "disassemble", "block", "(", "new", "dumb", "mem", "buffer", "impl", "(", "program", "get", "memory", "(", ")", ",", "addr", ")", ",", "default", "context", "value", ",", "limit", ")", ";", "}" ]

[ "define", "a", "factory", "for", "a", "class" ]

[ "public", "static", "void", "set", "factory", "(", "class", "c", ",", "writable", "factory", "factory", ")", "{", "class", "to", "factory", "put", "(", "c", ",", "factory", ")", ";", "}" ]

[ "determine", "the", "target", "type", "for", "the", "given", "generic", "parameter", "type" ]

[ "public", "static", "class", "<", "?", ">", "resolve", "parameter", "type", "(", "method", "parameter", "method", "parameter", ",", "class", "<", "?", ">", "implementation", "class", ")", "{", "assert", "not", "null", "(", "method", "parameter", ",", "\"", "method", "parameter", "must", "not", "be", "null", "\"", ")", ";", "assert", "not", "null", "(", "implementation", "class", ",", "\"", "class", "must", "not", "be", "null", "\"", ")", ";", "method", "parameter", "set", "containing", "class", "(", "implementation", "class", ")", ";", "return", "method", "parameter", "get", "parameter", "type", "(", ")", ";", "}" ]

[ "wait", "for", "the", "given", "job", "to", "complete" ]

[ "public", "void", "wait", "for", "job", "completion", "(", "job", "job", ")", "throws", "exception", "{", "assert", "job", "!", "=", "null", ";", "if", "(", "!", "job", "wait", "for", "completion", "(", "true", ")", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "dist", "cp", "failure", ":", "job", "\"", "+", "job", "get", "job", "i", "d", "(", ")", "+", "\"", "has", "failed", ":", "\"", "+", "job", "get", "status", "(", ")", "get", "failure", "info", "(", ")", ")", ";", "}", "}" ]

[ "looks", "up", "finalizer", "start", "finalizer", "(", ")" ]

[ "static", "method", "get", "start", "finalizer", "(", "class", "<", "?", ">", "finalizer", ")", "{", "try", "{", "return", "finalizer", "get", "method", "(", "\"", "start", "finalizer", "\"", ",", "class", "class", ",", "reference", "queue", "class", ",", "phantom", "reference", "class", ")", ";", "}", "catch", "(", "no", "such", "method", "exception", "e", ")", "{", "throw", "new", "assertion", "error", "(", "e", ")", ";", "}", "}" ]

[ "update", "the", "frontier", "for", "a", "path", "pathfinding", "thread", "only" ]

[ "private", "void", "update", "frontier", "(", "flowfield", "path", ",", "long", "ns", "to", "run", ")", "{", "long", "start", "=", "time", "nanos", "(", ")", ";", "while", "(", "path", "frontier", "size", ">", "0", "&", "&", "(", "ns", "to", "run", "<", "0", "|", "|", "time", "time", "since", "nanos", "(", "start", ")", "<", "=", "ns", "to", "run", ")", ")", "{", "tile", "tile", "=", "world", "tile", "(", "path", "frontier", "remove", "last", "(", ")", ")", ";", "if", "(", "tile", "=", "=", "null", "|", "|", "path", "weights", "=", "=", "null", ")", "return", ";", "/", "/", "something", "went", "horribly", "wrong", ",", "bail", "int", "cost", "=", "path", "weights", "[", "tile", "x", "]", "[", "tile", "y", "]", ";", "/", "/", "pathfinding", "overflowed", "for", "some", "reason", ",", "time", "to", "bail", "the", "next", "block", "update", "will", "handle", "this", ",", "hopefully", "if", "(", "path", "frontier", "size", ">", "=", "world", "width", "(", ")", "*", "world", "height", "(", ")", ")", "{", "path", "frontier", "clear", "(", ")", ";", "return", ";", "}", "if", "(", "cost", "!", "=", "impassable", ")", "{", "for", "(", "point", "2", "point", ":", "geometry", "d", "4", ")", "{", "int", "dx", "=", "tile", "x", "+", "point", "x", ",", "dy", "=", "tile", "y", "+", "point", "y", ";", "if", "(", "dx", "<", "0", "|", "|", "dy", "<", "0", "|", "|", "dx", ">", "=", "tiles", "length", "|", "|", "dy", ">", "=", "tiles", "[", "0", "]", "length", ")", "continue", ";", "int", "other", "cost", "=", "path", "cost", "get", "cost", "(", "path", "team", ",", "tiles", "[", "dx", "]", "[", "dy", "]", ")", ";", "if", "(", "(", "path", "weights", "[", "dx", "]", "[", "dy", "]", ">", "cost", "+", "other", "cost", "|", "|", "path", "searches", "[", "dx", "]", "[", "dy", "]", "<", "path", "search", ")", "&", "&", "other", "cost", "!", "=", "impassable", ")", "{", "path", "frontier", "add", "first", "(", "point", "2", "pack", "(", "dx", ",", "dy", ")", ")", ";", "path", "weights", "[", "dx", "]", "[", "dy", "]", "=", "cost", "+", "other", "cost", ";", "path", "searches", "[", "dx", "]", "[", "dy", "]", "=", "(", "short", ")", "path", "search", ";", "}", "}", "}", "}", "}" ]

[ "notifies", "consumer", "of", "new", "result", "and", "finishes", "if", "the", "result", "is", "final" ]

[ "private", "void", "handle", "result", "(", "final", "closeable", "image", "decoded", "image", ",", "final", "@", "status", "int", "status", ")", "{", "closeable", "reference", "<", "closeable", "image", ">", "decoded", "image", "ref", "=", "m", "closeable", "reference", "factory", "create", "(", "decoded", "image", ")", ";", "try", "{", "maybe", "finish", "(", "is", "last", "(", "status", ")", ")", ";", "get", "consumer", "(", ")", "on", "new", "result", "(", "decoded", "image", "ref", ",", "status", ")", ";", "}", "finally", "{", "closeable", "reference", "close", "safely", "(", "decoded", "image", "ref", ")", ";", "}", "}" ]

[ "build", "the", "{", "@", "code", "mock", "rest", "service", "server", "}", "and", "set", "up", "the", "underlying", "{", "@", "code", "rest", "template", "}", "or", "{", "@", "code", "async", "rest", "template", "}", "with", "a", "{", "@", "link", "client", "http", "request", "factory", "}", "that", "creates", "mock", "requests" ]

[ "mock", "rest", "service", "server", "build", "(", ")", ";" ]

[ "if", "the", "file", "created", "by", "{", "@", "link", "#", "write", "temp", "cache", "file", "(", "input", "stream", ",", "file", "extension", ")", "}", "was", "successfully", "parsed", ",", "this", "should", "be", "called", "to", "remove", "the", "temporary", "part", "of", "its", "name", "which", "will", "allow", "it", "to", "be", "a", "cache", "hit", "in", "the", "future" ]

[ "void", "rename", "temp", "file", "(", "string", "url", ",", "file", "extension", "extension", ")", "{", "string", "file", "name", "=", "filename", "for", "url", "(", "url", ",", "extension", ",", "true", ")", ";", "file", "file", "=", "new", "file", "(", "parent", "dir", "(", ")", ",", "file", "name", ")", ";", "string", "new", "file", "name", "=", "file", "get", "absolute", "path", "(", ")", "replace", "(", "\"", "temp", "\"", ",", "\"", "\"", ")", ";", "file", "new", "file", "=", "new", "file", "(", "new", "file", "name", ")", ";", "boolean", "renamed", "=", "file", "rename", "to", "(", "new", "file", ")", ";", "logger", "debug", "(", "\"", "copying", "temp", "file", "to", "real", "file", "(", "\"", "+", "new", "file", "+", "\"", ")", "\"", ")", ";", "if", "(", "!", "renamed", ")", "{", "logger", "warning", "(", "\"", "unable", "to", "rename", "cache", "file", "\"", "+", "file", "get", "absolute", "path", "(", ")", "+", "\"", "to", "\"", "+", "new", "file", "get", "absolute", "path", "(", ")", "+", "\"", "\"", ")", ";", "}", "}" ]

[ "makes", "sure", "the", "aspect", "will", "propagate", "to", "its", "implicit", "attributes", "if", "there", "is", "a", "\"", "regular", "\"", "dependency", "path", "to", "it", "(", "i", "e", "not", "through", "its", "own", "implicit", "attributes", ")" ]

[ "public", "void", "aspect", "with", "all", "attributes", "propagates", "to", "its", "tool", "if", "there", "is", "path", "(", ")", "throws", "exception", "{", "set", "rules", "available", "in", "tests", "(", "test", "aspects", "base", "rule", ",", "test", "aspects", "simple", "rule", ",", "test", "aspects", "all", "attributes", "with", "tool", "aspect", "rule", ")", ";", "pkg", "(", "\"", "a", "\"", ",", "\"", "simple", "(", "name", "=", "'", "tool", "'", ")", "\"", ",", "\"", "simple", "(", "name", "=", "'", "a", "'", ",", "foo", "=", "[", "'", ":", "b", "'", "]", ",", "foo", "1", "=", "'", ":", "c", "'", ",", "txt", "=", "'", "some", "text", "'", ")", "\"", ",", "\"", "simple", "(", "name", "=", "'", "b", "'", ",", "foo", "=", "[", "]", ",", "txt", "=", "'", "some", "text", "'", ")", "\"", ",", "\"", "simple", "(", "name", "=", "'", "c", "'", ",", "foo", "=", "[", "'", ":", "tool", "'", "]", ",", "txt", "=", "'", "more", "text", "'", ")", "\"", ",", "\"", "all", "attributes", "with", "tool", "aspect", "(", "name", "=", "'", "x", "'", ",", "foo", "=", "[", "'", ":", "a", "'", "]", ")", "\"", ")", ";", "configured", "target", "a", "=", "get", "configured", "target", "(", "\"", "/", "/", "a", ":", "x", "\"", ")", ";", "assert", "that", "(", "a", "get", "provider", "(", "rule", "info", "class", ")", "get", "data", "(", ")", "to", "list", "(", ")", ")", "contains", "exactly", "(", "\"", "aspect", "/", "/", "a", ":", "a", "\"", ",", "\"", "aspect", "/", "/", "a", ":", "b", "\"", ",", "\"", "aspect", "/", "/", "a", ":", "c", "\"", ",", "\"", "aspect", "/", "/", "a", ":", "tool", "\"", ",", "\"", "rule", "/", "/", "a", ":", "x", "\"", ")", ";", "}" ]