Datasets:
Anonymous2023
/
KGSum

Dataset card Data Studio Files
xet
Community
docstring_tokens
list
code_tokens
list
[ "this", "method", "interrogates", "the", "user", "-", "agent", "string", "and", "returns", "whether", "it", "refers", "to", "a", "browser", "if", "its", "not", "a", "browser", ",", "then", "the", "requirement", "for", "the", "csrf", "header", "will", "not", "be", "enforced", ";", "if", "it", "is", "a", "browser", ",", "the", "requirement", "will", "be", "enforced", "a", "user", "-", "agent", "string", "is", "considered", "to", "be", "a", "browser", "if", "it", "matches", "any", "of", "the", "regex", "patterns", "from", "browser", "-", "useragent", "-", "regex", ";", "the", "default", "behavior", "is", "to", "consider", "everything", "a", "browser", "that", "matches", "the", "following", ":", "\"", "^", "mozilla", ",", "^", "opera", "\"", "subclasses", "can", "optionally", "override", "this", "method", "to", "use", "different", "behavior" ]
[ "protected", "boolean", "is", "browser", "(", "string", "user", "agent", ")", "{", "if", "(", "user", "agent", "=", "=", "null", ")", "{", "return", "false", ";", "}", "for", "(", "pattern", "pattern", ":", "browser", "user", "agents", ")", "{", "matcher", "matcher", "=", "pattern", "matcher", "(", "user", "agent", ")", ";", "if", "(", "matcher", "matches", "(", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]
[ "sets", "a", "hadoop", "{", "@", "link", "configuration", "}", "for", "the", "parquet", "reader", "if", "no", "configuration", "is", "configured", ",", "an", "empty", "configuration", "is", "used" ]
[ "public", "builder", "with", "configuration", "(", "configuration", "config", ")", "{", "preconditions", "check", "not", "null", "(", "config", ",", "\"", "configuration", "must", "not", "be", "null", "\"", ")", ";", "this", "config", "=", "config", ";", "return", "this", ";", "}" ]
[ "adds", "the", "remaining", "values", "to", "the", "specified", "array" ]
[ "public", "float", "array", "to", "array", "(", "float", "array", "array", ")", "{", "while", "(", "has", "next", ")", "array", "add", "(", "next", "(", ")", ")", ";", "return", "array", ";", "}" ]
[ "returns", "true", "if", "the", "chart", "is", "not", "yet", "fully", "zoomed", "out", "on", "the", "x", "-", "axis" ]
[ "public", "boolean", "can", "zoom", "out", "more", "x", "(", ")", "{", "return", "m", "scale", "x", ">", "m", "min", "scale", "x", ";", "}" ]
[ "get", "the", "program", "address", "for", "an", "addressable", "word", "offset", "within", "the", "default", "address", "space", "this", "method", "is", "responsible", "for", "applying", "any", "program", "image", "base", "change", "imposed", "during", "the", "import", "(", "see", "{", "@", "link", "#", "get", "image", "base", "word", "adjustment", "offset", "(", ")", "}" ]
[ "address", "get", "default", "address", "(", "long", "addressable", "word", "offset", ")", ";" ]
[ "creates", "a", "new", "{", "@", "link", "criteria", "}", "query", "for", "{", "@", "code", "<", "e", ">", "}" ]
[ "protected", "criteria", "criteria", "(", ")", "{", "return", "current", "session", "(", ")", "create", "criteria", "(", "entity", "class", ")", ";", "}" ]
[ "returns", "the", "{", "@", "link", "channel", "handler", "}", "with", "the", "specified", "name", "in", "this", "pipeline" ]
[ "channel", "handler", "get", "(", "string", "name", ")", ";" ]
[ "convert", "a", "token", "object", "to", "a", "json", "string" ]
[ "public", "static", "string", "to", "json", "string", "(", "final", "token", "<", "?", "extends", "token", "identifier", ">", "token", ")", "throws", "i", "o", "exception", "{", "return", "to", "json", "string", "(", "token", "class", ",", "to", "json", "map", "(", "token", ")", ")", ";", "}" ]
[ "create", "a", "new", "resource", "by", "p", "o", "s", "ting", "the", "given", "object", "to", "the", "url", ",", "and", "returns", "the", "representation", "found", "in", "the", "response", "the", "{", "@", "code", "request", "}", "parameter", "can", "be", "a", "{", "@", "link", "http", "entity", "}", "in", "order", "to", "add", "additional", "http", "headers", "to", "the", "request", "the", "body", "of", "the", "entity", ",", "or", "{", "@", "code", "request", "}", "itself", ",", "can", "be", "a", "{", "@", "link", "org", "springframework", "util", "multi", "value", "map", "multi", "value", "map", "}", "to", "create", "a", "multipart", "request", "the", "values", "in", "the", "{", "@", "code", "multi", "value", "map", "}", "can", "be", "any", "object", "representing", "the", "body", "of", "the", "part", ",", "or", "an", "{", "@", "link", "org", "springframework", "http", "http", "entity", "http", "entity", "}", "representing", "a", "part", "with", "body", "and", "headers" ]
[ "<", "t", ">", "t", "post", "for", "object", "(", "uri", "url", ",", "@", "nullable", "object", "request", ",", "class", "<", "t", ">", "response", "type", ")", "throws", "rest", "client", "exception", ";" ]
[ "returns", "a", "{", "@", "link", "query", "runtime", "helper", "factory", "}", "that", "will", "be", "used", "by", "the", "query", ",", "cquery", ",", "and", "aquery", "commands", "it", "is", "an", "error", "if", "multiple", "modules", "return", "non", "-", "null", "values" ]
[ "public", "query", "runtime", "helper", "factory", "get", "query", "runtime", "helper", "factory", "(", ")", "{", "return", "null", ";", "}" ]
[ "test", "the", "property", "'", "big", "decimal", "'" ]
[ "public", "void", "big", "decimal", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "big", "decimal", "}" ]
[ "shrinks", "the", "starts", "and", "lengths", "array", "as", "items", "at", "the", "end", "of", "the", "list", "are", "removed" ]
[ "private", "void", "shrink", "arrays", "(", "int", "capacity", ")", "{", "int", "size", "=", "math", "max", "(", "capacity", ",", "4", ")", ";", "int", "[", "]", "new", "starts", "=", "new", "int", "[", "size", "]", ";", "short", "[", "]", "new", "lengths", "=", "new", "short", "[", "size", "]", ";", "system", "arraycopy", "(", "starts", ",", "0", ",", "new", "starts", ",", "0", ",", "new", "starts", "length", ")", ";", "system", "arraycopy", "(", "lengths", ",", "0", ",", "new", "lengths", ",", "0", ",", "new", "starts", "length", ")", ";", "starts", "=", "new", "starts", ";", "lengths", "=", "new", "lengths", ";", "}" ]
[ "creates", "a", "new", "out", "err", "instance", "from", "the", "specified", "output", "and", "error", "streams" ]
[ "public", "static", "out", "err", "create", "(", "output", "stream", "out", ",", "output", "stream", "err", ")", "{", "return", "new", "out", "err", "(", "out", ",", "err", ")", ";", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "boolean", "cancel", "(", "boolean", "may", "interrupt", "if", "running", ")", "{", "boolean", "canceled", "=", "super", "cancel", "(", "may", "interrupt", "if", "running", ")", ";", "if", "(", "canceled", ")", "{", "scheduled", "executor", "(", ")", "remove", "scheduled", "(", "this", ")", ";", "}", "return", "canceled", ";", "}" ]
[ "calls", "{", "@", "link", "channel", "handler", "context", "#", "write", "(", "object", ",", "channel", "promise", ")", "}", "to", "forward", "to", "the", "next", "{", "@", "link", "channel", "outbound", "handler", "}", "in", "the", "{", "@", "link", "channel", "pipeline", "}", "sub", "-", "classes", "may", "override", "this", "method", "to", "change", "behavior" ]
[ "public", "void", "write", "(", "channel", "handler", "context", "ctx", ",", "object", "msg", ",", "channel", "promise", "promise", ")", "throws", "exception", "{", "ctx", "write", "(", "msg", ",", "promise", ")", ";", "}" ]
[ "creates", "a", "{", "@", "link", "private", "key", "}", "from", "the", "contents", "of", "{", "@", "code", "b", "reader", "}", "that", "contains", "an", "plaintext", "private", "key", "encoded", "in", "pkcs", "#", "8" ]
[ "private", "static", "private", "key", "parse", "p", "k", "c", "s", "8", "(", "buffered", "reader", "b", "reader", ")", "throws", "i", "o", "exception", ",", "general", "security", "exception", "{", "string", "builder", "sb", "=", "new", "string", "builder", "(", ")", ";", "string", "line", "=", "b", "reader", "read", "line", "(", ")", ";", "while", "(", "line", "!", "=", "null", ")", "{", "if", "(", "pkcs8", "footer", "equals", "(", "line", "trim", "(", ")", ")", ")", "{", "break", ";", "}", "sb", "append", "(", "line", "trim", "(", ")", ")", ";", "line", "=", "b", "reader", "read", "line", "(", ")", ";", "}", "if", "(", "null", "=", "=", "line", "|", "|", "pkcs8", "footer", "equals", "(", "line", "trim", "(", ")", ")", "=", "=", "false", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "malformed", "pem", "file", ",", "pem", "footer", "is", "invalid", "or", "missing", "\"", ")", ";", "}", "byte", "[", "]", "key", "bytes", "=", "base", "6", "4", "get", "decoder", "(", ")", "decode", "(", "sb", "to", "string", "(", ")", ")", ";", "string", "key", "algo", "=", "get", "key", "algorithm", "identifier", "(", "key", "bytes", ")", ";", "key", "factory", "key", "factory", "=", "key", "factory", "get", "instance", "(", "key", "algo", ")", ";", "return", "key", "factory", "generate", "private", "(", "new", "p", "k", "c", "s", "8", "encoded", "key", "spec", "(", "key", "bytes", ")", ")", ";", "}" ]
[ "test", "concurrent", "creation", "and", "access", "of", "the", "mount" ]
[ "public", "void", "test", "multiple", "threads", "(", ")", "throws", "i", "o", "exception", "{", "array", "list", "<", "thread", ">", "threads", "=", "new", "array", "list", "<", "thread", ">", "(", ")", ";", "final", "atomic", "reference", "<", "string", ">", "error", "message", "=", "new", "atomic", "reference", "<", "string", ">", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "10", ";", "i", "+", "+", ")", "{", "thread", "t", "=", "new", "thread", "(", ")", "{", "public", "void", "run", "(", ")", "{", "try", "{", "file", "d", "=", "new", "file", "(", "mount", "point", ",", "\"", "dir", "\"", "+", "get", "id", "(", ")", ")", ";", "exec", "wait", "ret", "(", "\"", "mkdir", "\"", "+", "d", "get", "absolute", "path", "(", ")", ")", ";", "for", "(", "int", "j", "=", "0", ";", "j", "<", "10", ";", "j", "+", "+", ")", "{", "file", "f", "=", "new", "file", "(", "d", ",", "\"", "file", "\"", "+", "j", ")", ";", "final", "string", "contents", "=", "\"", "thread", "\"", "+", "get", "id", "(", ")", "+", "\"", "\"", "+", "j", ";", "create", "file", "(", "f", ",", "contents", ")", ";", "}", "for", "(", "int", "j", "=", "0", ";", "j", "<", "10", ";", "j", "+", "+", ")", "{", "file", "f", "=", "new", "file", "(", "d", ",", "\"", "file", "\"", "+", "j", ")", ";", "exec", "wait", "ret", "(", "\"", "cat", "\"", "+", "f", "get", "absolute", "path", "(", ")", ")", ";", "exec", "wait", "ret", "(", "\"", "rm", "\"", "+", "f", "get", "absolute", "path", "(", ")", ")", ";", "}", "exec", "wait", "ret", "(", "\"", "rmdir", "\"", "+", "d", "get", "absolute", "path", "(", ")", ")", ";", "}", "catch", "(", "i", "o", "exception", "ie", ")", "{", "error", "message", "set", "(", "string", "format", "(", "\"", "exception", "%", "s", "\"", ",", "string", "utils", "stringify", "exception", "(", "ie", ")", ")", ")", ";", "}", "}", "}", ";", "t", "start", "(", ")", ";", "threads", "add", "(", "t", ")", ";", "}", "for", "(", "thread", "t", ":", "threads", ")", "{", "try", "{", "t", "join", "(", ")", ";", "}", "catch", "(", "interrupted", "exception", "ie", ")", "{", "fail", "(", "\"", "thread", "interrupted", ":", "\"", "+", "ie", "get", "message", "(", ")", ")", ";", "}", "}", "assert", "null", "(", "error", "message", "get", "(", ")", ",", "error", "message", "get", "(", ")", ")", ";", "}" ]
[ "returns", "an", "immutable", "multiset", "containing", "the", "given", "elements", ",", "in", "the", "\"", "grouped", "iteration", "order", "\"", "described", "in", "the", "class", "documentation" ]
[ "public", "static", "<", "e", ">", "immutable", "multiset", "<", "e", ">", "copy", "of", "(", "iterator", "<", "?", "extends", "e", ">", "elements", ")", "{", "multiset", "<", "e", ">", "multiset", "=", "linked", "hash", "multiset", "create", "(", ")", ";", "iterators", "add", "all", "(", "multiset", ",", "elements", ")", ";", "return", "copy", "from", "entries", "(", "multiset", "entry", "set", "(", ")", ")", ";", "}" ]
[ "perform", "the", "merge", "process" ]
[ "public", "void", "merge", "(", "task", "monitor", "monitor", ")", "throws", "exception", ";" ]
[ "parse", "the", "group", "key" ]
[ "public", "static", "string", "[", "]", "parse", "key", "(", "string", "group", "key", ")", "{", "string", "builder", "sb", "=", "new", "string", "builder", "(", ")", ";", "string", "data", "id", "=", "null", ";", "string", "group", "=", "null", ";", "string", "tenant", "=", "null", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "group", "key", "length", "(", ")", ";", "+", "+", "i", ")", "{", "char", "c", "=", "group", "key", "char", "at", "(", "i", ")", ";", "if", "(", "'", "+", "'", "=", "=", "c", ")", "{", "if", "(", "null", "=", "=", "data", "id", ")", "{", "data", "id", "=", "sb", "to", "string", "(", ")", ";", "sb", "set", "length", "(", "0", ")", ";", "}", "else", "if", "(", "null", "=", "=", "group", ")", "{", "group", "=", "sb", "to", "string", "(", ")", ";", "sb", "set", "length", "(", "0", ")", ";", "}", "else", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "invalid", "groupkey", ":", "\"", "+", "group", "key", ")", ";", "}", "}", "else", "if", "(", "'", "%", "'", "=", "=", "c", ")", "{", "char", "next", "=", "group", "key", "char", "at", "(", "+", "+", "i", ")", ";", "char", "nextnext", "=", "group", "key", "char", "at", "(", "+", "+", "i", ")", ";", "if", "(", "'", "2", "'", "=", "=", "next", "&", "&", "'", "b", "'", "=", "=", "nextnext", ")", "{", "sb", "append", "(", "'", "+", "'", ")", ";", "}", "else", "if", "(", "'", "2", "'", "=", "=", "next", "&", "&", "'", "5", "'", "=", "=", "nextnext", ")", "{", "sb", "append", "(", "'", "%", "'", ")", ";", "}", "else", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "invalid", "groupkey", ":", "\"", "+", "group", "key", ")", ";", "}", "}", "else", "{", "sb", "append", "(", "c", ")", ";", "}", "}", "if", "(", "string", "utils", "is", "blank", "(", "group", ")", ")", "{", "group", "=", "sb", "to", "string", "(", ")", ";", "if", "(", "group", "length", "(", ")", "=", "=", "0", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "invalid", "groupkey", ":", "\"", "+", "group", "key", ")", ";", "}", "}", "else", "{", "tenant", "=", "sb", "to", "string", "(", ")", ";", "if", "(", "group", "length", "(", ")", "=", "=", "0", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "invalid", "groupkey", ":", "\"", "+", "group", "key", ")", ";", "}", "}", "return", "new", "string", "[", "]", "{", "data", "id", ",", "group", ",", "tenant", "}", ";", "}" ]
[ "builds", "query", "parameter", "line", "by", "figuring", "out", "what", "should", "be", "submitted" ]
[ "private", "void", "find", "parameters", "(", "method", "method", ")", "{", "for", "(", "parameter", "p", ":", "reflection", "utils", "get", "parameters", "(", "method", ")", ")", "{", "query", "parameter", "qp", "=", "p", "annotation", "(", "query", "parameter", "class", ")", ";", "if", "(", "qp", "!", "=", "null", ")", "{", "string", "name", "=", "qp", "value", "(", ")", ";", "if", "(", "name", "length", "(", ")", "=", "=", "0", ")", "name", "=", "p", "name", "(", ")", ";", "if", "(", "name", "=", "=", "null", "|", "|", "name", "length", "(", ")", "=", "=", "0", ")", "continue", ";", "/", "/", "unknown", "parameter", "name", "we", "'", "ll", "report", "the", "error", "when", "the", "form", "is", "submitted", "if", "(", "name", "equals", "(", "\"", "value", "\"", ")", ")", "continue", ";", "/", "/", "'", "value", "'", "parameter", "is", "implicit", "relative", "path", "rp", "=", "p", "annotation", "(", "relative", "path", "class", ")", ";", "if", "(", "rp", "!", "=", "null", ")", "name", "=", "rp", "value", "(", ")", "+", "'", "/", "'", "+", "name", ";", "names", "add", "(", "name", ")", ";", "continue", ";", "}", "method", "m", "=", "reflection", "utils", "get", "public", "method", "named", "(", "p", "type", "(", ")", ",", "\"", "from", "stapler", "\"", ")", ";", "if", "(", "m", "!", "=", "null", ")", "find", "parameters", "(", "m", ")", ";", "}", "}" ]
[ "drains", "the", "read", "buffer" ]
[ "void", "drain", "read", "buffer", "(", ")", "{", "if", "(", "!", "skip", "read", "buffer", "(", ")", ")", "{", "read", "buffer", "drain", "to", "(", "access", "policy", ")", ";", "}", "}" ]
[ "this", "implementation", "returns", "the", "name", "of", "the", "file", "that", "this", "class", "path", "resource", "refers", "to" ]
[ "public", "string", "get", "filename", "(", ")", "{", "return", "string", "utils", "get", "filename", "(", "this", "path", ")", ";", "}" ]
[ "if", "source", "group", "is", "a", "fragment", ",", "then", "merge", "code", "units", "from", "it", "into", "dest", "fragment", "otherwise", ",", "flatten", "the", "source", "module", "by", "moving", "all", "descendant", "fragments", "'", "code", "units", "into", "dest", "fragment" ]
[ "void", "merge", "group", "(", "group", "source", "group", ",", "program", "fragment", "dest", "fragment", ")", "throws", "not", "found", "exception", ",", "not", "empty", "exception", "{", "if", "(", "source", "group", "instanceof", "program", "fragment", ")", "{", "merge", "fragments", "(", "(", "program", "fragment", ")", "source", "group", ",", "dest", "fragment", ")", ";", "}", "else", "{", "flatten", "module", "(", "(", "program", "module", ")", "source", "group", ",", "dest", "fragment", ")", ";", "}", "}" ]
[ "returns", "true", "if", "this", "is", "a", "final", "result" ]
[ "public", "boolean", "is", "done", "(", ")", "{", "return", "false", ";", "}" ]
[ "deserializes", "a", "message", "contained", "in", "a", "byte", "buffer" ]
[ "m", "deserialize", "message", "(", "byte", "buf", "buf", ")", ";" ]
[ "get", "the", "current", "rolling", "average", "of", "the", "upload", "latency" ]
[ "public", "long", "get", "block", "upload", "latency", "(", ")", "{", "return", "current", "block", "upload", "latency", "get", "current", "average", "(", ")", ";", "}" ]
[ "returns", "the", "offset", "between", "{", "@", "link", "system", "clock", "#", "elapsed", "realtime", "(", ")", "}", "and", "the", "ntp", "server", "time", "in", "milliseconds", ",", "or", "{", "@", "link", "c", "#", "time", "unset", "}", "if", "{", "@", "link", "#", "is", "initialized", "(", ")", "}", "returns", "false", "the", "offset", "is", "calculated", "as", "{", "@", "code", "ntp", "server", "time", "-", "device", "elapsed", "real", "time", "}" ]
[ "public", "static", "long", "get", "elapsed", "realtime", "offset", "ms", "(", ")", "{", "synchronized", "(", "value", "lock", ")", "{", "return", "is", "initialized", "?", "elapsed", "realtime", "offset", "ms", ":", "c", "time", "unset", ";", "}", "}" ]
[ "close", "an", "extension", "if", "it", "is", "closeable", "any", "error", "raised", "is", "caught", "and", "logged" ]
[ "public", "static", "void", "close", "(", "object", "extension", ")", "{", "if", "bound", "d", "t", "extension", "(", "extension", ",", "v", "-", ">", "{", "i", "o", "utils", "close", "streams", "(", "v", ")", ";", "return", "null", ";", "}", ")", ";", "}" ]
[ "creates", "a", "reference", "on", "any", "operand", "that", "uses", "reads", "an", "offset", "from", "r", "2" ]
[ "public", "boolean", "added", "(", "program", "program", ",", "address", "set", "view", "function", "set", ",", "task", "monitor", "monitor", ",", "message", "log", "log", ")", "{", "symbol", "table", "symbol", "table", "=", "program", "get", "symbol", "table", "(", ")", ";", "listing", "listing", "=", "program", "get", "listing", "(", ")", ";", "reference", "manager", "reference", "manager", "=", "program", "get", "reference", "manager", "(", ")", ";", "symbol", "toc", "symbol", "=", "symbol", "utilities", "get", "expected", "label", "or", "function", "symbol", "(", "program", ",", "pef", "constants", "toc", ",", "err", "-", ">", "log", "error", "(", "get", "name", "(", ")", ",", "err", ")", ")", ";", "if", "(", "toc", "symbol", "=", "=", "null", ")", "{", "return", "true", ";", "}", "address", "set", "instruction", "set", "=", "get", "instruction", "set", "(", "program", ",", "function", "set", ",", "listing", ",", "toc", "symbol", ",", "monitor", ")", ";", "instruction", "iterator", "instructions", "=", "listing", "get", "instructions", "(", "instruction", "set", ",", "true", ")", ";", "while", "(", "instructions", "has", "next", "(", ")", ")", "{", "if", "(", "monitor", "is", "cancelled", "(", ")", ")", "{", "break", ";", "}", "instruction", "instruction", "=", "instructions", "next", "(", ")", ";", "if", "(", "instruction", "get", "num", "operands", "(", ")", "!", "=", "2", ")", "{", "continue", ";", "}", "object", "[", "]", "operand", "objects", "1", "=", "instruction", "get", "op", "objects", "(", "1", ")", ";", "/", "/", "op", "objects", "from", "1st", "operand", "if", "(", "operand", "objects", "1", "length", "!", "=", "2", ")", "{", "continue", ";", "}", "if", "(", "!", "(", "operand", "objects", "1", "[", "0", "]", "instanceof", "scalar", ")", ")", "{", "continue", ";", "}", "if", "(", "!", "(", "operand", "objects", "1", "[", "1", "]", "instanceof", "register", ")", ")", "{", "continue", ";", "}", "register", "register", "=", "(", "register", ")", "operand", "objects", "1", "[", "1", "]", ";", "if", "(", "!", "register", "get", "name", "(", ")", "equals", "(", "\"", "r", "2", "\"", ")", ")", "{", "continue", ";", "}", "scalar", "scalar", "=", "(", "scalar", ")", "operand", "objects", "1", "[", "0", "]", ";", "address", "dest", "addr", "=", "create", "reference", "(", "reference", "manager", ",", "toc", "symbol", ",", "instruction", ",", "scalar", ")", ";", "markup", "glue", "code", "(", "listing", ",", "symbol", "table", ",", "instruction", ",", "dest", "addr", ")", ";", "}", "return", "true", ";", "}" ]
[ "updates", "error", "messages", "of", "throwables", "appearing", "in", "the", "cause", "tree", "of", "the", "passed", "root", "throwable", "the", "passed", "function", "is", "applied", "on", "each", "throwable", "of", "the", "cause", "tree", "returning", "a", "string", "will", "cause", "the", "detail", "message", "of", "the", "corresponding", "throwable", "to", "be", "updated", "returning", "<", "code", ">", "null", "<", "code", ">", ",", "instead", ",", "won", "'", "t", "trigger", "any", "detail", "message", "update", "on", "that", "throwable" ]
[ "public", "static", "void", "update", "detail", "message", "(", "@", "nullable", "throwable", "root", ",", "@", "nullable", "function", "<", "throwable", ",", "string", ">", "throwable", "to", "message", ")", "{", "if", "(", "throwable", "to", "message", "=", "=", "null", ")", "{", "return", ";", "}", "throwable", "it", "=", "root", ";", "while", "(", "it", "!", "=", "null", ")", "{", "string", "new", "message", "=", "throwable", "to", "message", "apply", "(", "it", ")", ";", "if", "(", "new", "message", "!", "=", "null", ")", "{", "update", "detail", "message", "of", "throwable", "(", "it", ",", "new", "message", ")", ";", "}", "it", "=", "it", "get", "cause", "(", ")", ";", "}", "}" ]
[ "convert", "an", "object", "[", "]", "to", "a", "datanode", "info", "[", "]" ]
[ "static", "datanode", "info", "[", "]", "to", "datanode", "info", "array", "(", "final", "list", "<", "?", ">", "objects", ")", "throws", "i", "o", "exception", "{", "if", "(", "objects", "=", "=", "null", ")", "{", "return", "null", ";", "}", "else", "if", "(", "objects", "is", "empty", "(", ")", ")", "{", "return", "empty", "datanode", "info", "array", ";", "}", "else", "{", "final", "datanode", "info", "[", "]", "array", "=", "new", "datanode", "info", "[", "objects", "size", "(", ")", "]", ";", "int", "i", "=", "0", ";", "for", "(", "object", "object", ":", "objects", ")", "{", "array", "[", "i", "+", "+", "]", "=", "to", "datanode", "info", "(", "(", "map", "<", "?", ",", "?", ">", ")", "object", ")", ";", "}", "return", "array", ";", "}", "}" ]
[ "called", "when", "this", "rewinder", "is", "no", "longer", "needed", "and", "can", "be", "cleaned", "up", "the", "underlying", "data", "may", "still", "be", "in", "use", "and", "should", "not", "be", "closed", "or", "invalidated" ]
[ "void", "cleanup", "(", ")", ";" ]
[ "removes", "all", "listeners", "on", "this", "actor" ]
[ "public", "void", "clear", "listeners", "(", ")", "{", "listeners", "clear", "(", ")", ";", "capture", "listeners", "clear", "(", ")", ";", "}" ]
[ "skip", "len", "number", "of", "bytes", "in", "input", "streamin" ]
[ "public", "static", "void", "skip", "fully", "(", "data", "input", "in", ",", "int", "len", ")", "throws", "i", "o", "exception", "{", "int", "total", "=", "0", ";", "int", "cur", "=", "0", ";", "while", "(", "(", "total", "<", "len", ")", "&", "&", "(", "(", "cur", "=", "in", "skip", "bytes", "(", "len", "-", "total", ")", ")", ">", "0", ")", ")", "{", "total", "+", "=", "cur", ";", "}", "if", "(", "total", "<", "len", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "not", "able", "to", "skip", "\"", "+", "len", "+", "\"", "bytes", ",", "possibly", "\"", "+", "\"", "due", "to", "end", "of", "input", "\"", ")", ";", "}", "}" ]
[ "query", "profile", "task", "by", "id" ]
[ "public", "profile", "task", "get", "profile", "task", "by", "id", "(", "string", "id", ")", "{", "profile", "task", "profile", "=", "profile", "task", "id", "cache", "get", "if", "present", "(", "id", ")", ";", "if", "(", "profile", "=", "=", "null", ")", "{", "try", "{", "profile", "=", "get", "profile", "task", "query", "d", "a", "o", "(", ")", "get", "by", "id", "(", "id", ")", ";", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "logger", "error", "(", "e", "get", "message", "(", ")", ",", "e", ")", ";", "}", "if", "(", "profile", "!", "=", "null", ")", "{", "profile", "task", "id", "cache", "put", "(", "id", ",", "profile", ")", ";", "}", "}", "return", "profile", ";", "}" ]
[ ",", "(", "'", "+", "'", "'", "'", "'", "-", "'", "'", "'", ",", ")" ]
[ "public", "static", "string", "encode", "base", "6", "4", "url", "safe", "(", "byte", "[", "]", "input", ")", "{", "return", "base", "encoding", "base", "6", "4", "url", "(", ")", "encode", "(", "input", ")", ";", "}" ]
[ "build", "the", "exception", "to", "raise", "on", "invalid", "arguments" ]
[ "protected", "static", "exit", "util", "exit", "exception", "invalid", "args", "(", "string", "format", ",", "object", "args", ")", "{", "return", "exit", "exception", "(", "invalid", "argument", ",", "format", ",", "args", ")", ";", "}" ]
[ "return", "the", "contained", "request", "header", "expressions" ]
[ "public", "set", "<", "name", "value", "expression", "<", "string", ">", ">", "get", "expressions", "(", ")", "{", "return", "new", "linked", "hash", "set", "<", ">", "(", "this", "expressions", ")", ";", "}" ]
[ "install", "the", "app", "silently", "without", "root", "permission", "must", "hold", "{", "@", "code", "android", ":", "shared", "user", "id", "=", "\"", "android", "uid", "shell", "\"", "}", "and", "{", "@", "code", "<", "uses", "-", "permission", "android", ":", "name", "=", "\"", "android", "permission", "install", "packages", "\"", ">", "}" ]
[ "public", "static", "boolean", "install", "app", "silent", "(", "final", "file", "file", ")", "{", "return", "install", "app", "silent", "(", "file", ",", "null", ")", ";", "}" ]
[ "executes", "the", "given", "task", "in", "an", "io", "thread", "pool" ]
[ "public", "static", "<", "t", ">", "void", "execute", "by", "io", "(", "final", "task", "<", "t", ">", "task", ")", "{", "execute", "(", "get", "pool", "by", "type", "and", "priority", "(", "type", "io", ")", ",", "task", ")", ";", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "void", "visit", "branch", "(", "int", "opcode", ",", "int", "offset", ",", "int", "length", ",", "int", "target", ")", "{", "switch", "(", "opcode", ")", "{", "case", "byte", "ops", "goto", ":", "{", "visit", "common", "(", "offset", ",", "length", ",", "false", ")", ";", "target", "lists", "[", "offset", "]", "=", "int", "list", "make", "immutable", "(", "target", ")", ";", "break", ";", "}", "case", "byte", "ops", "jsr", ":", "{", "/", "*", "*", "each", "jsr", "is", "quarantined", "into", "a", "separate", "block", "(", "containing", "*", "only", "the", "jsr", "instruction", ")", "but", "is", "otherwise", "treated", "*", "as", "a", "conditional", "branch", "(", "that", "is", "to", "say", ",", "both", "its", "*", "target", "and", "next", "instruction", "begin", "new", "blocks", ")", "*", "/", "add", "work", "if", "necessary", "(", "offset", ",", "true", ")", ";", "/", "/", "fall", "through", "to", "next", "case", "}", "default", ":", "{", "int", "next", "=", "offset", "+", "length", ";", "visit", "common", "(", "offset", ",", "length", ",", "true", ")", ";", "add", "work", "if", "necessary", "(", "next", ",", "true", ")", ";", "target", "lists", "[", "offset", "]", "=", "int", "list", "make", "immutable", "(", "next", ",", "target", ")", ";", "break", ";", "}", "}", "add", "work", "if", "necessary", "(", "target", ",", "true", ")", ";", "}" ]
[ "post", "fakeouterstring", "test", "serialization", "of", "outer", "string", "types" ]
[ "default", "response", "entity", "<", "string", ">", "fake", "outer", "string", "serialize", "(", "@", "api", "param", "(", "value", "=", "\"", "input", "string", "as", "post", "body", "\"", ")", "@", "valid", "@", "request", "body", "(", "required", "=", "false", ")", "string", "body", ")", "{", "return", "new", "response", "entity", "<", ">", "(", "http", "status", "not", "implemented", ")", ";", "}" ]
[ "visits", "an", "{", "@", "code", "input", "}", "and", "adds", "{", "@", "link", "file", "node", "}", "s", "to", "{", "@", "code", "curr", "dir", "}", "this", "method", "mutates", "its", "parameter", "{", "@", "code", "curr", "dir", "}" ]
[ "int", "visit", "(", "t", "input", ",", "path", "fragment", "path", ",", "directory", "node", "curr", "dir", ")", "throws", "i", "o", "exception", ";" ]
[ "adds", "the", "indicated", "button", "press", "listener", "to", "both", "listing", "panels", "in", "this", "code", "comparison", "panel" ]
[ "public", "void", "add", "button", "pressed", "listener", "(", "button", "pressed", "listener", "listener", ")", "{", "for", "(", "listing", "panel", "listing", "panel", ":", "listing", "panels", ")", "{", "listing", "panel", "add", "button", "pressed", "listener", "(", "listener", ")", ";", "}", "}" ]
[ "get", "capital", "camel" ]
[ "public", "string", "get", "capital", "camel", "(", ")", "{", "return", "capital", "camel", ";", "}" ]
[ "returns", "task", "histograms", "this", "must", "be", "called", "between", "calls", "to", "{", "@", "link", "#", "start", "}", "and", "{", "@", "link", "#", "stop", "}", ",", "or", "the", "returned", "recorders", "are", "all", "empty", "note", "that", "the", "returned", "recorders", "may", "still", "be", "modified", "concurrently", "(", "but", "at", "least", "they", "are", "thread", "-", "safe", ",", "so", "that", "'", "s", "good", ")", "the", "stat", "recorders", "are", "indexed", "by", "{", "@", "code", "profiler", "task", "#", "ordinal", "}" ]
[ "public", "immutable", "list", "<", "stat", "recorder", ">", "get", "tasks", "histograms", "(", ")", "{", "return", "immutable", "list", "copy", "of", "(", "tasks", "histograms", ")", ";", "}" ]
[ "adds", "the", "remaining", "keys", "to", "the", "array" ]
[ "public", "array", "<", "k", ">", "to", "array", "(", "array", "<", "k", ">", "array", ")", "{", "while", "(", "has", "next", ")", "array", "add", "(", "next", "(", ")", ")", ";", "return", "array", ";", "}" ]
[ "get", "the", "resource", "spec", "of", "the", "job", "'", "s", "allocated", "{", "@", "code", "container", "}", "s", "key", "assumption", ":", "during", "job", "'", "s", "lifespan", ",", "its", "allocated", "{", "@", "code", "container", "}", "s", "have", "the", "same", "{", "@", "link", "resource", "}", "spec" ]
[ "public", "final", "resource", "get", "container", "spec", "(", ")", "{", "return", "container", "spec", ";", "}" ]
[ "test", "that", "checkpointing", "is", "still", "successful", "even", "if", "an", "issue", "was", "encountered", "while", "writing", "the", "legacy", "oiv", "image" ]
[ "public", "void", "test", "checkpoint", "succeeds", "with", "legacy", "o", "i", "v", "exception", "(", ")", "throws", "exception", "{", "/", "/", "delete", "the", "oiv", "image", "dir", "to", "cause", "an", "i", "o", "exception", "while", "saving", "file", "util", "fully", "delete", "(", "tmp", "oiv", "img", "dir", ")", ";", "do", "edits", "(", "0", ",", "10", ")", ";", "h", "a", "test", "util", "wait", "for", "standby", "to", "catch", "up", "(", "nns", "[", "0", "]", ",", "nns", "[", "1", "]", ")", ";", "/", "/", "once", "the", "standby", "catches", "up", ",", "it", "should", "notice", "that", "it", "needs", "to", "/", "/", "do", "a", "checkpoint", "and", "save", "one", "to", "its", "local", "directories", "h", "a", "test", "util", "wait", "for", "checkpoint", "(", "cluster", ",", "1", ",", "immutable", "list", "of", "(", "12", ")", ")", ";", "/", "/", "it", "should", "also", "upload", "it", "back", "to", "the", "active", "h", "a", "test", "util", "wait", "for", "checkpoint", "(", "cluster", ",", "0", ",", "immutable", "list", "of", "(", "12", ")", ")", ";", "}" ]
[ "refreshes", "the", "right", "side", "of", "this", "panel" ]
[ "public", "void", "refresh", "right", "panel", "(", ")", "{", "refresh", "panel", "(", "right", ")", ";", "}" ]
[ "get", "the", "current", "base", "path" ]
[ "public", "string", "get", "base", "path", "(", ")", "{", "return", "base", "path", ";", "}" ]
[ "invalidates", "the", "given", "the", "cache", "entry", "for", "the", "given", "key", "and", "it", "'", "s", "context" ]
[ "void", "invalidate", "(", "cache", "entity", "cache", "entity", ",", "mapping", "lookup", "cache", "key", "mapping", "cache", "key", ",", "directory", "reader", "reader", ",", "bytes", "reference", "cache", "key", ")", "{", "assert", "reader", "get", "reader", "cache", "helper", "(", ")", "!", "=", "null", ";", "cache", "invalidate", "(", "new", "key", "(", "cache", "entity", ",", "mapping", "cache", "key", ",", "reader", "get", "reader", "cache", "helper", "(", ")", "get", "key", "(", ")", ",", "cache", "key", ")", ")", ";", "}" ]
[ "returns", "integer", "value", "of", "big", "integer", "or", "integer", "max", "value", "if", "does", "not", "fit" ]
[ "static", "long", "big", "integer", "to", "long", "(", "pdb", "applicator", "my", "applicator", ",", "big", "integer", "big", ")", "{", "try", "{", "return", "big", "long", "value", "exact", "(", ")", ";", "}", "catch", "(", "arithmetic", "exception", "e", ")", "{", "string", "msg", "=", "\"", "big", "integer", "value", "greater", "than", "max", "long", ":", "\"", "+", "big", ";", "pdb", "log", "message", "(", "msg", ")", ";", "my", "applicator", "append", "log", "msg", "(", "msg", ")", ";", "return", "long", "max", "value", ";", "}", "}" ]
[ "set", "the", "empty", "flag" ]
[ "protected", "void", "set", "empty", "(", "boolean", "state", ")", "{", "empty", "=", "state", ";", "}" ]
[ "returns", "true", "if", "the", "parent", "resource", "directory", "is", "named", ",", "false", "indicates", "an", "id" ]
[ "public", "boolean", "is", "name", "entry", "(", ")", "{", "return", "is", "name", "entry", ";", "}" ]
[ "returns", "a", "sub", "-", "list", "if", "the", "given", "list", "is", "bigger", "than", "the", "specified", "{", "@", "code", "max", "size", "}", "warning", ":", "do", "not", "call", "this", "with", "a", "{", "@", "link", "run", "list", "}", ",", "or", "you", "will", "break", "lazy", "loading", "!" ]
[ "public", "static", "<", "t", ">", "list", "<", "t", ">", "sub", "list", "(", "list", "<", "t", ">", "base", ",", "int", "max", "size", ")", "{", "if", "(", "max", "size", "<", "base", "size", "(", ")", ")", "return", "base", "sub", "list", "(", "0", ",", "max", "size", ")", ";", "else", "return", "base", ";", "}" ]
[ "given", "a", "count", "of", "blackwhiteblackwhiteblack", "pixels", "just", "seen", "and", "an", "end", "position", ",", "figures", "the", "location", "of", "the", "center", "of", "this", "run" ]
[ "private", "static", "float", "center", "from", "end", "(", "int", "[", "]", "state", "count", ",", "int", "end", ")", "{", "return", "(", "end", "-", "state", "count", "[", "4", "]", "-", "state", "count", "[", "3", "]", ")", "-", "state", "count", "[", "2", "]", "/", "2", "0f", ";", "}" ]
[ "raw", "(", "no", "need", "to", "be", "html", "escaped", ")", "content" ]
[ "raw", "content", "r", "(", "object", "lines", ")", ";" ]
[ "invoked", "when", "the", "user", "-", "defined", "execution", "method", "in", "{", "@", "link", "hystrix", "invokable", "}", "starts" ]
[ "public", "<", "t", ">", "void", "on", "execution", "start", "(", "hystrix", "invokable", "<", "t", ">", "command", "instance", ")", "{", "/", "/", "do", "nothing", "by", "default", "}" ]
[ "returns", "latest", "immutable", "program", "this", "represents", "the", "current", "version", "program", "returned", "will", "be", "released", "by", "the", "merge", "test", "facilitator", "when", "disposed", "or", "re", "-", "initialized" ]
[ "public", "program", "d", "b", "get", "latest", "program", "(", ")", "{", "if", "(", "model", "=", "=", "null", ")", "{", "return", "null", ";", "/", "/", "initialize", "was", "never", "called", "}", "return", "model", "get", "latest", "program", "(", ")", ";", "}" ]
[ "gets", "the", "eh", "frame", "pointer", "encoding" ]
[ "public", "int", "get", "eh", "frame", "ptr", "encoding", "(", ")", "{", "return", "eh", "frame", "ptr", "encoding", ";", "}" ]
[ "returns", "the", "class", "responsible", "for", "triggering", "popups", "for", "this", "field", "panel" ]
[ "public", "hover", "handler", "get", "hover", "handler", "(", ")", "{", "return", "hover", "handler", ";", "}" ]
[ "get", "mapping", "of", "labels", "to", "nodes", "for", "specified", "set", "of", "labels" ]
[ "public", "map", "<", "string", ",", "set", "<", "node", "id", ">", ">", "get", "labels", "to", "nodes", "(", "set", "<", "string", ">", "labels", ")", "{", "read", "lock", "lock", "(", ")", ";", "try", "{", "map", "<", "string", ",", "set", "<", "node", "id", ">", ">", "labels", "to", "nodes", "=", "get", "labels", "to", "nodes", "mapping", "(", "labels", ",", "string", "class", ")", ";", "return", "collections", "unmodifiable", "map", "(", "labels", "to", "nodes", ")", ";", "}", "finally", "{", "read", "lock", "unlock", "(", ")", ";", "}", "}" ]
[ "this", "returns", "the", "vertex", "that", "is", "the", "dominator" ]
[ "public", "vertex", "get", "dominator", "(", "vertex", "v", ")", "{", "vector", "path", "set", "=", "this", "all", "paths", "containing", "(", "v", ")", ";", "if", "(", "path", "set", "is", "empty", "(", ")", ")", "{", "return", "v", ";", "}", "vector", "path", "=", "(", "vector", ")", "path", "set", "first", "element", "(", ")", ";", "return", "this", "all", "paths", "contain", "(", "path", "set", ",", "v", ",", "path", ")", ";", "}" ]
[ "scans", "for", "classes", "starting", "at", "the", "package", "provided", "and", "descending", "into", "subpackages", "each", "class", "is", "offered", "up", "to", "the", "test", "as", "it", "is", "discovered", ",", "and", "if", "the", "test", "returns", "true", "the", "class", "is", "retained", "accumulated", "classes", "can", "be", "fetched", "by", "calling", "{", "@", "link", "#", "get", "classes", "(", ")", "}" ]
[ "public", "resolver", "util", "<", "t", ">", "find", "(", "test", "test", ",", "string", "package", "name", ")", "{", "string", "path", "=", "get", "package", "path", "(", "package", "name", ")", ";", "try", "{", "list", "<", "string", ">", "children", "=", "vfs", "get", "instance", "(", ")", "list", "(", "path", ")", ";", "for", "(", "string", "child", ":", "children", ")", "{", "if", "(", "child", "ends", "with", "(", "\"", "class", "\"", ")", ")", "{", "add", "if", "matching", "(", "test", ",", "child", ")", ";", "}", "}", "}", "catch", "(", "i", "o", "exception", "ioe", ")", "{", "log", "error", "(", "\"", "could", "not", "read", "package", ":", "\"", "+", "package", "name", ",", "ioe", ")", ";", "}", "return", "this", ";", "}" ]
[ "create", "an", "http", "server", "for", "this", "router" ]
[ "protected", "router", "http", "server", "create", "http", "server", "(", ")", "{", "return", "new", "router", "http", "server", "(", "this", ")", ";", "}" ]
[ "setup", "response", "for", "the", "ipc", "call" ]
[ "private", "void", "setup", "response", "(", "rpc", "call", "call", ",", "rpc", "status", "proto", "status", ",", "rpc", "error", "code", "proto", "er", "code", ",", "writable", "rv", ",", "string", "error", "class", ",", "string", "error", ")", "throws", "i", "o", "exception", "{", "/", "/", "fatal", "responses", "will", "cause", "the", "reader", "to", "close", "the", "connection", "if", "(", "status", "=", "=", "rpc", "status", "proto", "fatal", ")", "{", "call", "connection", "set", "should", "close", "(", ")", ";", "}", "rpc", "response", "header", "proto", "builder", "header", "builder", "=", "rpc", "response", "header", "proto", "new", "builder", "(", ")", ";", "header", "builder", "set", "client", "id", "(", "byte", "string", "copy", "from", "(", "call", "client", "id", ")", ")", ";", "header", "builder", "set", "call", "id", "(", "call", "call", "id", ")", ";", "header", "builder", "set", "retry", "count", "(", "call", "retry", "count", ")", ";", "header", "builder", "set", "status", "(", "status", ")", ";", "header", "builder", "set", "server", "ipc", "version", "num", "(", "current", "version", ")", ";", "if", "(", "alignment", "context", "!", "=", "null", ")", "{", "alignment", "context", "update", "response", "state", "(", "header", "builder", ")", ";", "}", "if", "(", "status", "=", "=", "rpc", "status", "proto", "success", ")", "{", "rpc", "response", "header", "proto", "header", "=", "header", "builder", "build", "(", ")", ";", "try", "{", "setup", "response", "(", "call", ",", "header", ",", "rv", ")", ";", "}", "catch", "(", "throwable", "t", ")", "{", "log", "warn", "(", "\"", "error", "serializing", "call", "response", "for", "call", "\"", "+", "call", ",", "t", ")", ";", "/", "/", "call", "back", "to", "same", "function", "-", "this", "is", "ok", "since", "the", "/", "/", "buffer", "is", "reset", "at", "the", "top", ",", "and", "since", "status", "is", "changed", "/", "/", "to", "error", "it", "won", "'", "t", "infinite", "loop", "setup", "response", "(", "call", ",", "rpc", "status", "proto", "error", ",", "rpc", "error", "code", "proto", "error", "serializing", "response", ",", "null", ",", "t", "get", "class", "(", ")", "get", "name", "(", ")", ",", "string", "utils", "stringify", "exception", "(", "t", ")", ")", ";", "return", ";", "}", "}", "else", "{", "/", "/", "rpc", "failure", "header", "builder", "set", "exception", "class", "name", "(", "error", "class", ")", ";", "header", "builder", "set", "error", "msg", "(", "error", ")", ";", "header", "builder", "set", "error", "detail", "(", "er", "code", ")", ";", "setup", "response", "(", "call", ",", "header", "builder", "build", "(", ")", ",", "null", ")", ";", "}", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "protected", "void", "order", "items", "(", ")", "{", "int", "idx", "=", "0", ";", "for", "(", "string", "id", "item", "s", ":", "strings", "values", "(", ")", ")", "{", "s", "set", "index", "(", "idx", ")", ";", "idx", "+", "+", ";", "}", "}" ]
[ "incoming", "image", "will", "be", "displayed", "in", "{", "@", "link", "com", "nostra", "1", "3", "universalimageloader", "core", "imageaware", "image", "aware", "image", "aware", "view", "}", "if", "empty", "uri", "(", "null", "or", "empty", "string", ")", "will", "be", "passed", "to", "<", "b", ">", "image", "loader", "display", "image", "(", ")", "<", "b", ">", "method" ]
[ "public", "builder", "show", "image", "for", "empty", "uri", "(", "int", "image", "res", ")", "{", "image", "res", "for", "empty", "uri", "=", "image", "res", ";", "return", "this", ";", "}" ]
[ "get", "a", "{", "@", "linkplain", "sort", "value", "}", "for", "a", "long" ]
[ "public", "static", "sort", "value", "from", "(", "long", "l", ")", "{", "return", "new", "long", "sort", "value", "(", "l", ")", ";", "}" ]
[ "validate", "if", "the", "given", "config", "is", "a", "valid", "efo", "configuration" ]
[ "public", "static", "void", "validate", "efo", "configuration", "(", "properties", "config", ",", "list", "<", "string", ">", "streams", ")", "{", "e", "f", "o", "registration", "type", "efo", "registration", "type", ";", "if", "(", "config", "contains", "key", "(", "consumer", "config", "constants", "efo", "registration", "type", ")", ")", "{", "string", "type", "in", "string", "=", "config", "get", "property", "(", "consumer", "config", "constants", "efo", "registration", "type", ")", ";", "/", "/", "specified", "efo", "registration", "type", "in", "stream", "must", "be", "either", "lazy", ",", "eager", "or", "none", "try", "{", "efo", "registration", "type", "=", "e", "f", "o", "registration", "type", "value", "of", "(", "type", "in", "string", ")", ";", "}", "catch", "(", "illegal", "argument", "exception", "e", ")", "{", "string", "error", "message", "=", "arrays", "stream", "(", "e", "f", "o", "registration", "type", "values", "(", ")", ")", "map", "(", "enum", ":", ":", "name", ")", "collect", "(", "collectors", "joining", "(", "\"", ",", "\"", ")", ")", ";", "throw", "new", "illegal", "argument", "exception", "(", "\"", "invalid", "efo", "registration", "type", "in", "stream", "set", "in", "config", "valid", "values", "are", ":", "\"", "+", "error", "message", ")", ";", "}", "}", "else", "{", "efo", "registration", "type", "=", "e", "f", "o", "registration", "type", "lazy", ";", "}", "if", "(", "efo", "registration", "type", "=", "=", "e", "f", "o", "registration", "type", "none", ")", "{", "/", "/", "if", "the", "registration", "type", "is", "none", ",", "then", "for", "each", "stream", "there", "must", "be", "an", "according", "/", "/", "consumer", "arn", "list", "<", "string", ">", "missing", "consumer", "arn", "keys", "=", "new", "array", "list", "<", ">", "(", ")", ";", "for", "(", "string", "stream", ":", "streams", ")", "{", "string", "efo", "consumer", "a", "r", "n", "key", "=", "consumer", "config", "constants", "efo", "consumer", "arn", "prefix", "+", "\"", "\"", "+", "stream", ";", "if", "(", "!", "config", "contains", "key", "(", "efo", "consumer", "a", "r", "n", "key", ")", ")", "{", "missing", "consumer", "arn", "keys", "add", "(", "efo", "consumer", "a", "r", "n", "key", ")", ";", "}", "}", "if", "(", "!", "missing", "consumer", "arn", "keys", "is", "empty", "(", ")", ")", "{", "string", "error", "message", "=", "arrays", "stream", "(", "missing", "consumer", "arn", "keys", "to", "array", "(", ")", ")", "map", "(", "object", ":", ":", "to", "string", ")", "collect", "(", "collectors", "joining", "(", "\"", ",", "\"", ")", ")", ";", "throw", "new", "illegal", "argument", "exception", "(", "\"", "invalid", "efo", "consumer", "arn", "settings", "for", "not", "providing", "consumer", "arns", ":", "\"", "+", "error", "message", ")", ";", "}", "}", "else", "{", "/", "/", "if", "the", "registration", "type", "is", "lazy", "or", "eager", ",", "then", "user", "must", "provide", "a", "self", "-", "defined", "/", "/", "consumer", "name", "if", "(", "!", "config", "contains", "key", "(", "consumer", "config", "constants", "efo", "consumer", "name", ")", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "no", "valid", "enhanced", "fan", "-", "out", "consumer", "name", "is", "set", "through", "\"", "+", "consumer", "config", "constants", "efo", "consumer", "name", ")", ";", "}", "}", "}" ]
[ "get", "map", "map", "string" ]
[ "public", "map", "<", "string", ",", "map", "<", "string", ",", "string", ">", ">", "get", "map", "map", "string", "(", ")", "{", "return", "map", "map", "string", ";", "}" ]
[ "returns", "the", "server", "channel", "handlers", "+", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "+", "|", "server", "channel", "pipeline", "|", "|", "|", "|", "+", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "+", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "+", "(", "3", ")", "write", "+", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "+", "|", "|", "|", "queue", "of", "queues", "+", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", ">", "|", "message", "encoder", "|", "|", "|", "+", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "+", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "+", "+", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "+", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "+", "|", "|", "|", "\\", "\\", "|", "|", "|", "|", "(", "2", ")", "enqueue", "|", "|", "|", "+", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "+", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "+", "|", "|", "|", "|", "request", "handler", "|", "|", "|", "|", "+", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "+", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "+", "|", "|", "|", "|", "\\", "|", "|", "|", "|", "|", "|", "|", "+", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "+", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "+", "|", "|", "|", "|", "message", "+", "frame", "decoder", "|", "|", "|", "|", "+", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "+", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "+", "|", "|", "|", "|", "\\", "|", "|", "+", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "+", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "+", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "+", "|", "|", "(", "1", ")", "client", "request", "\\", "|", "+", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "+", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "+", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "+", "|", "|", "|", "|", "|", "[", "socket", "read", "(", ")", "]", "[", "socket", "write", "(", ")", "]", "|", "|", "|", "|", "netty", "internal", "io", "threads", "(", "transport", "implementation", ")", "|", "+", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "+" ]
[ "public", "channel", "handler", "[", "]", "get", "server", "channel", "handlers", "(", ")", "{", "partition", "request", "queue", "queue", "of", "partition", "queues", "=", "new", "partition", "request", "queue", "(", ")", ";", "partition", "request", "server", "handler", "server", "handler", "=", "new", "partition", "request", "server", "handler", "(", "partition", "provider", ",", "task", "event", "publisher", ",", "queue", "of", "partition", "queues", ")", ";", "return", "new", "channel", "handler", "[", "]", "{", "message", "encoder", ",", "new", "netty", "message", "netty", "message", "decoder", "(", ")", ",", "server", "handler", ",", "queue", "of", "partition", "queues", "}", ";", "}" ]
[ "generate", "a", "multipart", "boundary", "this", "implementation", "delegates", "to", "{", "@", "link", "mime", "type", "utils", "#", "generate", "multipart", "boundary", "(", ")", "}" ]
[ "protected", "byte", "[", "]", "generate", "multipart", "boundary", "(", ")", "{", "return", "mime", "type", "utils", "generate", "multipart", "boundary", "(", ")", ";", "}" ]
[ "put", "a", "keylong", "pair", "in", "the", "j", "s", "o", "n", "object" ]
[ "public", "j", "s", "o", "n", "object", "put", "(", "string", "key", ",", "long", "value", ")", "throws", "j", "s", "o", "n", "exception", "{", "put", "(", "key", ",", "new", "long", "(", "value", ")", ")", ";", "return", "this", ";", "}" ]
[ "returns", "an", "implementation", "of", "{", "@", "link", "list", "#", "list", "iterator", "(", "int", ")", "}" ]
[ "static", "<", "e", ">", "list", "iterator", "<", "e", ">", "list", "iterator", "impl", "(", "list", "<", "e", ">", "list", ",", "int", "index", ")", "{", "return", "new", "abstract", "list", "wrapper", "<", ">", "(", "list", ")", "list", "iterator", "(", "index", ")", ";", "}" ]
[ "handle", "an", "ioe", "on", "a", "read", "by", "attempting", "to", "re", "-", "open", "the", "stream", "the", "filesystem", "'", "s", "read", "exception", "count", "will", "be", "incremented" ]
[ "private", "void", "on", "read", "failure", "(", "i", "o", "exception", "ioe", ",", "int", "length", ",", "boolean", "force", "abort", ")", "throws", "i", "o", "exception", "{", "if", "(", "log", "is", "debug", "enabled", "(", ")", ")", "{", "log", "debug", "(", "\"", "got", "exception", "while", "trying", "to", "read", "from", "stream", "{", "}", ",", "\"", "+", "\"", "client", ":", "{", "}", "object", ":", "{", "}", ",", "trying", "to", "recover", ":", "\"", ",", "uri", ",", "client", ",", "object", ",", "ioe", ")", ";", "}", "else", "{", "log", "info", "(", "\"", "got", "exception", "while", "trying", "to", "read", "from", "stream", "{", "}", ",", "\"", "+", "\"", "client", ":", "{", "}", "object", ":", "{", "}", ",", "trying", "to", "recover", ":", "\"", "+", "ioe", ",", "uri", ",", "client", ",", "object", ")", ";", "}", "stream", "statistics", "read", "exception", "(", ")", ";", "reopen", "(", "\"", "failure", "recovery", "\"", ",", "pos", ",", "length", ",", "force", "abort", ")", ";", "}" ]
[ "set", "whether", "the", "reducer", "is", "written", "in", "java" ]
[ "public", "static", "void", "set", "is", "java", "reducer", "(", "job", "conf", "conf", ",", "boolean", "value", ")", "{", "conf", "set", "boolean", "(", "submitter", "is", "java", "reduce", ",", "value", ")", ";", "}" ]
[ "attaches", "the", "tool", "tip", "from", "the", "gui", "resources", "that", "corresponds", "to", "the", "given", "key", ",", "to", "the", "given", "component" ]
[ "private", "static", "j", "component", "tip", "(", "j", "component", "component", ",", "string", "message", "key", ")", "{", "component", "set", "tool", "tip", "text", "(", "msg", "(", "message", "key", ")", ")", ";", "return", "component", ";", "}" ]
[ "expected", "user", "name", "should", "be", "a", "short", "name" ]
[ "public", "static", "void", "check", "username", "(", "final", "string", "expected", ",", "final", "string", "name", ")", "throws", "i", "o", "exception", "{", "if", "(", "expected", "=", "=", "null", "&", "&", "name", "!", "=", "null", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "usernames", "not", "matched", ":", "expecting", "null", "but", "name", "=", "\"", "+", "name", ")", ";", "}", "if", "(", "name", "=", "=", "null", ")", "{", "/", "/", "name", "is", "optional", ",", "null", "is", "okay", "return", ";", "}", "kerberos", "name", "u", "=", "new", "kerberos", "name", "(", "name", ")", ";", "string", "short", "name", "=", "u", "get", "short", "name", "(", ")", ";", "if", "(", "!", "short", "name", "equals", "(", "expected", ")", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "usernames", "not", "matched", ":", "name", "=", "\"", "+", "short", "name", "+", "\"", "!", "=", "expected", "=", "\"", "+", "expected", ")", ";", "}", "}" ]
[ "unbind", "a", "resource", "for", "the", "given", "key", "from", "the", "current", "context" ]
[ "public", "object", "unbind", "resource", "if", "possible", "(", "object", "key", ")", "{", "object", "actual", "key", "=", "transaction", "synchronization", "utils", "unwrap", "resource", "if", "necessary", "(", "key", ")", ";", "return", "do", "unbind", "resource", "(", "actual", "key", ")", ";", "}" ]
[ "stops", "the", "upload", "immediately", "enqueued", "events", "that", "have", "not", "been", "sent", "yet", "will", "be", "lost" ]
[ "private", "void", "close", "now", "(", ")", "{", "synchronized", "(", "lock", ")", "{", "if", "(", "upload", "thread", "!", "=", "null", ")", "{", "if", "(", "upload", "thread", "is", "interrupted", "(", ")", ")", "{", "return", ";", "}", "upload", "thread", "interrupt", "(", ")", ";", "}", "}", "}" ]
[ "write", "the", "log", "content" ]
[ "public", "abstract", "void", "write", "(", "log", "key", "log", "key", ",", "log", "value", "log", "value", ")", "throws", "i", "o", "exception", ";" ]
[ "release", "the", "reference", "the", "bundle", "host", "reference", "when", "no", "references", "remain", ",", "{", "@", "link", "#", "dispose", "(", ")", "}", "is", "called" ]
[ "public", "static", "void", "release", "bundle", "host", "reference", "(", ")", "{", "if", "(", "reference", "count", "get", "and", "decrement", "(", ")", "=", "=", "1", ")", "{", "dispose", "(", ")", ";", "}", "}" ]
[ "restore", "the", "tool", "'", "s", "state" ]
[ "public", "void", "restore", "tool", "(", ")", "{", "iterator", "<", "plugin", "state", ">", "it", "=", "states", "iterator", "(", ")", ";", "while", "(", "it", "has", "next", "(", ")", ")", "{", "plugin", "state", "ps", "=", "it", "next", "(", ")", ";", "ps", "restore", "(", ")", ";", "}", "}" ]
[ "decreases", "the", "entry", "'", "s", "client", "count" ]
[ "private", "synchronized", "void", "decrease", "client", "count", "(", "entry", "<", "k", ",", "v", ">", "entry", ")", "{", "preconditions", "check", "not", "null", "(", "entry", ")", ";", "preconditions", "check", "state", "(", "entry", "client", "count", ">", "0", ")", ";", "entry", "client", "count", "-", "-", ";", "}" ]
[ "get", "map", "array", "integer" ]
[ "public", "map", "<", "string", ",", "list", "<", "integer", ">", ">", "get", "map", "array", "integer", "(", ")", "{", "return", "map", "array", "integer", ";", "}" ]
[ "ensure", "kafka", "is", "working", "on", "both", "producer", "and", "consumer", "side", "this", "executes", "a", "job", "that", "contains", "two", "flink", "pipelines", "(", "generator", "source", ")", "-", "-", ">", "(", "kafka", "sink", ")", "-", "[", "kafka", "-", "topic", "]", "-", "(", "kafka", "source", ")", "-", "-", ">", "(", "validating", "sink", ")", "we", "need", "to", "externally", "retry", "this", "test", "we", "cannot", "let", "flink", "'", "s", "retry", "mechanism", "do", "it", ",", "because", "the", "kafka", "producer", "does", "not", "guarantee", "exactly", "-", "once", "output", "hence", "a", "recovery", "would", "introduce", "duplicates", "that", "cause", "the", "test", "to", "fail", "this", "test", "also", "ensures", "that", "flink", "-", "3156", "doesn", "'", "t", "happen", "again", ":", "the", "following", "situation", "caused", "a", "npe", "in", "the", "flink", "kafka", "consumer", "topic", "-", "1", "<", "-", "-", "elements", "are", "only", "produced", "into", "topic", "1", "topic", "-", "2", "therefore", ",", "this", "test", "is", "consuming", "as", "well", "from", "an", "empty", "topic" ]
[ "public", "void", "run", "simple", "concurrent", "producer", "consumer", "topology", "(", ")", "throws", "exception", "{", "final", "string", "topic", "=", "\"", "concurrent", "producer", "consumer", "topic", "\"", "+", "uuid", "random", "u", "u", "i", "d", "(", ")", "to", "string", "(", ")", ";", "final", "string", "additional", "empty", "topic", "=", "\"", "additional", "empty", "topic", "\"", "+", "uuid", "random", "u", "u", "i", "d", "(", ")", "to", "string", "(", ")", ";", "final", "int", "parallelism", "=", "3", ";", "final", "int", "elements", "per", "partition", "=", "100", ";", "final", "int", "total", "elements", "=", "parallelism", "*", "elements", "per", "partition", ";", "create", "test", "topic", "(", "topic", ",", "parallelism", ",", "2", ")", ";", "create", "test", "topic", "(", "additional", "empty", "topic", ",", "parallelism", ",", "1", ")", ";", "/", "/", "create", "an", "empty", "topic", "which", "will", "remain", "empty", "all", "the", "time", "final", "stream", "execution", "environment", "env", "=", "stream", "execution", "environment", "get", "execution", "environment", "(", ")", ";", "env", "set", "parallelism", "(", "parallelism", ")", ";", "env", "enable", "checkpointing", "(", "500", ")", ";", "env", "set", "restart", "strategy", "(", "restart", "strategies", "no", "restart", "(", ")", ")", ";", "/", "/", "fail", "immediately", "type", "information", "<", "tuple", "2", "<", "long", ",", "string", ">", ">", "long", "string", "type", "=", "type", "information", "of", "(", "new", "type", "hint", "<", "tuple", "2", "<", "long", ",", "string", ">", ">", "(", ")", "{", "}", ")", ";", "type", "information", "serialization", "schema", "<", "tuple", "2", "<", "long", ",", "string", ">", ">", "source", "schema", "=", "new", "type", "information", "serialization", "schema", "<", ">", "(", "long", "string", "type", ",", "env", "get", "config", "(", ")", ")", ";", "type", "information", "serialization", "schema", "<", "tuple", "2", "<", "long", ",", "string", ">", ">", "sink", "schema", "=", "new", "type", "information", "serialization", "schema", "<", ">", "(", "long", "string", "type", ",", "env", "get", "config", "(", ")", ")", ";", "/", "/", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "add", "producer", "dataflow", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "data", "stream", "<", "tuple", "2", "<", "long", ",", "string", ">", ">", "stream", "=", "env", "add", "source", "(", "new", "rich", "parallel", "source", "function", "<", "tuple", "2", "<", "long", ",", "string", ">", ">", "(", ")", "{", "private", "boolean", "running", "=", "true", ";", "@", "override", "public", "void", "run", "(", "source", "context", "<", "tuple", "2", "<", "long", ",", "string", ">", ">", "ctx", ")", "throws", "interrupted", "exception", "{", "int", "cnt", "=", "get", "runtime", "context", "(", ")", "get", "index", "of", "this", "subtask", "(", ")", "*", "elements", "per", "partition", ";", "int", "limit", "=", "cnt", "+", "elements", "per", "partition", ";", "while", "(", "running", "&", "&", "cnt", "<", "limit", ")", "{", "ctx", "collect", "(", "new", "tuple", "2", "<", ">", "(", "1000l", "+", "cnt", ",", "\"", "kafka", "-", "\"", "+", "cnt", ")", ")", ";", "cnt", "+", "+", ";", "/", "/", "we", "delay", "data", "generation", "a", "bit", "so", "that", "we", "are", "sure", "that", "some", "/", "/", "checkpoints", "are", "/", "/", "triggered", "(", "for", "flink", "-", "3156", ")", "thread", "sleep", "(", "50", ")", ";", "}", "}", "@", "override", "public", "void", "cancel", "(", ")", "{", "running", "=", "false", ";", "}", "}", ")", ";", "properties", "producer", "properties", "=", "flink", "kafka", "producer", "base", "get", "properties", "from", "broker", "list", "(", "broker", "connection", "strings", ")", ";", "producer", "properties", "set", "property", "(", "\"", "retries", "\"", ",", "\"", "3", "\"", ")", ";", "producer", "properties", "put", "all", "(", "secure", "props", ")", ";", "kafka", "server", "produce", "into", "kafka", "(", "stream", ",", "topic", ",", "sink", "schema", ",", "producer", "properties", ",", "null", ")", ";", "/", "/", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "add", "consumer", "dataflow", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "list", "<", "string", ">", "topics", "=", "new", "array", "list", "<", ">", "(", ")", ";", "topics", "add", "(", "topic", ")", ";", "topics", "add", "(", "additional", "empty", "topic", ")", ";", "properties", "props", "=", "new", "properties", "(", ")", ";", "props", "put", "all", "(", "standard", "props", ")", ";", "props", "put", "all", "(", "secure", "props", ")", ";", "flink", "kafka", "consumer", "base", "<", "tuple", "2", "<", "long", ",", "string", ">", ">", "source", "=", "kafka", "server", "get", "consumer", "(", "topics", ",", "source", "schema", ",", "props", ")", ";", "data", "stream", "source", "<", "tuple", "2", "<", "long", ",", "string", ">", ">", "consuming", "=", "env", "add", "source", "(", "source", ")", "set", "parallelism", "(", "parallelism", ")", ";", "consuming", "add", "sink", "(", "new", "rich", "sink", "function", "<", "tuple", "2", "<", "long", ",", "string", ">", ">", "(", ")", "{", "private", "int", "el", "cnt", "=", "0", ";", "private", "bit", "set", "validator", "=", "new", "bit", "set", "(", "total", "elements", ")", ";", "@", "override", "public", "void", "invoke", "(", "tuple", "2", "<", "long", ",", "string", ">", "value", ")", "throws", "exception", "{", "string", "[", "]", "sp", "=", "value", "f", "1", "split", "(", "\"", "-", "\"", ")", ";", "int", "v", "=", "integer", "parse", "int", "(", "sp", "[", "1", "]", ")", ";", "assert", "equals", "(", "value", "f", "0", "-", "1000", ",", "(", "long", ")", "v", ")", ";", "assert", "false", "(", "\"", "received", "tuple", "twice", "\"", ",", "validator", "get", "(", "v", ")", ")", ";", "validator", "set", "(", "v", ")", ";", "el", "cnt", "+", "+", ";", "if", "(", "el", "cnt", "=", "=", "total", "elements", ")", "{", "/", "/", "check", "if", "everything", "in", "the", "bitset", "is", "set", "to", "true", "int", "nc", ";", "if", "(", "(", "nc", "=", "validator", "next", "clear", "bit", "(", "0", ")", ")", "!", "=", "total", "elements", ")", "{", "fail", "(", "\"", "the", "bitset", "was", "not", "set", "to", "1", "on", "all", "elements", "next", "clear", ":", "\"", "+", "nc", "+", "\"", "set", ":", "\"", "+", "validator", ")", ";", "}", "throw", "new", "success", "exception", "(", ")", ";", "}", "}", "@", "override", "public", "void", "close", "(", ")", "throws", "exception", "{", "super", "close", "(", ")", ";", "}", "}", ")", "set", "parallelism", "(", "1", ")", ";", "try", "{", "try", "execute", "propagate", "exceptions", "(", "env", ",", "\"", "run", "simple", "concurrent", "producer", "consumer", "topology", "\"", ")", ";", "}", "catch", "(", "program", "invocation", "exception", "|", "job", "execution", "exception", "e", ")", "{", "/", "/", "look", "for", "not", "leader", "for", "partition", "exception", "throwable", "cause", "=", "e", "get", "cause", "(", ")", ";", "/", "/", "search", "for", "nested", "success", "exceptions", "int", "depth", "=", "0", ";", "while", "(", "cause", "!", "=", "null", "&", "&", "depth", "+", "+", "<", "20", ")", "{", "if", "(", "cause", "instanceof", "not", "leader", "for", "partition", "exception", ")", "{", "throw", "(", "exception", ")", "cause", ";", "}", "cause", "=", "cause", "get", "cause", "(", ")", ";", "}", "throw", "e", ";", "}", "delete", "test", "topic", "(", "topic", ")", ";", "}" ]
[ "pulling", "the", "messages", "in", "the", "specified", "timeout" ]
[ "pull", "result", "pull", "(", "final", "message", "queue", "mq", ",", "final", "string", "sub", "expression", ",", "final", "long", "offset", ",", "final", "int", "max", "nums", ",", "final", "long", "timeout", ")", "throws", "m", "q", "client", "exception", ",", "remoting", "exception", ",", "m", "q", "broker", "exception", ",", "interrupted", "exception", ";" ]
[ "format", "url", "template", "using", "given", "variables" ]
[ "public", "string", "url", "(", "map", "<", "string", ",", "string", ">", "variables", ")", "{", "string", "url", "=", "this", "url", ";", "/", "/", "go", "through", "variables", "and", "replace", "placeholders", "for", "(", "map", "entry", "<", "string", ",", "server", "variable", ">", "variable", ":", "this", "variables", "entry", "set", "(", ")", ")", "{", "string", "name", "=", "variable", "get", "key", "(", ")", ";", "server", "variable", "server", "variable", "=", "variable", "get", "value", "(", ")", ";", "string", "value", "=", "server", "variable", "default", "value", ";", "if", "(", "variables", "!", "=", "null", "&", "&", "variables", "contains", "key", "(", "name", ")", ")", "{", "value", "=", "variables", "get", "(", "name", ")", ";", "if", "(", "server", "variable", "enum", "values", "size", "(", ")", ">", "0", "&", "&", "!", "server", "variable", "enum", "values", "contains", "(", "value", ")", ")", "{", "throw", "new", "runtime", "exception", "(", "\"", "the", "variable", "\"", "+", "name", "+", "\"", "in", "the", "server", "url", "has", "invalid", "value", "\"", "+", "value", "+", "\"", "\"", ")", ";", "}", "}", "url", "=", "url", "replace", "all", "(", "\"", "\\", "\\", "{", "\"", "+", "name", "+", "\"", "\\", "\\", "}", "\"", ",", "value", ")", ";", "}", "return", "url", ";", "}" ]
[ "specify", "the", "jdbc", "data", "source", "lookup", "that", "provides", "data", "sources", "for", "the", "persistence", "provider", ",", "resolving", "data", "source", "names", "in", "{", "@", "code", "persistence", "xml", "}", "against", "spring", "-", "managed", "data", "source", "instances", "default", "is", "jndi", "data", "source", "lookup", ",", "which", "resolves", "data", "source", "names", "as", "jndi", "names", "(", "as", "defined", "by", "standard", "jpa", ")", "specify", "a", "bean", "factory", "data", "source", "lookup", "instance", "if", "you", "want", "data", "source", "names", "to", "be", "resolved", "against", "spring", "bean", "names", "alternatively", ",", "consider", "passing", "in", "a", "map", "from", "names", "to", "data", "source", "instances", "via", "the", "\"", "data", "sources", "\"", "property", "if", "the", "{", "@", "code", "persistence", "xml", "}", "file", "does", "not", "define", "data", "source", "names", "at", "all", ",", "specify", "a", "default", "data", "source", "via", "the", "\"", "default", "data", "source", "\"", "property" ]
[ "public", "void", "set", "data", "source", "lookup", "(", "@", "nullable", "data", "source", "lookup", "data", "source", "lookup", ")", "{", "this", "data", "source", "lookup", "=", "(", "data", "source", "lookup", "!", "=", "null", "?", "data", "source", "lookup", ":", "new", "jndi", "data", "source", "lookup", "(", ")", ")", ";", "}" ]
[ "installs", "the", "default", "{", "@", "link", "table", "cell", "renderer", "}", "s", "for", "known", "ghidra", "table", "cell", "data", "classes", "subclasses", "can", "override", "this", "method", "to", "add", "additional", "types", "or", "to", "change", "the", "default", "associations" ]
[ "protected", "void", "init", "default", "renderers", "(", ")", "{", "super", "init", "default", "renderers", "(", ")", ";", "ghidra", "table", "cell", "renderer", "ghidra", "table", "cell", "renderer", "=", "new", "ghidra", "table", "cell", "renderer", "(", ")", ";", "set", "default", "renderer", "(", "string", "class", ",", "ghidra", "table", "cell", "renderer", ")", ";", "set", "default", "renderer", "(", "enum", "class", ",", "ghidra", "table", "cell", "renderer", ")", ";", "default", "g", "table", "renderer", "list", "add", "(", "ghidra", "table", "cell", "renderer", ")", ";", "preview", "data", "table", "cell", "renderer", "preview", "renderer", "=", "new", "preview", "data", "table", "cell", "renderer", "(", ")", ";", "set", "default", "renderer", "(", "preview", "table", "cell", "data", "class", ",", "preview", "renderer", ")", ";", "default", "g", "table", "renderer", "list", "add", "(", "preview", "renderer", ")", ";", "}" ]
[ "returns", "a", "multimap", "containing", "the", "mappings", "in", "{", "@", "code", "unfiltered", "}", "whose", "keys", "satisfy", "a", "predicate", "the", "returned", "multimap", "is", "a", "live", "view", "of", "{", "@", "code", "unfiltered", "}", ";", "changes", "to", "one", "affect", "the", "other", "the", "resulting", "multimap", "'", "s", "views", "have", "iterators", "that", "don", "'", "t", "support", "{", "@", "code", "remove", "(", ")", "}", ",", "but", "all", "other", "methods", "are", "supported", "by", "the", "multimap", "and", "its", "views", "when", "adding", "a", "key", "that", "doesn", "'", "t", "satisfy", "the", "predicate", ",", "the", "multimap", "'", "s", "{", "@", "code", "put", "(", ")", "}", ",", "{", "@", "code", "put", "all", "(", ")", "}", ",", "and", "{", "@", "code", "replace", "values", "(", ")", "}", "methods", "throw", "an", "{", "@", "link", "illegal", "argument", "exception", "}", "when", "methods", "such", "as", "{", "@", "code", "remove", "all", "(", ")", "}", "and", "{", "@", "code", "clear", "(", ")", "}", "are", "called", "on", "the", "filtered", "multimap", "or", "its", "views", ",", "only", "mappings", "whose", "keys", "satisfy", "the", "filter", "will", "be", "removed", "from", "the", "underlying", "multimap", "the", "returned", "multimap", "isn", "'", "t", "threadsafe", "or", "serializable", ",", "even", "if", "{", "@", "code", "unfiltered", "}", "is", "many", "of", "the", "filtered", "multimap", "'", "s", "methods", ",", "such", "as", "{", "@", "code", "size", "(", ")", "}", ",", "iterate", "across", "every", "keyvalue", "mapping", "in", "the", "underlying", "multimap", "and", "determine", "which", "satisfy", "the", "filter", "when", "a", "live", "view", "is", "not", "needed", ",", "it", "may", "be", "faster", "to", "copy", "the", "filtered", "multimap", "and", "use", "the", "copy", "<", "b", ">", "warning", ":", "<", "b", ">", "{", "@", "code", "key", "predicate", "}", "must", "be", "consistent", "with", "equals", ",", "as", "documented", "at", "{", "@", "link", "predicate", "#", "apply", "}", "do", "not", "provide", "a", "predicate", "such", "as", "{", "@", "code", "predicates", "instance", "of", "(", "array", "list", "class", ")", "}", ",", "which", "is", "inconsistent", "with", "equals" ]
[ "public", "static", "<", "k", ",", "v", ">", "set", "multimap", "<", "k", ",", "v", ">", "filter", "keys", "(", "set", "multimap", "<", "k", ",", "v", ">", "unfiltered", ",", "final", "predicate", "<", "?", "super", "k", ">", "key", "predicate", ")", "{", "if", "(", "unfiltered", "instanceof", "filtered", "key", "set", "multimap", ")", "{", "filtered", "key", "set", "multimap", "<", "k", ",", "v", ">", "prev", "=", "(", "filtered", "key", "set", "multimap", "<", "k", ",", "v", ">", ")", "unfiltered", ";", "return", "new", "filtered", "key", "set", "multimap", "<", ">", "(", "prev", "unfiltered", "(", ")", ",", "predicates", "<", "k", ">", "and", "(", "prev", "key", "predicate", ",", "key", "predicate", ")", ")", ";", "}", "else", "if", "(", "unfiltered", "instanceof", "filtered", "set", "multimap", ")", "{", "filtered", "set", "multimap", "<", "k", ",", "v", ">", "prev", "=", "(", "filtered", "set", "multimap", "<", "k", ",", "v", ">", ")", "unfiltered", ";", "return", "filter", "filtered", "(", "prev", ",", "maps", "<", "k", ">", "key", "predicate", "on", "entries", "(", "key", "predicate", ")", ")", ";", "}", "else", "{", "return", "new", "filtered", "key", "set", "multimap", "<", ">", "(", "unfiltered", ",", "key", "predicate", ")", ";", "}", "}" ]
[ "creates", "an", "{", "@", "code", "avro", "serializer", "}", "if", "flink", "-", "avro", "is", "present", ",", "otherwise", "throws", "an", "exception" ]
[ "public", "abstract", "<", "t", ">", "type", "serializer", "<", "t", ">", "create", "avro", "serializer", "(", "class", "<", "t", ">", "type", ")", ";" ]
[ "sets", "the", "node", "at", "{", "@", "code", "node", "index", "}", "to", "a", "leaf", "node" ]
[ "public", "builder", "add", "leaf", "(", "int", "node", "index", ",", "double", "value", ")", "{", "for", "(", "int", "i", "=", "nodes", "size", "(", ")", ";", "i", "<", "node", "index", "+", "1", ";", "i", "+", "+", ")", "{", "nodes", "add", "(", "null", ")", ";", "}", "nodes", "set", "(", "node", "index", ",", "tree", "node", "builder", "(", "node", "index", ")", "set", "leaf", "value", "(", "collections", "singleton", "list", "(", "value", ")", ")", ")", ";", "return", "this", ";", "}" ]
[ "sets", "optional", "acl", "entries" ]
[ "public", "void", "set", "acl", "entries", "(", "list", "<", "acl", "entry", ">", "acl", "entries", ")", "{", "this", "acl", "entries", "=", "acl", "entries", ";", "}" ]
[ "test", "metrics", "indicating", "the", "number", "of", "stale", "data", "nodes" ]
[ "public", "void", "test", "stale", "nodes", "(", ")", "throws", "exception", "{", "/", "/", "set", "two", "datanodes", "as", "stale", "for", "(", "int", "i", "=", "0", ";", "i", "<", "2", ";", "i", "+", "+", ")", "{", "data", "node", "dn", "=", "cluster", "get", "data", "nodes", "(", ")", "get", "(", "i", ")", ";", "data", "node", "test", "utils", "set", "heartbeats", "disabled", "for", "tests", "(", "dn", ",", "true", ")", ";", "long", "stale", "interval", "=", "conf", "get", "long", "(", "d", "f", "s", "config", "keys", "dfs", "namenode", "stale", "datanode", "interval", "key", ",", "d", "f", "s", "config", "keys", "dfs", "namenode", "stale", "datanode", "interval", "default", ")", ";", "datanode", "descriptor", "dn", "des", "=", "cluster", "get", "name", "node", "(", ")", "get", "namesystem", "(", ")", "get", "block", "manager", "(", ")", "get", "datanode", "manager", "(", ")", "get", "datanode", "(", "dn", "get", "datanode", "id", "(", ")", ")", ";", "d", "f", "s", "test", "util", "reset", "last", "updates", "with", "offset", "(", "dn", "des", ",", "-", "(", "stale", "interval", "+", "1", ")", ")", ";", "}", "/", "/", "let", "heartbeat", "manager", "to", "check", "heartbeat", "block", "manager", "test", "util", "check", "heartbeat", "(", "cluster", "get", "name", "node", "(", ")", "get", "namesystem", "(", ")", "get", "block", "manager", "(", ")", ")", ";", "assert", "gauge", "(", "\"", "stale", "data", "nodes", "\"", ",", "2", ",", "get", "metrics", "(", "ns", "metrics", ")", ")", ";", "/", "/", "reset", "stale", "datanodes", "for", "(", "int", "i", "=", "0", ";", "i", "<", "2", ";", "i", "+", "+", ")", "{", "data", "node", "dn", "=", "cluster", "get", "data", "nodes", "(", ")", "get", "(", "i", ")", ";", "data", "node", "test", "utils", "set", "heartbeats", "disabled", "for", "tests", "(", "dn", ",", "false", ")", ";", "datanode", "descriptor", "dn", "des", "=", "cluster", "get", "name", "node", "(", ")", "get", "namesystem", "(", ")", "get", "block", "manager", "(", ")", "get", "datanode", "manager", "(", ")", "get", "datanode", "(", "dn", "get", "datanode", "id", "(", ")", ")", ";", "d", "f", "s", "test", "util", "reset", "last", "updates", "with", "offset", "(", "dn", "des", ",", "0", ")", ";", "}", "/", "/", "let", "heartbeat", "manager", "to", "refresh", "block", "manager", "test", "util", "check", "heartbeat", "(", "cluster", "get", "name", "node", "(", ")", "get", "namesystem", "(", ")", "get", "block", "manager", "(", ")", ")", ";", "assert", "gauge", "(", "\"", "stale", "data", "nodes", "\"", ",", "0", ",", "get", "metrics", "(", "ns", "metrics", ")", ")", ";", "}" ]
[ "reproduces", "https", ":", "github", "comantlrantlr", "4issues", "7", "7", "3" ]
[ "@", "test", "public", "void", "test", "arg", "on", "primary", "rule", "in", "left", "recursive", "rule", "(", ")", "throws", "exception", "{", "string", "grammar", "=", "\"", "grammar", "t", ";", "\\", "n", "\"", "+", "\"", "val", ":", "dval", "[", "1", "]", "\\", "n", "\"", "+", "\"", "|", "val", "'", "*", "'", "val", "\\", "n", "\"", "+", "\"", ";", "\\", "n", "\"", "+", "\"", "dval", "[", "int", "x", "]", ":", "'", "'", ";", "\\", "n", "\"", ";", "string", "expected", "=", "\"", "\"", ";", "/", "/", "dval", "[", "1", "]", "should", "not", "be", "error", "test", "errors", "(", "new", "string", "[", "]", "{", "grammar", ",", "expected", "}", ",", "false", ")", ";", "}" ]
[ "it", "will", "enrich", "the", "application", "submission", "context", "with", "value", "provided" ]
[ "void", "process", "(", "string", "host", ",", "string", "value", ",", "application", "id", "application", "id", ",", "application", "submission", "context", "submission", "context", ")", ";" ]