Datasets:
Anonymous2023
/
KGSum

Dataset card Data Studio Files Community
docstring_tokens
list
code_tokens
list
[ "test", "a", "thread", "command", "execution", "that", "throws", "an", "hystrix", "exception", "synchronously", "and", "didn", "'", "t", "implement", "get", "fallback" ]
[ "public", "void", "test", "thread", "isolated", "observe", "known", "sync", "failure", "with", "no", "fallback", "(", ")", "{", "test", "observe", "known", "failure", "with", "no", "fallback", "(", "execution", "isolation", "strategy", "thread", ",", "false", ")", ";", "}" ]
[ "test", "the", "property", "'", "breed", "'" ]
[ "public", "void", "breed", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "breed", "}" ]
[ "initiates", "a", "scan", "for", "all", "known", "barcode", "types", "with", "the", "specified", "camera" ]
[ "public", "final", "alert", "dialog", "initiate", "scan", "(", "int", "camera", "id", ")", "{", "return", "initiate", "scan", "(", "all", "code", "types", ",", "camera", "id", ")", ";", "}" ]
[ "sets", "the", "width", "and", "height", "of", "this", "ellipse" ]
[ "public", "ellipse", "set", "size", "(", "float", "width", ",", "float", "height", ")", "{", "this", "width", "=", "width", ";", "this", "height", "=", "height", ";", "return", "this", ";", "}" ]
[ "test", "the", "property", "'", "array", "array", "number", "'" ]
[ "public", "void", "array", "array", "number", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "array", "array", "number", "}" ]
[ "the", "settings", "to", "crete", "the", "index", "template", "with", "(", "either", "json", "or", "yaml", "format", ")" ]
[ "public", "put", "index", "template", "request", "builder", "set", "settings", "(", "map", "<", "string", ",", "object", ">", "source", ")", "{", "request", "settings", "(", "source", ")", ";", "return", "this", ";", "}" ]
[ "gets", "the", "merge", "manager", "associated", "with", "this", "plug", "-", "in" ]
[ "merge", "manager", "get", "merge", "manager", "(", ")", "{", "return", "merge", "manager", ";", "}" ]
[ "create", "an", "initialized", "memory", "block", "using", "bytes", "from", "a", "{", "@", "link", "file", "bytes", "}", "object" ]
[ "public", "memory", "block", "create", "initialized", "block", "(", "string", "name", ",", "address", "start", ",", "file", "bytes", "file", "bytes", ",", "long", "offset", ",", "long", "size", ",", "boolean", "overlay", ")", "throws", "lock", "exception", ",", "illegal", "argument", "exception", ",", "memory", "conflict", "exception", ",", "address", "overflow", "exception", ";" ]
[ "get", "attribute", "boolean" ]
[ "public", "boolean", "get", "attribute", "boolean", "(", ")", "{", "return", "attribute", "boolean", ";", "}" ]
[ "translate", "{", "@", "link", "vertex", "}", "and", "{", "@", "link", "edge", "}", "i", "ds", "using", "the", "given", "{", "@", "link", "map", "function", "}" ]
[ "public", "<", "new", ">", "graph", "<", "new", ",", "vv", ",", "ev", ">", "translate", "graph", "ids", "(", "translate", "function", "<", "k", ",", "new", ">", "translator", ")", "throws", "exception", "{", "return", "run", "(", "new", "translate", "graph", "ids", "<", ">", "(", "translator", ")", ")", ";", "}" ]
[ "default", ":", "null" ]
[ "public", "builder", "set", "alignment", "context", "(", "alignment", "context", "alignment", "context", ")", "{", "this", "alignment", "context", "=", "alignment", "context", ";", "return", "this", ";", "}" ]
[ "moves", "the", "reading", "offset", "by", "{", "@", "code", "bytes", "}" ]
[ "public", "void", "skip", "bytes", "(", "int", "bytes", ")", "{", "set", "position", "(", "position", "+", "bytes", ")", ";", "}" ]
[ "write", "an", "operation", "to", "the", "edit", "log", "<", "p", ">", "additionally", ",", "this", "will", "sync", "the", "edit", "log", "if", "required", "by", "the", "underlying", "edit", "stream", "'", "s", "automatic", "sync", "policy", "(", "e", "g", "when", "the", "buffer", "is", "full", ",", "or", "if", "a", "time", "interval", "has", "elapsed", ")" ]
[ "void", "log", "edit", "(", "final", "f", "s", "edit", "log", "op", "op", ")", "{", "boolean", "needs", "sync", "=", "false", ";", "synchronized", "(", "this", ")", "{", "assert", "is", "open", "for", "write", "(", ")", ":", "\"", "bad", "state", ":", "\"", "+", "state", ";", "/", "/", "wait", "if", "an", "automatic", "sync", "is", "scheduled", "wait", "if", "auto", "sync", "scheduled", "(", ")", ";", "/", "/", "check", "if", "it", "is", "time", "to", "schedule", "an", "automatic", "sync", "needs", "sync", "=", "do", "edit", "transaction", "(", "op", ")", ";", "if", "(", "needs", "sync", ")", "{", "is", "auto", "sync", "scheduled", "=", "true", ";", "}", "}", "/", "/", "sync", "the", "log", "if", "an", "automatic", "sync", "is", "required", "if", "(", "needs", "sync", ")", "{", "log", "sync", "(", ")", ";", "}", "}" ]
[ "deserialize", "from", "a", "byte", "array" ]
[ "public", "t", "from", "bytes", "(", "byte", "[", "]", "bytes", ")", "throws", "i", "o", "exception", "{", "return", "from", "json", "(", "new", "string", "(", "bytes", ",", "0", ",", "bytes", "length", ",", "utf", "8", ")", ")", ";", "}" ]
[ "evaluate", "the", "json", "path", "expression", "against", "the", "response", "content", "and", "assert", "that", "a", "non", "-", "empty", "value", "exists", "at", "the", "given", "path", "for", "the", "semantics", "of", "empty", ",", "consult", "the", "javadoc", "for", "{", "@", "link", "org", "springframework", "util", "object", "utils", "#", "is", "empty", "(", "object", ")", "}" ]
[ "public", "result", "matcher", "is", "not", "empty", "(", ")", "{", "return", "result", "-", ">", "this", "json", "path", "helper", "assert", "value", "is", "not", "empty", "(", "get", "content", "(", "result", ")", ")", ";", "}" ]
[ "tests", "the", "making", "of", "a", "new", "directory", "which", "is", "not", "matching", "to", "any", "of", "internal", "directory", "under", "the", "root" ]
[ "public", "void", "test", "mkdir", "of", "new", "dir", "with", "out", "matching", "to", "mount", "or", "fallback", "dir", "tree", "(", ")", "throws", "exception", "{", "configuration", "conf", "=", "new", "configuration", "(", ")", ";", "conf", "set", "boolean", "(", "constants", "config", "viewfs", "mount", "links", "as", "symlinks", ",", "false", ")", ";", "config", "util", "add", "link", "(", "conf", ",", "\"", "/", "user", "1", "/", "hive", "/", "warehouse", "/", "partition", "-", "0", "\"", ",", "new", "path", "(", "target", "test", "root", "to", "string", "(", ")", ")", "to", "uri", "(", ")", ")", ";", "path", "fallback", "target", "=", "new", "path", "(", "target", "test", "root", ",", "\"", "fallback", "dir", "\"", ")", ";", "fs", "target", "mkdirs", "(", "fallback", "target", ")", ";", "config", "util", "add", "link", "fallback", "(", "conf", ",", "fallback", "target", "to", "uri", "(", ")", ")", ";", "abstract", "file", "system", "vfs", "=", "abstract", "file", "system", "get", "(", "view", "fs", "default", "cluster", "uri", ",", "conf", ")", ";", "/", "/", "user", "2", "does", "not", "exist", "in", "fallback", "path", "p", "=", "new", "path", "(", "\"", "/", "user", "2", "\"", ")", ";", "path", "test", "=", "path", "merge", "paths", "(", "fallback", "target", ",", "p", ")", ";", "assert", "false", "(", "fs", "target", "exists", "(", "test", ")", ")", ";", "vfs", "mkdir", "(", "p", ",", "null", ",", "true", ")", ";", "assert", "true", "(", "fs", "target", "exists", "(", "test", ")", ")", ";", "}" ]
[ "return", "detailed", "information", "about", "vertex", "frequencies", "as", "part", "of", "json", "results", "-", "defaults", "to", "false" ]
[ "public", "void", "return", "detailed", "info", "(", "boolean", "value", ")", "{", "this", "return", "detailed", "info", "=", "value", ";", "}" ]
[ "get", "capital", "snake" ]
[ "public", "string", "get", "capital", "snake", "(", ")", "{", "return", "capital", "snake", ";", "}" ]
[ "returns", "pet", "inventories", "by", "status", "returns", "a", "map", "of", "status", "codes", "to", "quantities" ]
[ "completion", "stage", "<", "response", "<", "map", "<", "string", ",", "integer", ">", ">", ">", "get", "inventory", "(", ")", ";" ]
[ "if", "the", "computer", "was", "offline", "(", "either", "temporarily", "or", "not", ")", ",", "this", "method", "will", "return", "the", "cause", "as", "a", "string", "(", "without", "user", "info", ")" ]
[ "public", "string", "get", "offline", "cause", "reason", "(", ")", "{", "if", "(", "offline", "cause", "=", "=", "null", ")", "{", "return", "\"", "\"", ";", "}", "/", "/", "fetch", "the", "localized", "string", "for", "\"", "disconnected", "by", "\"", "string", "gsub", "base", "=", "hudson", "slaves", "messages", "slave", "computer", "disconnected", "by", "(", "\"", "\"", ",", "\"", "\"", ")", ";", "/", "/", "regex", "to", "remove", "commented", "reason", "base", "string", "string", "gsub", "1", "=", "\"", "^", "\"", "+", "gsub", "base", "+", "\"", "[", "\\", "\\", "w", "\\", "\\", "w", "]", "*", "\\", "\\", ":", "\"", ";", "/", "/", "regex", "to", "remove", "non", "-", "commented", "reason", "base", "string", "string", "gsub", "2", "=", "\"", "^", "\"", "+", "gsub", "base", "+", "\"", "[", "\\", "\\", "w", "\\", "\\", "w", "]", "*", "\"", ";", "string", "new", "string", "=", "offline", "cause", "to", "string", "(", ")", "replace", "all", "(", "gsub", "1", ",", "\"", "\"", ")", ";", "return", "new", "string", "replace", "all", "(", "gsub", "2", ",", "\"", "\"", ")", ";", "}" ]
[ "sets", "whether", "the", "font", "owns", "the", "texture", "in", "case", "it", "does", ",", "the", "font", "will", "also", "dispose", "of", "the", "texture", "when", "{", "@", "link", "#", "dispose", "(", ")", "}", "is", "called", "use", "with", "care", "!" ]
[ "public", "void", "set", "owns", "texture", "(", "boolean", "owns", "texture", ")", "{", "this", "owns", "texture", "=", "owns", "texture", ";", "}" ]
[ "report", "corrupt", "blocks", "that", "were", "discovered", "by", "the", "client" ]
[ "public", "void", "report", "bad", "blocks", "(", "located", "block", "[", "]", "blocks", ")", "throws", "i", "o", "exception", "{", "check", "open", "(", ")", ";", "namenode", "report", "bad", "blocks", "(", "blocks", ")", ";", "}" ]
[ "return", "a", "randomly", "chosen", "application", "directory", "from", "a", "list", "of", "local", "storage", "directories", "the", "probability", "of", "selecting", "a", "directory", "is", "proportional", "to", "its", "size" ]
[ "protected", "path", "get", "working", "dir", "(", "list", "<", "string", ">", "local", "dirs", ",", "string", "user", ",", "string", "app", "id", ")", "throws", "i", "o", "exception", "{", "long", "total", "available", "=", "0l", ";", "long", "[", "]", "available", "on", "disk", "=", "new", "long", "[", "local", "dirs", "size", "(", ")", "]", ";", "int", "i", "=", "0", ";", "/", "/", "randomly", "choose", "the", "app", "directory", "/", "/", "the", "chance", "of", "picking", "a", "directory", "is", "proportional", "to", "/", "/", "the", "available", "space", "on", "the", "directory", "/", "/", "firstly", "calculate", "the", "sum", "of", "all", "available", "space", "on", "these", "directories", "for", "(", "string", "local", "dir", ":", "local", "dirs", ")", "{", "path", "cur", "base", "=", "get", "application", "dir", "(", "new", "path", "(", "local", "dir", ")", ",", "user", ",", "app", "id", ")", ";", "long", "space", "=", "0l", ";", "try", "{", "space", "=", "get", "disk", "free", "space", "(", "cur", "base", ")", ";", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "log", "warn", "(", "\"", "unable", "to", "get", "free", "space", "for", "{", "}", "\"", ",", "cur", "base", ",", "e", ")", ";", "}", "available", "on", "disk", "[", "i", "+", "+", "]", "=", "space", ";", "total", "available", "+", "=", "space", ";", "}", "/", "/", "throw", "an", "i", "o", "exception", "if", "total", "available", "is", "0", "if", "(", "total", "available", "<", "=", "0l", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "not", "able", "to", "find", "a", "working", "directory", "for", "\"", "+", "user", ")", ";", "}", "/", "/", "make", "probability", "to", "pick", "a", "directory", "proportional", "to", "/", "/", "the", "available", "space", "on", "the", "directory", "long", "random", "position", "=", "random", "utils", "next", "long", "(", ")", "%", "total", "available", ";", "int", "dir", "=", "pick", "directory", "(", "random", "position", ",", "available", "on", "disk", ")", ";", "return", "get", "application", "dir", "(", "new", "path", "(", "local", "dirs", "get", "(", "dir", ")", ")", ",", "user", ",", "app", "id", ")", ";", "}" ]
[ "escapes", "the", "characters", "in", "a", "<", "code", ">", "string", "<", "code", ">", "using", "java", "string", "rules", "deals", "correctly", "with", "quotes", "and", "control", "-", "chars", "(", "tab", ",", "backslash", ",", "cr", ",", "ff", ",", "etc", ")", "so", "a", "tab", "becomes", "the", "characters", "<", "code", ">", "'", "\\", "\\", "'", "<", "code", ">", "and", "<", "code", ">", "'", "t", "'", "<", "code", ">", "the", "only", "difference", "between", "java", "strings", "and", "java", "script", "strings", "is", "that", "in", "java", "script", ",", "a", "single", "quote", "must", "be", "escaped", "example", ":", "input", "string", ":", "he", "didn", "'", "t", "say", ",", "\"", "stop", "!", "\"", "output", "string", ":", "he", "didn", "'", "t", "say", ",", "\\", "\"", "stop", "!", "\\", "\"" ]
[ "public", "static", "string", "escape", "java", "(", "string", "str", ")", "{", "return", "escape", "java", "style", "string", "(", "str", ",", "false", ")", ";", "}" ]
[ "checks", "if", "the", "state", "is", "{", "@", "link", "#", "completed", "}", ",", "{", "@", "link", "#", "cancelled", "}", ",", "or", "{", "@", "link", "#", "interrupted", "}" ]
[ "boolean", "is", "done", "(", ")", "{", "return", "(", "get", "state", "(", ")", "&", "(", "completed", "|", "cancelled", "|", "interrupted", ")", ")", "!", "=", "0", ";", "}" ]
[ "get", "enum", "number" ]
[ "public", "enum", "number", "enum", "get", "enum", "number", "(", ")", "{", "return", "enum", "number", ";", "}" ]
[ "test", "for", "the", "case", "when", "the", "application", "tag", "based", "placement", "is", "enabled", "and", "submitting", "user", "'", "user", "1", "'", "is", "whitelisted", "and", "there", "are", "multiple", "valid", "username", "tags", "passed", "expected", "behaviour", ":", "the", "placement", "is", "done", "for", "the", "first", "valid", "username", "from", "the", "tag", "'", "user", "2", "'" ]
[ "public", "void", "test", "get", "user", "name", "for", "placement", "tag", "based", "placement", "multiple", "user", "ids", "(", ")", "throws", "yarn", "exception", "{", "string", "user", "=", "\"", "user", "1", "\"", ";", "string", "expected", "queue", "=", "\"", "user", "1", "queue", "\"", ";", "string", "user", "name", "from", "app", "tag", "=", "\"", "user", "2", "\"", ";", "string", "expected", "user", "=", "user", "name", "from", "app", "tag", ";", "string", "user", "id", "tag", "=", "user", "id", "prefix", "+", "expected", "user", ";", "string", "user", "id", "tag", "2", "=", "user", "id", "prefix", "+", "\"", "user", "3", "\"", ";", "set", "application", "tags", "(", "\"", "tag", "1", "\"", ",", "user", "id", "tag", ",", "\"", "tag", "2", "\"", ",", "user", "id", "tag", "2", ")", ";", "enable", "application", "tag", "placement", "(", "true", ",", "user", ")", ";", "verify", "placement", "username", "(", "expected", "queue", ",", "user", ",", "user", "name", "from", "app", "tag", ",", "expected", "user", ")", ";", "}" ]
[ "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", "\"", ")", ";", "}" ]
[ "compare", "{", "@", "code", "pattern", "}", "matched", "as", "rule", "{", "@", "code", "pattern", "rule", "index", "}", "against", "{", "@", "code", "tree", "}", "and", "return", "a", "{", "@", "link", "parse", "tree", "match", "}", "object", "that", "contains", "the", "matched", "elements", ",", "or", "the", "node", "at", "which", "the", "match", "failed" ]
[ "public", "parse", "tree", "match", "match", "(", "parse", "tree", "tree", ",", "string", "pattern", ",", "int", "pattern", "rule", "index", ")", "{", "parse", "tree", "pattern", "p", "=", "compile", "(", "pattern", ",", "pattern", "rule", "index", ")", ";", "return", "match", "(", "tree", ",", "p", ")", ";", "}" ]
[ "called", "when", "we", "need", "to", "know", "which", "tree", "changed", "(", "not", "enough", "to", "know", "that", "the", "structures", "are", "different", ")" ]
[ "private", "boolean", "tree", "structure", "changed", "(", "program", "module", "root", "1", ",", "program", "module", "root", "2", ")", "{", "if", "(", "root", "1", "=", "=", "null", ")", "{", "return", "true", ";", "}", "return", "root", "1", "get", "modification", "number", "(", ")", "!", "=", "root", "2", "get", "modification", "number", "(", ")", ";", "}" ]
[ "executes", "an", "ldap", "search", "against", "the", "supplied", "url" ]
[ "protected", "search", "response", "perform", "ldap", "search", "(", "final", "string", "ldap", "u", "r", "l", ")", "throws", "ldap", "exception", "{", "val", "operation", "=", "search", "operation", "copy", "(", "this", "search", "operation", ")", ";", "operation", "set", "connection", "factory", "(", "prepare", "connection", "factory", "(", "ldap", "u", "r", "l", ")", ")", ";", "return", "operation", "execute", "(", ")", ";", "}" ]
[ "set", "the", "event", "list", "to", "the", "given", "list", "of", "events", "related", "to", "the", "entity" ]
[ "public", "void", "set", "events", "(", "list", "<", "timeline", "event", ">", "events", ")", "{", "this", "events", "=", "events", ";", "}" ]
[ "tests", "that", "async", "callables", "can", "be", "executed", "in", "the", "main", "thread", "without", "checking", "the", "fencing", "token" ]
[ "public", "void", "test", "call", "async", "without", "fencing", "(", ")", "throws", "exception", "{", "final", "uuid", "new", "fencing", "token", "=", "uuid", "random", "u", "u", "i", "d", "(", ")", ";", "completable", "future", "<", "boolean", ">", "result", "future", "=", "test", "run", "async", "(", "endpoint", "-", ">", "endpoint", "call", "async", "without", "fencing", "(", "(", ")", "-", ">", "true", ",", "timeout", ")", ",", "new", "fencing", "token", ")", ";", "assert", "true", "(", "result", "future", "get", "(", "timeout", "to", "milliseconds", "(", ")", ",", "time", "unit", "milliseconds", ")", ")", ";", "}" ]
[ "retrieve", "a", "jdbc", "object", "value", "for", "the", "specified", "column", "the", "default", "implementation", "calls", "{", "@", "link", "jdbc", "utils", "#", "get", "result", "set", "value", "(", "java", "sql", "result", "set", ",", "int", ",", "class", ")", "}", "if", "no", "required", "type", "has", "been", "specified", ",", "this", "method", "delegates", "to", "{", "@", "code", "get", "column", "value", "(", "rs", ",", "index", ")", "}", ",", "which", "basically", "calls", "{", "@", "code", "result", "set", "get", "object", "(", "index", ")", "}", "but", "applies", "some", "additional", "default", "conversion", "to", "appropriate", "value", "types" ]
[ "protected", "object", "get", "column", "value", "(", "result", "set", "rs", ",", "int", "index", ",", "@", "nullable", "class", "<", "?", ">", "required", "type", ")", "throws", "s", "q", "l", "exception", "{", "if", "(", "required", "type", "!", "=", "null", ")", "{", "return", "jdbc", "utils", "get", "result", "set", "value", "(", "rs", ",", "index", ",", "required", "type", ")", ";", "}", "else", "{", "/", "/", "no", "required", "type", "specified", "-", ">", "perform", "default", "extraction", "return", "get", "column", "value", "(", "rs", ",", "index", ")", ";", "}", "}" ]
[ "create", "an", "f", "s", "data", "output", "stream", "at", "the", "indicated", "path", "with", "write", "-", "progress", "reporting" ]
[ "public", "f", "s", "data", "output", "stream", "create", "(", "path", "f", ",", "fs", "permission", "permission", ",", "enum", "set", "<", "create", "flag", ">", "flags", ",", "int", "buffer", "size", ",", "short", "replication", ",", "long", "block", "size", ",", "progressable", "progress", ")", "throws", "i", "o", "exception", "{", "return", "create", "(", "f", ",", "permission", ",", "flags", ",", "buffer", "size", ",", "replication", ",", "block", "size", ",", "progress", ",", "null", ")", ";", "}" ]
[ "calculate", "the", "bounding", "box", "of", "this", "model", "instance", "this", "is", "a", "potential", "slow", "operation", ",", "it", "is", "advised", "to", "cache", "the", "result" ]
[ "public", "bounding", "box", "calculate", "bounding", "box", "(", "final", "bounding", "box", "out", ")", "{", "out", "inf", "(", ")", ";", "return", "extend", "bounding", "box", "(", "out", ")", ";", "}" ]
[ "convert", "from", "an", "antlr", "string", "literal", "found", "in", "a", "grammar", "file", "to", "an", "equivalent", "string", "literal", "in", "the", "target", "language", "for", "java", ",", "this", "is", "the", "translation", "{", "@", "code", "'", "a", "\\", "n", "\"", "'", "}", "&", "rarr", ";", "{", "@", "code", "\"", "a", "\\", "n", "\\", "\"", "\"", "}", "expect", "single", "quotes", "around", "the", "incoming", "literal", "just", "flip", "the", "quotes", "and", "replace", "double", "quotes", "with", "{", "@", "code", "\\", "\"", "}", "note", "that", "we", "have", "decided", "to", "allow", "people", "to", "use", "'", "\\", "\"", "'", "without", "penalty", ",", "so", "we", "must", "build", "the", "target", "string", "in", "a", "loop", "as", "{", "@", "link", "string", "#", "replace", "}", "cannot", "handle", "both", "{", "@", "code", "\\", "\"", "}", "and", "{", "@", "code", "\"", "}", "without", "a", "lot", "of", "messing", "around" ]
[ "public", "string", "get", "target", "string", "literal", "from", "a", "n", "t", "l", "r", "string", "literal", "(", "code", "generator", "generator", ",", "string", "literal", ",", "boolean", "add", "quotes", ")", "{", "string", "builder", "sb", "=", "new", "string", "builder", "(", ")", ";", "string", "is", "=", "literal", ";", "if", "(", "add", "quotes", ")", "sb", "append", "(", "'", "\"", "'", ")", ";", "for", "(", "int", "i", "=", "1", ";", "i", "<", "is", "length", "(", ")", "-", "1", ";", ")", "{", "int", "code", "point", "=", "is", "code", "point", "at", "(", "i", ")", ";", "int", "to", "advance", "=", "character", "char", "count", "(", "code", "point", ")", ";", "if", "(", "code", "point", "=", "=", "'", "\\", "\\", "'", ")", "{", "/", "/", "anything", "escaped", "is", "what", "it", "is", "!", "we", "assume", "that", "/", "/", "people", "know", "how", "to", "escape", "characters", "correctly", "however", "/", "/", "we", "catch", "anything", "that", "does", "not", "need", "an", "escape", "in", "java", "(", "which", "/", "/", "is", "what", "the", "default", "implementation", "is", "dealing", "with", "and", "remove", "/", "/", "the", "escape", "the", "c", "target", "does", "this", "for", "instance", "/", "/", "int", "escaped", "code", "point", "=", "is", "code", "point", "at", "(", "i", "+", "to", "advance", ")", ";", "to", "advance", "+", "+", ";", "switch", "(", "escaped", "code", "point", ")", "{", "/", "/", "pass", "through", "any", "escapes", "that", "java", "also", "needs", "/", "/", "case", "'", "n", "'", ":", "case", "'", "r", "'", ":", "case", "'", "t", "'", ":", "case", "'", "b", "'", ":", "case", "'", "f", "'", ":", "case", "'", "\\", "\\", "'", ":", "/", "/", "pass", "the", "escape", "through", "sb", "append", "(", "'", "\\", "\\", "'", ")", ";", "sb", "append", "code", "point", "(", "escaped", "code", "point", ")", ";", "break", ";", "case", "'", "u", "'", ":", "/", "/", "either", "unnnn", "or", "u", "{", "nnnnnn", "}", "if", "(", "is", "char", "at", "(", "i", "+", "to", "advance", ")", "=", "=", "'", "{", "'", ")", "{", "while", "(", "is", "char", "at", "(", "i", "+", "to", "advance", ")", "!", "=", "'", "}", "'", ")", "{", "to", "advance", "+", "+", ";", "}", "to", "advance", "+", "+", ";", "}", "else", "{", "to", "advance", "+", "=", "4", ";", "}", "if", "(", "i", "+", "to", "advance", "<", "=", "is", "length", "(", ")", ")", "{", "/", "/", "we", "might", "have", "an", "invalid", "\\", "\\", "u", "a", "b", "or", "something", "string", "full", "escape", "=", "is", "substring", "(", "i", ",", "i", "+", "to", "advance", ")", ";", "append", "unicode", "escaped", "code", "point", "(", "char", "support", "get", "char", "value", "from", "char", "in", "grammar", "literal", "(", "full", "escape", ")", ",", "sb", ")", ";", "}", "break", ";", "default", ":", "if", "(", "should", "use", "unicode", "escape", "for", "code", "point", "in", "double", "quoted", "string", "(", "escaped", "code", "point", ")", ")", "{", "append", "unicode", "escaped", "code", "point", "(", "escaped", "code", "point", ",", "sb", ")", ";", "}", "else", "{", "sb", "append", "code", "point", "(", "escaped", "code", "point", ")", ";", "}", "break", ";", "}", "}", "else", "{", "if", "(", "code", "point", "=", "=", "0x", "2", "2", ")", "{", "/", "/", "antlr", "doesn", "'", "t", "escape", "\"", "in", "literal", "strings", ",", "/", "/", "but", "every", "other", "language", "needs", "to", "do", "so", "sb", "append", "(", "\"", "\\", "\\", "\\", "\"", "\"", ")", ";", "}", "else", "if", "(", "should", "use", "unicode", "escape", "for", "code", "point", "in", "double", "quoted", "string", "(", "code", "point", ")", ")", "{", "append", "unicode", "escaped", "code", "point", "(", "code", "point", ",", "sb", ")", ";", "}", "else", "{", "sb", "append", "code", "point", "(", "code", "point", ")", ";", "}", "}", "i", "+", "=", "to", "advance", ";", "}", "if", "(", "add", "quotes", ")", "sb", "append", "(", "'", "\"", "'", ")", ";", "return", "sb", "to", "string", "(", ")", ";", "}" ]
[ "returns", "the", "current", "processing", "time" ]
[ "long", "get", "current", "processing", "time", "(", ")", ";" ]
[ "returns", "true", "if", "an", "entry", "with", "the", "given", "name", "may", "be", "copied", "over" ]
[ "boolean", "allowed", "(", "string", "path", ")", ";" ]
[ "returns", "a", "matcher", "which", "matches", "objects", "equal", "to", "the", "given", "object" ]
[ "public", "static", "matcher", "<", "object", ">", "only", "(", "object", "value", ")", "{", "return", "new", "only", "(", "value", ")", ";", "}" ]
[ "sets", "the", "executor", "to", "use", "for", "parallel", "glob", "evaluation", "if", "unset", ",", "evaluation", "is", "done", "in", "-", "thread" ]
[ "public", "builder", "set", "executor", "(", "executor", "pool", ")", "{", "this", "executor", "=", "pool", ";", "return", "this", ";", "}" ]
[ "invokes", "{", "@", "code", "condition", "}", "{", "@", "link", "condition", "#", "await", "(", "long", ",", "time", "unit", ")", "await", "(", "timeout", ",", "unit", ")", "}", "uninterruptibly" ]
[ "public", "static", "boolean", "await", "uninterruptibly", "(", "condition", "condition", ",", "duration", "timeout", ")", "{", "return", "await", "uninterruptibly", "(", "condition", ",", "to", "nanos", "saturated", "(", "timeout", ")", ",", "time", "unit", "nanoseconds", ")", ";", "}" ]
[ "optional", "callback", "to", "perform", "tear", "down", "operation", "on", "the", "sticky", "view", ",", "by", "default", "it", "doesn", "'", "t", "do", "anything", "the", "sub", "-", "classes", "should", "override", "the", "function", "if", "they", "are", "using", "sticky", "header", "feature" ]
[ "public", "void", "teardown", "sticky", "header", "view", "(", "@", "not", "null", "view", "sticky", "header", ")", "{", "/", "/", "no", "-", "op", "}" ]
[ "add", "a", "task" ]
[ "void", "add", "task", "(", "task", "task", ")", "{", "preconditions", "check", "state", "(", "task", "target", "!", "=", "this", ",", "\"", "source", "and", "target", "are", "the", "same", "storage", "group", "\"", "+", "get", "display", "name", "(", ")", ")", ";", "inc", "scheduled", "size", "(", "task", "size", ")", ";", "tasks", "add", "(", "task", ")", ";", "}" ]
[ "disable", "the", "check", "whether", "the", "authority", "is", "valid" ]
[ "public", "managed", "channel", "impl", "builder", "disable", "check", "authority", "(", ")", "{", "authority", "checker", "disabled", "=", "true", ";", "return", "this", ";", "}" ]
[ "disable", "those", "operations", "which", "the", "checksummed", "fs", "blocks", "{", "@", "inherit", "doc", "}" ]
[ "public", "boolean", "has", "path", "capability", "(", "final", "path", "path", ",", "final", "string", "capability", ")", "throws", "i", "o", "exception", "{", "/", "/", "query", "the", "superclass", ",", "which", "triggers", "argument", "validation", "final", "path", "p", "=", "make", "qualified", "(", "path", ")", ";", "switch", "(", "validate", "path", "capability", "args", "(", "p", ",", "capability", ")", ")", "{", "case", "common", "path", "capabilities", "fs", "append", ":", "case", "common", "path", "capabilities", "fs", "concat", ":", "return", "false", ";", "default", ":", "return", "super", "has", "path", "capability", "(", "p", ",", "capability", ")", ";", "}", "}" ]
[ "returns", "the", "target", "of", "a", "symbolic", "link", "see", "{", "@", "link", "path", "#", "read", "symbolic", "link", "}", "for", "specification", "note", ":", "for", "{", "@", "link", "file", "system", "}", "s", "where", "{", "@", "link", "#", "supports", "symbolic", "links", "natively", "(", "path", ")", "}", "returns", "false", ",", "this", "method", "will", "throw", "an", "{", "@", "link", "unsupported", "operation", "exception", "}", "if", "the", "link", "points", "to", "a", "non", "-", "existent", "file" ]
[ "protected", "abstract", "path", "fragment", "read", "symbolic", "link", "(", "path", "path", ")", "throws", "i", "o", "exception", ";" ]
[ "attempts", "to", "find", "the", "user", "specified", "by", "{", "@", "code", "username", "}", "in", "one", "of", "the", "delegated", "realms", "the", "realms", "are", "searched", "in", "the", "order", "specified", "during", "construction", "returns", "a", "{", "@", "link", "authentication", "result", "#", "success", "(", "user", ")", "successful", "result", "}", "if", "a", "{", "@", "link", "user", "}", "was", "found", ",", "otherwise", "returns", "an", "{", "@", "link", "authentication", "result", "#", "unsuccessful", "(", "string", ",", "exception", ")", "unsuccessful", "result", "}", "with", "a", "meaningful", "diagnostic", "message" ]
[ "public", "void", "resolve", "(", "string", "username", ",", "action", "listener", "<", "authentication", "result", ">", "result", "listener", ")", "{", "boolean", "authz", "ok", "=", "license", "state", "is", "security", "enabled", "(", ")", "&", "&", "license", "state", "check", "feature", "(", "feature", "security", "authorization", "realm", ")", ";", "if", "(", "authz", "ok", "=", "=", "false", ")", "{", "result", "listener", "on", "response", "(", "authentication", "result", "unsuccessful", "(", "delegated", "authorization", "settings", "authz", "realms", "suffix", "+", "\"", "are", "not", "permitted", "\"", ",", "license", "utils", "new", "compliance", "exception", "(", "delegated", "authorization", "settings", "authz", "realms", "suffix", ")", ")", ")", ";", "return", ";", "}", "if", "(", "has", "delegation", "(", ")", "=", "=", "false", ")", "{", "result", "listener", "on", "response", "(", "authentication", "result", "unsuccessful", "(", "\"", "no", "[", "\"", "+", "delegated", "authorization", "settings", "authz", "realms", "suffix", "+", "\"", "]", "have", "been", "configured", "\"", ",", "null", ")", ")", ";", "return", ";", "}", "action", "listener", "<", "tuple", "<", "user", ",", "realm", ">", ">", "user", "listener", "=", "action", "listener", "wrap", "(", "tuple", "-", ">", "{", "if", "(", "tuple", "!", "=", "null", ")", "{", "logger", "trace", "(", "\"", "found", "user", "\"", "+", "tuple", "v", "1", "(", ")", "+", "\"", "in", "realm", "\"", "+", "tuple", "v", "2", "(", ")", ")", ";", "result", "listener", "on", "response", "(", "authentication", "result", "success", "(", "tuple", "v", "1", "(", ")", ")", ")", ";", "}", "else", "{", "result", "listener", "on", "response", "(", "authentication", "result", "unsuccessful", "(", "\"", "the", "principal", "[", "\"", "+", "username", "+", "\"", "]", "was", "authenticated", ",", "but", "no", "user", "could", "be", "found", "in", "realms", "[", "\"", "+", "collection", "to", "delimited", "string", "(", "lookup", "get", "realms", "(", ")", ",", "\"", ",", "\"", ")", "+", "\"", "]", "\"", ",", "null", ")", ")", ";", "}", "}", ",", "result", "listener", ":", ":", "on", "failure", ")", ";", "lookup", "lookup", "(", "username", ",", "user", "listener", ")", ";", "}" ]
[ "method", "used", "to", "deserialize", "this", "class", "from", "disk" ]
[ "abstract", "void", "deserialize", "(", "task", "monitor", "monitor", ")", "throws", "i", "o", "exception", ",", "cancelled", "exception", ";" ]
[ "get", "the", "rotational", "inertia", "of", "the", "body", "about", "the", "local", "origin" ]
[ "public", "float", "get", "inertia", "(", ")", "{", "return", "jni", "get", "inertia", "(", "addr", ")", ";", "}" ]
[ "finds", "unreserved", "rop", "registers", "with", "a", "specific", "category" ]
[ "private", "int", "find", "next", "unreserved", "rop", "reg", "(", "int", "start", "reg", ",", "int", "reg", "category", ")", "{", "return", "find", "next", "unreserved", "rop", "reg", "(", "start", "reg", ",", "reg", "category", ",", "get", "alignment", "(", "reg", "category", ")", ")", ";", "}" ]
[ "returns", "the", "{", "@", "code", "boolean", "}", "value", "of", "a", "header", "with", "the", "specified", "{", "@", "code", "name", "}", "and", "removes", "the", "header", "from", "this", "object", "if", "there", "is", "more", "than", "one", "value", "for", "the", "specified", "name", ",", "the", "first", "value", "in", "insertion", "order", "is", "returned", "in", "any", "case", "all", "values", "for", "{", "@", "code", "name", "}", "are", "removed", "if", "an", "exception", "occurs", "during", "the", "translation", "from", "type", "{", "@", "code", "t", "}", "all", "entries", "with", "{", "@", "code", "name", "}", "may", "still", "be", "removed" ]
[ "boolean", "get", "boolean", "and", "remove", "(", "k", "name", ",", "boolean", "default", "value", ")", ";" ]
[ "returns", "the", "{", "@", "link", "ad", "display", "container", "}", "used", "by", "this", "loader", ",", "or", "{", "@", "code", "null", "}", "if", "ads", "have", "not", "been", "requested", "yet", "note", ":", "any", "video", "controls", "overlays", "registered", "via", "{", "@", "link", "ad", "display", "container", "#", "register", "friendly", "obstruction", "(", "friendly", "obstruction", ")", "}", "will", "be", "unregistered", "automatically", "when", "the", "media", "source", "detaches", "from", "this", "instance", "it", "is", "therefore", "necessary", "to", "re", "-", "register", "views", "each", "time", "the", "ads", "loader", "is", "reused", "alternatively", ",", "provide", "overlay", "views", "via", "the", "{", "@", "link", "com", "google", "android", "exoplayer", "2", "source", "ads", "ads", "loader", "ad", "view", "provider", "}", "when", "creating", "the", "media", "source", "to", "benefit", "from", "automatic", "registration" ]
[ "public", "ad", "display", "container", "get", "ad", "display", "container", "(", ")", "{", "return", "ad", "display", "container", ";", "}" ]
[ "returns", "the", "equate", "defined", "on", "the", "data" ]
[ "public", "final", "equate", "get", "equate", "(", "data", "data", ")", "{", "object", "obj", "=", "data", "get", "value", "(", ")", ";", "if", "(", "obj", "instanceof", "scalar", ")", "{", "return", "current", "program", "get", "equate", "table", "(", ")", "get", "equate", "(", "data", "get", "min", "address", "(", ")", ",", "0", ",", "(", "(", "scalar", ")", "obj", ")", "get", "value", "(", ")", ")", ";", "}", "return", "null", ";", "}" ]
[ "uploads", "an", "image", "(", "required", ")" ]
[ "public", "void", "upload", "file", "with", "required", "file", "test", "(", ")", "{", "long", "pet", "id", "=", "null", ";", "file", "required", "file", "=", "null", ";", "string", "additional", "metadata", "=", "null", ";", "/", "/", "model", "api", "response", "response", "=", "api", "upload", "file", "with", "required", "file", "(", "pet", "id", ",", "required", "file", ",", "additional", "metadata", ")", ";", "/", "/", "todo", ":", "test", "validations", "}" ]
[ "assert", "that", "an", "object", "is", "{", "@", "code", "null", "}", "<", "pre", "class", "=", "\"", "code", "\"", ">", "assert", "is", "null", "(", "value", ",", "\"", "the", "value", "must", "be", "null", "\"", ")", ";" ]
[ "public", "static", "void", "is", "null", "(", "@", "nullable", "object", "object", ",", "string", "message", ")", "{", "if", "(", "object", "!", "=", "null", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "message", ")", ";", "}", "}" ]
[ "create", "a", "new", "status", "updater", "for", "the", "local", "namenode" ]
[ "protected", "namenode", "heartbeat", "service", "create", "local", "namenode", "heartbeat", "service", "(", ")", "{", "/", "/", "detect", "nn", "running", "in", "this", "machine", "string", "ns", "id", "=", "d", "f", "s", "util", "get", "namenode", "name", "service", "id", "(", "conf", ")", ";", "string", "nn", "id", "=", "null", ";", "if", "(", "h", "a", "util", "is", "h", "a", "enabled", "(", "conf", ",", "ns", "id", ")", ")", "{", "nn", "id", "=", "h", "a", "util", "get", "name", "node", "id", "(", "conf", ",", "ns", "id", ")", ";", "if", "(", "nn", "id", "=", "=", "null", ")", "{", "log", "error", "(", "\"", "cannot", "find", "namenode", "id", "for", "local", "{", "}", "\"", ",", "ns", "id", ")", ";", "}", "}", "return", "create", "namenode", "heartbeat", "service", "(", "ns", "id", ",", "nn", "id", ")", ";", "}" ]
[ "recursive", "helper", "function", "used", "by", "{", "@", "link", "accumulo", "row", "serializer", "#", "get", "array", "from", "block", "}", "and", "{", "@", "link", "accumulo", "row", "serializer", "#", "get", "map", "from", "block", "}", "to", "decode", "the", "block", "into", "a", "java", "type" ]
[ "static", "object", "read", "object", "(", "type", "type", ",", "block", "block", ",", "int", "position", ")", "{", "if", "(", "types", "is", "array", "type", "(", "type", ")", ")", "{", "type", "element", "type", "=", "types", "get", "element", "type", "(", "type", ")", ";", "return", "get", "array", "from", "block", "(", "element", "type", ",", "block", "get", "block", "(", "position", ")", ")", ";", "}", "else", "if", "(", "types", "is", "map", "type", "(", "type", ")", ")", "{", "return", "get", "map", "from", "block", "(", "type", ",", "block", "get", "block", "(", "position", ")", ")", ";", "}", "else", "{", "if", "(", "type", "get", "java", "type", "(", ")", "=", "=", "slice", "class", ")", "{", "slice", "slice", "=", "(", "slice", ")", "type", "utils", "read", "native", "value", "(", "type", ",", "block", ",", "position", ")", ";", "return", "type", "equals", "(", "varchar", "type", "varchar", ")", "?", "slice", "to", "string", "utf", "8", "(", ")", ":", "slice", "get", "bytes", "(", ")", ";", "}", "return", "type", "utils", "read", "native", "value", "(", "type", ",", "block", ",", "position", ")", ";", "}", "}" ]
[ "commit", ":", "commit", "cached", "data", "on", "a", "server", "to", "stable", "storage" ]
[ "public", "n", "f", "s", "3", "response", "commit", "(", "xdr", "xdr", ",", "rpc", "info", "info", ")", ";" ]
[ "exit", "a", "parse", "tree", "produced", "by", "the", "{", "@", "code", "query", "primary", "default", "}", "labeled", "alternative", "in", "{", "@", "link", "sql", "base", "parser", "#", "query", "term", "}" ]
[ "void", "exit", "query", "primary", "default", "(", "sql", "base", "parser", "query", "primary", "default", "context", "ctx", ")", ";" ]
[ "returns", "true", "if", "<", "code", ">", "i", "<", "code", ">", "is", "less", "than", "or", "equal", "to", "<", "code", ">", "j", "<", "code", ">" ]
[ "public", "static", "boolean", "unsigned", "less", "than", "or", "equal", "(", "long", "i", ",", "long", "j", ")", "{", "return", "comp", "(", "less", "than", "or", "equal", ",", "i", ",", "j", ")", ";", "}" ]
[ "logs", "user", "into", "the", "system" ]
[ "string", "login", "user", "(", "@", "param", "(", "\"", "username", "\"", ")", "string", "username", ",", "@", "param", "(", "\"", "password", "\"", ")", "string", "password", ")", ";" ]
[ "returns", "true", "if", "connection", "recently", "was", "lost", "unexpectedly" ]
[ "public", "boolean", "had", "unexpected", "disconnect", "(", ")", "{", "return", "unexpected", "disconnect", ";", "}" ]
[ "returns", "out", "valence", "as", "a", "double", "should", "be", "overridden", "extending", "classes" ]
[ "public", "double", "out", "degree", "(", "vertex", "v", ")", "{", "return", "out", "valence", "(", "v", ")", ";", "}" ]
[ "sets", "the", "corner", "radius", "to", "be", "applied", "when", "drawing", "the", "bitmap" ]
[ "public", "void", "set", "corner", "radius", "(", "@", "float", "range", "(", "from", "=", "0", ")", "float", "corner", "radius", ")", "{", "set", "corner", "radius", "safely", "(", "corner", "radius", ")", ";", "}" ]
[ "transfer", "byte", "buffer", "to", "string" ]
[ "public", "static", "string", "byte", "buffer", "to", "string", "(", "byte", "buffer", "buffer", ",", "string", "charset", "name", ")", "throws", "i", "o", "exception", "{", "charset", "charset", "=", "null", ";", "charset", "decoder", "decoder", "=", "null", ";", "char", "buffer", "char", "buffer", "=", "null", ";", "charset", "=", "charset", "for", "name", "(", "charset", "name", ")", ";", "decoder", "=", "charset", "new", "decoder", "(", ")", ";", "char", "buffer", "=", "decoder", "decode", "(", "buffer", "as", "read", "only", "buffer", "(", ")", ")", ";", "return", "char", "buffer", "to", "string", "(", ")", ";", "}" ]
[ "returns", "true", "if", "the", "text", "cannot", "be", "broken", "into", "lines", "due", "to", "the", "usage", "of", "particular", "html", "constructs" ]
[ "private", "static", "boolean", "is", "unbreakable", "h", "t", "m", "l", "(", "string", "text", ")", "{", "if", "(", "text", "contains", "(", "html", "space", ")", "&", "&", "!", "text", "contains", "(", "\"", "\"", ")", ")", "{", "/", "/", "this", "can", "happen", "if", "the", "client", "has", "called", "a", "method", "on", "this", "class", "that", "turns", "spaces", "/", "/", "to", "the", "html", "space", "return", "true", ";", "}", "if", "(", "text", "contains", "(", "html", "new", "line", ")", ")", "{", "/", "/", "this", "implies", "the", "client", "has", "already", "broken", "lines", "in", "their", "preferred", "location", "return", "true", ";", "}", "return", "false", ";", "}" ]
[ "creates", "a", "flink", "{", "@", "link", "input", "format", "}", "to", "read", "a", "hadoop", "sequence", "file", "for", "the", "given", "key", "and", "value", "classes" ]
[ "public", "static", "<", "k", ",", "v", ">", "hadoop", "input", "format", "<", "k", ",", "v", ">", "read", "sequence", "file", "(", "class", "<", "k", ">", "key", ",", "class", "<", "v", ">", "value", ",", "string", "input", "path", ")", "throws", "i", "o", "exception", "{", "return", "read", "hadoop", "file", "(", "new", "org", "apache", "hadoop", "mapred", "sequence", "file", "input", "format", "<", "k", ",", "v", ">", "(", ")", ",", "key", ",", "value", ",", "input", "path", ")", ";", "}" ]
[ "clears", "memory", "cache" ]
[ "public", "void", "clear", "memory", "cache", "(", ")", "{", "check", "configuration", "(", ")", ";", "configuration", "memory", "cache", "clear", "(", ")", ";", "}" ]
[ "returns", "true", "if", "field", "corresponding", "to", "field", "i", "d", "is", "set", "(", "has", "been", "assigned", "a", "value", ")", "and", "false", "otherwise" ]
[ "public", "boolean", "is", "set", "(", "fields", "field", ")", "{", "if", "(", "field", "=", "=", "null", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", ")", ";", "}", "switch", "(", "field", ")", "{", "case", "name", ":", "return", "is", "set", "name", "(", ")", ";", "}", "throw", "new", "illegal", "state", "exception", "(", ")", ";", "}" ]
[ "get", "method", "is", "modified", "to", "support", "impersonation", "and", "kerberos", "spnego", "token", "by", "forcing", "client", "side", "redirect", "when", "accessing", "\"", "\"", "(", "root", ")", "of", "the", "web", "application", "context" ]
[ "protected", "void", "do", "get", "(", "http", "servlet", "request", "request", ",", "http", "servlet", "response", "response", ")", "throws", "servlet", "exception", ",", "i", "o", "exception", "{", "if", "(", "request", "get", "request", "u", "r", "i", "(", ")", "equals", "(", "\"", "/", "\"", ")", ")", "{", "string", "builder", "location", "=", "new", "string", "builder", "(", ")", ";", "location", "append", "(", "\"", "index", "html", "\"", ")", ";", "if", "(", "request", "get", "query", "string", "(", ")", "!", "=", "null", ")", "{", "/", "/", "echo", "query", "string", "but", "prevent", "http", "response", "splitting", "location", "append", "(", "\"", "?", "\"", ")", ";", "location", "append", "(", "request", "get", "query", "string", "(", ")", "replace", "all", "(", "\"", "\\", "n", "\"", ",", "\"", "\"", ")", "replace", "all", "(", "\"", "\\", "r", "\"", ",", "\"", "\"", ")", ")", ";", "}", "response", "send", "redirect", "(", "location", "to", "string", "(", ")", ")", ";", "}", "else", "{", "super", "do", "get", "(", "request", ",", "response", ")", ";", "}", "}" ]
[ "test", "the", "property", "'", "name", "'" ]
[ "public", "void", "name", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "name", "}" ]
[ "reads", "the", "{", "@", "link", "debug", "info", "entry", "}", "records", "for", "this", "compilation", "unit", "from", "the", "debug", "info", "section" ]
[ "public", "void", "read", "d", "i", "es", "(", "list", "<", "debug", "info", "entry", ">", "entries", ",", "task", "monitor", "monitor", ")", "throws", "i", "o", "exception", ",", "d", "w", "a", "r", "f", "exception", ",", "cancelled", "exception", "{", "binary", "reader", "br", "=", "dwarf", "program", "get", "debug", "info", "(", ")", ";", "br", "set", "pointer", "index", "(", "get", "first", "d", "i", "e", "offset", "(", ")", ")", ";", "deque", "<", "debug", "info", "entry", ">", "parent", "stack", "=", "new", "array", "deque", "<", ">", "(", ")", ";", "debug", "info", "entry", "parent", "=", "null", ";", "debug", "info", "entry", "die", ";", "debug", "info", "entry", "unexpected", "terminator", "=", "null", ";", "while", "(", "(", "br", "get", "pointer", "index", "(", ")", "<", "get", "end", "offset", "(", ")", ")", "&", "&", "(", "die", "=", "debug", "info", "entry", "read", "(", "br", ",", "this", ",", "dwarf", "program", "get", "attribute", "factory", "(", ")", ")", ")", "!", "=", "null", ")", "{", "monitor", "check", "canceled", "(", ")", ";", "if", "(", "die", "is", "terminator", "(", ")", ")", "{", "if", "(", "parent", "=", "=", "null", "&", "&", "parent", "stack", "is", "empty", "(", ")", ")", "{", "unexpected", "terminator", "=", "die", ";", "continue", ";", "}", "parent", "=", "!", "parent", "stack", "is", "empty", "(", ")", "?", "parent", "stack", "pop", "(", ")", ":", "null", ";", "continue", ";", "}", "if", "(", "unexpected", "terminator", "!", "=", "null", ")", "{", "throw", "new", "d", "w", "a", "r", "f", "exception", "(", "\"", "unexpected", "terminator", "entry", "at", "\"", "+", "long", "to", "hex", "string", "(", "unexpected", "terminator", "get", "offset", "(", ")", ")", ")", ";", "}", "entries", "add", "(", "die", ")", ";", "if", "(", "parent", "!", "=", "null", ")", "{", "parent", "add", "child", "(", "die", ")", ";", "die", "set", "parent", "(", "parent", ")", ";", "}", "else", "{", "if", "(", "die", "get", "offset", "(", ")", "!", "=", "get", "first", "d", "i", "e", "offset", "(", ")", ")", "{", "throw", "new", "d", "w", "a", "r", "f", "exception", "(", "\"", "unexpected", "root", "level", "die", "at", "\"", "+", "long", "to", "hex", "string", "(", "die", "get", "offset", "(", ")", ")", ")", ";", "}", "}", "if", "(", "die", "get", "abbreviation", "(", ")", "has", "children", "(", ")", ")", "{", "if", "(", "parent", "!", "=", "null", ")", "{", "parent", "stack", "push", "(", "parent", ")", ";", "}", "parent", "=", "die", ";", "}", "}", "}" ]
[ "{", "@", "inherit", "doc", "}", "because", "a", "{", "@", "code", "set", "multimap", "}", "has", "unique", "values", "for", "a", "given", "key", ",", "this", "method", "returns", "a", "{", "@", "link", "set", "}", ",", "instead", "of", "the", "{", "@", "link", "java", "util", "collection", "}", "specified", "in", "the", "{", "@", "link", "multimap", "}", "interface" ]
[ "set", "<", "entry", "<", "k", ",", "v", ">", ">", "entries", "(", ")", ";" ]
[ "return", "the", "parameters", "for", "this", "script" ]
[ "public", "map", "<", "string", ",", "object", ">", "get", "params", "(", ")", "{", "return", "params", ";", "}" ]
[ "{", "@", "inherit", "doc", "}", "the", "default", "implementation", "does", "nothing" ]
[ "@", "override", "public", "void", "exit", "extract", "template", "(", "sql", "base", "parser", "extract", "template", "context", "ctx", ")", "{", "}" ]
[ "returns", "a", "description", "of", "all", "the", "options", "this", "parser", "can", "digest", "in", "addition", "to", "{", "@", "link", "option", "}", "annotations", ",", "this", "method", "also", "interprets", "{", "@", "link", "options", "usage", "}", "annotations", "which", "give", "an", "intuitive", "short", "description", "for", "the", "options", "options", "of", "the", "same", "category", "(", "see", "{", "@", "link", "option", "#", "category", "}", ")", "will", "be", "grouped", "together" ]
[ "public", "string", "describe", "options", "with", "deprecated", "categories", "(", "map", "<", "string", ",", "string", ">", "category", "descriptions", ",", "help", "verbosity", "help", "verbosity", ")", "{", "options", "data", "data", "=", "impl", "get", "options", "data", "(", ")", ";", "string", "builder", "desc", "=", "new", "string", "builder", "(", ")", ";", "if", "(", "!", "data", "get", "options", "classes", "(", ")", "is", "empty", "(", ")", ")", "{", "list", "<", "option", "definition", ">", "all", "fields", "=", "new", "array", "list", "<", ">", "(", ")", ";", "for", "(", "class", "<", "?", "extends", "options", "base", ">", "options", "class", ":", "data", "get", "options", "classes", "(", ")", ")", "{", "all", "fields", "add", "all", "(", "options", "data", "get", "all", "option", "definitions", "for", "class", "(", "options", "class", ")", ")", ";", "}", "collections", "sort", "(", "all", "fields", ",", "option", "definition", "by", "category", ")", ";", "string", "prev", "category", "=", "null", ";", "for", "(", "option", "definition", "option", "definition", ":", "all", "fields", ")", "{", "string", "category", "=", "option", "definition", "get", "option", "category", "(", ")", ";", "if", "(", "!", "category", "equals", "(", "prev", "category", ")", "&", "&", "option", "definition", "get", "documentation", "category", "(", ")", "!", "=", "option", "documentation", "category", "undocumented", ")", "{", "string", "description", "=", "category", "descriptions", "get", "(", "category", ")", ";", "if", "(", "description", "=", "=", "null", ")", "{", "description", "=", "\"", "options", "category", "'", "\"", "+", "category", "+", "\"", "'", "\"", ";", "}", "desc", "append", "(", "\"", "\\", "n", "\"", ")", "append", "(", "description", ")", "append", "(", "\"", ":", "\\", "n", "\"", ")", ";", "prev", "category", "=", "category", ";", "}", "if", "(", "option", "definition", "get", "documentation", "category", "(", ")", "!", "=", "option", "documentation", "category", "undocumented", ")", "{", "options", "usage", "get", "usage", "(", "option", "definition", ",", "desc", ",", "help", "verbosity", ",", "impl", "get", "options", "data", "(", ")", ",", "false", ")", ";", "}", "}", "}", "return", "desc", "to", "string", "(", ")", "trim", "(", ")", ";", "}" ]
[ "create", "a", "file", "system", "instance", "for", "the", "specified", "uri", "using", "the", "conf", "the", "conf", "is", "used", "to", "find", "the", "class", "name", "that", "implements", "the", "file", "system", "the", "conf", "is", "also", "passed", "to", "the", "file", "system", "for", "its", "configuration" ]
[ "public", "static", "abstract", "file", "system", "create", "file", "system", "(", "uri", "uri", ",", "configuration", "conf", ")", "throws", "unsupported", "file", "system", "exception", "{", "final", "string", "fs", "impl", "conf", "=", "string", "format", "(", "\"", "fs", "abstract", "file", "system", "%", "s", "impl", "\"", ",", "uri", "get", "scheme", "(", ")", ")", ";", "class", "<", "?", ">", "clazz", "=", "conf", "get", "class", "(", "fs", "impl", "conf", ",", "null", ")", ";", "if", "(", "clazz", "=", "=", "null", ")", "{", "throw", "new", "unsupported", "file", "system", "exception", "(", "string", "format", "(", "\"", "%", "s", "=", "null", ":", "%", "s", ":", "%", "s", "\"", ",", "fs", "impl", "conf", ",", "no", "abstract", "fs", "error", ",", "uri", "get", "scheme", "(", ")", ")", ")", ";", "}", "return", "(", "abstract", "file", "system", ")", "new", "instance", "(", "clazz", ",", "uri", ",", "conf", ")", ";", "}" ]
[ "update", "metadata", "store", "to", "reflect", "creation", "of", "the", "given", "directories", "if", "an", "i", "o", "exception", "is", "raised", "while", "trying", "to", "update", "the", "entry", ",", "this", "operation", "catches", "the", "exception", ",", "swallows", "it", "and", "returns" ]
[ "public", "static", "void", "make", "dirs", "ordered", "(", "metadata", "store", "ms", ",", "list", "<", "path", ">", "dirs", ",", "string", "owner", ",", "boolean", "authoritative", ",", "i", "ttl", "time", "provider", "time", "provider", ")", "{", "if", "(", "dirs", "=", "=", "null", ")", "{", "return", ";", "}", "/", "*", "we", "discussed", "atomicity", "of", "this", "implementation", "*", "the", "concern", "is", "that", "multiple", "clients", "could", "race", "to", "write", "different", "*", "cached", "directories", "to", "the", "metadata", "store", "two", "solutions", "are", "proposed", ":", "*", "1", "move", "mkdirs", "(", ")", "into", "metadata", "store", "interface", "and", "let", "implementations", "*", "ensure", "they", "are", "atomic", "*", "2", "specify", "that", "the", "semantics", "of", "metadata", "store", "#", "put", "list", "status", "(", ")", "is", "*", "always", "additive", ",", "that", "is", ",", "if", "metadata", "store", "has", "list", "status", "(", ")", "state", "*", "for", "/", "a", "/", "b", "that", "contains", "[", "/", "a", "/", "b", "/", "file", "0", ",", "/", "a", "/", "b", "/", "file", "1", "]", ",", "and", "we", "then", "call", "*", "put", "list", "status", "(", "/", "a", "/", "b", "-", ">", "[", "/", "a", "/", "b", "/", "file", "2", ",", "/", "a", "/", "b", "/", "file", "3", "]", ",", "is", "authoritative", "=", "true", ")", ",", "*", "then", "we", "will", "end", "up", "with", "final", "state", "of", "*", "[", "/", "a", "/", "b", "/", "file", "0", ",", "/", "a", "/", "b", "/", "file", "1", ",", "/", "a", "/", "b", "/", "file", "2", ",", "/", "a", "/", "b", "/", "file", "3", "]", ",", "is", "authoritative", "=", "*", "true", "*", "/", "s", "3", "a", "file", "status", "prev", "status", "=", "null", ";", "/", "/", "use", "new", "batched", "put", "to", "reduce", "round", "trips", "list", "<", "path", "metadata", ">", "path", "metas", "=", "new", "array", "list", "<", ">", "(", "dirs", "size", "(", ")", ")", ";", "try", "{", "/", "/", "iterate", "from", "leaf", "to", "root", "for", "(", "int", "i", "=", "0", ";", "i", "<", "dirs", "size", "(", ")", ";", "i", "+", "+", ")", "{", "boolean", "is", "leaf", "=", "(", "prev", "status", "=", "=", "null", ")", ";", "path", "f", "=", "dirs", "get", "(", "i", ")", ";", "assert", "qualified", "(", "f", ")", ";", "s", "3", "a", "file", "status", "status", "=", "create", "upload", "file", "status", "(", "f", ",", "true", ",", "0", ",", "0", ",", "owner", ",", "null", ",", "null", ")", ";", "/", "/", "we", "only", "need", "to", "put", "a", "dir", "listing", "metadata", "if", "we", "are", "setting", "/", "/", "authoritative", "bit", "dir", "listing", "metadata", "dir", "meta", "=", "null", ";", "if", "(", "authoritative", ")", "{", "collection", "<", "path", "metadata", ">", "children", ";", "if", "(", "is", "leaf", ")", "{", "children", "=", "dir", "listing", "metadata", "empty", "dir", ";", "}", "else", "{", "children", "=", "new", "array", "list", "<", ">", "(", "1", ")", ";", "children", "add", "(", "new", "path", "metadata", "(", "prev", "status", ")", ")", ";", "}", "dir", "meta", "=", "new", "dir", "listing", "metadata", "(", "f", ",", "children", ",", "authoritative", ")", ";", "s", "3", "guard", "put", "with", "ttl", "(", "ms", ",", "dir", "meta", ",", "collections", "empty", "list", "(", ")", ",", "time", "provider", ",", "null", ")", ";", "}", "path", "metas", "add", "(", "new", "path", "metadata", "(", "status", ")", ")", ";", "prev", "status", "=", "status", ";", "}", "/", "/", "batched", "put", "s", "3", "guard", "put", "with", "ttl", "(", "ms", ",", "path", "metas", ",", "time", "provider", ",", "null", ")", ";", "}", "catch", "(", "i", "o", "exception", "ioe", ")", "{", "log", "error", "(", "\"", "metadata", "store", "#", "put", "(", ")", "failure", ":", "\"", ",", "ioe", ")", ";", "}", "}" ]
[ "called", "on", "the", "test", "thread", "after", "the", "test", "has", "finished", "and", "been", "stopped", "implementations", "may", "use", "this", "method", "to", "assert", "that", "test", "criteria", "were", "met" ]
[ "void", "on", "finished", "(", ")", ";" ]
[ "alert", "listeners", "that", "there", "is", "a", "change", "in", "the", "selected", "filters" ]
[ "protected", "void", "fire", "item", "state", "changed", "(", "item", "event", "e", ")", "{", "/", "/", "guaranteed", "to", "return", "a", "non", "-", "null", "array", "object", "[", "]", "listeners", "=", "listener", "list", "get", "listener", "list", "(", ")", ";", "/", "/", "process", "the", "listeners", "last", "to", "first", ",", "notifying", "/", "/", "those", "that", "are", "interested", "in", "this", "event", "for", "(", "int", "i", "=", "listeners", "length", "-", "2", ";", "i", ">", "=", "0", ";", "i", "-", "=", "2", ")", "{", "if", "(", "listeners", "[", "i", "]", "=", "=", "item", "listener", "class", ")", "{", "(", "(", "item", "listener", ")", "listeners", "[", "i", "+", "1", "]", ")", "item", "state", "changed", "(", "e", ")", ";", "}", "}", "}" ]
[ "primitive", "int", "version", "of", "append" ]
[ "private", "static", "int", "[", "]", "append", "(", "int", "[", "]", "array", ",", "int", "current", "size", ",", "int", "element", ")", "{", "if", "(", "current", "size", "+", "1", ">", "array", "length", ")", "{", "int", "[", "]", "new", "array", "=", "new", "int", "[", "grow", "size", "(", "current", "size", ")", "]", ";", "system", "arraycopy", "(", "array", ",", "0", ",", "new", "array", ",", "0", ",", "current", "size", ")", ";", "array", "=", "new", "array", ";", "}", "array", "[", "current", "size", "]", "=", "element", ";", "return", "array", ";", "}" ]
[ "test", "webflux", "webclient", "plugin" ]
[ "private", "void", "test", "get", "(", "string", "remote", "uri", ")", "{", "mono", "<", "string", ">", "response", "=", "web", "client", "create", "(", ")", "get", "(", ")", "uri", "(", "remote", "uri", ")", "retrieve", "(", ")", "body", "to", "mono", "(", "string", "class", ")", ";", "response", "subscribe", "(", ")", ";", "}" ]
[ "add", "additional", "{", "@", "link", "web", "request", "matcher", "}", "instances", "that", "return", "{", "@", "code", "true", "}", "if", "a", "supplied", "host", "matches", "&", "mdash", ";", "for", "example", ",", "{", "@", "code", "\"", "example", "com", "\"", "}", "or", "{", "@", "code", "\"", "example", "com", ":", "8080", "\"", "}" ]
[ "public", "t", "use", "mock", "mvc", "for", "hosts", "(", "string", "hosts", ")", "{", "this", "request", "matchers", "add", "(", "new", "host", "request", "matcher", "(", "hosts", ")", ")", ";", "return", "(", "t", ")", "this", ";", "}" ]
[ "to", "byte", "array" ]
[ "public", "static", "byte", "[", "]", "long", "2bytes", "(", "long", "v", ")", "{", "byte", "[", "]", "ret", "=", "{", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", "}", ";", "long", "2bytes", "(", "v", ",", "ret", ")", ";", "return", "ret", ";", "}" ]
[ "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", "\"", ")", ";", "}" ]
[ "cancels", "all", "running", "and", "scheduled", "display", "image", "tasks", "<", "br", ">", "<", "b", ">", "note", ":", "<", "b", ">", "this", "method", "doesn", "'", "t", "shutdown", "{", "@", "linkplain", "com", "nostra", "1", "3", "universalimageloader", "core", "image", "loader", "configuration", "builder", "#", "task", "executor", "(", "java", "util", "concurrent", "executor", ")", "custom", "task", "executors", "}", "if", "you", "set", "them", "<", "br", ">", "image", "loader", "still", "can", "be", "used", "after", "calling", "this", "method" ]
[ "public", "void", "stop", "(", ")", "{", "if", "(", "is", "inited", "(", ")", ")", "{", "engine", "stop", "(", ")", ";", "}", "else", "{", "l", "w", "(", "\"", "trying", "to", "stop", "not", "-", "initialized", "image", "loader", "\"", ")", ";", "}", "}" ]
[ "gets", "the", "thread", "that", "currently", "owns", "the", "lock" ]
[ "public", "thread", "get", "owner", "(", ")", "{", "return", "owner", ";", "}" ]
[ "logs", "out", "current", "logged", "in", "user", "session" ]
[ "public", "void", "logout", "user", "test", "(", ")", "{", "/", "/", "api", "logout", "user", "(", ")", ";", "/", "/", "todo", ":", "test", "validations", "}" ]
[ "get", "positions", "selected" ]
[ "public", "list", "<", "integer", ">", "get", "positions", "selected", "(", ")", "{", "return", "touch", "listener", "get", "positions", "selected", "(", ")", ";", "}" ]
[ "downloads", "the", "given", "blob", "from", "the", "given", "server", "and", "stores", "its", "contents", "to", "a", "(", "local", ")", "file", "transient", "blob", "files", "are", "deleted", "after", "a", "successful", "copy", "of", "the", "server", "'", "s", "data", "into", "the", "given", "<", "tt", ">", "local", "jar", "file", "<", "tt", ">" ]
[ "static", "void", "download", "from", "blob", "server", "(", "@", "nullable", "job", "i", "d", "job", "id", ",", "blob", "key", "blob", "key", ",", "file", "local", "jar", "file", ",", "inet", "socket", "address", "server", "address", ",", "configuration", "blob", "client", "config", ",", "int", "num", "fetch", "retries", ")", "throws", "i", "o", "exception", "{", "final", "byte", "[", "]", "buf", "=", "new", "byte", "[", "buffer", "size", "]", ";", "log", "info", "(", "\"", "downloading", "{", "}", "/", "{", "}", "from", "{", "}", "\"", ",", "job", "id", ",", "blob", "key", ",", "server", "address", ")", ";", "/", "/", "loop", "over", "retries", "int", "attempt", "=", "0", ";", "while", "(", "true", ")", "{", "try", "(", "final", "blob", "client", "bc", "=", "new", "blob", "client", "(", "server", "address", ",", "blob", "client", "config", ")", ";", "final", "input", "stream", "is", "=", "bc", "get", "internal", "(", "job", "id", ",", "blob", "key", ")", ";", "final", "output", "stream", "os", "=", "new", "file", "output", "stream", "(", "local", "jar", "file", ")", ")", "{", "while", "(", "true", ")", "{", "final", "int", "read", "=", "is", "read", "(", "buf", ")", ";", "if", "(", "read", "<", "0", ")", "{", "break", ";", "}", "os", "write", "(", "buf", ",", "0", ",", "read", ")", ";", "}", "return", ";", "}", "catch", "(", "throwable", "t", ")", "{", "string", "message", "=", "\"", "failed", "to", "fetch", "blob", "\"", "+", "job", "id", "+", "\"", "/", "\"", "+", "blob", "key", "+", "\"", "from", "\"", "+", "server", "address", "+", "\"", "and", "store", "it", "under", "\"", "+", "local", "jar", "file", "get", "absolute", "path", "(", ")", ";", "if", "(", "attempt", "<", "num", "fetch", "retries", ")", "{", "if", "(", "log", "is", "debug", "enabled", "(", ")", ")", "{", "log", "error", "(", "message", "+", "\"", "retrying", "\"", ",", "t", ")", ";", "}", "else", "{", "log", "error", "(", "message", "+", "\"", "retrying", "\"", ")", ";", "}", "}", "else", "{", "log", "error", "(", "message", "+", "\"", "no", "retries", "left", "\"", ",", "t", ")", ";", "throw", "new", "i", "o", "exception", "(", "message", ",", "t", ")", ";", "}", "/", "/", "retry", "+", "+", "attempt", ";", "log", "info", "(", "\"", "downloading", "{", "}", "/", "{", "}", "from", "{", "}", "(", "retry", "{", "}", ")", "\"", ",", "job", "id", ",", "blob", "key", ",", "server", "address", ",", "attempt", ")", ";", "}", "}", "/", "/", "end", "loop", "over", "retries", "}" ]
[ "sets", "the", "{", "@", "link", "nested", "sort", "builder", "}", "to", "be", "used", "for", "fields", "that", "are", "inside", "a", "nested", "object", "the", "{", "@", "link", "nested", "sort", "builder", "}", "takes", "a", "`", "path", "`", "argument", "and", "an", "optional", "nested", "filter", "that", "the", "nested", "objects", "should", "match", "with", "in", "order", "to", "be", "taken", "into", "account", "for", "sorting" ]
[ "public", "geo", "distance", "sort", "builder", "set", "nested", "sort", "(", "final", "nested", "sort", "builder", "nested", "sort", ")", "{", "this", "nested", "sort", "=", "nested", "sort", ";", "return", "this", ";", "}" ]
[ "retrieve", "or", "build", "a", "default", "executor", "for", "this", "advice", "instance", "an", "executor", "returned", "from", "here", "will", "be", "cached", "for", "further", "use", "the", "default", "implementation", "searches", "for", "a", "unique", "{", "@", "link", "task", "executor", "}", "bean", "in", "the", "context", ",", "or", "for", "an", "{", "@", "link", "executor", "}", "bean", "named", "\"", "task", "executor", "\"", "otherwise", "if", "neither", "of", "the", "two", "is", "resolvable", ",", "this", "implementation", "will", "return", "{", "@", "code", "null", "}" ]
[ "protected", "executor", "get", "default", "executor", "(", "@", "nullable", "bean", "factory", "bean", "factory", ")", "{", "if", "(", "bean", "factory", "!", "=", "null", ")", "{", "try", "{", "/", "/", "search", "for", "task", "executor", "bean", "not", "plain", "executor", "since", "that", "would", "/", "/", "match", "with", "scheduled", "executor", "service", "as", "well", ",", "which", "is", "unusable", "for", "/", "/", "our", "purposes", "here", "task", "executor", "is", "more", "clearly", "designed", "for", "it", "return", "bean", "factory", "get", "bean", "(", "task", "executor", "class", ")", ";", "}", "catch", "(", "no", "unique", "bean", "definition", "exception", "ex", ")", "{", "logger", "debug", "(", "\"", "could", "not", "find", "unique", "task", "executor", "bean", "\"", ",", "ex", ")", ";", "try", "{", "return", "bean", "factory", "get", "bean", "(", "default", "task", "executor", "bean", "name", ",", "executor", "class", ")", ";", "}", "catch", "(", "no", "such", "bean", "definition", "exception", "ex", "2", ")", "{", "if", "(", "logger", "is", "info", "enabled", "(", ")", ")", "{", "logger", "info", "(", "\"", "more", "than", "one", "task", "executor", "bean", "found", "within", "the", "context", ",", "and", "none", "is", "named", "\"", "+", "\"", "'", "task", "executor", "'", "mark", "one", "of", "them", "as", "primary", "or", "name", "it", "'", "task", "executor", "'", "(", "possibly", "\"", "+", "\"", "as", "an", "alias", ")", "in", "order", "to", "use", "it", "for", "async", "processing", ":", "\"", "+", "ex", "get", "bean", "names", "found", "(", ")", ")", ";", "}", "}", "}", "catch", "(", "no", "such", "bean", "definition", "exception", "ex", ")", "{", "logger", "debug", "(", "\"", "could", "not", "find", "default", "task", "executor", "bean", "\"", ",", "ex", ")", ";", "try", "{", "return", "bean", "factory", "get", "bean", "(", "default", "task", "executor", "bean", "name", ",", "executor", "class", ")", ";", "}", "catch", "(", "no", "such", "bean", "definition", "exception", "ex", "2", ")", "{", "logger", "info", "(", "\"", "no", "task", "executor", "bean", "found", "for", "async", "processing", ":", "\"", "+", "\"", "no", "bean", "of", "type", "task", "executor", "and", "no", "bean", "named", "'", "task", "executor", "'", "either", "\"", ")", ";", "}", "/", "/", "giving", "up", "-", ">", "either", "using", "local", "default", "executor", "or", "none", "at", "all", "}", "}", "return", "null", ";", "}" ]
[ "tries", "to", "moverename", "a", "file", "from", "one", "path", "to", "another", "uses", "{", "@", "link", "java", "nio", "file", "files", "#", "move", "}", "when", "available", "does", "not", "use", "{", "@", "link", "java", "nio", "file", "standard", "copy", "option", "#", "replace", "existing", "}", "or", "any", "other", "options", "todo", "candidate", "for", "moving", "to", "{", "@", "link", "util", "}" ]
[ "static", "void", "move", "(", "file", "src", ",", "file", "dest", ")", "throws", "i", "o", "exception", "{", "try", "{", "files", "move", "(", "src", "to", "path", "(", ")", ",", "dest", "to", "path", "(", ")", ")", ";", "}", "catch", "(", "i", "o", "exception", "x", ")", "{", "throw", "x", ";", "}", "catch", "(", "exception", "x", ")", "{", "throw", "new", "i", "o", "exception", "(", "x", ")", ";", "}", "}" ]
[ "new", "authn", "statement" ]
[ "public", "authn", "statement", "new", "authn", "statement", "(", "final", "string", "context", "class", "ref", ",", "final", "zoned", "date", "time", "authn", "instant", ",", "final", "string", "session", "index", ")", "{", "logger", "trace", "(", "\"", "building", "authentication", "statement", "with", "context", "class", "ref", "[", "{", "}", "]", "@", "[", "{", "}", "]", "with", "index", "[", "{", "}", "]", "\"", ",", "context", "class", "ref", ",", "authn", "instant", ",", "session", "index", ")", ";", "val", "stmt", "=", "new", "saml", "object", "(", "authn", "statement", "class", ")", ";", "val", "ctx", "=", "new", "saml", "object", "(", "authn", "context", "class", ")", ";", "val", "class", "ref", "=", "new", "saml", "object", "(", "authn", "context", "class", "ref", "class", ")", ";", "class", "ref", "set", "u", "r", "i", "(", "context", "class", "ref", ")", ";", "ctx", "set", "authn", "context", "class", "ref", "(", "class", "ref", ")", ";", "stmt", "set", "authn", "context", "(", "ctx", ")", ";", "stmt", "set", "authn", "instant", "(", "authn", "instant", "to", "instant", "(", ")", ")", ";", "stmt", "set", "session", "index", "(", "session", "index", ")", ";", "return", "stmt", ";", "}" ]
[ "remove", "global", "session", "1", "root", "session", "manager", "remove", "normal", "global", "session", "2", "retry", "commit", "session", "manager", "and", "retry", "rollback", "session", "manager", "remove", "retry", "expired", "global", "session" ]
[ "public", "void", "remove", "global", "session", "(", "global", "session", "session", ")", "throws", "transaction", "exception", "{", "boolean", "ret", "=", "transaction", "store", "manager", "write", "session", "(", "log", "operation", "global", "remove", ",", "session", ")", ";", "if", "(", "!", "ret", ")", "{", "throw", "new", "store", "exception", "(", "\"", "remove", "global", "session", "failed", "\"", ")", ";", "}", "}" ]
[ "returns", "the", "min", "height", "of", "the", "specified", "row" ]
[ "public", "float", "get", "row", "min", "height", "(", "int", "row", "index", ")", "{", "if", "(", "size", "invalid", ")", "compute", "size", "(", ")", ";", "return", "row", "min", "height", "[", "row", "index", "]", ";", "}" ]
[ "this", "method", "will", "be", "removed", "in", "a", "certain", "version", "after", "april", "5", ",", "2020", ",", "so", "please", "do", "not", "use", "this", "method" ]
[ "public", "query", "result", "query", "message", "(", "string", "topic", ",", "string", "key", ",", "int", "max", "num", ",", "long", "begin", ",", "long", "end", ")", "throws", "m", "q", "client", "exception", ",", "interrupted", "exception", "{", "return", "this", "default", "m", "q", "pull", "consumer", "impl", "query", "message", "(", "with", "namespace", "(", "topic", ")", ",", "key", ",", "max", "num", ",", "begin", ",", "end", ")", ";", "}" ]
[ "return", "the", "underlying", "result", "set", "(", "usually", "a", "{", "@", "code", "javax", "sql", "rowset", "cached", "row", "set", "}", ")" ]
[ "public", "final", "result", "set", "get", "result", "set", "(", ")", "{", "return", "this", "result", "set", ";", "}" ]
[ "sets", "{", "@", "link", "align", "#", "left", "}", "and", "clears", "{", "@", "link", "align", "#", "right", "}", "for", "the", "alignment", "of", "the", "actor", "within", "the", "container" ]
[ "public", "container", "<", "t", ">", "left", "(", ")", "{", "align", "|", "=", "align", "left", ";", "align", "&", "=", "~", "align", "right", ";", "return", "this", ";", "}" ]