Datasets:

---

Anonymous2023

/

KGSum

like 0

[ "return", "the", "path", "of", "datadatapackagecode", "cache" ]

[ "public", "static", "string", "get", "internal", "app", "code", "cache", "dir", "(", ")", "{", "if", "(", "build", "version", "sdk", "int", "<", "build", "version", "codes", "lollipop", ")", "{", "return", "utils", "get", "app", "(", ")", "get", "application", "info", "(", ")", "data", "dir", "+", "\"", "/", "code", "cache", "\"", ";", "}", "return", "get", "absolute", "path", "(", "utils", "get", "app", "(", ")", "get", "code", "cache", "dir", "(", ")", ")", ";", "}" ]

[ "this", "subclass", "of", "the", "{", "@", "code", "path", "(", "path", ")", "}", "operation", "adds", "the", "seek", "policy", "to", "the", "end", "to", "guarantee", "uniqueness", "across", "different", "calls", "of", "the", "same", "method", "{", "@", "inherit", "doc", "}" ]

[ "protected", "path", "path", "(", "final", "string", "filepath", ")", "throws", "i", "o", "exception", "{", "return", "super", "path", "(", "filepath", "+", "\"", "-", "\"", "+", "seek", "policy", ")", ";", "}" ]

[ "destroy", "callback", "for", "updating", "factory", "book", "keeping" ]

[ "void", "destroy", "buffer", "pool", "(", "buffer", "pool", "buffer", "pool", ")", "throws", "i", "o", "exception", ";" ]

[ "adds", "a", "framed", "data", "in", "binary", "format" ]

[ "public", "bulk", "request", "add", "(", "byte", "[", "]", "data", ",", "int", "from", ",", "int", "length", ",", "x", "content", "type", "x", "content", "type", ")", "throws", "i", "o", "exception", "{", "return", "add", "(", "data", ",", "from", ",", "length", ",", "null", ",", "x", "content", "type", ")", ";", "}" ]

[ "checks", "if", "all", "the", "addresses", "from", "start", "to", "end", "have", "undefined", "data" ]

[ "public", "boolean", "is", "undefined", "(", "address", "start", ",", "address", "end", ")", "{", "if", "(", "!", "start", "get", "address", "space", "(", ")", "equals", "(", "end", "get", "address", "space", "(", ")", ")", ")", "{", "return", "false", ";", "}", "if", "(", "!", "program", "get", "memory", "(", ")", "contains", "(", "start", ",", "end", ")", ")", "{", "return", "false", ";", "}", "if", "(", "get", "instruction", "containing", "(", "start", ")", "!", "=", "null", ")", "{", "return", "false", ";", "}", "if", "(", "get", "defined", "data", "containing", "(", "start", ")", "!", "=", "null", ")", "{", "return", "false", ";", "}", "address", "range", "range", "=", "new", "address", "range", "impl", "(", "start", ",", "end", ")", ";", "instruction", "inst", "=", "get", "instruction", "after", "(", "start", ")", ";", "if", "(", "inst", "!", "=", "null", ")", "{", "address", "addr", "=", "inst", "get", "min", "address", "(", ")", ";", "if", "(", "range", "contains", "(", "addr", ")", ")", "{", "return", "false", ";", "}", "}", "data", "data", "=", "get", "defined", "data", "after", "(", "start", ")", ";", "if", "(", "data", "!", "=", "null", ")", "{", "address", "addr", "=", "data", "get", "min", "address", "(", ")", ";", "if", "(", "range", "contains", "(", "addr", ")", ")", "{", "return", "false", ";", "}", "}", "return", "true", ";", "}" ]

[ "returns", "the", "applicable", "{", "@", "link", "repository", "browser", "}", "for", "files", "controlled", "by", "this", "{", "@", "link", "scm", "}" ]

[ "public", "final", "@", "check", "for", "null", "repository", "browser", "<", "?", ">", "get", "effective", "browser", "(", ")", "{", "repository", "browser", "<", "?", ">", "b", "=", "get", "browser", "(", ")", ";", "if", "(", "b", "!", "=", "null", ")", "return", "b", ";", "if", "(", "use", "auto", "browser", "holder", ")", "{", "if", "(", "auto", "browser", "holder", "=", "=", "null", ")", "{", "auto", "browser", "holder", "=", "new", "auto", "browser", "holder", "(", "this", ")", ";", "}", "return", "auto", "browser", "holder", "get", "(", ")", ";", "}", "else", "{", "try", "{", "return", "guess", "browser", "(", ")", ";", "}", "catch", "(", "runtime", "exception", "x", ")", "{", "logger", "log", "(", "level", "warning", ",", "null", ",", "x", ")", ";", "return", "null", ";", "}", "}", "}" ]

[ "returns", "the", "sample", "rate", "of", "output", "audio" ]

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

[ "return", "the", "configured", "max", "length", "for", "frames" ]

[ "public", "int", "get", "max", "frame", "payload", "length", "(", ")", "{", "return", "get", "websocket", "server", "spec", "(", ")", "max", "frame", "payload", "length", "(", ")", ";", "}" ]

[ "sets", "the", "executable", "path", "used", "by", "expanded", "actions", "the", "path", "is", "interpreted", "relative", "to", "the", "execution", "root", "calling", "this", "method", "overrides", "any", "previous", "values", "set", "via", "calls", "to", "{", "@", "link", "#", "set", "executable", "(", "artifact", ")", "}", "and", "{", "@", "link", "#", "set", "executable", "(", "files", "to", "run", "provider", ")", "}" ]

[ "public", "builder", "set", "executable", "(", "path", "fragment", "executable", ")", "{", "spawn", "action", "builder", "set", "executable", "(", "executable", ")", ";", "this", "executable", "=", "executable", ";", "return", "this", ";", "}" ]

[ "for", "each", "tuple", "emitted", ",", "return", "a", "value", "(", "typically", "one", "of", "the", "values", "in", "the", "tuple", ")", "modifying", "the", "writables", "in", "the", "tuple", "is", "permitted", "and", "unlikely", "to", "affect", "join", "behavior", "in", "most", "cases", ",", "but", "it", "is", "not", "recommended", "it", "'", "s", "safer", "to", "clone", "first" ]

[ "protected", "abstract", "v", "emit", "(", "tuple", "writable", "dst", ")", "throws", "i", "o", "exception", ";" ]

[ "returns", "a", "list", "containing", "an", "override", "{", "@", "link", "method", "spec", "}", "for", "all", "{", "@", "link", "glide", "option", "}", "annotated", "methods", "in", "the", "classes", "that", "correspond", "to", "the", "given", "extension", "class", "names" ]

[ "list", "<", "method", "spec", ">", "generate", "instance", "methods", "for", "extensions", "(", "set", "<", "string", ">", "glide", "extension", "class", "names", ")", "{", "list", "<", "executable", "element", ">", "request", "option", "extension", "methods", "=", "get", "request", "option", "extension", "methods", "(", "glide", "extension", "class", "names", ")", ";", "list", "<", "method", "spec", ">", "result", "=", "new", "array", "list", "<", ">", "(", "request", "option", "extension", "methods", "size", "(", ")", ")", ";", "for", "(", "executable", "element", "request", "options", "extension", "method", ":", "request", "option", "extension", "methods", ")", "{", "result", "add", "(", "generate", "methods", "for", "request", "options", "extension", "(", "request", "options", "extension", "method", ")", ")", ";", "}", "return", "result", ";", "}" ]

[ "the", "main", "work", "method" ]

