docstring_tokens
list
code_tokens
list
[ "performs", "the", "actual", "autodetection", "process", ",", "delegating", "to", "an", "{", "@", "code", "autodetect", "callback", "}", "instance", "to", "vote", "on", "the", "inclusion", "of", "a", "given", "bean" ]
[ "private", "void", "autodetect", "(", "map", "<", "string", ",", "object", ">", "beans", ",", "autodetect", "callback", "callback", ")", "{", "assert", "state", "(", "this", "bean", "factory", "!", "=", "null", ",", "\"", "no", "bean", "factory", "set", "\"", ")", ";", "set", "<", "string", ">", "bean", "names", "=", "new", "linked", "hash", "set", "<", ">", "(", "this", "bean", "factory", "get", "bean", "definition", "count", "(", ")", ")", ";", "collections", "add", "all", "(", "bean", "names", ",", "this", "bean", "factory", "get", "bean", "definition", "names", "(", ")", ")", ";", "if", "(", "this", "bean", "factory", "instanceof", "configurable", "bean", "factory", ")", "{", "collections", "add", "all", "(", "bean", "names", ",", "(", "(", "configurable", "bean", "factory", ")", "this", "bean", "factory", ")", "get", "singleton", "names", "(", ")", ")", ";", "}", "for", "(", "string", "bean", "name", ":", "bean", "names", ")", "{", "if", "(", "!", "is", "excluded", "(", "bean", "name", ")", "&", "&", "!", "is", "bean", "definition", "abstract", "(", "this", "bean", "factory", ",", "bean", "name", ")", ")", "{", "try", "{", "class", "<", "?", ">", "bean", "class", "=", "this", "bean", "factory", "get", "type", "(", "bean", "name", ")", ";", "if", "(", "bean", "class", "!", "=", "null", "&", "&", "callback", "include", "(", "bean", "class", ",", "bean", "name", ")", ")", "{", "boolean", "lazy", "init", "=", "is", "bean", "definition", "lazy", "init", "(", "this", "bean", "factory", ",", "bean", "name", ")", ";", "object", "bean", "instance", "=", "null", ";", "if", "(", "!", "lazy", "init", ")", "{", "bean", "instance", "=", "this", "bean", "factory", "get", "bean", "(", "bean", "name", ")", ";", "if", "(", "!", "bean", "class", "is", "instance", "(", "bean", "instance", ")", ")", "{", "continue", ";", "}", "}", "if", "(", "!", "scoped", "proxy", "utils", "is", "scoped", "target", "(", "bean", "name", ")", "&", "&", "!", "beans", "contains", "value", "(", "bean", "name", ")", "&", "&", "(", "bean", "instance", "=", "=", "null", "|", "|", "!", "collection", "utils", "contains", "instance", "(", "beans", "values", "(", ")", ",", "bean", "instance", ")", ")", ")", "{", "/", "/", "not", "already", "registered", "for", "jmx", "exposure", "beans", "put", "(", "bean", "name", ",", "(", "bean", "instance", "!", "=", "null", "?", "bean", "instance", ":", "bean", "name", ")", ")", ";", "if", "(", "logger", "is", "debug", "enabled", "(", ")", ")", "{", "logger", "debug", "(", "\"", "bean", "with", "name", "'", "\"", "+", "bean", "name", "+", "\"", "'", "has", "been", "autodetected", "for", "jmx", "exposure", "\"", ")", ";", "}", "}", "else", "{", "if", "(", "logger", "is", "trace", "enabled", "(", ")", ")", "{", "logger", "trace", "(", "\"", "bean", "with", "name", "'", "\"", "+", "bean", "name", "+", "\"", "'", "is", "already", "registered", "for", "jmx", "exposure", "\"", ")", ";", "}", "}", "}", "}", "catch", "(", "cannot", "load", "bean", "class", "exception", "ex", ")", "{", "if", "(", "this", "allow", "eager", "init", ")", "{", "throw", "ex", ";", "}", "/", "/", "otherwise", "ignore", "beans", "where", "the", "class", "is", "not", "resolvable", "}", "}", "}", "}" ]
[ "the", "interface", "used", "by", "client", "to", "get", "node", "to", "attributes", "mappings", "in", "existing", "cluster" ]
[ "get", "nodes", "to", "attributes", "response", "get", "nodes", "to", "attributes", "(", "get", "nodes", "to", "attributes", "request", "request", ")", "throws", "yarn", "exception", ",", "i", "o", "exception", ";" ]
[ "tear", "down", "the", "cluster" ]
[ "public", "static", "void", "teardown", "cluster", "(", ")", "throws", "exception", "{", "service", "operations", "stop", "quietly", "(", "log", ",", "cluster", ")", ";", "}" ]
[ "locates", "a", "file", "resource", "by", "the", "given", "name" ]
[ "public", "static", "file", "get", "resource", "file", "(", "string", "filename", ")", "{", "url", "url", "=", "get", "resource", "(", "filename", ")", ";", "if", "(", "url", "=", "=", "null", "|", "|", "!", "\"", "file", "\"", "equals", "(", "url", "get", "protocol", "(", ")", ")", ")", "{", "return", "null", ";", "}", "try", "{", "uri", "uri", "=", "new", "uri", "(", "url", "to", "external", "form", "(", ")", ")", ";", "return", "new", "file", "(", "uri", ")", ";", "}", "catch", "(", "u", "r", "i", "syntax", "exception", "e", ")", "{", "throw", "new", "runtime", "exception", "(", "\"", "can", "not", "find", "resource", "\"", "+", "filename", ")", ";", "}", "}" ]
[ "a", "timestamp", "that", "may", "be", "used", "to", "obtain", "wall", "time", ",", "but", "is", "not", "guaranteed", "to", "be", "monotonic", "<", "b", ">", "warning", ":", "<", "b", ">", "the", "returned", "timestamp", "is", "not", "guaranteed", "to", "be", "monotonic", ",", "and", "it", "may", "appear", "to", "go", "back", "in", "time", "in", "certain", "cases", "(", "e", "g", "daylight", "saving", "time", ")" ]
[ "abstract", "instant", "wall", "time", "(", ")", ";" ]
[ "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", "\"", ")", ";", "}" ]
[ "sets", "the", "type", "of", "the", "text", "query" ]
[ "public", "multi", "match", "query", "builder", "type", "(", "object", "type", ")", "{", "if", "(", "type", "=", "=", "null", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "[", "\"", "+", "name", "+", "\"", "]", "requires", "type", "to", "be", "non", "-", "null", "\"", ")", ";", "}", "this", "type", "=", "type", "parse", "(", "type", "to", "string", "(", ")", "to", "lower", "case", "(", "locale", "root", ")", ",", "logging", "deprecation", "handler", "instance", ")", ";", "return", "this", ";", "}" ]
[ "show", "that", "bootstrapping", "will", "fail", "on", "a", "given", "name", "node", "if", "its", "directories", "already", "exist", "its", "not", "run", "across", "all", "the", "nn", "because", "its", "testing", "the", "state", "local", "on", "each", "node" ]
[ "public", "void", "test", "standby", "dirs", "already", "exist", "(", ")", "throws", "exception", "{", "/", "/", "should", "not", "pass", "since", "standby", "dirs", "exist", ",", "force", "not", "given", "int", "rc", "=", "bootstrap", "standby", "run", "(", "new", "string", "[", "]", "{", "\"", "-", "non", "interactive", "\"", "}", ",", "cluster", "get", "configuration", "(", "1", ")", ")", ";", "assert", "equals", "(", "bootstrap", "standby", "err", "code", "already", "formatted", ",", "rc", ")", ";", "/", "/", "should", "pass", "with", "-", "force", "assert", "equals", "(", "0", ",", "force", "bootstrap", "(", "1", ")", ")", ";", "}" ]
[ "get", "my", "number" ]
[ "public", "big", "decimal", "get", "my", "number", "(", ")", "{", "return", "my", "number", ";", "}" ]
[ "same", "as", "{", "@", "link", "#", "collect", "bucket", "(", "leaf", "bucket", "collector", ",", "int", ",", "long", ")", "}", ",", "but", "doesn", "'", "t", "check", "if", "the", "doc", "counts", "needs", "to", "be", "re", "-", "sized" ]
[ "public", "final", "void", "collect", "existing", "bucket", "(", "leaf", "bucket", "collector", "sub", "collector", ",", "int", "doc", ",", "long", "bucket", "ord", ")", "throws", "i", "o", "exception", "{", "int", "doc", "count", "=", "doc", "count", "provider", "get", "doc", "count", "(", "doc", ")", ";", "if", "(", "doc", "counts", "increment", "(", "bucket", "ord", ",", "doc", "count", ")", "=", "=", "doc", "count", ")", "{", "/", "/", "we", "calculate", "the", "final", "number", "of", "buckets", "only", "during", "the", "reduce", "phase", "but", "we", "still", "need", "to", "/", "/", "trigger", "bucket", "consumer", "from", "time", "to", "time", "in", "order", "to", "give", "it", "a", "chance", "to", "check", "available", "memory", "and", "break", "/", "/", "the", "execution", "if", "we", "are", "running", "out", "to", "achieve", "that", "we", "are", "passing", "0", "as", "a", "bucket", "count", "multi", "bucket", "consumer", "accept", "(", "0", ")", ";", "}", "sub", "collector", "collect", "(", "doc", ",", "bucket", "ord", ")", ";", "}" ]
[ "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", "\"", ")", ";", "}" ]
[ "<", "code", ">", "optional", "string", "prefix", "=", "1", ";", "<", "code", ">" ]
[ "public", "builder", "set", "prefix", "bytes", "(", "com", "google", "protobuf", "byte", "string", "value", ")", "{", "copy", "on", "write", "(", ")", ";", "instance", "set", "prefix", "bytes", "(", "value", ")", ";", "return", "this", ";", "}" ]
[ "returns", "the", "language", "used" ]
[ "public", "string", "get", "language", "(", ")", "{", "return", "language", "to", "string", "(", ")", ";", "}" ]
[ "assert", "that", "the", "data", "read", "matches", "the", "dataset", "at", "the", "given", "offset", "this", "helps", "verify", "that", "the", "seek", "process", "is", "moving", "the", "read", "pointer", "to", "the", "correct", "location", "in", "the", "file" ]
[ "private", "void", "assert", "dataset", "equals", "(", "final", "int", "read", "offset", ",", "final", "string", "operation", ",", "final", "byte", "[", "]", "data", ",", "int", "length", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "length", ";", "i", "+", "+", ")", "{", "int", "o", "=", "read", "offset", "+", "i", ";", "assert", "equals", "(", "operation", "+", "\"", "with", "seek", "policy", "\"", "+", "seek", "policy", "+", "\"", "and", "read", "offset", "\"", "+", "read", "offset", "+", "\"", ":", "data", "[", "\"", "+", "i", "+", "\"", "]", "!", "=", "dataset", "[", "\"", "+", "o", "+", "\"", "]", "\"", ",", "dataset", "[", "o", "]", ",", "data", "[", "i", "]", ")", ";", "}", "}" ]
[ "identical", "to", "{", "@", "link", "platform", "dependent", "0", "#", "hash", "code", "ascii", "sanitize", "(", "int", ")", "}", "but", "for", "{", "@", "link", "char", "sequence", "}" ]
[ "private", "static", "int", "hash", "code", "ascii", "sanitize", "int", "(", "char", "sequence", "value", ",", "int", "offset", ")", "{", "if", "(", "big", "endian", "native", "order", ")", "{", "/", "/", "mimic", "a", "unsafe", "get", "int", "call", "on", "a", "big", "endian", "machine", "return", "(", "value", "char", "at", "(", "offset", "+", "3", ")", "&", "0x", "1f", ")", "|", "(", "value", "char", "at", "(", "offset", "+", "2", ")", "&", "0x", "1f", ")", "<", "<", "8", "|", "(", "value", "char", "at", "(", "offset", "+", "1", ")", "&", "0x", "1f", ")", "<", "<", "16", "|", "(", "value", "char", "at", "(", "offset", ")", "&", "0x", "1f", ")", "<", "<", "24", ";", "}", "return", "(", "value", "char", "at", "(", "offset", "+", "3", ")", "&", "0x", "1f", ")", "<", "<", "24", "|", "(", "value", "char", "at", "(", "offset", "+", "2", ")", "&", "0x", "1f", ")", "<", "<", "16", "|", "(", "value", "char", "at", "(", "offset", "+", "1", ")", "&", "0x", "1f", ")", "<", "<", "8", "|", "(", "value", "char", "at", "(", "offset", ")", "&", "0x", "1f", ")", ";", "}" ]
[ "in", "the", "run", "method", "the", "thief", "repeatedly", "tries", "to", "take", "a", "bean", "until", "none", "are", "left" ]
[ "public", "void", "run", "(", ")", "{", "var", "beans", "=", "0", ";", "while", "(", "jar", "take", "bean", "(", ")", ")", "{", "beans", "=", "beans", "+", "1", ";", "logger", "info", "(", "\"", "{", "}", "took", "a", "bean", "\"", ",", "name", ")", ";", "}", "logger", "info", "(", "\"", "{", "}", "took", "{", "}", "beans", "\"", ",", "name", ",", "beans", ")", ";", "}" ]
[ "check", "if", "lottery", "ticket", "has", "won" ]
[ "public", "lottery", "ticket", "check", "result", "check", "ticket", "for", "prize", "(", "lottery", "ticket", "id", "id", ",", "lottery", "numbers", "winning", "numbers", ")", "{", "return", "lottery", "utils", "check", "ticket", "for", "prize", "(", "repository", ",", "id", ",", "winning", "numbers", ")", ";", "}" ]
[ "returns", "an", "unmodifiable", "view", "of", "the", "specified", "table", "this", "method", "allows", "modules", "to", "provide", "users", "with", "\"", "read", "-", "only", "\"", "access", "to", "internal", "tables", "query", "operations", "on", "the", "returned", "table", "\"", "read", "through", "\"", "to", "the", "specified", "table", ",", "and", "attempts", "to", "modify", "the", "returned", "table", ",", "whether", "direct", "or", "via", "its", "collection", "views", ",", "result", "in", "an", "{", "@", "code", "unsupported", "operation", "exception", "}", "the", "returned", "table", "will", "be", "serializable", "if", "the", "specified", "table", "is", "serializable", "consider", "using", "an", "{", "@", "link", "immutable", "table", "}", ",", "which", "is", "guaranteed", "never", "to", "change" ]
[ "public", "static", "<", "r", ",", "c", ",", "v", ">", "table", "<", "r", ",", "c", ",", "v", ">", "unmodifiable", "table", "(", "table", "<", "?", "extends", "r", ",", "?", "extends", "c", ",", "?", "extends", "v", ">", "table", ")", "{", "return", "new", "unmodifiable", "table", "<", ">", "(", "table", ")", ";", "}" ]
[ "attempts", "to", "cancel", "the", "currently", "running", "fetcher", "this", "will", "be", "called", "on", "the", "main", "thread", "and", "should", "complete", "quickly" ]
[ "void", "cancel", "(", ")", ";" ]
[ "creates", "a", "fresh", "single", "subject" ]
[ "public", "static", "<", "t", ">", "single", "subject", "<", "t", ">", "create", "(", ")", "{", "return", "new", "single", "subject", "<", ">", "(", ")", ";", "}" ]
[ "fires", "the", "latch", "code", "that", "is", "blocked", "on", "{", "@", "link", "#", "await", "(", ")", "}", "will", "now", "return" ]
[ "public", "void", "trigger", "(", ")", "{", "synchronized", "(", "lock", ")", "{", "triggered", "=", "true", ";", "lock", "notify", "all", "(", ")", ";", "}", "}" ]
[ "guaranteed", "to", "throw", "an", "exception", "and", "leave", "the", "multimap", "unmodified" ]
[ "public", "immutable", "collection", "<", "v", ">", "remove", "all", "(", "object", "key", ")", "{", "throw", "new", "unsupported", "operation", "exception", "(", ")", ";", "}" ]
[ "rethrows", "the", "throwable", "if", "it", "is", "a", "fatal", "exception", "or", "calls", "{", "@", "link", "#", "on", "error", "(", "throwable", ")", "}" ]
[ "protected", "final", "void", "fail", "(", "throwable", "t", ")", "{", "exceptions", "throw", "if", "fatal", "(", "t", ")", ";", "upstream", "cancel", "(", ")", ";", "on", "error", "(", "t", ")", ";", "}" ]
[ "checks", "if", "the", "validation", "is", "successful" ]
[ "public", "validator", "<", "t", ">", "validate", "(", "predicate", "<", "t", ">", "validation", ",", "string", "message", ")", "{", "if", "(", "!", "validation", "test", "(", "obj", ")", ")", "{", "exceptions", "add", "(", "new", "illegal", "state", "exception", "(", "message", ")", ")", ";", "}", "return", "this", ";", "}" ]
[ "customize", "the", "supplied", "{", "@", "link", "groovy", "object", "}", "for", "example", ",", "this", "can", "be", "used", "to", "set", "a", "custom", "metaclass", "to", "handle", "missing", "methods" ]
[ "void", "customize", "(", "groovy", "object", "goo", ")", ";" ]
[ "an", "index", "into", "the", "symbol", "table", "indicating", "the", "defined", "external", "symbols", "to", "which", "this", "entry", "refers" ]
[ "public", "int", "get", "symbol", "index", "(", ")", "{", "return", "symbol", "index", ";", "}" ]
[ "test", "for", "the", "case", "when", "the", "following", "submit", "application", "and", "administer", "queue", "a", "c", "ls", "are", "defined", ":", "root", ":", "(", "all", ")", "d", ":", "(", "none", ")", "d1", ":", "(", "all", ")", "expected", "result", ":", "access", "to", "d", "will", "be", "permitted", "from", "the", "root", "queue", ",", "so", "the", "user", "will", "be", "able", "to", "access", "queues", "root", ",", "d", "and", "d1" ]
[ "public", "void", "test", "queue", "acl", "restricted", "d", "(", ")", "throws", "i", "o", "exception", "{", "update", "config", "with", "d", "and", "d", "1", "queues", "(", "all", "acl", ",", "none", "acl", ",", "all", "acl", ")", ";", "check", "access", "(", "true", ",", "true", ",", "true", ")", ";", "}" ]
[ "returns", "true", "if", "this", "cache", "entry", "is", "corrupted", "and", "should", "be", "ignored" ]
[ "public", "boolean", "is", "corrupted", "(", ")", "{", "return", "this", "=", "=", "corrupted", ";", "}" ]
[ "sets", "the", "progress", "to", "the", "specified", "frame", "if", "the", "composition", "isn", "'", "t", "set", "yet", ",", "the", "progress", "will", "be", "set", "to", "the", "frame", "when", "it", "is" ]
[ "public", "void", "set", "frame", "(", "int", "frame", ")", "{", "lottie", "drawable", "set", "frame", "(", "frame", ")", ";", "}" ]
[ "returns", "an", "unmodifiable", "map", "of", "the", "index", "names", "to", "{", "@", "link", "index", "id", "}", "in", "the", "repository" ]
[ "public", "map", "<", "string", ",", "index", "id", ">", "get", "indices", "(", ")", "{", "return", "indices", ";", "}" ]
[ "test", "that", "a", "union", "can", "'", "t", "contain", "another", "union", "that", "contains", "it" ]
[ "public", "void", "test", "cyclic", "dependency", "problem", "4", "(", ")", "{", "union", "another", "union", "=", "create", "union", "(", "\"", "another", "union", "\"", ")", ";", "another", "union", "add", "(", "union", ")", ";", "try", "{", "union", "add", "(", "another", "union", ")", ";", "assert", "fail", "(", "\"", "shouldn", "'", "t", "be", "able", "to", "add", "another", "union", ",", "which", "contains", "this", "union", ",", "to", "this", "union", "\"", ")", ";", "}", "catch", "(", "illegal", "argument", "exception", "e", ")", "{", "/", "/", "should", "get", "an", "exception", "from", "adding", "the", "union", "to", "itself", "}", "try", "{", "union", "insert", "(", "0", ",", "another", "union", ")", ";", "assert", "fail", "(", "\"", "shouldn", "'", "t", "be", "able", "to", "insert", "another", "union", ",", "which", "contains", "this", "union", ",", "to", "this", "union", "\"", ")", ";", "}", "catch", "(", "illegal", "argument", "exception", "e", ")", "{", "/", "/", "should", "get", "an", "exception", "from", "inserting", "the", "union", "to", "itself", "}", "}" ]
[ "sets", "a", "custom", "partitioner", "for", "the", "co", "group", "operation", "the", "partitioner", "will", "be", "called", "on", "the", "join", "keys", "to", "determine", "the", "partition", "a", "key", "should", "be", "assigned", "to", "the", "partitioner", "is", "evaluated", "on", "both", "inputs", "in", "the", "same", "way", "note", ":", "a", "custom", "partitioner", "can", "only", "be", "used", "with", "single", "-", "field", "co", "group", "keys", ",", "not", "with", "composite", "co", "group", "keys" ]
[ "public", "co", "group", "operator", "<", "i1", ",", "i2", ",", "out", ">", "with", "partitioner", "(", "partitioner", "<", "?", ">", "partitioner", ")", "{", "if", "(", "partitioner", "!", "=", "null", ")", "{", "keys", "1", "validate", "custom", "partitioner", "(", "partitioner", ",", "null", ")", ";", "keys", "2", "validate", "custom", "partitioner", "(", "partitioner", ",", "null", ")", ";", "}", "this", "custom", "partitioner", "=", "get", "input", "1", "(", ")", "clean", "(", "partitioner", ")", ";", "return", "this", ";", "}" ]
[ "return", "the", "address", "size", "of", "the", "os", "4", "(", "for", "32", "bits", "systems", ")", "and", "8", "(", "for", "64", "bits", "systems", ")" ]
[ "public", "static", "int", "address", "size", "(", ")", "{", "return", "address", "size", ";", "}" ]
[ "creates", "a", "string", "with", "the", "indicated", "number", "of", "html", "space", "characters", "(", "<", "code", ">", "&", "#", "x", "2", "6", ";", "nbsp", ";", "<", "code", ">", ")" ]
[ "public", "static", "string", "spaces", "(", "int", "num", ")", "{", "string", "builder", "buf", "=", "new", "string", "builder", "(", "html", "space", "length", "(", ")", "*", "num", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "num", ";", "i", "+", "+", ")", "{", "buf", "append", "(", "html", "space", ")", ";", "}", "return", "buf", "to", "string", "(", ")", ";", "}" ]
[ "sets", "the", "results", "from", "the", "dialog", "only", "if", "choice", "is", "true", "<", "p", ">", "in", "other", "words", ",", "if", "the", "user", "selects", "the", "check", "box", ",", "then", "the", "result", "will", "be", "saved", "the", ",", "whenever", "the", "dialog", "is", "\"", "shown", "\"", ",", "if", "there", "is", "a", "saved", "result", ",", "it", "will", "be", "returned", "instead", "of", "actually", "showing", "the", "dialog" ]
[ "public", "void", "remember", "result", "(", "int", "choice", ")", "{", "this", "has", "remembered", "result", "=", "true", ";", "this", "remembered", "result", "=", "choice", ";", "}" ]
[ "returns", "a", "{", "@", "code", "top", "k", "selector", "}", "that", "collects", "the", "lowest", "{", "@", "code", "k", "}", "elements", "added", "to", "it", ",", "relative", "to", "the", "specified", "comparator", ",", "and", "returns", "them", "via", "{", "@", "link", "#", "top", "k", "}", "in", "ascending", "order" ]
[ "public", "static", "<", "t", ">", "top", "k", "selector", "<", "t", ">", "least", "(", "int", "k", ",", "comparator", "<", "?", "super", "t", ">", "comparator", ")", "{", "return", "new", "top", "k", "selector", "<", "t", ">", "(", "comparator", ",", "k", ")", ";", "}" ]
[ "sets", "the", "default", "background", "color" ]
[ "public", "void", "set", "background", "color", "(", "color", "c", ")", "{", "background", "color", "model", "set", "default", "background", "color", "(", "c", ")", ";", "paint", "context", "set", "default", "background", "color", "(", "c", ")", ";", "}" ]
[ "handler", "for", "a", "goaway", "being", "received", "fails", "any", "streams", "created", "after", "the", "last", "known", "stream", "may", "only", "be", "called", "during", "a", "read" ]
[ "private", "void", "going", "away", "(", "long", "error", "code", ",", "byte", "[", "]", "debug", "data", ")", "{", "status", "final", "status", "=", "status", "from", "h", "2", "error", "(", "status", "code", "unavailable", ",", "\"", "goaway", "shut", "down", "transport", "\"", ",", "error", "code", ",", "debug", "data", ")", ";", "lifecycle", "manager", "notify", "graceful", "shutdown", "(", "final", "status", ")", ";", "abrupt", "go", "away", "status", "=", "status", "from", "h", "2", "error", "(", "status", "code", "unavailable", ",", "\"", "abrupt", "goaway", "closed", "unsent", "stream", "\"", ",", "error", "code", ",", "debug", "data", ")", ";", "/", "/", "while", "this", "should", "be", "unavailable", ",", "netty", "uses", "the", "wrong", "stream", "id", "in", "the", "goaway", "when", "it", "/", "/", "fails", "streams", "due", "to", "hpack", "failures", "(", "e", "g", ",", "header", "list", "too", "large", ")", "to", "be", "more", "conservative", ",", "/", "/", "we", "assume", "any", "sent", "streams", "may", "be", "related", "to", "the", "goaway", "this", "should", "rarely", "impact", "users", "/", "/", "since", "the", "main", "time", "servers", "should", "use", "abrupt", "g", "o", "a", "w", "a", "ys", "is", "if", "there", "is", "a", "protocol", "error", ",", "and", "if", "/", "/", "there", "wasn", "'", "t", "a", "protocol", "error", "the", "error", "code", "was", "probably", "no", "error", "which", "is", "mapped", "to", "/", "/", "unavailable", "https", ":", "/", "/", "github", "com", "/", "netty", "/", "netty", "/", "issues", "/", "10670", "final", "status", "abrupt", "go", "away", "status", "conservative", "=", "status", "from", "h", "2", "error", "(", "null", ",", "\"", "abrupt", "goaway", "closed", "sent", "stream", "\"", ",", "error", "code", ",", "debug", "data", ")", ";", "/", "/", "try", "to", "allocate", "as", "many", "in", "-", "flight", "streams", "as", "possible", ",", "to", "reduce", "race", "window", "of", "/", "/", "https", ":", "/", "/", "github", "com", "/", "grpc", "/", "grpc", "-", "java", "/", "issues", "/", "2562", "to", "be", "of", "any", "help", ",", "the", "server", "has", "to", "/", "/", "gracefully", "shut", "down", "the", "connection", "with", "two", "g", "o", "a", "w", "a", "ys", "g", "r", "p", "c", "servers", "generally", "send", "a", "ping", "/", "/", "after", "the", "first", "goaway", ",", "so", "they", "can", "very", "precisely", "detect", "when", "the", "goaway", "has", "been", "/", "/", "processed", "and", "thus", "this", "processing", "must", "be", "in", "-", "line", "before", "processing", "additional", "reads", "/", "/", "this", "can", "cause", "reentrancy", ",", "but", "should", "be", "minor", "since", "it", "is", "normal", "to", "handle", "writes", "in", "/", "/", "response", "to", "a", "read", "also", ",", "the", "call", "stack", "is", "rather", "shallow", "at", "this", "point", "client", "write", "queue", "drain", "now", "(", ")", ";", "if", "(", "lifecycle", "manager", "notify", "shutdown", "(", "final", "status", ")", ")", "{", "/", "/", "this", "is", "for", "the", "only", "r", "p", "cs", "that", "are", "actually", "covered", "by", "the", "goaway", "error", "code", "all", "other", "/", "/", "r", "p", "cs", "were", "not", "observed", "by", "the", "remote", "and", "so", "should", "be", "unavailable", "channel", "inactive", "reason", "=", "status", "from", "h", "2", "error", "(", "null", ",", "\"", "connection", "closed", "after", "goaway", "\"", ",", "error", "code", ",", "debug", "data", ")", ";", "}", "final", "int", "last", "known", "stream", "=", "connection", "(", ")", "local", "(", ")", "last", "stream", "known", "by", "peer", "(", ")", ";", "try", "{", "connection", "(", ")", "for", "each", "active", "stream", "(", "new", "http", "2", "stream", "visitor", "(", ")", "{", "@", "override", "public", "boolean", "visit", "(", "http", "2", "stream", "stream", ")", "throws", "http", "2", "exception", "{", "if", "(", "stream", "id", "(", ")", ">", "last", "known", "stream", ")", "{", "netty", "client", "stream", "transport", "state", "client", "stream", "=", "client", "stream", "(", "stream", ")", ";", "if", "(", "client", "stream", "!", "=", "null", ")", "{", "/", "/", "rpc", "progress", "should", "be", "refused", ",", "but", "are", "being", "conservative", "see", "comment", "for", "/", "/", "abrupt", "go", "away", "status", "conservative", "this", "does", "reduce", "our", "ability", "to", "perform", "transparent", "/", "/", "retries", ",", "but", "our", "main", "goal", "of", "transporent", "retries", "is", "to", "resolve", "the", "local", "race", "we", "/", "/", "still", "hope", "/", "expect", "servers", "to", "use", "the", "graceful", "double", "-", "goaway", "when", "closing", "/", "/", "connections", "client", "stream", "transport", "report", "status", "(", "abrupt", "go", "away", "status", "conservative", ",", "rpc", "progress", "processed", ",", "false", ",", "new", "metadata", "(", ")", ")", ";", "}", "stream", "close", "(", ")", ";", "}", "return", "true", ";", "}", "}", ")", ";", "}", "catch", "(", "http", "2", "exception", "e", ")", "{", "throw", "new", "runtime", "exception", "(", "e", ")", ";", "}", "}" ]
[ "commits", "this", "edit", "so", "it", "is", "visible", "to", "readers", "this", "releases", "the", "edit", "lock", "so", "another", "edit", "may", "be", "started", "on", "the", "same", "key" ]
[ "public", "void", "commit", "(", ")", "throws", "i", "o", "exception", "{", "if", "(", "has", "errors", ")", "{", "complete", "edit", "(", "this", ",", "false", ")", ";", "remove", "(", "entry", "key", ")", ";", "/", "/", "the", "previous", "entry", "is", "stale", "}", "else", "{", "complete", "edit", "(", "this", ",", "true", ")", ";", "}", "committed", "=", "true", ";", "}" ]
[ "gets", "the", "serializer", "for", "the", "keys", "in", "the", "state" ]
[ "public", "type", "serializer", "<", "uk", ">", "get", "key", "serializer", "(", ")", "{", "final", "type", "serializer", "<", "map", "<", "uk", ",", "uv", ">", ">", "raw", "serializer", "=", "get", "serializer", "(", ")", ";", "if", "(", "!", "(", "raw", "serializer", "instanceof", "map", "serializer", ")", ")", "{", "throw", "new", "illegal", "state", "exception", "(", "\"", "unexpected", "serializer", "type", "\"", ")", ";", "}", "return", "(", "(", "map", "serializer", "<", "uk", ",", "uv", ">", ")", "raw", "serializer", ")", "get", "key", "serializer", "(", ")", ";", "}" ]
[ "this", "test", "verifies", "that", "the", "timestamp", "extractor", "forwards", "long", "max", "value", "watermarks", "same", "test", "as", "before", ",", "but", "using", "a", "different", "timestamp", "extractor" ]
[ "public", "void", "test", "timestamp", "extractor", "with", "long", "max", "watermark", "from", "source", "2", "(", ")", "throws", "exception", "{", "final", "int", "num", "elements", "=", "10", ";", "stream", "execution", "environment", "env", "=", "stream", "execution", "environment", "get", "execution", "environment", "(", ")", ";", "env", "get", "config", "(", ")", "set", "auto", "watermark", "interval", "(", "10", ")", ";", "env", "set", "parallelism", "(", "2", ")", ";", "data", "stream", "<", "integer", ">", "source", "1", "=", "env", "add", "source", "(", "new", "source", "function", "<", "integer", ">", "(", ")", "{", "@", "override", "public", "void", "run", "(", "source", "context", "<", "integer", ">", "ctx", ")", "throws", "exception", "{", "int", "index", "=", "1", ";", "while", "(", "index", "<", "=", "num", "elements", ")", "{", "ctx", "collect", "with", "timestamp", "(", "index", ",", "index", ")", ";", "ctx", "collect", "with", "timestamp", "(", "index", "-", "1", ",", "index", "-", "1", ")", ";", "index", "+", "+", ";", "ctx", "emit", "watermark", "(", "new", "watermark", "(", "index", "-", "2", ")", ")", ";", "}", "/", "/", "emit", "the", "final", "long", "max", "value", "watermark", ",", "do", "it", "twice", "and", "verify", "/", "/", "that", "/", "/", "we", "only", "see", "one", "in", "the", "result", "ctx", "emit", "watermark", "(", "new", "watermark", "(", "long", "max", "value", ")", ")", ";", "ctx", "emit", "watermark", "(", "new", "watermark", "(", "long", "max", "value", ")", ")", ";", "}", "@", "override", "public", "void", "cancel", "(", ")", "{", "}", "}", ")", ";", "source", "1", "assign", "timestamps", "and", "watermarks", "(", "new", "assigner", "with", "periodic", "watermarks", "<", "integer", ">", "(", ")", "{", "@", "override", "public", "long", "extract", "timestamp", "(", "integer", "element", ",", "long", "current", "timestamp", ")", "{", "return", "element", ";", "}", "@", "override", "public", "watermark", "get", "current", "watermark", "(", ")", "{", "return", "null", ";", "}", "}", ")", "transform", "(", "\"", "watermark", "check", "\"", ",", "basic", "type", "info", "int", "type", "info", ",", "new", "custom", "operator", "(", "true", ")", ")", ";", "env", "execute", "(", ")", ";", "assert", "assert", "true", "(", "custom", "operator", "final", "watermarks", "[", "0", "]", "size", "(", ")", "=", "=", "1", ")", ";", "assert", "assert", "true", "(", "custom", "operator", "final", "watermarks", "[", "0", "]", "get", "(", "0", ")", "get", "timestamp", "(", ")", "=", "=", "long", "max", "value", ")", ";", "}" ]
[ "applies", "this", "function", "to", "two", "inputs", ",", "or", "throws", "an", "exception", "if", "unable", "to", "do", "so", "any", "objects", "that", "are", "passed", "to", "{", "@", "link", "deferred", "closer", "#", "eventually", "close", "(", "closeable", ",", "executor", ")", "closer", "eventually", "close", "(", ")", "}", "will", "be", "closed", "when", "the", "{", "@", "link", "closing", "future", "}", "pipeline", "is", "done", "(", "but", "not", "before", "this", "method", "completes", ")", ",", "even", "if", "this", "method", "throws", "or", "the", "pipeline", "is", "cancelled" ]
[ "u", "apply", "(", "deferred", "closer", "closer", ",", "@", "nullable", "decl", "v1", "value", "1", ",", "@", "nullable", "decl", "v2", "value", "2", ")", "throws", "exception", ";" ]
[ "sorts", "the", "specified", "range", "of", "elements", "using", "the", "specified", "swapper", "and", "according", "to", "the", "order", "induced", "by", "the", "specified", "comparator", "using", "quick", "sort", "<", "p", ">", "the", "sorting", "algorithm", "is", "a", "tuned", "quick", "sort", "adapted", "from", "jon", "l", "bentley", "and", "m", "douglas", "mc", "ilroy", ",", "&", "ldquo", ";", "engineering", "a", "sort", "function", "&", "rdquo", ";", ",", "software", ":", "practice", "and", "experience", ",", "23", "(", "11", ")", ",", "pages", "1249", "&", "minus", ";", "1265", ",", "1993" ]
[ "private", "void", "quick", "sort", "(", "pages", "index", "pages", "index", ",", "int", "from", ",", "int", "to", ")", "{", "int", "len", "=", "to", "-", "from", ";", "/", "/", "insertion", "sort", "on", "smallest", "arrays", "if", "(", "len", "<", "small", ")", "{", "for", "(", "int", "i", "=", "from", ";", "i", "<", "to", ";", "i", "+", "+", ")", "{", "for", "(", "int", "j", "=", "i", ";", "j", ">", "from", "&", "&", "(", "comparator", "compare", "to", "(", "pages", "index", ",", "j", "-", "1", ",", "j", ")", ">", "0", ")", ";", "j", "-", "-", ")", "{", "pages", "index", "swap", "(", "j", ",", "j", "-", "1", ")", ";", "}", "}", "return", ";", "}", "/", "/", "choose", "a", "partition", "element", ",", "v", "int", "m", "=", "from", "+", "len", "/", "2", ";", "/", "/", "small", "arrays", ",", "middle", "element", "if", "(", "len", ">", "small", ")", "{", "int", "l", "=", "from", ";", "int", "n", "=", "to", "-", "1", ";", "if", "(", "len", ">", "medium", ")", "{", "/", "/", "big", "arrays", ",", "pseudomedian", "of", "9", "int", "s", "=", "len", "/", "8", ";", "l", "=", "median", "3", "(", "pages", "index", ",", "l", ",", "l", "+", "s", ",", "l", "+", "2", "*", "s", ")", ";", "m", "=", "median", "3", "(", "pages", "index", ",", "m", "-", "s", ",", "m", ",", "m", "+", "s", ")", ";", "n", "=", "median", "3", "(", "pages", "index", ",", "n", "-", "2", "*", "s", ",", "n", "-", "s", ",", "n", ")", ";", "}", "m", "=", "median", "3", "(", "pages", "index", ",", "l", ",", "m", ",", "n", ")", ";", "/", "/", "mid", "-", "size", ",", "med", "of", "3", "}", "/", "/", "int", "v", "=", "x", "[", "m", "]", ";", "int", "a", "=", "from", ";", "int", "b", "=", "a", ";", "int", "c", "=", "to", "-", "1", ";", "/", "/", "establish", "invariant", ":", "v", "*", "(", "<", "v", ")", "*", "(", ">", "v", ")", "*", "v", "*", "int", "d", "=", "c", ";", "while", "(", "true", ")", "{", "int", "comparison", ";", "while", "(", "b", "<", "=", "c", "&", "&", "(", "(", "comparison", "=", "comparator", "compare", "to", "(", "pages", "index", ",", "b", ",", "m", ")", ")", "<", "=", "0", ")", ")", "{", "if", "(", "comparison", "=", "=", "0", ")", "{", "if", "(", "a", "=", "=", "m", ")", "{", "m", "=", "b", ";", "/", "/", "moving", "target", ";", "delta", "to", "jdk", "!", "!", "!", "}", "else", "if", "(", "b", "=", "=", "m", ")", "{", "m", "=", "a", ";", "/", "/", "moving", "target", ";", "delta", "to", "jdk", "!", "!", "!", "}", "pages", "index", "swap", "(", "a", "+", "+", ",", "b", ")", ";", "}", "b", "+", "+", ";", "}", "while", "(", "c", ">", "=", "b", "&", "&", "(", "(", "comparison", "=", "comparator", "compare", "to", "(", "pages", "index", ",", "c", ",", "m", ")", ")", ">", "=", "0", ")", ")", "{", "if", "(", "comparison", "=", "=", "0", ")", "{", "if", "(", "c", "=", "=", "m", ")", "{", "m", "=", "d", ";", "/", "/", "moving", "target", ";", "delta", "to", "jdk", "!", "!", "!", "}", "else", "if", "(", "d", "=", "=", "m", ")", "{", "m", "=", "c", ";", "/", "/", "moving", "target", ";", "delta", "to", "jdk", "!", "!", "!", "}", "pages", "index", "swap", "(", "c", ",", "d", "-", "-", ")", ";", "}", "c", "-", "-", ";", "}", "if", "(", "b", ">", "c", ")", "{", "break", ";", "}", "if", "(", "b", "=", "=", "m", ")", "{", "m", "=", "d", ";", "/", "/", "moving", "target", ";", "delta", "to", "jdk", "!", "!", "!", "}", "else", "if", "(", "c", "=", "=", "m", ")", "{", "m", "=", "c", ";", "/", "/", "moving", "target", ";", "delta", "to", "jdk", "!", "!", "!", "}", "pages", "index", "swap", "(", "b", "+", "+", ",", "c", "-", "-", ")", ";", "}", "/", "/", "swap", "partition", "elements", "back", "to", "middle", "int", "s", ";", "int", "n", "=", "to", ";", "s", "=", "math", "min", "(", "a", "-", "from", ",", "b", "-", "a", ")", ";", "vector", "swap", "(", "pages", "index", ",", "from", ",", "b", "-", "s", ",", "s", ")", ";", "s", "=", "math", "min", "(", "d", "-", "c", ",", "n", "-", "d", "-", "1", ")", ";", "vector", "swap", "(", "pages", "index", ",", "b", ",", "n", "-", "s", ",", "s", ")", ";", "/", "/", "recursively", "sort", "non", "-", "partition", "-", "elements", "if", "(", "(", "s", "=", "b", "-", "a", ")", ">", "1", ")", "{", "quick", "sort", "(", "pages", "index", ",", "from", ",", "from", "+", "s", ")", ";", "}", "if", "(", "(", "s", "=", "d", "-", "c", ")", ">", "1", ")", "{", "quick", "sort", "(", "pages", "index", ",", "n", "-", "s", ",", "n", ")", ";", "}", "}" ]
[ "ensures", "the", "cluster", "is", "healthy", "after", "the", "disruption" ]
[ "public", "void", "ensure", "healthy", "(", "internal", "test", "cluster", "cluster", ")", "{", "assert", "active", "disruption", "=", "=", "false", ";", "ensure", "node", "count", "(", "cluster", ")", ";", "ensure", "fully", "connected", "cluster", "(", "cluster", ")", ";", "}" ]
[ "returns", "the", "current", "wizard", "panel" ]
[ "public", "wizard", "panel", "get", "current", "wizard", "panel", "(", ")", "{", "return", "curr", "wiz", "panel", ";", "}" ]
[ "find", "purchase", "order", "by", "id", "for", "valid", "response", "try", "integer", "i", "ds", "with", "value", "&", "lt", ";", "&", "#", "x", "3", "d", ";", "5", "or", "&", "gt", ";", "10", "other", "values", "will", "generated", "exceptions" ]
[ "public", "order", "get", "order", "by", "id", "(", "long", "order", "id", ")", "throws", "api", "exception", "{", "object", "local", "var", "post", "body", "=", "null", ";", "/", "/", "verify", "the", "required", "parameter", "'", "order", "id", "'", "is", "set", "if", "(", "order", "id", "=", "=", "null", ")", "{", "throw", "new", "api", "exception", "(", "400", ",", "\"", "missing", "the", "required", "parameter", "'", "order", "id", "'", "when", "calling", "get", "order", "by", "id", "\"", ")", ";", "}", "/", "/", "create", "path", "and", "map", "variables", "string", "local", "var", "path", "=", "\"", "/", "store", "/", "order", "/", "{", "order", "id", "}", "\"", "replace", "all", "(", "\"", "\\", "\\", "{", "format", "\\", "\\", "}", "\"", ",", "\"", "json", "\"", ")", "replace", "all", "(", "\"", "\\", "\\", "{", "\"", "+", "\"", "order", "id", "\"", "+", "\"", "\\", "\\", "}", "\"", ",", "api", "invoker", "escape", "string", "(", "order", "id", "to", "string", "(", ")", ")", ")", ";", "/", "/", "query", "params", "list", "<", "pair", ">", "local", "var", "query", "params", "=", "new", "array", "list", "<", "pair", ">", "(", ")", ";", "/", "/", "header", "params", "map", "<", "string", ",", "string", ">", "local", "var", "header", "params", "=", "new", "hash", "map", "<", "string", ",", "string", ">", "(", ")", ";", "/", "/", "form", "params", "map", "<", "string", ",", "string", ">", "local", "var", "form", "params", "=", "new", "hash", "map", "<", "string", ",", "string", ">", "(", ")", ";", "string", "[", "]", "local", "var", "content", "types", "=", "{", "}", ";", "string", "local", "var", "content", "type", "=", "local", "var", "content", "types", "length", ">", "0", "?", "local", "var", "content", "types", "[", "0", "]", ":", "\"", "application", "/", "json", "\"", ";", "if", "(", "local", "var", "content", "type", "starts", "with", "(", "\"", "multipart", "/", "form", "-", "data", "\"", ")", ")", "{", "/", "/", "file", "uploading", "multipart", "entity", "builder", "local", "var", "builder", "=", "multipart", "entity", "builder", "create", "(", ")", ";", "local", "var", "post", "body", "=", "local", "var", "builder", "build", "(", ")", ";", "}", "else", "{", "/", "/", "normal", "form", "params", "}", "try", "{", "string", "local", "var", "response", "=", "api", "invoker", "invoke", "a", "p", "i", "(", "base", "path", ",", "local", "var", "path", ",", "\"", "get", "\"", ",", "local", "var", "query", "params", ",", "local", "var", "post", "body", ",", "local", "var", "header", "params", ",", "local", "var", "form", "params", ",", "local", "var", "content", "type", ")", ";", "if", "(", "local", "var", "response", "!", "=", "null", ")", "{", "return", "(", "order", ")", "api", "invoker", "deserialize", "(", "local", "var", "response", ",", "\"", "\"", ",", "order", "class", ")", ";", "}", "else", "{", "return", "null", ";", "}", "}", "catch", "(", "api", "exception", "ex", ")", "{", "throw", "ex", ";", "}", "}" ]
[ "add", "an", "attribute", "for", "a", "transactional", "method", "method", "names", "can", "end", "or", "start", "with", "\"", "\"", "for", "matching", "multiple", "methods" ]
[ "public", "void", "add", "transactional", "method", "(", "class", "<", "?", ">", "clazz", ",", "string", "mapped", "name", ",", "transaction", "attribute", "attr", ")", "{", "assert", "not", "null", "(", "clazz", ",", "\"", "class", "must", "not", "be", "null", "\"", ")", ";", "assert", "not", "null", "(", "mapped", "name", ",", "\"", "mapped", "name", "must", "not", "be", "null", "\"", ")", ";", "string", "name", "=", "clazz", "get", "name", "(", ")", "+", "'", "'", "+", "mapped", "name", ";", "method", "[", "]", "methods", "=", "clazz", "get", "declared", "methods", "(", ")", ";", "list", "<", "method", ">", "matching", "methods", "=", "new", "array", "list", "<", ">", "(", ")", ";", "for", "(", "method", "method", ":", "methods", ")", "{", "if", "(", "is", "match", "(", "method", "get", "name", "(", ")", ",", "mapped", "name", ")", ")", "{", "matching", "methods", "add", "(", "method", ")", ";", "}", "}", "if", "(", "matching", "methods", "is", "empty", "(", ")", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "could", "not", "find", "method", "'", "\"", "+", "mapped", "name", "+", "\"", "'", "on", "class", "[", "\"", "+", "clazz", "get", "name", "(", ")", "+", "\"", "]", "\"", ")", ";", "}", "/", "/", "register", "all", "matching", "methods", "for", "(", "method", "method", ":", "matching", "methods", ")", "{", "string", "reg", "method", "name", "=", "this", "method", "name", "map", "get", "(", "method", ")", ";", "if", "(", "reg", "method", "name", "=", "=", "null", "|", "|", "(", "!", "reg", "method", "name", "equals", "(", "name", ")", "&", "&", "reg", "method", "name", "length", "(", ")", "<", "=", "name", "length", "(", ")", ")", ")", "{", "/", "/", "no", "already", "registered", "method", "name", ",", "or", "more", "specific", "/", "/", "method", "name", "specification", "now", "-", ">", "(", "re", "-", ")", "register", "method", "if", "(", "logger", "is", "debug", "enabled", "(", ")", "&", "&", "reg", "method", "name", "!", "=", "null", ")", "{", "logger", "debug", "(", "\"", "replacing", "attribute", "for", "transactional", "method", "[", "\"", "+", "method", "+", "\"", "]", ":", "current", "name", "'", "\"", "+", "name", "+", "\"", "'", "is", "more", "specific", "than", "'", "\"", "+", "reg", "method", "name", "+", "\"", "'", "\"", ")", ";", "}", "this", "method", "name", "map", "put", "(", "method", ",", "name", ")", ";", "add", "transactional", "method", "(", "method", ",", "attr", ")", ";", "}", "else", "{", "if", "(", "logger", "is", "debug", "enabled", "(", ")", ")", "{", "logger", "debug", "(", "\"", "keeping", "attribute", "for", "transactional", "method", "[", "\"", "+", "method", "+", "\"", "]", ":", "current", "name", "'", "\"", "+", "name", "+", "\"", "'", "is", "not", "more", "specific", "than", "'", "\"", "+", "reg", "method", "name", "+", "\"", "'", "\"", ")", ";", "}", "}", "}", "}" ]
[ "execute", "the", "command", "asynchronously" ]
[ "public", "static", "utils", "task", "<", "command", "result", ">", "exec", "cmd", "async", "(", "final", "string", "command", ",", "final", "boolean", "is", "rooted", ",", "final", "utils", "consumer", "<", "command", "result", ">", "consumer", ")", "{", "return", "exec", "cmd", "async", "(", "new", "string", "[", "]", "{", "command", "}", ",", "is", "rooted", ",", "true", ",", "consumer", ")", ";", "}" ]
[ "delete", "user", "this", "can", "only", "be", "done", "by", "the", "logged", "in", "user", "<", "b", ">", "400", "<", "b", ">", "-", "invalid", "username", "supplied", "<", "b", ">", "404", "<", "b", ">", "-", "user", "not", "found" ]
[ "public", "void", "delete", "user", "(", "string", "username", ")", "throws", "rest", "client", "exception", "{", "delete", "user", "with", "http", "info", "(", "username", ")", ";", "}" ]
[ "performs", "necessary", "checks", ",", "cancels", "the", "task", "and", "calls", "the", "runnable", "upon", "completion" ]
[ "void", "cancel", "task", "(", "task", "manager", "task", "manager", ",", "runnable", "runnable", ",", "string", "reason", ")", ";" ]
[ "test", "the", "property", "'", "int", "3", "2", "'" ]
[ "public", "void", "int", "3", "2", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "int", "3", "2", "}" ]
[ "get", "the", "cursor", "location", "if", "there", "is", "no", "current", "view", ",", "then", "return", "null" ]
[ "byte", "block", "info", "get", "cursor", "location", "(", ")", "{", "if", "(", "current", "view", "=", "=", "null", ")", "{", "return", "null", ";", "}", "return", "current", "view", "get", "viewer", "cursor", "location", "(", ")", ";", "}" ]
[ "computes", "the", "barycentric", "coordinates", "v", ",", "w", "for", "the", "specified", "point", "in", "the", "triangle", "if", "barycentric", "x", ">", "=", "0", "&", "&", "barycentric", "y", ">", "=", "0", "&", "&", "barycentric", "x", "+", "barycentric", "y", "<", "=", "1", "then", "the", "point", "is", "inside", "the", "triangle", "if", "vertices", "a", ",", "b", ",", "c", "have", "values", "aa", ",", "bb", ",", "cc", "then", "to", "get", "an", "interpolated", "value", "at", "point", "p", ":", "geometry", "utils", "barycentric", "(", "p", ",", "a", ",", "b", ",", "c", ",", "barycentric", ")", ";", "float", "u", "=", "1", "f", "-", "barycentric", "x", "-", "barycentric", "y", ";", "float", "x", "=", "u", "aa", "x", "+", "barycentric", "x", "bb", "x", "+", "barycentric", "y", "cc", "x", ";", "float", "y", "=", "u", "aa", "y", "+", "barycentric", "x", "bb", "y", "+", "barycentric", "y", "cc", "y", ";" ]
[ "static", "public", "vector", "2", "to", "barycoord", "(", "vector", "2", "p", ",", "vector", "2", "a", ",", "vector", "2", "b", ",", "vector", "2", "c", ",", "vector", "2", "barycentric", "out", ")", "{", "vector", "2", "v", "0", "=", "tmp", "1", "set", "(", "b", ")", "sub", "(", "a", ")", ";", "vector", "2", "v", "1", "=", "tmp", "2", "set", "(", "c", ")", "sub", "(", "a", ")", ";", "vector", "2", "v", "2", "=", "tmp", "3", "set", "(", "p", ")", "sub", "(", "a", ")", ";", "float", "d", "0", "0", "=", "v", "0", "dot", "(", "v", "0", ")", ";", "float", "d", "0", "1", "=", "v", "0", "dot", "(", "v", "1", ")", ";", "float", "d", "1", "1", "=", "v", "1", "dot", "(", "v", "1", ")", ";", "float", "d", "2", "0", "=", "v", "2", "dot", "(", "v", "0", ")", ";", "float", "d", "2", "1", "=", "v", "2", "dot", "(", "v", "1", ")", ";", "float", "denom", "=", "d", "0", "0", "*", "d", "1", "1", "-", "d", "0", "1", "*", "d", "0", "1", ";", "barycentric", "out", "x", "=", "(", "d", "1", "1", "*", "d", "2", "0", "-", "d", "0", "1", "*", "d", "2", "1", ")", "/", "denom", ";", "barycentric", "out", "y", "=", "(", "d", "0", "0", "*", "d", "2", "1", "-", "d", "0", "1", "*", "d", "2", "0", ")", "/", "denom", ";", "return", "barycentric", "out", ";", "}" ]
[ "specifies", "the", "computation", "of", "a", "median", "(", "i", "e", "the", "1st", "2", "-", "quantile", ")" ]
[ "public", "static", "scale", "and", "index", "median", "(", ")", "{", "return", "scale", "(", "2", ")", "index", "(", "1", ")", ";", "}" ]
[ "tries", "to", "release", "the", "memory", "for", "the", "specified", "segment", "if", "the", "segment", "has", "already", "been", "released", ",", "it", "is", "only", "freed", "if", "it", "is", "null", "or", "has", "no", "owner", ",", "the", "request", "is", "simply", "ignored", "the", "segment", "is", "only", "freed", "and", "made", "eligible", "for", "reclamation", "by", "the", "gc", "the", "segment", "will", "be", "returned", "to", "the", "memory", "pool", ",", "increasing", "its", "available", "limit", "for", "the", "later", "allocations" ]
[ "public", "void", "release", "(", "memory", "segment", "segment", ")", "{", "preconditions", "check", "state", "(", "!", "is", "shut", "down", ",", "\"", "memory", "manager", "has", "been", "shut", "down", "\"", ")", ";", "/", "/", "check", "if", "segment", "is", "null", "or", "has", "already", "been", "freed", "if", "(", "segment", "=", "=", "null", "|", "|", "segment", "get", "owner", "(", ")", "=", "=", "null", ")", "{", "return", ";", "}", "/", "/", "remove", "the", "reference", "in", "the", "map", "for", "the", "owner", "try", "{", "allocated", "segments", "compute", "if", "present", "(", "segment", "get", "owner", "(", ")", ",", "(", "o", ",", "segs", "for", "owner", ")", "-", ">", "{", "segment", "free", "(", ")", ";", "segs", "for", "owner", "remove", "(", "segment", ")", ";", "return", "segs", "for", "owner", "is", "empty", "(", ")", "?", "null", ":", "segs", "for", "owner", ";", "}", ")", ";", "}", "catch", "(", "throwable", "t", ")", "{", "throw", "new", "runtime", "exception", "(", "\"", "error", "removing", "book", "-", "keeping", "reference", "to", "allocated", "memory", "segment", "\"", ",", "t", ")", ";", "}", "}" ]
[ "tests", "join", "program", "with", "replicated", "data", "source", "behind", "flat", "map" ]
[ "public", "void", "check", "join", "with", "replicated", "source", "input", "behind", "flat", "map", "(", ")", "{", "execution", "environment", "env", "=", "execution", "environment", "create", "local", "environment", "(", ")", ";", "env", "set", "parallelism", "(", "default", "parallelism", ")", ";", "tuple", "type", "info", "<", "tuple", "1", "<", "string", ">", ">", "type", "info", "=", "tuple", "type", "info", "get", "basic", "tuple", "type", "info", "(", "string", "class", ")", ";", "replicating", "input", "format", "<", "tuple", "1", "<", "string", ">", ",", "file", "input", "split", ">", "rif", "=", "new", "replicating", "input", "format", "<", "tuple", "1", "<", "string", ">", ",", "file", "input", "split", ">", "(", "new", "tuple", "csv", "input", "format", "<", "tuple", "1", "<", "string", ">", ">", "(", "new", "path", "(", "\"", "/", "some", "/", "path", "\"", ")", ",", "type", "info", ")", ")", ";", "data", "set", "<", "tuple", "1", "<", "string", ">", ">", "source", "1", "=", "env", "create", "input", "(", "rif", ",", "new", "tuple", "type", "info", "<", "tuple", "1", "<", "string", ">", ">", "(", "basic", "type", "info", "string", "type", "info", ")", ")", ";", "data", "set", "<", "tuple", "1", "<", "string", ">", ">", "source", "2", "=", "env", "read", "csv", "file", "(", "\"", "/", "some", "/", "otherpath", "\"", ")", "types", "(", "string", "class", ")", ";", "data", "sink", "<", "tuple", "2", "<", "tuple", "1", "<", "string", ">", ",", "tuple", "1", "<", "string", ">", ">", ">", "out", "=", "source", "1", "flat", "map", "(", "new", "id", "flat", "map", "(", ")", ")", "join", "(", "source", "2", ")", "where", "(", "\"", "*", "\"", ")", "equal", "to", "(", "\"", "*", "\"", ")", "write", "as", "text", "(", "\"", "/", "some", "/", "newpath", "\"", ")", ";", "plan", "plan", "=", "env", "create", "program", "plan", "(", ")", ";", "/", "/", "submit", "the", "plan", "to", "the", "compiler", "optimized", "plan", "o", "plan", "=", "compile", "no", "stats", "(", "plan", ")", ";", "/", "/", "check", "the", "optimized", "plan", "/", "/", "when", "join", "should", "have", "forward", "strategy", "on", "both", "sides", "sink", "plan", "node", "sink", "node", "=", "o", "plan", "get", "data", "sinks", "(", ")", "iterator", "(", ")", "next", "(", ")", ";", "dual", "input", "plan", "node", "join", "node", "=", "(", "dual", "input", "plan", "node", ")", "sink", "node", "get", "predecessor", "(", ")", ";", "ship", "strategy", "type", "join", "in", "1", "=", "join", "node", "get", "input", "1", "(", ")", "get", "ship", "strategy", "(", ")", ";", "ship", "strategy", "type", "join", "in", "2", "=", "join", "node", "get", "input", "2", "(", ")", "get", "ship", "strategy", "(", ")", ";", "assert", "assert", "equals", "(", "\"", "invalid", "ship", "strategy", "for", "an", "operator", "\"", ",", "ship", "strategy", "type", "forward", ",", "join", "in", "1", ")", ";", "assert", "assert", "equals", "(", "\"", "invalid", "ship", "strategy", "for", "an", "operator", "\"", ",", "ship", "strategy", "type", "forward", ",", "join", "in", "2", ")", ";", "}" ]
[ "process", "the", "symbol", "table", "section", "of", "the", "xml", "file" ]
[ "void", "read", "(", "xml", "pull", "parser", "parser", ",", "boolean", "is", "overwrite", "primary", ",", "task", "monitor", "monitor", ")", "throws", "cancelled", "exception", "{", "read", "(", "parser", ",", "is", "overwrite", "primary", ",", "1", ",", "monitor", ")", ";", "}" ]
[ "undoes", "the", "last", "action" ]
[ "public", "void", "undo", "(", ")", "{", "undo", "(", "true", ")", ";", "}" ]
[ "waits", "for", "the", "all", "the", "services", "to", "reach", "a", "terminal", "state", "after", "this", "method", "returns", "all", "services", "will", "either", "be", "{", "@", "linkplain", "service", "state", "#", "terminated", "terminated", "}", "or", "{", "@", "linkplain", "service", "state", "#", "failed", "failed", "}" ]
[ "public", "void", "await", "stopped", "(", ")", "{", "state", "await", "stopped", "(", ")", ";", "}" ]
[ "<", "code", ">", "repeated", "io", "netty", "example", "worldclock", "local", "time", "local", "time", "=", "1", ";", "<", "code", ">" ]
[ "public", "java", "util", "list", "<", "io", "netty", "example", "worldclock", "world", "clock", "protocol", "local", "time", "builder", ">", "get", "local", "time", "builder", "list", "(", ")", "{", "return", "get", "local", "time", "field", "builder", "(", ")", "get", "builder", "list", "(", ")", ";", "}" ]
[ "copies", "the", "contents", "of", "this", "directory", "recursively", "into", "the", "specified", "target", "directory" ]
[ "public", "int", "copy", "recursive", "to", "(", "file", "path", "target", ")", "throws", "i", "o", "exception", ",", "interrupted", "exception", "{", "return", "copy", "recursive", "to", "(", "\"", "*", "*", "/", "*", "\"", ",", "target", ")", ";", "}" ]
[ "to", "simplify", "code", ",", "this", "doesn", "'", "t", "actually", "invoke", "the", "underlying", "{", "@", "link", "#", "execute", "(", ")", "}", "method", "this", "is", "ok", "because", "in", "almost", "all", "cases", ",", "doing", "so", "would", "imply", "invoking", "{", "@", "link", "#", "enqueue", "(", "callback", ")", "}", "anyway" ]
[ "@", "override", "protected", "void", "do", "execute", "(", ")", "throws", "i", "o", "exception", "{", "/", "/", "enqueue", "the", "call", "invocation", "on", "the", "executor", "and", "block", "until", "it", "completes", "do", "enqueue", "(", "noop", "callback", ")", ";", "if", "(", "!", "await", "(", "latch", ")", ")", "throw", "new", "interrupted", "i", "o", "exception", "(", ")", ";", "/", "/", "check", "if", "the", "run", "resulted", "in", "an", "exception", "throwable", "t", "=", "this", "throwable", ";", "if", "(", "t", "=", "=", "null", ")", "return", "null", ";", "/", "/", "success", "/", "/", "coerce", "the", "throwable", "to", "the", "signature", "of", "call", "execute", "(", ")", "if", "(", "t", "instanceof", "error", ")", "throw", "(", "error", ")", "t", ";", "if", "(", "t", "instanceof", "i", "o", "exception", ")", "throw", "(", "i", "o", "exception", ")", "t", ";", "if", "(", "t", "instanceof", "runtime", "exception", ")", "throw", "(", "runtime", "exception", ")", "t", ";", "throw", "new", "runtime", "exception", "(", "t", ")", ";", "}" ]
[ "get", "the", "interval", "from", "{", "@", "code", "histogram", "aggregation", "}", "or", "throw", "an", "{", "@", "code", "illegal", "state", "exception", "}", "if", "{", "@", "code", "histogram", "aggregation", "}", "is", "not", "a", "{", "@", "link", "histogram", "aggregation", "builder", "}", "or", "a", "{", "@", "link", "date", "histogram", "aggregation", "builder", "}" ]
[ "public", "static", "long", "get", "histogram", "interval", "millis", "(", "aggregation", "builder", "histogram", "aggregation", ")", "{", "if", "(", "histogram", "aggregation", "instanceof", "histogram", "aggregation", "builder", ")", "{", "return", "(", "long", ")", "(", "(", "histogram", "aggregation", "builder", ")", "histogram", "aggregation", ")", "interval", "(", ")", ";", "}", "else", "if", "(", "histogram", "aggregation", "instanceof", "date", "histogram", "aggregation", "builder", ")", "{", "return", "validate", "and", "get", "date", "histogram", "interval", "(", "(", "date", "histogram", "aggregation", "builder", ")", "histogram", "aggregation", ")", ";", "}", "else", "{", "throw", "new", "illegal", "state", "exception", "(", "\"", "invalid", "histogram", "aggregation", "[", "\"", "+", "histogram", "aggregation", "get", "name", "(", ")", "+", "\"", "]", "\"", ")", ";", "}", "}" ]
[ "add", "a", "custom", "formatter", ",", "applying", "it", "to", "all", "fields", "matching", "the", "{", "@", "link", "formatter", "}", "-", "declared", "type", "registers", "a", "corresponding", "{", "@", "link", "property", "editor", "}", "adapter", "underneath", "the", "covers" ]
[ "public", "void", "add", "custom", "formatter", "(", "formatter", "<", "?", ">", "formatter", ")", "{", "formatter", "property", "editor", "adapter", "adapter", "=", "new", "formatter", "property", "editor", "adapter", "(", "formatter", ")", ";", "get", "property", "editor", "registry", "(", ")", "register", "custom", "editor", "(", "adapter", "get", "field", "type", "(", ")", ",", "adapter", ")", ";", "}" ]
[ "return", "the", "attribute", "of", "the", "specified", "keyed", "object", "as", "a", "string" ]
[ "public", "string", "get", "value", "as", "string", "(", "keyed", "object", "o", ")", "{", "try", "{", "return", "integer", "to", "string", "(", "get", "value", "(", "o", ")", ")", ";", "}", "catch", "(", "ghidra", "util", "exception", "no", "value", "exception", "exc", ")", "{", "return", "\"", "0", "\"", ";", "}", "}" ]
[ "returns", "list", "of", "groups", "for", "a", "user", "this", "calls", "{", "@", "link", "ldap", "groups", "mapping", "}", "'", "s", "get", "groups", "and", "applies", "the", "configured", "rules", "on", "group", "names", "before", "returning" ]
[ "public", "synchronized", "list", "<", "string", ">", "get", "groups", "(", "string", "user", ")", "{", "list", "<", "string", ">", "groups", "=", "super", "get", "groups", "(", "user", ")", ";", "switch", "(", "rule", ")", "{", "case", "to", "upper", ":", "return", "groups", "stream", "(", ")", "map", "(", "string", "utils", ":", ":", "to", "upper", "case", ")", "collect", "(", "collectors", "to", "list", "(", ")", ")", ";", "case", "to", "lower", ":", "return", "groups", "stream", "(", ")", "map", "(", "string", "utils", ":", ":", "to", "lower", "case", ")", "collect", "(", "collectors", "to", "list", "(", ")", ")", ";", "case", "none", ":", "default", ":", "return", "groups", ";", "}", "}" ]
[ "copies", "important", "fields", "from", "the", "current", "http", "request", "and", "makes", "them", "available", "during", "{", "@", "link", "#", "compute", "}", "this", "is", "necessary", "because", "some", "model", "methods", "such", "as", "{", "@", "link", "abstract", "item", "#", "get", "url", "}", "behave", "differently", "when", "called", "from", "a", "request" ]
[ "private", "static", "request", "impl", "create", "mock", "request", "(", ")", "{", "request", "impl", "current", "request", "=", "(", "request", "impl", ")", "stapler", "get", "current", "request", "(", ")", ";", "http", "servlet", "request", "original", "=", "(", "http", "servlet", "request", ")", "current", "request", "get", "request", "(", ")", ";", "final", "map", "<", "string", ",", "object", ">", "getters", "=", "new", "hash", "map", "<", ">", "(", ")", ";", "for", "(", "method", "method", ":", "http", "servlet", "request", "class", "get", "methods", "(", ")", ")", "{", "string", "m", "=", "method", "get", "name", "(", ")", ";", "if", "(", "(", "m", "starts", "with", "(", "\"", "get", "\"", ")", "|", "|", "m", "starts", "with", "(", "\"", "is", "\"", ")", ")", "&", "&", "method", "get", "parameter", "types", "(", ")", "length", "=", "=", "0", ")", "{", "class", "<", "?", ">", "type", "=", "method", "get", "return", "type", "(", ")", ";", "/", "/", "todo", "could", "add", "other", "types", "which", "are", "known", "to", "be", "safe", "to", "copy", ":", "cookie", "[", "]", ",", "principal", ",", "http", "session", ",", "etc", "if", "(", "type", "is", "primitive", "(", ")", "|", "|", "type", "=", "=", "string", "class", "|", "|", "type", "=", "=", "locale", "class", ")", "{", "try", "{", "getters", "put", "(", "m", ",", "method", "invoke", "(", "original", ")", ")", ";", "}", "catch", "(", "exception", "x", ")", "{", "log", "log", "(", "level", "warning", ",", "\"", "cannot", "mock", "stapler", "request", "\"", "+", "method", ",", "x", ")", ";", "}", "}", "}", "}", "list", "/", "*", "<", "ancestor", "impl", ">", "*", "/", "ancestors", "=", "current", "request", "ancestors", ";", "log", "log", "(", "level", "finer", ",", "\"", "mocking", "ancestors", "{", "0", "}", "using", "{", "1", "}", "\"", ",", "new", "object", "[", "]", "{", "ancestors", ",", "getters", "}", ")", ";", "token", "list", "tokens", "=", "current", "request", "tokens", ";", "return", "new", "request", "impl", "(", "stapler", "get", "current", "(", ")", ",", "(", "http", "servlet", "request", ")", "proxy", "new", "proxy", "instance", "(", "progressive", "rendering", "class", "get", "class", "loader", "(", ")", ",", "new", "class", "<", "?", ">", "[", "]", "{", "http", "servlet", "request", "class", "}", ",", "new", "invocation", "handler", "(", ")", "{", "@", "override", "public", "object", "invoke", "(", "object", "proxy", ",", "method", "method", ",", "object", "[", "]", "args", ")", "throws", "throwable", "{", "string", "m", "=", "method", "get", "name", "(", ")", ";", "if", "(", "getters", "contains", "key", "(", "m", ")", ")", "{", "return", "getters", "get", "(", "m", ")", ";", "}", "else", "{", "/", "/", "todo", "implement", "other", "methods", "as", "needed", "throw", "new", "unsupported", "operation", "exception", "(", "m", ")", ";", "}", "}", "}", ")", ",", "ancestors", ",", "tokens", ")", ";", "}" ]
[ "returns", "a", "{", "@", "link", "java", "proto", "aspect", "common", "}", "instance", "that", "handles", "logic", "for", "{", "@", "code", "java", "proto", "library", "}" ]
[ "static", "java", "proto", "aspect", "common", "get", "speed", "instance", "(", "rule", "context", "rule", "context", ",", "java", "semantics", "java", "semantics", ",", "rpc", "support", "rpc", "support", ")", "{", "return", "new", "java", "proto", "aspect", "common", "(", "rule", "context", ",", "java", "semantics", ",", "rpc", "support", ",", "speed", "proto", "toolchain", "attr", ",", "speed", "jar", "suffix", ")", ";", "}" ]
[ "return", "time", "duration", "in", "the", "given", "time", "unit", "valid", "units", "are", "encoded", "in", "properties", "as", "suffixes", ":", "nanoseconds", "(", "ns", ")", ",", "microseconds", "(", "us", ")", ",", "milliseconds", "(", "ms", ")", ",", "seconds", "(", "s", ")", ",", "minutes", "(", "m", ")", ",", "hours", "(", "h", ")", ",", "and", "days", "(", "d", ")" ]
[ "public", "long", "get", "time", "duration", "helper", "(", "string", "name", ",", "string", "v", "str", ",", "time", "unit", "unit", ")", "{", "v", "str", "=", "v", "str", "trim", "(", ")", ";", "v", "str", "=", "string", "utils", "to", "lower", "case", "(", "v", "str", ")", ";", "parsed", "time", "duration", "v", "unit", "=", "parsed", "time", "duration", "unit", "for", "(", "v", "str", ")", ";", "if", "(", "null", "=", "=", "v", "unit", ")", "{", "log", "deprecation", "(", "\"", "no", "unit", "for", "\"", "+", "name", "+", "\"", "(", "\"", "+", "v", "str", "+", "\"", ")", "assuming", "\"", "+", "unit", ")", ";", "v", "unit", "=", "parsed", "time", "duration", "unit", "for", "(", "unit", ")", ";", "}", "else", "{", "v", "str", "=", "v", "str", "substring", "(", "0", ",", "v", "str", "last", "index", "of", "(", "v", "unit", "suffix", "(", ")", ")", ")", ";", "}", "long", "raw", "=", "long", "parse", "long", "(", "v", "str", ")", ";", "long", "converted", "=", "unit", "convert", "(", "raw", ",", "v", "unit", "unit", "(", ")", ")", ";", "if", "(", "v", "unit", "unit", "(", ")", "convert", "(", "converted", ",", "unit", ")", "<", "raw", ")", "{", "log", "deprecation", "(", "\"", "possible", "loss", "of", "precision", "converting", "\"", "+", "v", "str", "+", "v", "unit", "suffix", "(", ")", "+", "\"", "to", "\"", "+", "unit", "+", "\"", "for", "\"", "+", "name", ")", ";", "}", "return", "converted", ";", "}" ]
[ "get", "my", "string" ]
[ "public", "string", "get", "my", "string", "(", ")", "{", "return", "my", "string", ";", "}" ]
[ "sets", "the", "<", "code", ">", "prefix", "array", "<", "code", ">", "property" ]
[ "public", "xml", "item", "prefix", "array", "(", "list", "<", "integer", ">", "prefix", "array", ")", "{", "this", "prefix", "array", "=", "prefix", "array", ";", "return", "this", ";", "}" ]
[ "adds", "the", "specified", "vertices", "to", "the", "cache", "each", "vertex", "should", "have", "5", "elements", ",", "one", "for", "each", "of", "the", "attributes", ":", "x", ",", "y", ",", "color", ",", "u", ",", "and", "v", "if", "indexed", "geometry", "is", "used", ",", "each", "image", "should", "be", "specified", "as", "4", "vertices", ",", "otherwise", "each", "image", "should", "be", "specified", "as", "6", "vertices" ]
[ "public", "void", "add", "(", "texture", "texture", ",", "float", "[", "]", "vertices", ",", "int", "offset", ",", "int", "length", ")", "{", "if", "(", "current", "cache", "=", "=", "null", ")", "throw", "new", "illegal", "state", "exception", "(", "\"", "begin", "cache", "must", "be", "called", "before", "add", "\"", ")", ";", "int", "vertices", "per", "image", "=", "mesh", "get", "num", "indices", "(", ")", ">", "0", "?", "4", ":", "6", ";", "int", "count", "=", "length", "/", "(", "vertices", "per", "image", "*", "vertex", "size", ")", "*", "6", ";", "int", "last", "index", "=", "textures", "size", "-", "1", ";", "if", "(", "last", "index", "<", "0", "|", "|", "textures", "get", "(", "last", "index", ")", "!", "=", "texture", ")", "{", "textures", "add", "(", "texture", ")", ";", "counts", "add", "(", "count", ")", ";", "}", "else", "counts", "incr", "(", "last", "index", ",", "count", ")", ";", "mesh", "get", "vertices", "buffer", "(", ")", "put", "(", "vertices", ",", "offset", ",", "length", ")", ";", "}" ]
[ "dequeues", "the", "playing", "period", "holder", "from", "the", "front", "of", "the", "queue", "and", "advances", "the", "playing", "period", "holder", "to", "be", "the", "next", "item", "in", "the", "queue" ]
[ "public", "media", "period", "holder", "advance", "playing", "period", "(", ")", "{", "if", "(", "playing", "=", "=", "null", ")", "{", "return", "null", ";", "}", "if", "(", "playing", "=", "=", "reading", ")", "{", "reading", "=", "playing", "get", "next", "(", ")", ";", "}", "playing", "release", "(", ")", ";", "length", "-", "-", ";", "if", "(", "length", "=", "=", "0", ")", "{", "loading", "=", "null", ";", "old", "front", "period", "uid", "=", "playing", "uid", ";", "old", "front", "period", "window", "sequence", "number", "=", "playing", "info", "id", "window", "sequence", "number", ";", "}", "playing", "=", "playing", "get", "next", "(", ")", ";", "notify", "queue", "update", "(", ")", ";", "return", "playing", ";", "}" ]
[ "model", "tests", "for", "tag" ]
[ "public", "void", "test", "tag", "(", ")", "{", "/", "/", "todo", ":", "test", "tag", "}" ]
[ "creates", "a", "new", "{", "@", "code", "session", "windows", "}", "{", "@", "link", "window", "assigner", "}", "that", "assigns", "elements", "to", "sessions", "based", "on", "the", "element", "timestamp" ]
[ "public", "static", "processing", "time", "session", "windows", "with", "gap", "(", "time", "size", ")", "{", "return", "new", "processing", "time", "session", "windows", "(", "size", "to", "milliseconds", "(", ")", ")", ";", "}" ]
[ "get", "server", "port", "of", "this", "http", "server" ]
[ "public", "static", "string", "get", "port", "(", ")", "{", "if", "(", "runtime", "port", ">", "0", ")", "{", "return", "string", "value", "of", "(", "runtime", "port", ")", ";", "}", "return", "sentinel", "config", "get", "config", "(", "server", "port", ")", ";", "}" ]
[ "retrieve", "the", "given", "annotation", "'", "s", "attributes", "as", "an", "{", "@", "link", "annotation", "attributes", "}", "map", "this", "method", "provides", "fully", "recursive", "annotation", "reading", "capabilities", "on", "par", "with", "the", "reflection", "-", "based", "{", "@", "link", "org", "springframework", "core", "type", "standard", "annotation", "metadata", "}" ]
[ "public", "static", "annotation", "attributes", "get", "annotation", "attributes", "(", "annotation", "annotation", ",", "boolean", "class", "values", "as", "string", ",", "boolean", "nested", "annotations", "as", "map", ")", "{", "return", "get", "annotation", "attributes", "(", "null", ",", "annotation", ",", "class", "values", "as", "string", ",", "nested", "annotations", "as", "map", ")", ";", "}" ]
[ "allows", "to", "override", "the", "node", "client", "username", "(", "used", "while", "sending", "requests", "to", "the", "test", "cluster", ")", "when", "the", "{", "@", "link", "org", "elasticsearch", "test", "e", "s", "integ", "test", "case", "cluster", "scope", "}", "is", "set", "to", "{", "@", "link", "org", "elasticsearch", "test", "e", "s", "integ", "test", "case", "scope", "#", "suite", "}", "or", "{", "@", "link", "org", "elasticsearch", "test", "e", "s", "integ", "test", "case", "scope", "#", "test", "}" ]
[ "protected", "string", "node", "client", "username", "(", ")", "{", "return", "security", "default", "settings", "node", "client", "username", "(", ")", ";", "}" ]
[ "helper", "for", "{", "@", "link", "#", "process", "block", "}", ",", "which", "merges", "frames", "and", "adds", "to", "the", "work", "set", ",", "as", "necessary" ]
[ "private", "void", "merge", "and", "work", "as", "necessary", "(", "int", "label", ",", "int", "pred", ",", "subroutine", "called", "subroutine", ",", "frame", "frame", ",", "int", "[", "]", "work", "set", ")", "{", "frame", "existing", "=", "start", "frames", "[", "label", "]", ";", "frame", "merged", ";", "if", "(", "existing", "!", "=", "null", ")", "{", "/", "*", "*", "some", "other", "block", "also", "continues", "at", "this", "label", "merge", "*", "the", "frames", ",", "and", "re", "-", "set", "the", "bit", "in", "the", "work", "set", "if", "there", "*", "was", "a", "change", "*", "/", "if", "(", "called", "subroutine", "!", "=", "null", ")", "{", "merged", "=", "existing", "merge", "with", "subroutine", "caller", "(", "frame", ",", "called", "subroutine", "get", "start", "block", "(", ")", ",", "pred", ")", ";", "}", "else", "{", "merged", "=", "existing", "merge", "with", "(", "frame", ")", ";", "}", "if", "(", "merged", "!", "=", "existing", ")", "{", "start", "frames", "[", "label", "]", "=", "merged", ";", "bits", "set", "(", "work", "set", ",", "label", ")", ";", "}", "}", "else", "{", "/", "/", "this", "is", "the", "first", "time", "this", "label", "has", "been", "encountered", "if", "(", "called", "subroutine", "!", "=", "null", ")", "{", "start", "frames", "[", "label", "]", "=", "frame", "make", "new", "subroutine", "start", "frame", "(", "label", ",", "pred", ")", ";", "}", "else", "{", "start", "frames", "[", "label", "]", "=", "frame", ";", "}", "bits", "set", "(", "work", "set", ",", "label", ")", ";", "}", "}" ]
[ "imports", "the", "given", "files", "into", "the", "specified", "ghidra", "project", "folder" ]
[ "public", "void", "import", "files", "(", "domain", "folder", "folder", ",", "list", "<", "file", ">", "files", ")", ";" ]
[ "this", "method", "returns", "the", "normalized", "name", "of", "the", "result", "queue", "currently", "only", "makes", "sense", "when", "result", "=", "=", "place", "normalized", "value", "must", "be", "set", "externally", ",", "this", "class", "cannot", "normalize", "it", "just", "provides", "a", "way", "to", "store", "the", "normalized", "name", "of", "a", "queue" ]
[ "public", "string", "get", "normalized", "queue", "(", ")", "{", "return", "normalized", "queue", ";", "}" ]
[ "returns", "the", "list", "of", "selected", "track", "selection", "overrides", "there", "will", "be", "at", "most", "one", "override", "for", "each", "track", "group" ]
[ "public", "list", "<", "selection", "override", ">", "get", "overrides", "(", ")", "{", "list", "<", "selection", "override", ">", "override", "list", "=", "new", "array", "list", "<", ">", "(", "overrides", "size", "(", ")", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "overrides", "size", "(", ")", ";", "i", "+", "+", ")", "{", "override", "list", "add", "(", "overrides", "value", "at", "(", "i", ")", ")", ";", "}", "return", "override", "list", ";", "}" ]
[ "return", "the", "underlying", "type", "provider" ]
[ "type", "provider", "get", "type", "provider", "(", ")", ";" ]
[ "get", "the", "group", "paths", "that", "are", "in", "the", "tree", "selection" ]
[ "public", "group", "path", "[", "]", "get", "group", "paths", "(", ")", "{", "return", "group", "paths", ";", "}" ]
[ "this", "test", "checks", "a", "race", "condition", "between", "getting", "and", "adding", "tokens", "for", "the", "current", "user", "calling", "user", "group", "information", "get", "current", "user", "(", ")", "returns", "a", "new", "object", "each", "time", ",", "so", "simply", "making", "these", "methods", "synchronized", "was", "not", "enough", "to", "prevent", "race", "conditions", "and", "causing", "a", "concurrent", "modification", "exception", "these", "methods", "are", "synchronized", "on", "the", "subject", ",", "which", "is", "the", "same", "object", "between", "user", "group", "information", "instances", "this", "test", "tries", "to", "cause", "a", "cme", ",", "by", "exposing", "the", "race", "condition", "previously", "this", "test", "would", "fail", "every", "time", ";", "now", "it", "does", "not" ]
[ "public", "void", "test", "token", "race", "condition", "(", ")", "throws", "exception", "{", "user", "group", "information", "user", "group", "info", "=", "user", "group", "information", "create", "user", "for", "testing", "(", "user", "name", ",", "group", "names", ")", ";", "user", "group", "info", "do", "as", "(", "new", "privileged", "exception", "action", "<", "void", ">", "(", ")", "{", "@", "override", "public", "void", "run", "(", ")", "throws", "exception", "{", "/", "/", "make", "sure", "it", "is", "not", "the", "same", "as", "the", "login", "user", "because", "we", "use", "the", "/", "/", "same", "ugi", "object", "for", "every", "instantiation", "of", "the", "login", "user", "and", "you", "/", "/", "won", "'", "t", "run", "into", "the", "race", "condition", "otherwise", "assert", "not", "equals", "(", "user", "group", "information", "get", "login", "user", "(", ")", ",", "user", "group", "information", "get", "current", "user", "(", ")", ")", ";", "get", "token", "thread", "thread", "=", "new", "get", "token", "thread", "(", ")", ";", "try", "{", "thread", "start", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "100", ";", "i", "+", "+", ")", "{", "@", "suppress", "warnings", "(", "\"", "unchecked", "\"", ")", "token", "<", "?", "extends", "token", "identifier", ">", "t", "=", "mock", "(", "token", "class", ")", ";", "when", "(", "t", "get", "service", "(", ")", ")", "then", "return", "(", "new", "text", "(", "\"", "t", "\"", "+", "i", ")", ")", ";", "user", "group", "information", "get", "current", "user", "(", ")", "add", "token", "(", "t", ")", ";", "assert", "null", "(", "\"", "concurrent", "modification", "exception", "encountered", "\"", ",", "thread", "cme", ")", ";", "}", "}", "catch", "(", "concurrent", "modification", "exception", "cme", ")", "{", "cme", "print", "stack", "trace", "(", ")", ";", "fail", "(", "\"", "concurrent", "modification", "exception", "encountered", "\"", ")", ";", "}", "finally", "{", "thread", "run", "thread", "=", "false", ";", "thread", "join", "(", "5", "*", "1000", ")", ";", "}", "return", "null", ";", "}", "}", ")", ";", "}" ]
[ "returns", "a", "(", "wrapped", ")", "{", "@", "link", "marshalled", "credential", "provider", "}", "which", "requires", "the", "marshalled", "credentials", "to", "contain", "session", "secrets" ]
[ "public", "a", "w", "s", "credential", "provider", "list", "bind", "to", "token", "identifier", "(", "final", "abstract", "s", "3", "a", "token", "identifier", "retrieved", "identifier", ")", "throws", "i", "o", "exception", "{", "role", "token", "identifier", "token", "identifier", "=", "convert", "token", "identifier", "(", "retrieved", "identifier", ",", "role", "token", "identifier", "class", ")", ";", "set", "token", "identifier", "(", "optional", "of", "(", "token", "identifier", ")", ")", ";", "marshalled", "credentials", "marshalled", "credentials", "=", "token", "identifier", "get", "marshalled", "credentials", "(", ")", ";", "set", "expiration", "date", "time", "(", "marshalled", "credentials", "get", "expiration", "date", "time", "(", ")", ")", ";", "return", "new", "a", "w", "s", "credential", "provider", "list", "(", "\"", "role", "token", "binding", "\"", ",", "new", "marshalled", "credential", "provider", "(", "component", ",", "get", "store", "context", "(", ")", "get", "fs", "u", "r", "i", "(", ")", ",", "get", "config", "(", ")", ",", "marshalled", "credentials", ",", "marshalled", "credentials", "credential", "type", "required", "session", "only", ")", ")", ";", "}" ]
[ "test", "serialization", "and", "deserialization", "of", "the", "test", "shape" ]
[ "public", "void", "test", "serialization", "(", ")", "throws", "i", "o", "exception", "{", "for", "(", "int", "runs", "=", "0", ";", "runs", "<", "number", "of", "testbuilders", ";", "runs", "+", "+", ")", "{", "sb", "test", "shape", "=", "create", "test", "shape", "builder", "(", ")", ";", "sb", "deserialized", "shape", "=", "copy", "shape", "(", "test", "shape", ")", ";", "assert", "equals", "(", "test", "shape", ",", "deserialized", "shape", ")", ";", "assert", "equals", "(", "test", "shape", "hash", "code", "(", ")", ",", "deserialized", "shape", "hash", "code", "(", ")", ")", ";", "assert", "not", "same", "(", "test", "shape", ",", "deserialized", "shape", ")", ";", "}", "}" ]
[ "collects", "the", "attributes", "of", "this", "field", "into", "the", "given", "set", "of", "attribute", "prototypes" ]
[ "final", "void", "collect", "attribute", "prototypes", "(", "final", "attribute", "set", "attribute", "prototypes", ")", "{", "attribute", "prototypes", "add", "attributes", "(", "first", "attribute", ")", ";", "}" ]
[ "initialize", "the", "given", "{", "@", "code", "message", "header", "accessor", "}" ]
[ "void", "init", "headers", "(", "message", "header", "accessor", "header", "accessor", ")", ";" ]
[ "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", "\"", ")", ";", "}" ]
[ "return", "the", "method", "parameter", "bound", "to", "the", "request", "header" ]
[ "public", "final", "method", "parameter", "get", "parameter", "(", ")", "{", "return", "this", "parameter", ";", "}" ]
[ "gets", "the", "data", "node", "rpc", "port" ]
[ "public", "int", "get", "port", "(", ")", "{", "return", "port", ";", "}" ]
[ "test", "the", "property", "'", "name", "'" ]
[ "public", "void", "name", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "name", "}" ]
[ "add", "a", "custom", "{", "@", "link", "object", "error", "}", "or", "{", "@", "link", "field", "error", "}", "to", "the", "errors", "list", "intended", "to", "be", "used", "by", "cooperating", "strategies", "such", "as", "{", "@", "link", "binding", "error", "processor", "}" ]
[ "void", "add", "error", "(", "object", "error", "error", ")", ";" ]
[ "not", "supported", "<", "b", ">", "you", "are", "attempting", "to", "create", "a", "multiset", "that", "may", "contain", "a", "non", "-", "{", "@", "code", "comparable", "}", "element", "<", "b", ">", "proper", "calls", "will", "resolve", "to", "the", "version", "in", "{", "@", "code", "immutable", "sorted", "multiset", "}", ",", "not", "this", "dummy", "version" ]
[ "public", "static", "<", "e", ">", "immutable", "sorted", "multiset", "<", "e", ">", "of", "(", "e", "e", "1", ",", "e", "e", "2", ",", "e", "e", "3", ",", "e", "e", "4", ")", "{", "throw", "new", "unsupported", "operation", "exception", "(", ")", ";", "}" ]
[ "parses", "a", "job", "i", "d", "from", "the", "given", "string" ]
[ "public", "static", "job", "i", "d", "from", "hex", "string", "(", "string", "hex", "string", ")", "{", "try", "{", "return", "new", "job", "i", "d", "(", "string", "utils", "hex", "string", "to", "byte", "(", "hex", "string", ")", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "cannot", "parse", "job", "i", "d", "from", "\\", "\"", "\"", "+", "hex", "string", "+", "\"", "\\", "\"", "the", "expected", "format", "is", "\"", "+", "\"", "[", "0", "-", "9a", "-", "f", "a", "-", "f", "]", "{", "32", "}", ",", "e", "g", "fd", "7", "2", "0", "1", "4d", "4c", "8", "6", "4", "9", "9", "3a", "2e", "5a", "9", "2", "8", "7b", "4a", "9c", "5d", "\"", ",", "e", ")", ";", "}", "}" ]
[ "initializes", "the", "registry", "based", "on", "available", "parameters", "in", "the", "hadoop", "configuration" ]
[ "void", "initialize", "zones", "(", "configuration", "conf", ")", "throws", "i", "o", "exception", "{", "ttl", "=", "conf", "get", "time", "duration", "(", "key", "dns", "ttl", ",", "1l", ",", "time", "unit", "seconds", ")", ";", "record", "creator", "factory", "set", "ttl", "(", "ttl", ")", ";", "set", "d", "n", "s", "s", "e", "c", "enabled", "(", "conf", ")", ";", "initialize", "zones", "from", "files", "(", "conf", ")", ";", "zone", "registry", "zone", "=", "configure", "zone", "(", "name", "from", "string", "(", "domain", "name", ")", ",", "conf", ")", ";", "zones", "put", "(", "registry", "zone", "get", "origin", "(", ")", ",", "registry", "zone", ")", ";", "initialize", "reverse", "lookup", "zone", "(", "conf", ")", ";", "string", "builder", "builder", "=", "new", "string", "builder", "(", ")", ";", "builder", "append", "(", "\"", "dns", "zones", ":", "\"", ")", "append", "(", "system", "line", "separator", "(", ")", ")", ";", "for", "(", "map", "entry", "<", "name", ",", "zone", ">", "entry", ":", "zones", "entry", "set", "(", ")", ")", "{", "builder", "append", "(", "system", "line", "separator", "(", ")", ")", "append", "(", "entry", "get", "value", "(", ")", ")", ";", "}", "log", "info", "(", "builder", "to", "string", "(", ")", ")", ";", "}" ]
[ "returns", "true", "if", "both", "drag", "offsets", "(", "x", "and", "y", ")", "are", "zero", "or", "smaller" ]
[ "public", "boolean", "has", "no", "drag", "offset", "(", ")", "{", "return", "m", "trans", "offset", "x", "<", "=", "0", "&", "&", "m", "trans", "offset", "y", "<", "=", "0", ";", "}" ]
[ "get", "the", "bitfield", "packing", "information", "associated", "with", "the", "underlying", "data", "organization" ]
[ "public", "default", "bit", "field", "packing", "get", "bit", "field", "packing", "(", ")", "{", "return", "get", "data", "organization", "(", ")", "get", "bit", "field", "packing", "(", ")", ";", "}" ]
[ "get", "date", "time" ]
[ "public", "date", "get", "date", "time", "(", ")", "{", "return", "date", "time", ";", "}" ]