[ "public", "void", "invoke", "(", ")", "throws", "exception", "{", "/", "/", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "/", "/", "initialize", "/", "/", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "if", "(", "log", "is", "debug", "enabled", "(", ")", ")", "{", "log", "debug", "(", "format", "log", "string", "(", "\"", "start", "registering", "input", "and", "output", "\"", ")", ")", ";", "}", "/", "/", "obtain", "task", "configuration", "(", "including", "stub", "parameters", ")", "configuration", "task", "conf", "=", "get", "task", "configuration", "(", ")", ";", "this", "config", "=", "new", "task", "config", "(", "task", "conf", ")", ";", "/", "/", "now", "get", "the", "operator", "class", "which", "drives", "the", "operation", "final", "class", "<", "?", "extends", "driver", "<", "s", ",", "ot", ">", ">", "driver", "class", "=", "this", "config", "get", "driver", "(", ")", ";", "this", "driver", "=", "instantiation", "util", "instantiate", "(", "driver", "class", ",", "driver", "class", ")", ";", "string", "head", "name", "=", "get", "environment", "(", ")", "get", "task", "info", "(", ")", "get", "task", "name", "(", ")", "split", "(", "\"", "-", ">", "\"", ")", "[", "0", "]", "trim", "(", ")", ";", "this", "metrics", "=", "get", "environment", "(", ")", "get", "metric", "group", "(", ")", "get", "or", "add", "operator", "(", "head", "name", "starts", "with", "(", "\"", "chain", "\"", ")", "?", "head", "name", "substring", "(", "6", ")", ":", "head", "name", ")", ";", "this", "metrics", "get", "i", "o", "metric", "group", "(", ")", "reuse", "input", "metrics", "for", "task", "(", ")", ";", "if", "(", "config", "get", "number", "of", "chained", "stubs", "(", ")", "=", "=", "0", ")", "{", "this", "metrics", "get", "i", "o", "metric", "group", "(", ")", "reuse", "output", "metrics", "for", "task", "(", ")", ";", "}", "/", "/", "initialize", "the", "readers", "/", "/", "this", "does", "not", "yet", "trigger", "any", "stream", "consuming", "or", "processing", "init", "input", "readers", "(", ")", ";", "init", "broadcast", "input", "readers", "(", ")", ";", "/", "/", "initialize", "the", "writers", "init", "outputs", "(", ")", ";", "if", "(", "log", "is", "debug", "enabled", "(", ")", ")", "{", "log", "debug", "(", "format", "log", "string", "(", "\"", "finished", "registering", "input", "and", "output", "\"", ")", ")", ";", "}", "/", "/", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "/", "/", "invoke", "/", "/", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "if", "(", "log", "is", "debug", "enabled", "(", ")", ")", "{", "log", "debug", "(", "format", "log", "string", "(", "\"", "start", "task", "code", "\"", ")", ")", ";", "}", "this", "runtime", "udf", "context", "=", "create", "runtime", "context", "(", "metrics", ")", ";", "/", "/", "whatever", "happens", "in", "this", "scope", ",", "make", "sure", "that", "the", "local", "strategies", "are", "cleaned", "up", "!", "/", "/", "note", "that", "the", "initialization", "of", "the", "local", "strategies", "is", "in", "the", "try", "-", "finally", "block", "as", "well", ",", "/", "/", "so", "that", "the", "thread", "that", "creates", "them", "catches", "its", "own", "errors", "that", "may", "happen", "in", "that", "/", "/", "process", "/", "/", "this", "is", "especially", "important", ",", "since", "there", "may", "be", "asynchronous", "closes", "(", "such", "as", "through", "/", "/", "canceling", ")", "try", "{", "/", "/", "initialize", "the", "remaining", "data", "structures", "on", "the", "input", "and", "trigger", "the", "local", "/", "/", "processing", "/", "/", "the", "local", "processing", "includes", "building", "the", "dams", "/", "caches", "try", "{", "int", "num", "inputs", "=", "driver", "get", "number", "of", "inputs", "(", ")", ";", "int", "num", "comparators", "=", "driver", "get", "number", "of", "driver", "comparators", "(", ")", ";", "int", "num", "broadcast", "inputs", "=", "this", "config", "get", "num", "broadcast", "inputs", "(", ")", ";", "init", "inputs", "serializers", "and", "comparators", "(", "num", "inputs", ",", "num", "comparators", ")", ";", "init", "broadcast", "inputs", "serializers", "(", "num", "broadcast", "inputs", ")", ";", "/", "/", "set", "the", "iterative", "status", "for", "inputs", "and", "broadcast", "inputs", "{", "list", "<", "integer", ">", "iterative", "inputs", "=", "new", "array", "list", "<", ">", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "num", "inputs", ";", "i", "+", "+", ")", "{", "final", "int", "number", "of", "events", "until", "interrupt", "=", "get", "task", "config", "(", ")", "get", "number", "of", "events", "until", "interrupt", "in", "iterative", "gate", "(", "i", ")", ";", "if", "(", "number", "of", "events", "until", "interrupt", "<", "0", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", ")", ";", "}", "else", "if", "(", "number", "of", "events", "until", "interrupt", ">", "0", ")", "{", "this", "input", "readers", "[", "i", "]", "set", "iterative", "reader", "(", ")", ";", "iterative", "inputs", "add", "(", "i", ")", ";", "if", "(", "log", "is", "debug", "enabled", "(", ")", ")", "{", "log", "debug", "(", "format", "log", "string", "(", "\"", "input", "[", "\"", "+", "i", "+", "\"", "]", "reads", "in", "supersteps", "with", "[", "\"", "+", "number", "of", "events", "until", "interrupt", "+", "\"", "]", "event", "(", "s", ")", "till", "next", "superstep", "\"", ")", ")", ";", "}", "}", "}", "this", "iterative", "inputs", "=", "as", "array", "(", "iterative", "inputs", ")", ";", "}", "{", "list", "<", "integer", ">", "iterative", "bc", "inputs", "=", "new", "array", "list", "<", ">", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "num", "broadcast", "inputs", ";", "i", "+", "+", ")", "{", "final", "int", "number", "of", "events", "until", "interrupt", "=", "get", "task", "config", "(", ")", "get", "number", "of", "events", "until", "interrupt", "in", "iterative", "broadcast", "gate", "(", "i", ")", ";", "if", "(", "number", "of", "events", "until", "interrupt", "<", "0", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", ")", ";", "}", "else", "if", "(", "number", "of", "events", "until", "interrupt", ">", "0", ")", "{", "this", "broadcast", "input", "readers", "[", "i", "]", "set", "iterative", "reader", "(", ")", ";", "iterative", "bc", "inputs", "add", "(", "i", ")", ";", "if", "(", "log", "is", "debug", "enabled", "(", ")", ")", "{", "log", "debug", "(", "format", "log", "string", "(", "\"", "broadcast", "input", "[", "\"", "+", "i", "+", "\"", "]", "reads", "in", "supersteps", "with", "[", "\"", "+", "number", "of", "events", "until", "interrupt", "+", "\"", "]", "event", "(", "s", ")", "till", "next", "superstep", "\"", ")", ")", ";", "}", "}", "}", "this", "iterative", "broadcast", "inputs", "=", "as", "array", "(", "iterative", "bc", "inputs", ")", ";", "}", "init", "local", "strategies", "(", "num", "inputs", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "throw", "new", "runtime", "exception", "(", "\"", "initializing", "the", "input", "processing", "failed", "\"", "+", "(", "e", "get", "message", "(", ")", "=", "=", "null", "?", "\"", "\"", ":", "\"", ":", "\"", "+", "e", "get", "message", "(", ")", ")", ",", "e", ")", ";", "}", "if", "(", "!", "this", "running", ")", "{", "if", "(", "log", "is", "debug", "enabled", "(", ")", ")", "{", "log", "debug", "(", "format", "log", "string", "(", "\"", "task", "cancelled", "before", "task", "code", "was", "started", "\"", ")", ")", ";", "}", "return", ";", "}", "/", "/", "pre", "main", "-", "function", "initialization", "initialize", "(", ")", ";", "/", "/", "read", "the", "broadcast", "variables", "they", "will", "be", "released", "in", "the", "finally", "clause", "for", "(", "int", "i", "=", "0", ";", "i", "<", "this", "config", "get", "num", "broadcast", "inputs", "(", ")", ";", "i", "+", "+", ")", "{", "final", "string", "name", "=", "this", "config", "get", "broadcast", "input", "name", "(", "i", ")", ";", "read", "and", "set", "broadcast", "input", "(", "i", ",", "name", ",", "this", "runtime", "udf", "context", ",", "1", "/", "*", "superstep", "one", "for", "the", "start", "*", "/", ")", ";", "}", "/", "/", "the", "work", "goes", "here", "run", "(", ")", ";", "}", "finally", "{", "/", "/", "clean", "up", "in", "any", "case", "!", "close", "local", "strategies", "and", "caches", "(", ")", ";", "clear", "readers", "(", "input", "readers", ")", ";", "clear", "writers", "(", "eventual", "outputs", ")", ";", "}", "if", "(", "this", "running", ")", "{", "if", "(", "log", "is", "debug", "enabled", "(", ")", ")", "{", "log", "debug", "(", "format", "log", "string", "(", "\"", "finished", "task", "code", "\"", ")", ")", ";", "}", "}", "else", "{", "if", "(", "log", "is", "debug", "enabled", "(", ")", ")", "{", "log", "debug", "(", "format", "log", "string", "(", "\"", "task", "code", "cancelled", "\"", ")", ")", ";", "}", "}", "}" ]

[ "returns", "the", "greatest", "common", "divisor", "of", "{", "@", "code", "a", ",", "b", "}", "returns", "{", "@", "code", "0", "}", "if", "{", "@", "code", "a", "=", "=", "0", "&", "&", "b", "=", "=", "0", "}" ]

[ "public", "static", "int", "gcd", "(", "int", "a", ",", "int", "b", ")", "{", "/", "*", "*", "the", "reason", "we", "require", "both", "arguments", "to", "be", ">", "=", "0", "is", "because", "otherwise", ",", "what", "do", "you", "return", "on", "*", "gcd", "(", "0", ",", "integer", "min", "value", ")", "?", "big", "integer", "gcd", "would", "return", "positive", "2", "^", "31", ",", "but", "positive", "2", "^", "31", "isn", "'", "t", "*", "an", "int", "*", "/", "check", "non", "negative", "(", "\"", "a", "\"", ",", "a", ")", ";", "check", "non", "negative", "(", "\"", "b", "\"", ",", "b", ")", ";", "if", "(", "a", "=", "=", "0", ")", "{", "/", "/", "0", "%", "b", "=", "=", "0", ",", "so", "b", "divides", "a", ",", "but", "the", "converse", "doesn", "'", "t", "hold", "/", "/", "big", "integer", "gcd", "is", "consistent", "with", "this", "decision", "return", "b", ";", "}", "else", "if", "(", "b", "=", "=", "0", ")", "{", "return", "a", ";", "/", "/", "similar", "logic", "}", "/", "*", "*", "uses", "the", "binary", "gcd", "algorithm", ";", "see", "http", ":", "/", "/", "en", "wikipedia", "org", "/", "wiki", "/", "binary", "gcd", "algorithm", "this", "is", "*", ">", "40", "%", "faster", "than", "the", "euclidean", "algorithm", "in", "benchmarks", "*", "/", "int", "a", "twos", "=", "integer", "number", "of", "trailing", "zeros", "(", "a", ")", ";", "a", ">", ">", "=", "a", "twos", ";", "/", "/", "divide", "out", "all", "2s", "int", "b", "twos", "=", "integer", "number", "of", "trailing", "zeros", "(", "b", ")", ";", "b", ">", ">", "=", "b", "twos", ";", "/", "/", "divide", "out", "all", "2s", "while", "(", "a", "!", "=", "b", ")", "{", "/", "/", "both", "a", ",", "b", "are", "odd", "/", "/", "the", "key", "to", "the", "binary", "gcd", "algorithm", "is", "as", "follows", ":", "/", "/", "both", "a", "and", "b", "are", "odd", "assume", "a", ">", "b", ";", "then", "gcd", "(", "a", "-", "b", ",", "b", ")", "=", "gcd", "(", "a", ",", "b", ")", "/", "/", "but", "in", "gcd", "(", "a", "-", "b", ",", "b", ")", ",", "a", "-", "b", "is", "even", "and", "b", "is", "odd", ",", "so", "we", "can", "divide", "out", "powers", "of", "two", "/", "/", "we", "bend", "over", "backwards", "to", "avoid", "branching", ",", "adapting", "a", "technique", "from", "/", "/", "http", ":", "/", "/", "graphics", "stanford", "edu", "/", "~", "seander", "/", "bithacks", "html", "#", "integer", "min", "or", "max", "int", "delta", "=", "a", "-", "b", ";", "/", "/", "can", "'", "t", "overflow", ",", "since", "a", "and", "b", "are", "nonnegative", "int", "min", "delta", "or", "zero", "=", "delta", "&", "(", "delta", ">", ">", "(", "integer", "size", "-", "1", ")", ")", ";", "/", "/", "equivalent", "to", "math", "min", "(", "delta", ",", "0", ")", "a", "=", "delta", "-", "min", "delta", "or", "zero", "-", "min", "delta", "or", "zero", ";", "/", "/", "sets", "a", "to", "math", "abs", "(", "a", "-", "b", ")", "/", "/", "a", "is", "now", "nonnegative", "and", "even", "b", "+", "=", "min", "delta", "or", "zero", ";", "/", "/", "sets", "b", "to", "min", "(", "old", "a", ",", "b", ")", "a", ">", ">", "=", "integer", "number", "of", "trailing", "zeros", "(", "a", ")", ";", "/", "/", "divide", "out", "all", "2s", ",", "since", "2", "doesn", "'", "t", "divide", "b", "}", "return", "a", "<", "<", "min", "(", "a", "twos", ",", "b", "twos", ")", ";", "}" ]

[ "creates", "and", "returns", "a", "new", "builder", ",", "configured", "to", "build", "{", "@", "code", "min", "max", "priority", "queue", "}", "instances", "that", "use", "{", "@", "code", "comparator", "}", "to", "determine", "the", "least", "and", "greatest", "elements" ]

[ "public", "static", "<", "b", ">", "builder", "<", "b", ">", "ordered", "by", "(", "comparator", "<", "b", ">", "comparator", ")", "{", "return", "new", "builder", "<", "b", ">", "(", "comparator", ")", ";", "}" ]

[ "sets", "the", "tag", "of", "the", "view" ]

[ "public", "base", "adapter", "helper", "set", "tag", "(", "int", "view", "id", ",", "int", "key", ",", "object", "tag", ")", "{", "view", "view", "=", "retrieve", "view", "(", "view", "id", ")", ";", "view", "set", "tag", "(", "key", ",", "tag", ")", ";", "return", "this", ";", "}" ]

[ "returns", "a", "builder", "that", "creates", "immutable", "sorted", "sets", "with", "an", "explicit", "comparator", "if", "the", "comparator", "has", "a", "more", "general", "type", "than", "the", "set", "being", "generated", ",", "such", "as", "creating", "a", "{", "@", "code", "sorted", "set", "<", "integer", ">", "}", "with", "a", "{", "@", "code", "comparator", "<", "number", ">", "}", ",", "use", "the", "{", "@", "link", "builder", "}", "constructor", "instead" ]

[ "public", "static", "<", "e", ">", "builder", "<", "e", ">", "ordered", "by", "(", "comparator", "<", "e", ">", "comparator", ")", "{", "return", "new", "builder", "<", "e", ">", "(", "comparator", ")", ";", "}" ]

[ "return", "the", "default", "class", "loader", "to", "use", ":", "typically", "the", "thread", "context", "class", "loader", ",", "if", "available", ";", "the", "class", "loader", "that", "loaded", "the", "class", "utils", "class", "will", "be", "used", "as", "fallback", "call", "this", "method", "if", "you", "intend", "to", "use", "the", "thread", "context", "class", "loader", "in", "a", "scenario", "where", "you", "absolutely", "need", "a", "non", "-", "null", "class", "loader", "reference", ":", "for", "example", ",", "for", "class", "path", "resource", "loading", "(", "but", "not", "necessarily", "for", "<", "code", ">", "class", "for", "name", "<", "code", ">", ",", "which", "accepts", "a", "<", "code", ">", "null", "<", "code", ">", "class", "loader", "reference", "as", "well", ")" ]

[ "public", "static", "class", "loader", "get", "class", "loader", "(", ")", "{", "return", "get", "class", "loader", "(", "class", "utils", "class", ")", ";", "}" ]

[ "sets", "set", "resource", "sets" ]

[ "public", "void", "set", "resource", "sets", "(", "set", "<", "string", ">", "resource", "sets", ")", "{", "this", "resource", "sets", "=", "resource", "sets", ";", "}" ]

[ "get", "attribute", "integer" ]

[ "public", "integer", "get", "attribute", "integer", "(", ")", "{", "return", "attribute", "integer", ";", "}" ]

[ "find", "the", "fields", "constant", "that", "matches", "name", ",", "or", "null", "if", "its", "not", "found" ]

[ "public", "static", "fields", "find", "by", "name", "(", "string", "name", ")", "{", "return", "by", "name", "get", "(", "name", ")", ";", "}" ]

[ "adds", "a", "field", "to", "be", "highlighted", "with", "a", "provided", "fragment", "size", "(", "in", "characters", ")", ",", "and", "a", "provided", "(", "maximum", ")", "number", "of", "fragments" ]

[ "public", "highlight", "builder", "field", "(", "string", "name", ",", "int", "fragment", "size", ",", "int", "number", "of", "fragments", ",", "int", "fragment", "offset", ")", "{", "return", "field", "(", "new", "field", "(", "name", ")", "fragment", "size", "(", "fragment", "size", ")", "num", "of", "fragments", "(", "number", "of", "fragments", ")", "fragment", "offset", "(", "fragment", "offset", ")", ")", ";", "}" ]

[ "returns", "a", "new", "parameterized", "type", ",", "applying", "{", "@", "code", "type", "arguments", "}", "to", "{", "@", "code", "raw", "type", "}", "use", "this", "method", "if", "{", "@", "code", "raw", "type", "}", "is", "enclosed", "in", "{", "@", "code", "owner", "type", "}" ]

[ "public", "static", "parameterized", "type", "new", "parameterized", "type", "with", "owner", "(", "type", "owner", "type", ",", "type", "raw", "type", ",", "type", "type", "arguments", ")", "{", "if", "(", "type", "arguments", "length", "=", "=", "0", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "missing", "type", "arguments", "for", "\"", "+", "raw", "type", ")", ";", "}", "return", "new", "parameterized", "type", "impl", "(", "owner", "type", ",", "raw", "type", ",", "type", "arguments", ")", ";", "}" ]

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

[ "batched", "version", "of", "{", "@", "link", "#", "reencrypt", "encrypted", "key", "(", "encrypted", "key", "version", ")", "}", "for", "each", "encrypted", "key", "version", ",", "re", "-", "encrypts", "an", "encrypted", "key", "version", ",", "using", "its", "initialization", "vector", "and", "key", "material", ",", "but", "with", "the", "latest", "key", "version", "name", "of", "its", "key", "name", "if", "the", "latest", "key", "version", "name", "in", "the", "provider", "is", "the", "same", "as", "the", "one", "encrypted", "the", "passed", "-", "in", "encrypted", "key", "version", ",", "the", "same", "encrypted", "key", "version", "is", "returned", "note", ":", "the", "generated", "key", "is", "not", "stored", "by", "the", "<", "code", ">", "key", "provider", "<", "code", ">" ]

[ "void", "reencrypt", "encrypted", "keys", "(", "list", "<", "encrypted", "key", "version", ">", "ekvs", ")", "throws", "i", "o", "exception", ",", "general", "security", "exception", ";" ]

[ "fetch", "the", "data", "for", "edits", "starting", "at", "the", "specific", "transaction", "id", ",", "fetching", "up", "to", "{", "@", "code", "max", "txns", "}", "transactions", "populates", "a", "list", "of", "output", "buffers", "which", "contains", "a", "serialized", "version", "of", "the", "edits", ",", "and", "returns", "the", "count", "of", "edits", "contained", "within", "the", "serialized", "buffers", "the", "serialized", "edits", "are", "prefixed", "with", "a", "standard", "edit", "log", "header", "containing", "information", "about", "the", "layout", "version", "the", "transactions", "returned", "are", "guaranteed", "to", "have", "contiguous", "transaction", "i", "ds", "if", "{", "@", "code", "requested", "start", "txn", "}", "is", "higher", "than", "the", "highest", "transaction", "which", "has", "been", "added", "to", "this", "cache", ",", "a", "response", "with", "an", "empty", "buffer", "and", "a", "transaction", "count", "of", "0", "will", "be", "returned", "if", "{", "@", "code", "requested", "start", "txn", "}", "is", "lower", "than", "the", "lowest", "transaction", "currently", "contained", "in", "this", "cache", ",", "or", "no", "transactions", "have", "yet", "been", "added", "to", "the", "cache", ",", "an", "exception", "will", "be", "thrown" ]

[ "int", "retrieve", "edits", "(", "long", "requested", "start", "txn", ",", "int", "max", "txns", ",", "list", "<", "byte", "buffer", ">", "output", "buffers", ")", "throws", "i", "o", "exception", "{", "int", "txn", "count", "=", "0", ";", "try", "(", "auto", "closeable", "lock", "l", "=", "read", "lock", "acquire", "(", ")", ")", "{", "if", "(", "lowest", "txn", "id", "=", "=", "invalid", "txn", "id", "|", "|", "requested", "start", "txn", "<", "lowest", "txn", "id", ")", "{", "throw", "get", "cache", "miss", "exception", "(", "requested", "start", "txn", ")", ";", "}", "else", "if", "(", "requested", "start", "txn", ">", "highest", "txn", "id", ")", "{", "return", "0", ";", "}", "output", "buffers", "add", "(", "layout", "header", ")", ";", "iterator", "<", "map", "entry", "<", "long", ",", "byte", "[", "]", ">", ">", "incr", "buff", "iter", "=", "data", "map", "tail", "map", "(", "data", "map", "floor", "key", "(", "requested", "start", "txn", ")", ",", "true", ")", "entry", "set", "(", ")", "iterator", "(", ")", ";", "long", "prev", "txn", "=", "requested", "start", "txn", ";", "byte", "[", "]", "prev", "buf", "=", "null", ";", "/", "/", "stop", "when", "maximum", "transactions", "reached", "while", "(", "(", "txn", "count", "<", "max", "txns", ")", "&", "&", "/", "/", "or", "there", "are", "no", "more", "entries", "(", "incr", "buff", "iter", "has", "next", "(", ")", "|", "|", "prev", "buf", "!", "=", "null", ")", ")", "{", "long", "curr", "txn", ";", "byte", "[", "]", "curr", "buf", ";", "if", "(", "incr", "buff", "iter", "has", "next", "(", ")", ")", "{", "map", "entry", "<", "long", ",", "byte", "[", "]", ">", "ent", "=", "incr", "buff", "iter", "next", "(", ")", ";", "curr", "txn", "=", "ent", "get", "key", "(", ")", ";", "curr", "buf", "=", "ent", "get", "value", "(", ")", ";", "}", "else", "{", "/", "/", "this", "accounts", "for", "the", "trailing", "entry", "curr", "txn", "=", "highest", "txn", "id", "+", "1", ";", "curr", "buf", "=", "null", ";", "}", "if", "(", "prev", "buf", "!", "=", "null", ")", "{", "/", "/", "true", "except", "for", "the", "first", "loop", "iteration", "output", "buffers", "add", "(", "byte", "buffer", "wrap", "(", "prev", "buf", ")", ")", ";", "/", "/", "if", "prev", "txn", "<", "requested", "start", "txn", ",", "the", "extra", "transactions", "will", "get", "/", "/", "removed", "after", "the", "loop", ",", "so", "don", "'", "t", "include", "them", "in", "the", "txn", "count", "txn", "count", "+", "=", "curr", "txn", "-", "math", "max", "(", "requested", "start", "txn", ",", "prev", "txn", ")", ";", "}", "prev", "txn", "=", "curr", "txn", ";", "prev", "buf", "=", "curr", "buf", ";", "}", "/", "/", "release", "the", "lock", "before", "doing", "operations", "on", "the", "buffers", "(", "deserializing", "/", "/", "to", "find", "transaction", "boundaries", ",", "and", "copying", "into", "an", "output", "buffer", ")", "}", "/", "/", "remove", "extra", "leading", "transactions", "in", "the", "first", "buffer", "byte", "buffer", "first", "buf", "=", "output", "buffers", "get", "(", "1", ")", ";", "/", "/", "0th", "is", "the", "header", "first", "buf", "position", "(", "find", "transaction", "position", "(", "first", "buf", "array", "(", ")", ",", "requested", "start", "txn", ")", ")", ";", "/", "/", "remove", "trailing", "transactions", "in", "the", "last", "buffer", "if", "necessary", "if", "(", "txn", "count", ">", "max", "txns", ")", "{", "byte", "buffer", "last", "buf", "=", "output", "buffers", "get", "(", "output", "buffers", "size", "(", ")", "-", "1", ")", ";", "int", "limit", "=", "find", "transaction", "position", "(", "last", "buf", "array", "(", ")", ",", "requested", "start", "txn", "+", "max", "txns", ")", ";", "last", "buf", "limit", "(", "limit", ")", ";", "txn", "count", "=", "max", "txns", ";", "}", "return", "txn", "count", ";", "}" ]

[ "adds", "corners", "in", "ogc", "standard", "bbox", "envelop", "format" ]

[ "public", "geo", "bounding", "box", "query", "builder", "set", "corners", "o", "g", "c", "(", "geo", "point", "bottom", "left", ",", "geo", "point", "top", "right", ")", "{", "return", "set", "corners", "(", "top", "right", "get", "lat", "(", ")", ",", "bottom", "left", "get", "lon", "(", ")", ",", "bottom", "left", "get", "lat", "(", ")", ",", "top", "right", "get", "lon", "(", ")", ")", ";", "}" ]

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

[ "xfs", "filter", "is", "enabled", "by", "default", "if", "the", "enabled", "flag", "is", "not", "explicitly", "specified", "and", "set", "to", "\"", "false", "\"", ",", "this", "method", "returns", "true" ]

[ "private", "boolean", "has", "x", "f", "s", "enabled", "(", ")", "{", "return", "conf", "get", "boolean", "(", "yarn", "configuration", "yarn", "xfs", "enabled", ",", "true", ")", ";", "}" ]

[ "write", "to", "the", "given", "output", "archive" ]

[ "void", "write", "(", "output", "archive", "oa", ")", "throws", "i", "o", "exception", ";" ]

[ "create", "a", "new", "{", "@", "code", "k", "table", "}", "by", "transforming", "the", "value", "of", "each", "record", "in", "this", "{", "@", "code", "k", "table", "}", "into", "a", "new", "value", "(", "with", "possibly", "a", "new", "type", ")", ",", "with", "the", "{", "@", "link", "serde", "key", "serde", "}", ",", "{", "@", "link", "serde", "value", "serde", "}", ",", "and", "the", "underlying", "{", "@", "link", "key", "value", "store", "materialized", "state", "storage", "}", "configured", "in", "the", "{", "@", "link", "materialized", "}", "instance", "a", "{", "@", "link", "value", "transformer", "with", "key", "}", "(", "provided", "by", "the", "given", "{", "@", "link", "value", "transformer", "with", "key", "supplier", "}", ")", "is", "applied", "to", "each", "input", "record", "value", "and", "computes", "a", "new", "value", "for", "it", "this", "is", "similar", "to", "{", "@", "link", "#", "map", "values", "(", "value", "mapper", "with", "key", ")", "}", ",", "but", "more", "flexible", ",", "allowing", "stateful", ",", "rather", "than", "stateless", ",", "record", "-", "by", "-", "record", "operation", ",", "access", "to", "additional", "state", "-", "stores", ",", "and", "access", "to", "the", "{", "@", "link", "processor", "context", "}", "furthermore", ",", "via", "{", "@", "link", "org", "apache", "kafka", "streams", "processor", "punctuator", "#", "punctuate", "(", "long", ")", "}", "the", "processing", "progress", "can", "be", "observed", "and", "additional", "periodic", "actions", "can", "be", "performed", "the", "resulting", "{", "@", "code", "k", "table", "}", "is", "materialized", "into", "another", "state", "store", "(", "additional", "to", "the", "provided", "state", "store", "names", ")", "as", "specified", "by", "the", "user", "via", "{", "@", "link", "materialized", "}", "parameter", ",", "and", "is", "queryable", "through", "its", "given", "name", "in", "order", "to", "assign", "a", "state", ",", "the", "state", "must", "be", "created", "and", "registered", "beforehand", ":", "{", "@", "code", "create", "store", "store", "builder", "<", "key", "value", "store", "<", "string", ",", "string", ">", ">", "key", "value", "store", "builder", "=", "stores", "key", "value", "store", "builder", "(", "stores", "persistent", "key", "value", "store", "(", "\"", "my", "value", "transform", "state", "\"", ")", ",", "serdes", "string", "(", ")", ",", "serdes", "string", "(", ")", ")", ";", "register", "store", "builder", "add", "state", "store", "(", "key", "value", "store", "builder", ")", ";", "k", "table", "output", "table", "=", "input", "table", "transform", "values", "(", "new", "value", "transformer", "with", "key", "supplier", "(", ")", "{", "}", ",", "materialized", "<", "string", ",", "string", ",", "key", "value", "store", "<", "bytes", ",", "byte", "[", "]", ">", ">", "as", "(", "\"", "output", "table", "\"", ")", "with", "key", "serde", "(", "serdes", "string", "(", ")", ")", "with", "value", "serde", "(", "serdes", "string", "(", ")", ")", ",", "\"", "my", "value", "transform", "state", "\"", ")", ";", "}", "within", "the", "{", "@", "link", "value", "transformer", "with", "key", "}", ",", "the", "state", "is", "obtained", "via", "the", "{", "@", "link", "processor", "context", "}", "to", "trigger", "periodic", "actions", "via", "{", "@", "link", "org", "apache", "kafka", "streams", "processor", "punctuator", "#", "punctuate", "(", "long", ")", "punctuate", "(", ")", "}", ",", "a", "schedule", "must", "be", "registered", "{", "@", "code", "new", "value", "transformer", "with", "key", "supplier", "(", ")", "{", "value", "transformer", "with", "key", "get", "(", ")", "{", "return", "new", "value", "transformer", "with", "key", "(", ")", "{", "private", "key", "value", "store", "<", "string", ",", "string", ">", "state", ";", "void", "init", "(", "processor", "context", "context", ")", "{", "this", "state", "=", "(", "key", "value", "store", "<", "string", ",", "string", ">", ")", "context", "get", "state", "store", "(", "\"", "my", "value", "transform", "state", "\"", ")", ";", "context", "schedule", "(", "duration", "of", "seconds", "(", "1", ")", ",", "punctuation", "type", "wall", "clock", "time", ",", "new", "punctuator", "(", ")", ")", ";", "punctuate", "each", "1", "0", "0", "0ms", ",", "can", "access", "this", "state", "}", "new", "value", "type", "transform", "(", "k", "read", "only", "key", ",", "v", "value", ")", "{", "can", "access", "this", "state", "and", "use", "read", "-", "only", "key", "return", "new", "new", "value", "type", "(", "read", "only", "key", ")", ";", "or", "null", "}", "void", "close", "(", ")", "{", "can", "access", "this", "state", "}", "}", "}", "}", "}", "note", "that", "the", "key", "is", "read", "-", "only", "and", "should", "not", "be", "modified", ",", "as", "this", "can", "lead", "to", "corrupt", "partitioning", "setting", "a", "new", "value", "preserves", "data", "co", "-", "location", "with", "respect", "to", "the", "key" ]

[ "<", "vr", ">", "k", "table", "<", "k", ",", "vr", ">", "transform", "values", "(", "final", "value", "transformer", "with", "key", "supplier", "<", "?", "super", "k", ",", "?", "super", "v", ",", "?", "extends", "vr", ">", "transformer", "supplier", ",", "final", "materialized", "<", "k", ",", "vr", ",", "key", "value", "store", "<", "bytes", ",", "byte", "[", "]", ">", ">", "materialized", ",", "final", "string", "state", "store", "names", ")", ";" ]

[ "synchronously", "writes", "the", "new", "checkpoints", "to", "state", "handle", "store", "and", "asynchronously", "removes", "older", "ones" ]

[ "public", "void", "add", "checkpoint", "(", "final", "completed", "checkpoint", "checkpoint", ",", "checkpoints", "cleaner", "checkpoints", "cleaner", ",", "runnable", "post", "cleanup", ")", "throws", "exception", "{", "check", "not", "null", "(", "checkpoint", ",", "\"", "checkpoint", "\"", ")", ";", "final", "string", "path", "=", "completed", "checkpoint", "store", "util", "checkpoint", "i", "d", "to", "name", "(", "checkpoint", "get", "checkpoint", "i", "d", "(", ")", ")", ";", "/", "/", "now", "add", "the", "new", "one", "if", "it", "fails", ",", "we", "don", "'", "t", "want", "to", "loose", "existing", "data", "checkpoint", "state", "handle", "store", "add", "and", "lock", "(", "path", ",", "checkpoint", ")", ";", "completed", "checkpoints", "add", "last", "(", "checkpoint", ")", ";", "/", "/", "everything", "worked", ",", "let", "'", "s", "remove", "a", "previous", "checkpoint", "if", "necessary", "while", "(", "completed", "checkpoints", "size", "(", ")", ">", "max", "number", "of", "checkpoints", "to", "retain", ")", "{", "final", "completed", "checkpoint", "completed", "checkpoint", "=", "completed", "checkpoints", "remove", "first", "(", ")", ";", "try", "remove", "completed", "checkpoint", "(", "completed", "checkpoint", ",", "completed", "checkpoint", "should", "be", "discarded", "on", "subsume", "(", ")", ",", "checkpoints", "cleaner", ",", "post", "cleanup", ")", ";", "}", "log", "debug", "(", "\"", "added", "{", "}", "to", "{", "}", "\"", ",", "checkpoint", ",", "path", ")", ";", "}" ]

[ "use", "this", "method", "only", "when", "using", "this", "class", "as", "an", "ordinary", "image", "view" ]

[ "public", "void", "set", "image", "u", "r", "i", "(", "uri", "uri", ")", "{", "init", "(", "get", "context", "(", ")", ")", ";", "m", "drawee", "holder", "set", "controller", "(", "null", ")", ";", "super", "set", "image", "u", "r", "i", "(", "uri", ")", ";", "}" ]

[ "set", "this", "node", "to", "be", "deleted", "so", "that", "it", "can", "be", "rendered", "as", "such" ]

[ "public", "void", "set", "is", "cut", "(", "boolean", "is", "cut", ")", "{", "this", "is", "cut", "=", "is", "cut", ";", "fire", "node", "changed", "(", "get", "parent", "(", ")", ",", "this", ")", ";", "}" ]

[ "returns", "the", "current", "value", "being", "referenced", ",", "or", "{", "@", "code", "null", "}", "if", "there", "is", "none", "(", "e", "g", "because", "either", "it", "got", "collected", ",", "or", "{", "@", "link", "#", "clear", "}", "was", "called", ",", "or", "it", "wasn", "'", "t", "set", "in", "the", "first", "place", ")" ]

[ "v", "get", "(", ")", ";" ]

[ "returns", "the", "gnu", "system", "name" ]

[ "public", "string", "get", "target", "gnu", "system", "name", "(", ")", "{", "return", "target", "system", "name", ";", "}" ]

[ "called", "after", "all", "the", "host", "'", "s", "children", "have", "been", "unbound" ]

[ "public", "void", "on", "unbind", "(", "extension", "state", "<", "state", ">", "extension", "state", ")", "{", "}" ]

[ "intercept", "the", "execution", "of", "a", "request", "handler", "before", "its", "invocation", "allows", "for", "preparing", "context", "resources", "(", "such", "as", "a", "hibernate", "session", ")", "and", "expose", "them", "as", "request", "attributes", "or", "as", "thread", "-", "local", "objects" ]

[ "void", "pre", "handle", "(", "web", "request", "request", ")", "throws", "exception", ";" ]

[ "sets", "the", "number", "of", "device", "screens", "worth", "of", "pixels", "the", "{", "@", "link", "com", "bumptech", "glide", "load", "engine", "bitmap", "recycle", "bitmap", "pool", "}", "should", "be", "able", "to", "hold", "and", "returns", "this", "builder" ]

[ "public", "builder", "set", "bitmap", "pool", "screens", "(", "float", "bitmap", "pool", "screens", ")", "{", "preconditions", "check", "argument", "(", "bitmap", "pool", "screens", ">", "=", "0", ",", "\"", "bitmap", "pool", "screens", "must", "be", "greater", "than", "or", "equal", "to", "0", "\"", ")", ";", "this", "bitmap", "pool", "screens", "=", "bitmap", "pool", "screens", ";", "return", "this", ";", "}" ]

[ "build", "jwt", "claims" ]

[ "protected", "jwt", "claims", "build", "jwt", "claims", "(", "final", "single", "logout", "request", "context", "request", ")", "{", "val", "oidc", "=", "configuration", "context", "get", "cas", "properties", "(", ")", "get", "authn", "(", ")", "get", "oidc", "(", ")", ";", "val", "claims", "=", "new", "jwt", "claims", "(", ")", ";", "claims", "set", "issuer", "(", "oidc", "get", "issuer", "(", ")", ")", ";", "claims", "set", "subject", "(", "request", "get", "execution", "request", "(", ")", "get", "ticket", "granting", "ticket", "(", ")", "get", "authentication", "(", ")", "get", "principal", "(", ")", "get", "id", "(", ")", ")", ";", "claims", "set", "audience", "(", "(", "(", "oidc", "registered", "service", ")", "request", "get", "registered", "service", "(", ")", ")", "get", "client", "id", "(", ")", ")", ";", "claims", "set", "issued", "at", "to", "now", "(", ")", ";", "claims", "set", "jwt", "id", "(", "uuid", "random", "u", "u", "i", "d", "(", ")", "to", "string", "(", ")", ")", ";", "val", "events", "=", "new", "hash", "map", "<", "string", ",", "object", ">", "(", ")", ";", "events", "put", "(", "\"", "http", ":", "/", "/", "schemas", "openid", "net", "/", "event", "/", "backchannel", "-", "logout", "\"", ",", "new", "hash", "map", "<", ">", "(", ")", ")", ";", "claims", "set", "claim", "(", "\"", "events", "\"", ",", "events", ")", ";", "claims", "set", "claim", "(", "oidc", "constants", "claim", "sessiond", "id", ",", "digest", "utils", "sha", "(", "request", "get", "execution", "request", "(", ")", "get", "ticket", "granting", "ticket", "(", ")", "get", "id", "(", ")", ")", ")", ";", "return", "claims", ";", "}" ]

[ "get", "the", "checked", "activity" ]

[ "static", "class", "<", "?", "extends", "activity", ">", "get", "return", "activity", "(", "final", "class", "<", "?", ">", "return", "activity", ")", "{", "class", "<", "?", "extends", "activity", ">", "checked", "return", "activity", "=", "null", ";", "if", "(", "return", "activity", "!", "=", "null", ")", "{", "if", "(", "activity", "class", "is", "assignable", "from", "(", "return", "activity", ")", ")", "{", "checked", "return", "activity", "=", "return", "activity", "as", "subclass", "(", "activity", "class", ")", ";", "}", "else", "{", "checked", "return", "activity", "=", "main", "activity", "class", ";", "}", "}", "return", "checked", "return", "activity", ";", "}" ]

[ "gets", "the", "platform", "for", "which", "these", "env", "vars", "targeted" ]

[ "public", "@", "check", "for", "null", "platform", "get", "platform", "(", ")", "{", "return", "platform", ";", "}" ]

[ "returns", "an", "iterator", "on", "a", "copy", "of", "the", "internal", "array", "so", "that", "the", "iterator", "won", "'", "t", "fail", "by", "buckets", "being", "addedremoved", "concurrently" ]

[ "public", "iterator", "<", "bucket", ">", "iterator", "(", ")", "{", "return", "collections", "unmodifiable", "list", "(", "arrays", "as", "list", "(", "get", "array", "(", ")", ")", ")", "iterator", "(", ")", ";", "}" ]

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

[ "public", "void", "write", "to", "(", "dex", "file", "file", ",", "annotated", "output", "out", ")", "{", "int", "field", "idx", "=", "file", "get", "field", "ids", "(", ")", "index", "of", "(", "field", ")", ";", "int", "annotations", "off", "=", "annotations", "get", "absolute", "offset", "(", ")", ";", "if", "(", "out", "annotates", "(", ")", ")", "{", "out", "annotate", "(", "0", ",", "\"", "\"", "+", "field", "to", "human", "(", ")", ")", ";", "out", "annotate", "(", "4", ",", "\"", "field", "idx", ":", "\"", "+", "hex", "u", "4", "(", "field", "idx", ")", ")", ";", "out", "annotate", "(", "4", ",", "\"", "annotations", "off", ":", "\"", "+", "hex", "u", "4", "(", "annotations", "off", ")", ")", ";", "}", "out", "write", "int", "(", "field", "idx", ")", ";", "out", "write", "int", "(", "annotations", "off", ")", ";", "}" ]

[ "binary", "search", "{", "@", "code", "right", "rows", "sorted", "}", "to", "find", "the", "latest", "right", "row", "to", "join", "with", "{", "@", "code", "left", "time", "}", "latest", "means", "a", "right", "row", "with", "largest", "time", "that", "is", "still", "smaller", "or", "equal", "to", "{", "@", "code", "left", "time", "}", "for", "example", "with", ":", "right", "state", "=", "[", "1", "(", "+", "i", ")", ",", "4", "(", "+", "u", ")", ",", "7", "(", "+", "u", ")", ",", "9", "(", "-", "d", ")", ",", "12", "(", "i", ")", "]", ",", "if", "left", "time", "is", "6", ",", "the", "valid", "period", "should", "be", "[", "4", ",", "7", ")", ",", "data", "4", "(", "+", "u", ")", "should", "be", "joined", "if", "left", "time", "is", "10", ",", "the", "valid", "period", "should", "be", "[", "9", ",", "12", ")", ",", "but", "data", "9", "(", "-", "d", ")", "is", "a", "delete", "message", "which", "means", "the", "the", "correspond", "version", "has", "no", "data", "in", "period", "[", "9", ",", "12", ")", ",", "data", "9", "(", "-", "d", ")", "should", "not", "be", "correlated" ]

[ "private", "optional", "<", "row", "data", ">", "latest", "right", "row", "to", "join", "(", "list", "<", "row", "data", ">", "right", "rows", "sorted", ",", "long", "left", "time", ")", "{", "return", "latest", "right", "row", "to", "join", "(", "right", "rows", "sorted", ",", "0", ",", "right", "rows", "sorted", "size", "(", ")", "-", "1", ",", "left", "time", ")", ";", "}" ]

[ "tests", "that", "a", "config", "setting", "only", "matches", "build", "configurations", "where", "all", "of", "its", "flag", "specifications", "match" ]

[ "public", "void", "matching", "criteria", "(", ")", "throws", "exception", "{", "write", "simple", "example", "(", ")", ";", "/", "/", "first", "flag", "mismatches", ":", "use", "configuration", "(", "\"", "-", "c", "\"", ",", "\"", "opt", "\"", ",", "\"", "-", "-", "stamp", "\"", ")", ";", "assert", "that", "(", "get", "config", "matching", "provider", "(", "\"", "/", "/", "pkg", ":", "foo", "\"", ")", "matches", "(", ")", ")", "is", "false", "(", ")", ";", "/", "/", "second", "flag", "mismatches", ":", "use", "configuration", "(", "\"", "-", "c", "\"", ",", "\"", "dbg", "\"", ",", "\"", "-", "-", "nostamp", "\"", ")", ";", "assert", "that", "(", "get", "config", "matching", "provider", "(", "\"", "/", "/", "pkg", ":", "foo", "\"", ")", "matches", "(", ")", ")", "is", "false", "(", ")", ";", "/", "/", "both", "flags", "mismatch", ":", "use", "configuration", "(", "\"", "-", "c", "\"", ",", "\"", "opt", "\"", ",", "\"", "-", "-", "nostamp", "\"", ")", ";", "assert", "that", "(", "get", "config", "matching", "provider", "(", "\"", "/", "/", "pkg", ":", "foo", "\"", ")", "matches", "(", ")", ")", "is", "false", "(", ")", ";", "/", "/", "both", "flags", "match", ":", "use", "configuration", "(", "\"", "-", "c", "\"", ",", "\"", "dbg", "\"", ",", "\"", "-", "-", "stamp", "\"", ")", ";", "assert", "that", "(", "get", "config", "matching", "provider", "(", "\"", "/", "/", "pkg", ":", "foo", "\"", ")", "matches", "(", ")", ")", "is", "true", "(", ")", ";", "}" ]

[ "add", "{", "@", "code", "node", "}", "as", "a", "successor", "to", "the", "origin", "node", "in", "the", "case", "of", "an", "undirected", "graph", ",", "it", "also", "becomes", "a", "predecessor", "associates", "{", "@", "code", "value", "}", "with", "the", "edge", "connecting", "the", "two", "nodes", "returns", "the", "value", "previously", "associated", "with", "the", "edge", "connecting", "the", "two", "nodes" ]

[ "v", "add", "successor", "(", "n", "node", ",", "v", "value", ")", ";" ]

[ "reset", "all", "breaker", "settings", "back", "to", "their", "defaults" ]

[ "private", "void", "reset", "(", ")", "{", "logger", "info", "(", "\"", "-", "-", ">", "resetting", "breaker", "settings", "\"", ")", ";", "/", "/", "clear", "all", "caches", ",", "we", "could", "be", "very", "close", "(", "or", "even", "above", ")", "the", "limit", "and", "then", "we", "will", "not", "be", "able", "to", "reset", "the", "breaker", "settings", "client", "(", ")", "admin", "(", ")", "indices", "(", ")", "prepare", "clear", "cache", "(", ")", "set", "field", "data", "cache", "(", "true", ")", "set", "query", "cache", "(", "true", ")", "set", "request", "cache", "(", "true", ")", "get", "(", ")", ";", "settings", "builder", "reset", "settings", "=", "settings", "builder", "(", ")", ";", "stream", "of", "(", "hierarchy", "circuit", "breaker", "service", "fielddata", "circuit", "breaker", "limit", "setting", ",", "hierarchy", "circuit", "breaker", "service", "fielddata", "circuit", "breaker", "overhead", "setting", ",", "hierarchy", "circuit", "breaker", "service", "request", "circuit", "breaker", "limit", "setting", ",", "hierarchy", "circuit", "breaker", "service", "request", "circuit", "breaker", "overhead", "setting", ",", "hierarchy", "circuit", "breaker", "service", "accounting", "circuit", "breaker", "limit", "setting", ",", "hierarchy", "circuit", "breaker", "service", "accounting", "circuit", "breaker", "overhead", "setting", ",", "hierarchy", "circuit", "breaker", "service", "in", "flight", "requests", "circuit", "breaker", "limit", "setting", ",", "hierarchy", "circuit", "breaker", "service", "in", "flight", "requests", "circuit", "breaker", "overhead", "setting", ",", "hierarchy", "circuit", "breaker", "service", "total", "circuit", "breaker", "limit", "setting", ")", "for", "each", "(", "s", "-", ">", "reset", "settings", "put", "null", "(", "s", "get", "key", "(", ")", ")", ")", ";", "assert", "acked", "(", "client", "(", ")", "admin", "(", ")", "cluster", "(", ")", "prepare", "update", "settings", "(", ")", "set", "transient", "settings", "(", "reset", "settings", ")", ")", ";", "}" ]

[ "returns", "true", "if", "there", "is", "a", "current", "open", "ghidra", "{", "@", "link", "program", "}", "that", "has", "metadata", "that", "links", "it", "to", "the", "specified", "{", "@", "link", "fsrl", "}", "(", "ie", "an", "open", "program", "has", "a", "md5", "or", "fsrl", "metadata", "value", "that", "matches", "the", "fsrl", "param", ")" ]

[ "public", "static", "boolean", "is", "file", "open", "(", "fsrl", "fsrl", ")", "{", "string", "expected", "m", "d", "5", "=", "fsrl", "get", "m", "d", "5", "(", ")", ";", "list", "<", "domain", "file", ">", "open", "domain", "files", "=", "new", "array", "list", "<", ">", "(", ")", ";", "app", "info", "get", "active", "project", "(", ")", "get", "project", "data", "(", ")", "find", "open", "files", "(", "open", "domain", "files", ")", ";", "object", "consumer", "=", "new", "object", "(", ")", ";", "for", "(", "domain", "file", "df", ":", "open", "domain", "files", ")", "{", "domain", "object", "opened", "domain", "object", "=", "df", "get", "opened", "domain", "object", "(", "consumer", ")", ";", "try", "{", "if", "(", "opened", "domain", "object", "instanceof", "program", ")", "{", "program", "program", "=", "(", "program", ")", "opened", "domain", "object", ";", "options", "property", "list", "=", "program", "get", "options", "(", "program", "program", "info", ")", ";", "string", "fsrl", "str", "=", "property", "list", "get", "string", "(", "program", "mapping", "service", "program", "source", "fsrl", ",", "null", ")", ";", "string", "md", "5", "=", "property", "list", "get", "string", "(", "program", "mapping", "service", "program", "metadata", "md5", ",", "null", ")", ";", "if", "(", "(", "expected", "m", "d", "5", "!", "=", "null", "&", "&", "expected", "m", "d", "5", "equals", "(", "md", "5", ")", ")", "|", "|", "fsrl", "is", "equivalent", "(", "fsrl", "str", ")", ")", "{", "create", "association", "(", "fsrl", ",", "program", ")", ";", "return", "true", ";", "}", "}", "}", "finally", "{", "if", "(", "opened", "domain", "object", "!", "=", "null", "&", "&", "opened", "domain", "object", "is", "used", "by", "(", "consumer", ")", ")", "{", "opened", "domain", "object", "release", "(", "consumer", ")", ";", "}", "}", "}", "return", "false", ";", "}" ]

[ "method", "to", "decide", "whether", "the", "element", "signals", "the", "end", "of", "the", "stream", "if", "true", "is", "returned", "the", "element", "won", "'", "t", "be", "emitted" ]

[ "boolean", "is", "end", "of", "stream", "(", "t", "next", "element", ")", ";" ]

[ "get", "prefix", "ns", "string" ]

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

[ "<", "code", ">", "merge", "function", "return", "<", "code", ">", "replaces", "the", "return", "typestorage", "of", "the", "function", "in", "program", "1", "with", "the", "return", "typestorage", "of", "the", "function", "in", "program", "2", "at", "the", "specified", "entry", "point", "address" ]

[ "public", "void", "merge", "function", "return", "(", "address", "entry", "2", ")", "{", "address", "entry", "=", "origin", "to", "result", "translator", "get", "address", "(", "entry", "2", ")", ";", "function", "f", "1", "=", "result", "program", "get", "function", "manager", "(", ")", "get", "function", "at", "(", "entry", ")", ";", "function", "f", "2", "=", "origin", "program", "get", "function", "manager", "(", ")", "get", "function", "at", "(", "entry", "2", ")", ";", "if", "(", "f", "1", "!", "=", "null", "&", "&", "f", "2", "!", "=", "null", ")", "{", "try", "{", "parameter", "f", "1", "return", "=", "f", "1", "get", "return", "(", ")", ";", "parameter", "f", "2", "return", "=", "f", "2", "get", "return", "(", ")", ";", "data", "type", "dt", "1", "=", "f", "1", "return", "get", "data", "type", "(", ")", ";", "data", "type", "dt", "2", "=", "f", "2", "return", "get", "data", "type", "(", ")", ";", "boolean", "storage", "matches", "=", "f", "1", "return", "get", "variable", "storage", "(", ")", "equals", "(", "f", "2", "return", "get", "variable", "storage", "(", ")", ")", ";", "if", "(", "same", "data", "type", "(", "dt", "1", ",", "dt", "2", ")", ")", "{", "if", "(", "storage", "matches", ")", "{", "return", ";", "}", "dt", "2", "=", "dt", "1", ";", "}", "else", "if", "(", "storage", "matches", ")", "{", "if", "(", "!", "f", "1", "has", "custom", "variable", "storage", "(", ")", ")", "{", "dt", "2", "=", "f", "2", "return", "get", "formal", "data", "type", "(", ")", ";", "}", "f", "1", "return", "set", "data", "type", "(", "dt", "2", ",", "f", "2", "get", "signature", "source", "(", ")", ")", ";", "return", ";", "}", "try", "{", "/", "/", "assume", "return", "storage", "does", "not", "match", "between", "f", "1", "and", "f", "2", "if", "(", "f", "2", "has", "custom", "variable", "storage", "(", ")", ")", "{", "f", "1", "set", "custom", "variable", "storage", "(", "true", ")", ";", "/", "/", "}", "else", "if", "(", "!", "f", "1", "has", "custom", "variable", "storage", "(", ")", ")", "{", "dt", "2", "=", "f", "2", "return", "get", "formal", "data", "type", "(", ")", ";", "/", "/", "allow", "dynamic", "storage", "to", "handle", "use", "of", "return", "storage", "pointer", "}", "f", "1", "return", "set", "data", "type", "(", "dt", "2", ",", "f", "2", "return", "get", "variable", "storage", "(", ")", ",", "true", ",", "f", "2", "get", "signature", "source", "(", ")", ")", ";", "}", "catch", "(", "invalid", "input", "exception", "e", ")", "{", "f", "1", "return", "set", "data", "type", "(", "dt", "2", ",", "variable", "storage", "unassigned", "storage", ",", "false", ",", "source", "type", "default", ")", ";", "string", "msg", "=", "\"", "return", "storage", "forced", "to", "unassigned", "for", "\"", "+", "f", "1", "get", "name", "(", "true", ")", "+", "\"", ":", "\\", "n", "\"", "+", "e", "get", "message", "(", ")", ";", "msg", "error", "(", "this", ",", "msg", ")", ";", "error", "msg", "append", "(", "msg", "+", "\"", "\\", "n", "\"", ")", ";", "}", "}", "catch", "(", "invalid", "input", "exception", "e", ")", "{", "error", "msg", "append", "(", "\"", "failed", "to", "replace", "function", "return", "for", "\"", "+", "f", "1", "get", "name", "(", ")", "+", "\"", ":", "\"", "+", "e", "get", "message", "(", ")", ")", ";", "}", "}", "}" ]

[ "increments", "a", "counter", "a", "certain", "number", "of", "times" ]

[ "public", "static", "void", "increment", "counter", "(", "startup", "progress", "prog", ",", "phase", "phase", ",", "step", "step", ",", "long", "delta", ")", "{", "startup", "progress", "counter", "counter", "=", "prog", "get", "counter", "(", "phase", ",", "step", ")", ";", "for", "(", "long", "i", "=", "0", ";", "i", "<", "delta", ";", "+", "+", "i", ")", "{", "counter", "increment", "(", ")", ";", "}", "}" ]

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

[ "public", "long", "skip", "(", "long", "n", ")", "{", "if", "(", "pos", "+", "n", ">", "count", ")", "{", "n", "=", "count", "-", "pos", ";", "}", "if", "(", "n", "<", "0", ")", "{", "return", "0", ";", "}", "pos", "+", "=", "n", ";", "return", "n", ";", "}" ]

[ "update", "global", "session", "status", "test" ]

[ "public", "void", "update", "global", "session", "status", "test", "(", "global", "session", "global", "session", ")", "throws", "exception", "{", "for", "(", "session", "manager", "session", "manager", ":", "session", "manager", "list", ")", "{", "session", "manager", "add", "global", "session", "(", "global", "session", ")", ";", "global", "session", "set", "status", "(", "global", "status", "finished", ")", ";", "session", "manager", "update", "global", "session", "status", "(", "global", "session", ",", "global", "status", "finished", ")", ";", "global", "session", "expected", "=", "session", "manager", "find", "global", "session", "(", "global", "session", "get", "xid", "(", ")", ")", ";", "assertions", "assert", "not", "null", "(", "expected", ")", ";", "assertions", "assert", "equals", "(", "global", "status", "finished", ",", "expected", "get", "status", "(", ")", ")", ";", "session", "manager", "remove", "global", "session", "(", "global", "session", ")", ";", "}", "}" ]

[ "create", "a", "rest", "command", "uri" ]

[ "public", "static", "string", "create", "command", "uri", "(", "action", "action", ",", "string", "parameter", ")", "{", "return", "endpoint", "prefix", "+", "action", "to", "string", "(", ")", "+", "(", "parameter", "!", "=", "null", "&", "&", "!", "parameter", "is", "empty", "(", ")", "?", "\"", "/", "\"", "+", "parameter", ":", "\"", "\"", ")", ";", "}" ]

[ "returns", "the", "total", "time", "spent", "rebuffering", ",", "in", "milliseconds", "this", "excludes", "initial", "join", "times", ",", "buffer", "times", "after", "a", "seek", "and", "buffering", "while", "paused" ]

[ "public", "long", "get", "total", "rebuffer", "time", "ms", "(", ")", "{", "return", "get", "playback", "state", "duration", "ms", "(", "playback", "state", "buffering", ")", ";", "}" ]

[ "add", "a", "listener", "to", "subscribe", "to", "job", "state", "updates", "listeners", "will", "be", "invoked", "on", "an", "arbitrary", "background", "thread", "you", "must", "eventually", "call", "{", "@", "link", "#", "remove", "listener", "(", "job", "listener", ")", "}", "to", "avoid", "memory", "leaks" ]

[ "synchronized", "void", "add", "listener", "(", "@", "non", "null", "job", "filter", "filter", ",", "@", "non", "null", "job", "listener", "listener", ")", "{", "job", "listeners", "add", "(", "new", "listener", "info", "(", "filter", ",", "listener", ")", ")", ";", "}" ]

[ "the", "maximum", "jvm", "heap", "size", ",", "in", "bytes", "this", "method", "uses", "the", "-", "xmx", "value", "of", "the", "jvm", ",", "if", "set", "if", "not", "set", ",", "it", "returns", "(", "as", "a", "heuristic", ")", "1", "4th", "of", "the", "physical", "memory", "size" ]

[ "public", "static", "long", "get", "max", "jvm", "heap", "memory", "(", ")", "{", "final", "long", "max", "memory", "=", "runtime", "get", "runtime", "(", ")", "max", "memory", "(", ")", ";", "if", "(", "max", "memory", "!", "=", "long", "max", "value", ")", "{", "/", "/", "we", "have", "the", "proper", "max", "memory", "return", "max", "memory", ";", "}", "else", "{", "/", "/", "max", "jvm", "heap", "size", "is", "not", "set", "-", "use", "the", "heuristic", "to", "use", "1", "/", "4th", "of", "the", "physical", "memory", "final", "long", "physical", "memory", "=", "hardware", "get", "size", "of", "physical", "memory", "(", ")", ";", "if", "(", "physical", "memory", "!", "=", "-", "1", ")", "{", "/", "/", "got", "proper", "value", "for", "physical", "memory", "return", "physical", "memory", "/", "4", ";", "}", "else", "{", "throw", "new", "runtime", "exception", "(", "\"", "could", "not", "determine", "the", "amount", "of", "free", "memory", "\\", "n", "\"", "+", "\"", "please", "set", "the", "maximum", "memory", "for", "the", "jvm", ",", "e", "g", "-", "xmx", "5", "1", "2", "m", "for", "512", "megabytes", "\"", ")", ";", "}", "}", "}" ]

[ "2016", "-", "11", "-", "10", "07", ":", "33", ":", "23", ",", "-", "12", "-", "1", "00", ":", "00", ":", "00" ]

[ "public", "static", "date", "next", "month", "(", "@", "not", "null", "final", "date", "date", ")", "{", "return", "date", "utils", "ceiling", "(", "date", ",", "calendar", "month", ")", ";", "}" ]

[ "rotates", "the", "vector", "2", "by", "the", "given", "angle", ",", "counter", "-", "clockwise", "assuming", "the", "y", "-", "axis", "points", "up" ]

[ "public", "vector", "2", "rotate", "deg", "(", "float", "degrees", ")", "{", "return", "rotate", "rad", "(", "degrees", "*", "math", "utils", "degrees", "to", "radians", ")", ";", "}" ]

[ "encodes", "\"", "-", "ue", "\"" ]

[ "boolean", "skip", "silent", "ue", "(", ")", "{", "/", "/", "always", "silent", "except", "for", "cases", "listed", "below", "if", "(", "(", "string", "at", "(", "(", "m", "current", "-", "1", ")", ",", "3", ",", "\"", "que", "\"", ",", "\"", "gue", "\"", ",", "\"", "\"", ")", "&", "&", "!", "string", "at", "(", "0", ",", "8", ",", "\"", "barbeque", "\"", ",", "\"", "palenque", "\"", ",", "\"", "applique", "\"", ",", "\"", "\"", ")", "/", "/", "'", "-", "que", "'", "cases", "usually", "french", "but", "missing", "the", "acute", "accent", "&", "&", "!", "string", "at", "(", "0", ",", "6", ",", "\"", "risque", "\"", ",", "\"", "\"", ")", "&", "&", "!", "string", "at", "(", "(", "m", "current", "-", "3", ")", ",", "5", ",", "\"", "argue", "\"", ",", "\"", "segue", "\"", ",", "\"", "\"", ")", "&", "&", "!", "string", "at", "(", "0", ",", "7", ",", "\"", "pirogue", "\"", ",", "\"", "enrique", "\"", ",", "\"", "\"", ")", "&", "&", "!", "string", "at", "(", "0", ",", "10", ",", "\"", "communique", "\"", ",", "\"", "\"", ")", ")", "&", "&", "(", "m", "current", ">", "1", ")", "&", "&", "(", "(", "(", "m", "current", "+", "1", ")", "=", "=", "m", "last", ")", "|", "|", "string", "at", "(", "0", ",", "7", ",", "\"", "jacques", "\"", ",", "\"", "\"", ")", ")", ")", "{", "m", "current", "=", "skip", "vowels", "(", "m", "current", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "adds", "the", "android", "jar", "from", "the", "sdk", "to", "the", "command", "line", "and", "inputs" ]

[ "public", "busy", "box", "action", "builder", "add", "android", "jar", "(", ")", "{", "return", "add", "input", "(", "\"", "-", "-", "android", "jar", "\"", ",", "data", "context", "get", "sdk", "(", ")", "get", "android", "jar", "(", ")", ")", ";", "}" ]

[ "remove", "the", "overlap", "between", "the", "expected", "types", "and", "the", "existing", "types" ]

[ "private", "static", "boolean", "remove", "overlap", "between", "storage", "types", "(", "list", "<", "storage", "type", ">", "expected", ",", "list", "<", "storage", "type", ">", "existing", ",", "boolean", "ignore", "non", "movable", ")", "{", "for", "(", "iterator", "<", "storage", "type", ">", "i", "=", "existing", "iterator", "(", ")", ";", "i", "has", "next", "(", ")", ";", ")", "{", "final", "storage", "type", "t", "=", "i", "next", "(", ")", ";", "if", "(", "expected", "remove", "(", "t", ")", ")", "{", "i", "remove", "(", ")", ";", "}", "}", "if", "(", "ignore", "non", "movable", ")", "{", "remove", "non", "movable", "(", "existing", ")", ";", "remove", "non", "movable", "(", "expected", ")", ";", "}", "return", "expected", "is", "empty", "(", ")", "|", "|", "existing", "is", "empty", "(", ")", ";", "}" ]

[ "gets", "the", "central", "directory", "entry", "for", "this", "zip", "entry", ",", "if", "any" ]

[ "public", "directory", "entry", "get", "dir", "entry", "(", ")", "{", "return", "entry", ";", "}" ]

[ "return", "the", "http", "status", "code", "value" ]

[ "public", "http", "status", "get", "status", "code", "(", ")", "{", "return", "http", "status", "value", "of", "(", "this", "status", "code", ")", ";", "}" ]

[ "close", "routine", "will", "close", "all", "providers", "in", "the", "list", "which", "implement", "{", "@", "code", "closeable", "}", "this", "matters", "because", "some", "providers", "start", "a", "background", "thread", "to", "refresh", "their", "secrets" ]

[ "public", "void", "close", "(", ")", "{", "synchronized", "(", "this", ")", "{", "if", "(", "closed", "get", "(", ")", ")", "{", "/", "/", "already", "closed", ":", "no", "-", "op", "return", ";", "}", "int", "remainder", "=", "ref", "count", "decrement", "and", "get", "(", ")", ";", "if", "(", "remainder", "!", "=", "0", ")", "{", "/", "/", "still", "actively", "used", ",", "or", "somehow", "things", "are", "/", "/", "now", "negative", "log", "debug", "(", "\"", "not", "closing", "{", "}", "\"", ",", "this", ")", ";", "return", ";", "}", "/", "/", "at", "this", "point", ",", "the", "closing", "is", "going", "to", "happen", "log", "debug", "(", "\"", "closing", "{", "}", "\"", ",", "this", ")", ";", "closed", "set", "(", "true", ")", ";", "}", "/", "/", "do", "this", "outside", "the", "synchronized", "block", "for", "(", "a", "w", "s", "credentials", "provider", "p", ":", "providers", ")", "{", "if", "(", "p", "instanceof", "closeable", ")", "{", "i", "o", "utils", "close", "stream", "(", "(", "closeable", ")", "p", ")", ";", "}", "else", "if", "(", "p", "instanceof", "auto", "closeable", ")", "{", "s", "3", "a", "utils", "close", "autocloseables", "(", "log", ",", "(", "auto", "closeable", ")", "p", ")", ";", "}", "}", "}" ]

[ "sets", "a", "new", "handshaker", "service", "address", "for", "testing" ]

[ "public", "builder", "set", "handshaker", "address", "for", "testing", "(", "string", "handshaker", "address", ")", "{", "/", "/", "instead", "of", "using", "the", "default", "shared", "channel", "to", "the", "handshaker", "service", ",", "create", "a", "separate", "/", "/", "resource", "to", "the", "test", "address", "handshaker", "channel", "pool", "=", "shared", "resource", "pool", "for", "resource", "(", "handshaker", "service", "channel", "get", "handshaker", "channel", "for", "testing", "(", "handshaker", "address", ")", ")", ";", "return", "this", ";", "}" ]

[ "insert", "a", "node", "as", "a", "successor", "to", "this", "node", "in", "the", "linked", "list", "note", ":", "called", "only", "after", "the", "node", "is", "inserted", "into", "the", "tree" ]

[ "private", "void", "insert", "after", "(", "node", "item", ")", "{", "item", "prev", "=", "this", ";", "item", "next", "=", "next", ";", "if", "(", "this", "next", "=", "=", "null", ")", "{", "tail", "=", "item", ";", "}", "else", "{", "this", "next", "prev", "=", "item", ";", "}", "this", "next", "=", "item", ";", "}" ]

[ "model", "tests", "for", "mixed", "properties", "and", "additional", "properties", "class" ]

[ "public", "void", "test", "mixed", "properties", "and", "additional", "properties", "class", "(", ")", "{", "/", "/", "todo", ":", "test", "mixed", "properties", "and", "additional", "properties", "class", "}" ]

[ "returns", "a", "description", "of", "the", "option" ]

[ "option", "description", "get", "option", "description", "(", "string", "name", ")", "throws", "options", "parsing", "exception", "{", "return", "impl", "get", "option", "description", "(", "name", ")", ";", "}" ]

[ "returns", "list", "of", "existing", ",", "not", "internal", ",", "topicspartitions", "that", "match", "given", "pattern", "and", "where", "partitions", "are", "in", "range", "[", "start", "partition", ",", "end", "partition", "]" ]

[ "static", "collection", "<", "topic", "partition", ">", "get", "matching", "topic", "partitions", "(", "admin", "admin", "client", ",", "string", "topic", "regex", ",", "int", "start", "partition", ",", "int", "end", "partition", ")", "throws", "throwable", "{", "final", "pattern", "topic", "name", "pattern", "=", "pattern", "compile", "(", "topic", "regex", ")", ";", "/", "/", "first", "get", "list", "of", "matching", "topics", "list", "<", "string", ">", "matched", "topics", "=", "new", "array", "list", "<", ">", "(", ")", ";", "list", "topics", "result", "res", "=", "admin", "client", "list", "topics", "(", "new", "list", "topics", "options", "(", ")", "timeout", "ms", "(", "admin", "request", "timeout", ")", ")", ";", "map", "<", "string", ",", "topic", "listing", ">", "topic", "listing", "map", "=", "res", "names", "to", "listings", "(", ")", "get", "(", ")", ";", "for", "(", "map", "entry", "<", "string", ",", "topic", "listing", ">", "topic", "listing", "entry", ":", "topic", "listing", "map", "entry", "set", "(", ")", ")", "{", "if", "(", "!", "topic", "listing", "entry", "get", "value", "(", ")", "is", "internal", "(", ")", "&", "&", "topic", "name", "pattern", "matcher", "(", "topic", "listing", "entry", "get", "key", "(", ")", ")", "matches", "(", ")", ")", "{", "matched", "topics", "add", "(", "topic", "listing", "entry", "get", "key", "(", ")", ")", ";", "}", "}", "/", "/", "create", "a", "list", "of", "topic", "/", "partitions", "list", "<", "topic", "partition", ">", "out", "=", "new", "array", "list", "<", ">", "(", ")", ";", "describe", "topics", "result", "topics", "result", "=", "admin", "client", "describe", "topics", "(", "matched", "topics", ",", "new", "describe", "topics", "options", "(", ")", "timeout", "ms", "(", "admin", "request", "timeout", ")", ")", ";", "map", "<", "string", ",", "topic", "description", ">", "topic", "description", "map", "=", "topics", "result", "all", "(", ")", "get", "(", ")", ";", "for", "(", "topic", "description", "desc", ":", "topic", "description", "map", "values", "(", ")", ")", "{", "list", "<", "topic", "partition", "info", ">", "partitions", "=", "desc", "partitions", "(", ")", ";", "for", "(", "topic", "partition", "info", "info", ":", "partitions", ")", "{", "if", "(", "(", "info", "partition", "(", ")", ">", "=", "start", "partition", ")", "&", "&", "(", "info", "partition", "(", ")", "<", "=", "end", "partition", ")", ")", "{", "out", "add", "(", "new", "topic", "partition", "(", "desc", "name", "(", ")", ",", "info", "partition", "(", ")", ")", ")", ";", "}", "}", "}", "return", "out", ";", "}" ]

[ "get", "the", "transferable", "at", "the", "given", "point" ]

[ "public", "transferable", "get", "transferable", "(", "point", "p", ")", ";" ]

[ "expand", "the", "first", "selected", "node", ";", "called", "from", "an", "action", "listener", "on", "a", "menu" ]

[ "private", "void", "expand", "(", ")", "{", "tree", "path", "path", "=", "tree", "get", "lead", "selection", "path", "(", ")", ";", "tree", "expand", "node", "(", "(", "program", "node", ")", "tree", "get", "last", "selected", "path", "component", "(", ")", ")", ";", "expand", "action", "set", "enabled", "(", "!", "all", "paths", "expanded", "(", "path", ")", ")", ";", "collapse", "action", "set", "enabled", "(", "!", "all", "paths", "collapsed", "(", "path", ")", ")", ";", "}" ]

[ "checks", "the", "permission", "to", "see", "if", "the", "current", "user", "can", "abort", "this", "executable", "returns", "normally", "from", "this", "method", "if", "it", "'", "s", "ok", "note", ":", "if", "you", "have", "implemented", "{", "@", "link", "access", "controlled", "}", "this", "should", "just", "be", "{", "@", "code", "check", "permission", "(", "hudson", "model", "item", "cancel", ")", ";", "}" ]

[ "void", "check", "abort", "permission", "(", ")", ";" ]

[ "to", "test", "enum", "parameters", "to", "test", "enum", "parameters" ]

[ "public", "void", "test", "enum", "parameters", "test", "(", ")", "throws", "api", "exception", "{", "list", "<", "string", ">", "enum", "header", "string", "array", "=", "null", ";", "string", "enum", "header", "string", "=", "null", ";", "list", "<", "string", ">", "enum", "query", "string", "array", "=", "null", ";", "string", "enum", "query", "string", "=", "null", ";", "integer", "enum", "query", "integer", "=", "null", ";", "double", "enum", "query", "double", "=", "null", ";", "list", "<", "string", ">", "enum", "form", "string", "array", "=", "null", ";", "string", "enum", "form", "string", "=", "null", ";", "api", "test", "enum", "parameters", "(", "enum", "header", "string", "array", ",", "enum", "header", "string", ",", "enum", "query", "string", "array", ",", "enum", "query", "string", ",", "enum", "query", "integer", ",", "enum", "query", "double", ",", "enum", "form", "string", "array", ",", "enum", "form", "string", ")", ";", "/", "/", "todo", ":", "test", "validations", "}" ]

[ "returns", "whether", "the", "objects", "are", "the", "same", "with", "respect", "to", "the", "program", "difference", "type", "this", "comparator", "is", "interested", "in", "returns", "whether", "the", "memory", ",", "stack", "and", "external", "references", "are", "the", "same", "for", "the", "mnemonic", ",", "operand", ",", "and", "value", "at", "the", "indicated", "address" ]

[ "public", "boolean", "is", "same", "(", "object", "obj", "1", ",", "object", "obj", "2", ")", "{", "address", "addr", "1", "=", "(", "address", ")", "obj", "1", ";", "address", "addr", "2", "=", "(", "address", ")", "obj", "2", ";", "/", "/", "check", "the", "references", "reference", "[", "]", "refs", "1", "=", "rm", "1", "get", "references", "from", "(", "addr", "1", ")", ";", "reference", "[", "]", "refs", "2", "=", "rm", "2", "get", "references", "from", "(", "addr", "2", ")", ";", "/", "/", "want", "to", "compare", "refs", "other", "than", "fallthrough", "refs", "reference", "[", "]", "diff", "refs", "1", "=", "get", "diff", "refs", "(", "refs", "1", ")", ";", "reference", "[", "]", "diff", "refs", "2", "=", "get", "diff", "refs", "(", "refs", "2", ")", ";", "arrays", "sort", "(", "diff", "refs", "1", ")", ";", "arrays", "sort", "(", "diff", "refs", "2", ")", ";", "return", "equal", "ref", "arrays", "(", "diff", "refs", "1", ",", "diff", "refs", "2", ")", ";", "}" ]

[ "sets", "a", "context", "environment", "factory", ",", "that", "creates", "the", "context", "environment", "for", "running", "programs", "with", "pre", "-", "configured", "environments", "examples", "are", "running", "programs", "from", "the", "command", "line", ",", "and", "running", "programs", "in", "the", "scala", "shell", "when", "the", "context", "environment", "factory", "is", "set", ",", "no", "other", "environments", "can", "be", "explicitly", "used" ]

[ "protected", "static", "void", "initialize", "context", "environment", "(", "execution", "environment", "factory", "ctx", ")", "{", "context", "environment", "factory", "=", "preconditions", "check", "not", "null", "(", "ctx", ")", ";", "thread", "local", "context", "environment", "factory", "set", "(", "context", "environment", "factory", ")", ";", "}" ]

[ "updates", "a", "provided", "status", "by", "ensuring", "the", "specified", "flag", "is", "turned", "off" ]

[ "public", "static", "@", "status", "int", "turn", "off", "status", "flag", "(", "@", "status", "int", "status", ",", "@", "status", "int", "flag", ")", "{", "return", "status", "&", "~", "flag", ";", "}" ]

[ "check", "that", "when", "available", "system", "memory", "is", "constrained", "by", "docker", ",", "the", "machine", "-", "dependant", "heap", "sizing", "logic", "sets", "the", "correct", "heap", "size", ",", "based", "on", "the", "container", "limits" ]

[ "public", "void", "test", "1", "5", "0", "machine", "dependent", "heap", "(", ")", "throws", "exception", "{", "/", "/", "start", "by", "ensuring", "`", "jvm", "options", "`", "doesn", "'", "t", "define", "any", "heap", "options", "final", "path", "jvm", "options", "path", "=", "temp", "dir", "resolve", "(", "\"", "jvm", "options", "\"", ")", ";", "final", "path", "container", "jvm", "options", "path", "=", "installation", "config", "(", "\"", "jvm", "options", "\"", ")", ";", "copy", "from", "container", "(", "container", "jvm", "options", "path", ",", "jvm", "options", "path", ")", ";", "final", "list", "<", "string", ">", "jvm", "options", "=", "files", "read", "all", "lines", "(", "jvm", "options", "path", ")", "stream", "(", ")", "filter", "(", "line", "-", ">", "(", "line", "starts", "with", "(", "\"", "-", "xms", "\"", ")", "|", "|", "line", "starts", "with", "(", "\"", "-", "xmx", "\"", ")", ")", "=", "=", "false", ")", "collect", "(", "collectors", "to", "list", "(", ")", ")", ";", "files", "write", "string", "(", "jvm", "options", "path", ",", "string", "join", "(", "\"", "\\", "n", "\"", ",", "jvm", "options", ")", ")", ";", "/", "/", "now", "run", "the", "container", ",", "being", "explicit", "about", "the", "available", "memory", "run", "container", "(", "distribution", "(", ")", ",", "builder", "(", ")", "memory", "(", "\"", "9", "4", "2m", "\"", ")", "volumes", "(", "map", "of", "(", "jvm", "options", "path", ",", "container", "jvm", "options", "path", ")", ")", ")", ";", "wait", "for", "elasticsearch", "(", "installation", ")", ";", "/", "/", "grab", "the", "container", "output", "and", "find", "the", "line", "where", "it", "print", "the", "jvm", "arguments", "this", "will", "/", "/", "let", "us", "see", "what", "the", "automatic", "heap", "sizing", "calculated", "final", "optional", "<", "string", ">", "jvm", "arguments", "line", "=", "get", "container", "logs", "(", ")", "stdout", "lines", "(", ")", "filter", "(", "line", "-", ">", "line", "contains", "(", "\"", "jvm", "arguments", "\"", ")", ")", "find", "first", "(", ")", ";", "assert", "that", "(", "\"", "failed", "to", "find", "jvm", "arguments", "in", "container", "logs", "\"", ",", "jvm", "arguments", "line", "is", "present", "(", ")", ",", "is", "(", "true", ")", ")", ";", "final", "json", "node", "json", "node", "=", "new", "object", "mapper", "(", ")", "read", "tree", "(", "jvm", "arguments", "line", "get", "(", ")", ")", ";", "final", "string", "args", "str", "=", "json", "node", "get", "(", "\"", "message", "\"", ")", "text", "value", "(", ")", ";", "final", "list", "<", "string", ">", "x", "args", "=", "arrays", "stream", "(", "args", "str", "substring", "(", "1", ",", "args", "str", "length", "(", ")", "-", "1", ")", "split", "(", "\"", ",", "\\", "\\", "s", "*", "\"", ")", ")", "filter", "(", "arg", "-", ">", "arg", "starts", "with", "(", "\"", "-", "x", "\"", ")", ")", "collect", "(", "collectors", "to", "list", "(", ")", ")", ";", "/", "/", "this", "is", "roughly", "0", "4", "*", "942", "assert", "that", "(", "x", "args", ",", "has", "items", "(", "\"", "-", "xms", "3", "7", "6m", "\"", ",", "\"", "-", "xmx", "3", "7", "6m", "\"", ")", ")", ";", "}" ]

[ "create", "a", "new", "key", "-", "value", "pair" ]

[ "public", "static", "<", "k", ",", "v", ">", "key", "value", "<", "k", ",", "v", ">", "pair", "(", "final", "k", "key", ",", "final", "v", "value", ")", "{", "return", "new", "key", "value", "<", ">", "(", "key", ",", "value", ")", ";", "}" ]

[ "configures", "location", "for", "static", "resources" ]

[ "public", "synchronized", "void", "configure", "(", "string", "folder", ")", "{", "assert", "not", "null", "(", "folder", ",", "\"", "'", "folder", "'", "must", "not", "be", "null", "\"", ")", ";", "if", "(", "!", "static", "resources", "set", ")", "{", "if", "(", "static", "resource", "handlers", "=", "=", "null", ")", "{", "static", "resource", "handlers", "=", "new", "array", "list", "<", ">", "(", ")", ";", "}", "static", "resource", "handlers", "add", "(", "new", "class", "path", "resource", "handler", "(", "folder", ",", "\"", "index", "html", "\"", ")", ")", ";", "log", "info", "(", "\"", "static", "resource", "handler", "configured", "with", "folder", "=", "\"", "+", "folder", ")", ";", "static", "resources", "set", "=", "true", ";", "}", "}" ]

[ "the", "extension", "can", "optionally", "return", "a", "{", "@", "link", "mount", "extension", "}", "which", "can", "be", "used", "to", "augment", "the", "render", "core", "'", "s", "mounting", "phase", "the", "{", "@", "link", "#", "<", "input", ">", "}", "collected", "in", "the", "latest", "layout", "pass", "will", "be", "passed", "to", "the", "extension", "before", "mount" ]

[ "public", "@", "nullable", "mount", "extension", "<", "?", "extends", "input", ",", "state", ">", "get", "mount", "extension", "(", ")", "{", "return", "null", ";", "}" ]

[ "determine", "the", "cache", "operation", "(", "s", ")", "for", "the", "given", "{", "@", "link", "cache", "operation", "provider", "}", "this", "implementation", "delegates", "to", "configured", "{", "@", "link", "cache", "annotation", "parser", "cache", "annotation", "parsers", "}", "for", "parsing", "known", "annotations", "into", "spring", "'", "s", "metadata", "attribute", "class", "can", "be", "overridden", "to", "support", "custom", "annotations", "that", "carry", "caching", "metadata" ]

[ "protected", "collection", "<", "cache", "operation", ">", "determine", "cache", "operations", "(", "cache", "operation", "provider", "provider", ")", "{", "collection", "<", "cache", "operation", ">", "ops", "=", "null", ";", "for", "(", "cache", "annotation", "parser", "parser", ":", "this", "annotation", "parsers", ")", "{", "collection", "<", "cache", "operation", ">", "ann", "ops", "=", "provider", "get", "cache", "operations", "(", "parser", ")", ";", "if", "(", "ann", "ops", "!", "=", "null", ")", "{", "if", "(", "ops", "=", "=", "null", ")", "{", "ops", "=", "ann", "ops", ";", "}", "else", "{", "collection", "<", "cache", "operation", ">", "combined", "=", "new", "array", "list", "<", ">", "(", "ops", "size", "(", ")", "+", "ann", "ops", "size", "(", ")", ")", ";", "combined", "add", "all", "(", "ops", ")", ";", "combined", "add", "all", "(", "ann", "ops", ")", ";", "ops", "=", "combined", ";", "}", "}", "}", "return", "ops", ";", "}" ]

[ "returns", "a", "{", "@", "link", "set", "}", "view", "of", "the", "keys", "contained", "in", "this", "map", "the", "set", "is", "backed", "by", "the", "map", ",", "so", "changes", "to", "the", "map", "are", "reflected", "in", "the", "set", ",", "and", "vice", "-", "versa", "the", "set", "supports", "element", "removal", ",", "which", "removes", "the", "corresponding", "mapping", "from", "this", "map", ",", "via", "the", "<", "tt", ">", "iterator", "remove", "<", "tt", ">", ",", "<", "tt", ">", "set", "remove", "<", "tt", ">", ",", "<", "tt", ">", "remove", "all", "<", "tt", ">", ",", "<", "tt", ">", "retain", "all", "<", "tt", ">", ",", "and", "<", "tt", ">", "clear", "<", "tt", ">", "operations", "it", "does", "not", "support", "the", "<", "tt", ">", "add", "<", "tt", ">", "or", "<", "tt", ">", "add", "all", "<", "tt", ">", "operations", "the", "view", "'", "s", "<", "tt", ">", "iterator", "<", "tt", ">", "is", "a", "\"", "weakly", "consistent", "\"", "iterator", "that", "will", "never", "throw", "{", "@", "link", "concurrent", "modification", "exception", "}", ",", "and", "guarantees", "to", "traverse", "elements", "as", "they", "existed", "upon", "construction", "of", "the", "iterator", ",", "and", "may", "(", "but", "is", "not", "guaranteed", "to", ")", "reflect", "any", "modifications", "subsequent", "to", "construction" ]

[ "public", "set", "<", "k", ">", "key", "set", "(", ")", "{", "set", "<", "k", ">", "ks", "=", "key", "set", ";", "return", "(", "ks", "!", "=", "null", ")", "?", "ks", ":", "(", "key", "set", "=", "new", "key", "set", "(", ")", ")", ";", "}" ]

[ "returns", "a", "string", "representation", "of", "this", "array", "in", "the", "same", "form", "as", "{", "@", "link", "arrays", "#", "to", "string", "(", "long", "[", "]", ")", "}", ",", "for", "example", "{", "@", "code", "\"", "[", "1", ",", "2", ",", "3", "]", "\"", "}" ]

[ "public", "string", "to", "string", "(", ")", "{", "if", "(", "is", "empty", "(", ")", ")", "{", "return", "\"", "[", "]", "\"", ";", "}", "string", "builder", "builder", "=", "new", "string", "builder", "(", "length", "(", ")", "*", "5", ")", ";", "/", "/", "rough", "estimate", "is", "fine", "builder", "append", "(", "'", "[", "'", ")", "append", "(", "array", "[", "start", "]", ")", ";", "for", "(", "int", "i", "=", "start", "+", "1", ";", "i", "<", "end", ";", "i", "+", "+", ")", "{", "builder", "append", "(", "\"", ",", "\"", ")", "append", "(", "array", "[", "i", "]", ")", ";", "}", "builder", "append", "(", "'", "]", "'", ")", ";", "return", "builder", "to", "string", "(", ")", ";", "}" ]

[ "find", "an", "available", "port", "for", "this", "{", "@", "code", "socket", "type", "}", ",", "randomly", "selected", "from", "the", "range", "[", "{", "@", "code", "min", "port", "}", ",", "{", "@", "code", "max", "port", "}", "]" ]

[ "int", "find", "available", "port", "(", "int", "min", "port", ",", "int", "max", "port", ")", "{", "assert", "is", "true", "(", "min", "port", ">", "0", ",", "\"", "'", "min", "port", "'", "must", "be", "greater", "than", "0", "\"", ")", ";", "assert", "is", "true", "(", "max", "port", ">", "=", "min", "port", ",", "\"", "'", "max", "port", "'", "must", "be", "greater", "than", "or", "equal", "to", "'", "min", "port", "'", "\"", ")", ";", "assert", "is", "true", "(", "max", "port", "<", "=", "port", "range", "max", ",", "\"", "'", "max", "port", "'", "must", "be", "less", "than", "or", "equal", "to", "\"", "+", "port", "range", "max", ")", ";", "int", "port", "range", "=", "max", "port", "-", "min", "port", ";", "int", "candidate", "port", ";", "int", "search", "counter", "=", "0", ";", "do", "{", "if", "(", "search", "counter", ">", "port", "range", ")", "{", "throw", "new", "illegal", "state", "exception", "(", "string", "format", "(", "\"", "could", "not", "find", "an", "available", "%", "s", "port", "in", "the", "range", "[", "%", "d", ",", "%", "d", "]", "after", "%", "d", "attempts", "\"", ",", "name", "(", ")", ",", "min", "port", ",", "max", "port", ",", "search", "counter", ")", ")", ";", "}", "candidate", "port", "=", "find", "random", "port", "(", "min", "port", ",", "max", "port", ")", ";", "search", "counter", "+", "+", ";", "}", "while", "(", "!", "is", "port", "available", "(", "candidate", "port", ")", ")", ";", "return", "candidate", "port", ";", "}" ]

[ "enter", "a", "parse", "tree", "produced", "by", "{", "@", "link", "sql", "base", "parser", "#", "function", "template", "}" ]

[ "void", "enter", "function", "template", "(", "sql", "base", "parser", "function", "template", "context", "ctx", ")", ";" ]

[ "the", "following", "methods", "are", "customized", "for", "the", "requirement", "of", "dubbo", "'", "s", "rpc", "protocol", "implementation", "legacy", "protocol", "implementation", "will", "try", "to", "write", "map", ",", "throwable", "and", "null", "value", "directly", "to", "the", "stream", ",", "which", "does", "not", "meet", "the", "restrictions", "of", "all", "serialization", "protocols", "see", "how", "protobuf", "serialization", ",", "kryo", "serialization", "implemented", "these", "methods", "for", "more", "details", "the", "binding", "of", "rpc", "protocol", "and", "biz", "serialization", "protocol", "is", "not", "a", "good", "practice", "encoding", "of", "rpc", "protocol", "should", "be", "highly", "independent", "and", "portable", ",", "easy", "to", "cross", "platforms", "and", "languages", ",", "for", "example", ",", "like", "the", "http", "headers", ",", "restricting", "the", "content", "of", "headers", "attachments", "to", "ascii", "strings", "and", "uses", "iso", "8859", "1", "to", "encode", "them", "https", ":", "tools", "ietf", "orghtmlrfc", "7", "5", "4", "0", "#", "section", "-", "8", "1", "2" ]

[ "default", "void", "write", "throwable", "(", "object", "obj", ")", "throws", "i", "o", "exception", "{", "write", "object", "(", "obj", ")", ";", "}" ]

[ "generate", "spnego", "challenge", "request", "token" ]

[ "public", "static", "string", "generate", "token", "(", "string", "server", ")", "throws", "i", "o", "exception", ",", "interrupted", "exception", "{", "user", "group", "information", "current", "user", "=", "user", "group", "information", "get", "current", "user", "(", ")", ";", "log", "debug", "(", "\"", "the", "user", "credential", "is", "{", "}", "\"", ",", "current", "user", ")", ";", "string", "challenge", "=", "current", "user", "do", "as", "(", "new", "privileged", "exception", "action", "<", "string", ">", "(", ")", "{", "@", "override", "public", "string", "run", "(", ")", "throws", "exception", "{", "try", "{", "/", "/", "this", "oid", "for", "kerberos", "gss", "-", "api", "mechanism", "oid", "mech", "oid", "=", "kerberos", "util", "get", "oid", "instance", "(", "\"", "gss", "krb5", "mech", "oid", "\"", ")", ";", "g", "s", "s", "manager", "manager", "=", "g", "s", "s", "manager", "get", "instance", "(", ")", ";", "/", "/", "gss", "name", "for", "server", "g", "s", "s", "name", "server", "name", "=", "manager", "create", "name", "(", "\"", "http", "@", "\"", "+", "server", ",", "g", "s", "s", "name", "nt", "hostbased", "service", ")", ";", "/", "/", "create", "a", "g", "s", "s", "context", "for", "authentication", "with", "the", "service", "/", "/", "we", "'", "re", "passing", "client", "credentials", "as", "null", "since", "we", "want", "them", "to", "/", "/", "be", "read", "from", "the", "subject", "g", "s", "s", "context", "gss", "context", "=", "manager", "create", "context", "(", "server", "name", "canonicalize", "(", "mech", "oid", ")", ",", "mech", "oid", ",", "null", ",", "g", "s", "s", "context", "default", "lifetime", ")", ";", "gss", "context", "request", "mutual", "auth", "(", "true", ")", ";", "gss", "context", "request", "cred", "deleg", "(", "true", ")", ";", "/", "/", "establish", "context", "byte", "[", "]", "in", "token", "=", "new", "byte", "[", "0", "]", ";", "byte", "[", "]", "out", "token", "=", "gss", "context", "init", "sec", "context", "(", "in", "token", ",", "0", ",", "in", "token", "length", ")", ";", "gss", "context", "dispose", "(", ")", ";", "/", "/", "base", "6", "4", "encoded", "and", "stringified", "token", "for", "server", "log", "debug", "(", "\"", "got", "valid", "challenge", "for", "host", "{", "}", "\"", ",", "server", "name", ")", ";", "return", "new", "string", "(", "base", "64", "codec", "encode", "(", "out", "token", ")", ",", "standard", "charsets", "us", "ascii", ")", ";", "}", "catch", "(", "g", "s", "s", "exception", "|", "illegal", "access", "exception", "|", "no", "such", "field", "exception", "|", "class", "not", "found", "exception", "e", ")", "{", "log", "error", "(", "\"", "error", ":", "\"", ",", "e", ")", ";", "throw", "new", "authentication", "exception", "(", "e", ")", ";", "}", "}", "}", ")", ";", "return", "challenge", ";", "}" ]

[ "returns", "a", "{", "@", "link", "table", "environment", "}", "for", "a", "java", "batch", "{", "@", "link", "execution", "environment", "}", "that", "works", "with", "{", "@", "link", "data", "set", "}", "s", "a", "table", "environment", "can", "be", "used", "to", ":", "convert", "a", "{", "@", "link", "data", "set", "}", "to", "a", "{", "@", "link", "table", "}", "register", "a", "{", "@", "link", "data", "set", "}", "in", "the", "{", "@", "link", "table", "environment", "}", "'", "s", "catalog", "register", "a", "{", "@", "link", "table", "}", "in", "the", "{", "@", "link", "table", "environment", "}", "'", "s", "catalog", "scan", "a", "registered", "table", "to", "obtain", "a", "{", "@", "link", "table", "}", "specify", "a", "sql", "query", "on", "registered", "tables", "to", "obtain", "a", "{", "@", "link", "table", "}", "convert", "a", "{", "@", "link", "table", "}", "into", "a", "{", "@", "link", "data", "set", "}", "explain", "the", "ast", "and", "execution", "plan", "of", "a", "{", "@", "link", "table", "}" ]

[ "static", "batch", "table", "environment", "create", "(", "execution", "environment", "execution", "environment", ",", "table", "config", "table", "config", ")", "{", "try", "{", "/", "/", "temporary", "solution", "until", "flink", "-", "15635", "is", "fixed", "class", "loader", "class", "loader", "=", "thread", "current", "thread", "(", ")", "get", "context", "class", "loader", "(", ")", ";", "module", "manager", "module", "manager", "=", "new", "module", "manager", "(", ")", ";", "string", "default", "catalog", "=", "\"", "default", "catalog", "\"", ";", "catalog", "manager", "catalog", "manager", "=", "catalog", "manager", "new", "builder", "(", ")", "class", "loader", "(", "class", "loader", ")", "config", "(", "table", "config", "get", "configuration", "(", ")", ")", "default", "catalog", "(", "default", "catalog", ",", "new", "generic", "in", "memory", "catalog", "(", "default", "catalog", ",", "\"", "default", "database", "\"", ")", ")", "execution", "config", "(", "execution", "environment", "get", "config", "(", ")", ")", "build", "(", ")", ";", "class", "<", "?", ">", "clazz", "=", "class", "for", "name", "(", "\"", "org", "apache", "flink", "table", "api", "bridge", "java", "internal", "batch", "table", "environment", "impl", "\"", ")", ";", "constructor", "<", "?", ">", "con", "=", "clazz", "get", "constructor", "(", "execution", "environment", "class", ",", "table", "config", "class", ",", "catalog", "manager", "class", ",", "module", "manager", "class", ")", ";", "return", "(", "batch", "table", "environment", ")", "con", "new", "instance", "(", "execution", "environment", ",", "table", "config", ",", "catalog", "manager", ",", "module", "manager", ")", ";", "}", "catch", "(", "throwable", "t", ")", "{", "throw", "new", "table", "exception", "(", "\"", "create", "batch", "table", "environment", "failed", "\"", ",", "t", ")", ";", "}", "}" ]

[ "should", "be", "invoked", "before", "a", "{", "@", "link", "change", "log", "set", "}", "is", "exposed", "to", "public" ]

[ "protected", "void", "set", "parent", "(", "change", "log", "set", "parent", ")", "{", "this", "parent", "=", "parent", ";", "}" ]

[ "sets", "checkpoints", "to", "determine", "the", "allocation", "bandwidth", "based", "on", "the", "total", "bandwidth" ]

[ "public", "void", "experimental", "set", "bandwidth", "allocation", "checkpoints", "(", "long", "[", "]", "[", "]", "allocation", "checkpoints", ")", "{", "(", "(", "default", "bandwidth", "provider", ")", "bandwidth", "provider", ")", "experimental", "set", "bandwidth", "allocation", "checkpoints", "(", "allocation", "checkpoints", ")", ";", "}" ]

[ "find", "a", "getter", "method", "for", "the", "specified", "property" ]

[ "protected", "method", "find", "getter", "for", "property", "(", "string", "property", "name", ",", "class", "<", "?", ">", "clazz", ",", "boolean", "must", "be", "static", ")", "{", "method", "method", "=", "find", "method", "for", "property", "(", "get", "property", "method", "suffixes", "(", "property", "name", ")", ",", "\"", "get", "\"", ",", "clazz", ",", "must", "be", "static", ",", "0", ",", "any", "types", ")", ";", "if", "(", "method", "=", "=", "null", ")", "{", "method", "=", "find", "method", "for", "property", "(", "get", "property", "method", "suffixes", "(", "property", "name", ")", ",", "\"", "is", "\"", ",", "clazz", ",", "must", "be", "static", ",", "0", ",", "boolean", "types", ")", ";", "if", "(", "method", "=", "=", "null", ")", "{", "/", "/", "record", "-", "style", "plain", "accessor", "method", ",", "e", "g", "name", "(", ")", "method", "=", "find", "method", "for", "property", "(", "new", "string", "[", "]", "{", "property", "name", "}", ",", "\"", "\"", ",", "clazz", ",", "must", "be", "static", ",", "0", ",", "any", "types", ")", ";", "}", "}", "return", "method", ";", "}" ]

[ "model", "tests", "for", "enum", "class" ]

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

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

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

[ "gets", "the", "index", "of", "this", "task", "id", "in", "get", "component", "tasks", "(", "get", "this", "component", "id", "(", ")", ")", "an", "example", "use", "case", "for", "this", "method", "is", "determining", "which", "task", "accesses", "which", "resource", "in", "a", "distributed", "resource", "to", "ensure", "an", "even", "distribution" ]

[ "public", "int", "get", "this", "task", "index", "(", ")", "{", "list", "<", "integer", ">", "tasks", "=", "new", "array", "list", "<", "integer", ">", "(", "get", "component", "tasks", "(", "get", "this", "component", "id", "(", ")", ")", ")", ";", "collections", "sort", "(", "tasks", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "tasks", "size", "(", ")", ";", "i", "+", "+", ")", "{", "if", "(", "tasks", "get", "(", "i", ")", "=", "=", "get", "this", "task", "id", "(", ")", ")", "{", "return", "i", ";", "}", "}", "throw", "new", "runtime", "exception", "(", "\"", "fatal", ":", "could", "not", "find", "this", "task", "id", "in", "this", "component", "\"", ")", ";", "}" ]

[ "retry", "a", "query", "for", "state", "for", "keys", "between", "0", "and", "{", "@", "link", "#", "max", "parallelism", "}", "until", "<", "tt", ">", "expected", "<", "tt", ">", "equals", "the", "value", "of", "the", "result", "tuple", "'", "s", "second", "field" ]

[ "private", "void", "execute", "value", "query", "(", "final", "deadline", "deadline", ",", "final", "queryable", "state", "client", "client", ",", "final", "job", "i", "d", "job", "id", ",", "final", "string", "queryable", "state", "name", ",", "final", "value", "state", "descriptor", "<", "tuple", "2", "<", "integer", ",", "long", ">", ">", "state", "descriptor", ",", "final", "long", "expected", ")", "throws", "exception", "{", "for", "(", "int", "key", "=", "0", ";", "key", "<", "max", "parallelism", ";", "key", "+", "+", ")", "{", "boolean", "success", "=", "false", ";", "while", "(", "deadline", "has", "time", "left", "(", ")", "&", "&", "!", "success", ")", "{", "completable", "future", "<", "value", "state", "<", "tuple", "2", "<", "integer", ",", "long", ">", ">", ">", "future", "=", "get", "kv", "state", "(", "deadline", ",", "client", ",", "job", "id", ",", "queryable", "state", "name", ",", "key", ",", "basic", "type", "info", "int", "type", "info", ",", "state", "descriptor", ",", "false", ",", "executor", ")", ";", "tuple", "2", "<", "integer", ",", "long", ">", "value", "=", "future", "get", "(", "deadline", "time", "left", "(", ")", "to", "millis", "(", ")", ",", "time", "unit", "milliseconds", ")", "value", "(", ")", ";", "assert", "equals", "(", "\"", "key", "mismatch", "\"", ",", "key", ",", "value", "f", "0", "int", "value", "(", ")", ")", ";", "if", "(", "expected", "=", "=", "value", "f", "1", ")", "{", "success", "=", "true", ";", "}", "else", "{", "/", "/", "retry", "thread", "sleep", "(", "retry", "timeout", ")", ";", "}", "}", "assert", "true", "(", "\"", "did", "not", "succeed", "query", "\"", ",", "success", ")", ";", "}", "}" ]

[ "checks", "for", "and", "skips", "a", "given", "token" ]

[ "protected", "static", "int", "expect", "(", "byte", "[", "]", "chars", ",", "int", "pos", ",", "int", "end", ",", "string", "expected", ")", "{", "int", "si", "=", "0", ";", "int", "expected", "len", "=", "expected", "length", "(", ")", ";", "while", "(", "pos", "<", "end", ")", "{", "if", "(", "si", "=", "=", "expected", "len", ")", "{", "return", "pos", ";", "}", "if", "(", "(", "chars", "[", "pos", "+", "+", "]", "&", "0xff", ")", "!", "=", "expected", "char", "at", "(", "si", "+", "+", ")", ")", "{", "return", "-", "1", ";", "}", "}", "return", "-", "1", ";", "}" ]

[ "sets", "a", "{", "@", "link", "media", "format", "}", "'", "s", "codec", "specific", "data", "buffers" ]

[ "public", "static", "void", "set", "csd", "buffers", "(", "media", "format", "format", ",", "list", "<", "byte", "[", "]", ">", "csd", "buffers", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "csd", "buffers", "size", "(", ")", ";", "i", "+", "+", ")", "{", "format", "set", "byte", "buffer", "(", "\"", "csd", "-", "\"", "+", "i", ",", "byte", "buffer", "wrap", "(", "csd", "buffers", "get", "(", "i", ")", ")", ")", ";", "}", "}" ]

[ "validates", "a", "{", "@", "link", "user", "defined", "function", "}", "class", "for", "usage", "in", "the", "api" ]

[ "private", "static", "void", "validate", "class", "(", "class", "<", "?", "extends", "user", "defined", "function", ">", "function", "class", ",", "boolean", "requires", "default", "constructor", ")", "{", "if", "(", "table", "function", "class", "is", "assignable", "from", "(", "function", "class", ")", ")", "{", "validate", "not", "singleton", "(", "function", "class", ")", ";", "}", "validate", "instantiation", "(", "function", "class", ",", "requires", "default", "constructor", ")", ";", "validate", "implementation", "methods", "(", "function", "class", ")", ";", "}" ]