Datasets:
Anonymous2023
/
KGSum

Dataset card Data Studio Files Community
docstring_tokens
list
code_tokens
list
[ "generate", "this", "file" ]
[ "public", "void", "generate", "(", ")", "throws", "i", "o", "exception", "{", "dependency", "diff", "=", "get", "dependency", "diff", "(", ")", ";", "/", "/", "if", "it", "'", "s", "patch", ",", "get", "the", "diff", "operation", "if", "(", "null", "=", "=", "dependency", "diff", ")", "{", "return", ";", "}", "try", "{", "app", "variant", "output", "context", "artifact", "bundle", "infos", "=", "get", "artifact", "bundle", "info", "(", "get", "dependency", "diff", "(", ")", ",", "get", "manifest", "file", "(", ")", ",", "get", "ap", "dir", "(", ")", ")", ";", "file", "utils", "write", "string", "to", "file", "(", "new", "file", "(", "get", "out", "json", "file", "(", ")", ",", "\"", "dependency", "diff", "json", "\"", ")", ",", "json", "to", "j", "s", "o", "n", "string", "(", "dependency", "diff", ",", "true", ")", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "throw", "new", "gradle", "exception", "(", "e", "get", "message", "(", ")", ")", ";", "}", "}" ]
[ "get", "the", "number", "of", "characters", "separating", "units" ]
[ "public", "int", "get", "unit", "delimiter", "size", "(", ")", "{", "return", "1", ";", "}" ]
[ "copy", "source", "animations", "to", "this", "model", "instance" ]
[ "public", "void", "copy", "animations", "(", "final", "iterable", "<", "animation", ">", "source", ",", "boolean", "share", "keyframes", ")", "{", "for", "(", "final", "animation", "anim", ":", "source", ")", "{", "copy", "animation", "(", "anim", ",", "share", "keyframes", ")", ";", "}", "}" ]
[ "returns", "the", "current", "set", "of", "received", "values" ]
[ "public", "list", "<", "t", ">", "get", "values", "(", ")", "{", "return", "collections", "unmodifiable", "list", "(", "results", ")", ";", "}" ]
[ "get", "the", "api", "cilent" ]
[ "public", "api", "client", "get", "api", "client", "(", ")", "{", "return", "api", "client", ";", "}" ]
[ "add", "new", "entries", "to", "the", "pending", "cached", "list" ]
[ "private", "void", "add", "new", "pending", "cached", "(", "final", "int", "needed", "cached", ",", "cached", "block", "cached", "block", ",", "list", "<", "datanode", "descriptor", ">", "cached", ",", "list", "<", "datanode", "descriptor", ">", "pending", "cached", ")", "{", "/", "/", "to", "figure", "out", "which", "replicas", "can", "be", "cached", ",", "we", "consult", "the", "/", "/", "blocks", "map", "we", "don", "'", "t", "want", "to", "try", "to", "cache", "a", "corrupt", "replica", ",", "though", "block", "info", "block", "info", "=", "block", "manager", "get", "stored", "block", "(", "new", "block", "(", "cached", "block", "get", "block", "id", "(", ")", ")", ")", ";", "if", "(", "block", "info", "=", "=", "null", ")", "{", "log", "debug", "(", "\"", "block", "{", "}", ":", "can", "'", "t", "add", "new", "cached", "replicas", ",", "\"", "+", "\"", "because", "there", "is", "no", "record", "of", "this", "block", "\"", "+", "\"", "on", "the", "name", "node", "\"", ",", "cached", "block", "get", "block", "id", "(", ")", ")", ";", "return", ";", "}", "if", "(", "!", "block", "info", "is", "complete", "(", ")", ")", "{", "log", "debug", "(", "\"", "block", "{", "}", ":", "can", "'", "t", "cache", "this", "block", ",", "because", "it", "is", "not", "yet", "\"", "+", "\"", "complete", "\"", ",", "cached", "block", "get", "block", "id", "(", ")", ")", ";", "return", ";", "}", "/", "/", "filter", "the", "list", "of", "replicas", "to", "only", "the", "valid", "targets", "list", "<", "datanode", "descriptor", ">", "possibilities", "=", "new", "linked", "list", "<", "datanode", "descriptor", ">", "(", ")", ";", "int", "num", "replicas", "=", "block", "info", "get", "capacity", "(", ")", ";", "collection", "<", "datanode", "descriptor", ">", "corrupt", "=", "block", "manager", "get", "corrupt", "replicas", "(", "block", "info", ")", ";", "int", "out", "of", "capacity", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "num", "replicas", ";", "i", "+", "+", ")", "{", "datanode", "descriptor", "datanode", "=", "block", "info", "get", "datanode", "(", "i", ")", ";", "if", "(", "datanode", "=", "=", "null", ")", "{", "continue", ";", "}", "if", "(", "!", "datanode", "is", "in", "service", "(", ")", ")", "{", "continue", ";", "}", "if", "(", "corrupt", "!", "=", "null", "&", "&", "corrupt", "contains", "(", "datanode", ")", ")", "{", "continue", ";", "}", "if", "(", "pending", "cached", "contains", "(", "datanode", ")", "|", "|", "cached", "contains", "(", "datanode", ")", ")", "{", "continue", ";", "}", "long", "pending", "bytes", "=", "0", ";", "/", "/", "subtract", "pending", "cached", "blocks", "from", "effective", "capacity", "iterator", "<", "cached", "block", ">", "it", "=", "datanode", "get", "pending", "cached", "(", ")", "iterator", "(", ")", ";", "while", "(", "it", "has", "next", "(", ")", ")", "{", "cached", "block", "c", "block", "=", "it", "next", "(", ")", ";", "block", "info", "info", "=", "block", "manager", "get", "stored", "block", "(", "new", "block", "(", "c", "block", "get", "block", "id", "(", ")", ")", ")", ";", "if", "(", "info", "!", "=", "null", ")", "{", "pending", "bytes", "-", "=", "info", "get", "num", "bytes", "(", ")", ";", "}", "}", "it", "=", "datanode", "get", "pending", "uncached", "(", ")", "iterator", "(", ")", ";", "/", "/", "add", "pending", "uncached", "blocks", "from", "effective", "capacity", "while", "(", "it", "has", "next", "(", ")", ")", "{", "cached", "block", "c", "block", "=", "it", "next", "(", ")", ";", "block", "info", "info", "=", "block", "manager", "get", "stored", "block", "(", "new", "block", "(", "c", "block", "get", "block", "id", "(", ")", ")", ")", ";", "if", "(", "info", "!", "=", "null", ")", "{", "pending", "bytes", "+", "=", "info", "get", "num", "bytes", "(", ")", ";", "}", "}", "long", "pending", "capacity", "=", "pending", "bytes", "+", "datanode", "get", "cache", "remaining", "(", ")", ";", "if", "(", "pending", "capacity", "<", "block", "info", "get", "num", "bytes", "(", ")", ")", "{", "log", "trace", "(", "\"", "block", "{", "}", ":", "data", "node", "{", "}", "is", "not", "a", "valid", "possibility", "\"", "+", "\"", "because", "the", "block", "has", "size", "{", "}", ",", "but", "the", "data", "node", "only", "has", "{", "}", "\"", "+", "\"", "bytes", "of", "cache", "remaining", "(", "{", "}", "pending", "bytes", ",", "{", "}", "already", "cached", ")", "\"", ",", "block", "info", "get", "block", "id", "(", ")", ",", "datanode", "get", "datanode", "uuid", "(", ")", ",", "block", "info", "get", "num", "bytes", "(", ")", ",", "pending", "capacity", ",", "pending", "bytes", ",", "datanode", "get", "cache", "remaining", "(", ")", ")", ";", "out", "of", "capacity", "+", "+", ";", "continue", ";", "}", "possibilities", "add", "(", "datanode", ")", ";", "}", "list", "<", "datanode", "descriptor", ">", "chosen", "=", "choose", "datanodes", "for", "caching", "(", "possibilities", ",", "needed", "cached", ",", "block", "manager", "get", "datanode", "manager", "(", ")", "get", "stale", "interval", "(", ")", ")", ";", "for", "(", "datanode", "descriptor", "datanode", ":", "chosen", ")", "{", "log", "trace", "(", "\"", "block", "{", "}", ":", "added", "to", "pending", "cached", "on", "data", "node", "{", "}", "\"", ",", "block", "info", "get", "block", "id", "(", ")", ",", "datanode", "get", "datanode", "uuid", "(", ")", ")", ";", "pending", "cached", "add", "(", "datanode", ")", ";", "boolean", "added", "=", "datanode", "get", "pending", "cached", "(", ")", "add", "(", "cached", "block", ")", ";", "assert", "added", ";", "}", "/", "/", "we", "were", "unable", "to", "satisfy", "the", "requested", "replication", "factor", "if", "(", "needed", "cached", ">", "chosen", "size", "(", ")", ")", "{", "log", "debug", "(", "\"", "block", "{", "}", ":", "we", "only", "have", "{", "}", "of", "{", "}", "cached", "replicas", "\"", "+", "\"", "{", "}", "data", "nodes", "have", "insufficient", "cache", "capacity", "\"", ",", "block", "info", "get", "block", "id", "(", ")", ",", "(", "cached", "block", "get", "replication", "(", ")", "-", "needed", "cached", "+", "chosen", "size", "(", ")", ")", ",", "cached", "block", "get", "replication", "(", ")", ",", "out", "of", "capacity", ")", ";", "}", "}" ]
[ "handles", "redoing", "a", "table", "whose", "key", "is", "address", "based", "when", "a", "ranges", "of", "addresses", "is", "moved" ]
[ "public", "static", "void", "update", "address", "key", "(", "table", "table", ",", "address", "map", "addr", "map", ",", "address", "from", "addr", ",", "address", "end", "addr", ",", "address", "to", "addr", ",", "task", "monitor", "monitor", ")", "throws", "i", "o", "exception", ",", "cancelled", "exception", "{", "long", "length", "=", "end", "addr", "subtract", "(", "from", "addr", ")", ";", "if", "(", "length", "<", "0", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "end", "addr", "must", "be", "greater", "than", "from", "addr", "\"", ")", ";", "}", "try", "{", "to", "addr", "add", "no", "wrap", "(", "length", ")", ";", "}", "catch", "(", "address", "overflow", "exception", "e", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "illegal", "range", ":", "end", "range", "overflow", "\"", ")", ";", "}", "d", "b", "handle", "tmp", "=", "new", "d", "b", "handle", "(", ")", ";", "try", "{", "tmp", "start", "transaction", "(", ")", ";", "table", "tmp", "table", "=", "tmp", "create", "table", "(", "\"", "tmp", "\"", ",", "table", "get", "schema", "(", ")", ")", ";", "record", "iterator", "it", "=", "new", "address", "key", "record", "iterator", "(", "table", ",", "addr", "map", ",", "from", "addr", ",", "end", "addr", ",", "from", "addr", ",", "true", ")", ";", "while", "(", "it", "has", "next", "(", ")", ")", "{", "if", "(", "monitor", "is", "cancelled", "(", ")", ")", "{", "throw", "new", "cancelled", "exception", "(", ")", ";", "}", "d", "b", "record", "rec", "=", "it", "next", "(", ")", ";", "address", "addr", "=", "addr", "map", "decode", "address", "(", "rec", "get", "key", "(", ")", ")", ";", "long", "offset", "=", "addr", "subtract", "(", "from", "addr", ")", ";", "addr", "=", "to", "addr", "add", "(", "offset", ")", ";", "rec", "set", "key", "(", "addr", "map", "get", "key", "(", "addr", ",", "true", ")", ")", ";", "tmp", "table", "put", "record", "(", "rec", ")", ";", "}", "address", "record", "deleter", "delete", "records", "(", "table", ",", "addr", "map", ",", "from", "addr", ",", "end", "addr", ")", ";", "it", "=", "tmp", "table", "iterator", "(", ")", ";", "while", "(", "it", "has", "next", "(", ")", ")", "{", "if", "(", "monitor", "is", "cancelled", "(", ")", ")", "{", "throw", "new", "cancelled", "exception", "(", ")", ";", "}", "d", "b", "record", "rec", "=", "it", "next", "(", ")", ";", "table", "put", "record", "(", "rec", ")", ";", "}", "}", "finally", "{", "tmp", "close", "(", ")", ";", "}", "}" ]
[ "saves", "the", "current", "selection", "in", "the", "structure", "components", "viewing", "area" ]
[ "public", "void", "set", "selection", "(", "int", "[", "]", "rows", ")", "{", "if", "(", "updating", "selection", ")", "{", "return", ";", "}", "field", "selection", "tmp", "selection", "=", "new", "field", "selection", "(", ")", ";", "int", "num", "components", "=", "view", "composite", "get", "num", "components", "(", ")", ";", "for", "(", "int", "row", "2", ":", "rows", ")", "{", "/", "/", "only", "add", "valid", "component", "rows", "(", "i", "e", "don", "'", "t", "include", "blank", "last", "line", ")", "if", "(", "row", "2", "<", "num", "components", ")", "{", "tmp", "selection", "add", "range", "(", "row", "2", ",", "row", "2", "+", "1", ")", ";", "}", "}", "if", "(", "this", "selection", "equals", "(", "tmp", "selection", ")", ")", "{", "return", ";", "}", "this", "selection", "=", "tmp", "selection", ";", "adjust", "current", "row", "(", ")", ";", "selection", "changed", "(", ")", ";", "}" ]
[ "get", "the", "max", "rt", "value", "that", "sentinel", "could", "accept", "for", "system", "bbr", "strategy" ]
[ "public", "static", "int", "statistic", "max", "rt", "(", ")", "{", "string", "v", "=", "props", "get", "(", "statistic", "max", "rt", ")", ";", "try", "{", "if", "(", "string", "util", "is", "empty", "(", "v", ")", ")", "{", "return", "default", "statistic", "max", "rt", ";", "}", "return", "integer", "parse", "int", "(", "v", ")", ";", "}", "catch", "(", "throwable", "throwable", ")", "{", "record", "log", "warn", "(", "\"", "[", "sentinel", "config", "]", "invalid", "statistic", "max", "rt", "value", ":", "{", "}", ",", "using", "the", "default", "value", "instead", ":", "\"", "+", "default", "statistic", "max", "rt", ",", "v", ",", "throwable", ")", ";", "sentinel", "config", "set", "config", "(", "statistic", "max", "rt", ",", "string", "value", "of", "(", "default", "statistic", "max", "rt", ")", ")", ";", "return", "default", "statistic", "max", "rt", ";", "}", "}" ]
[ "max", "number", "of", "concurrent", "maps", "to", "use", "for", "copy" ]
[ "public", "builder", "set", "map", "(", "int", "value", ")", "{", "this", "map", "=", "value", ";", "return", "this", ";", "}" ]
[ "start", "the", "activity", "for", "result" ]
[ "public", "static", "void", "start", "activity", "for", "result", "(", "@", "non", "null", "final", "activity", "activity", ",", "@", "non", "null", "final", "intent", "intent", ",", "final", "int", "request", "code", ",", "@", "nullable", "final", "bundle", "options", ")", "{", "start", "activity", "for", "result", "(", "intent", ",", "activity", ",", "request", "code", ",", "options", ")", ";", "}" ]
[ "get", "small", "snake" ]
[ "public", "string", "get", "small", "snake", "(", ")", "{", "return", "small", "snake", ";", "}" ]
[ "assert", "that", "all", "of", "the", "given", "paths", "have", "the", "exact", "same", "contents" ]
[ "public", "static", "void", "assert", "file", "contents", "same", "(", "file", "files", ")", "throws", "exception", "{", "if", "(", "files", "length", "<", "2", ")", "return", ";", "map", "<", "file", ",", "string", ">", "md", "5s", "=", "get", "file", "m", "d", "5s", "(", "files", ")", ";", "if", "(", "sets", "new", "hash", "set", "(", "md", "5s", "values", "(", ")", ")", "size", "(", ")", ">", "1", ")", "{", "fail", "(", "\"", "file", "contents", "differed", ":", "\\", "n", "\"", "+", "joiner", "on", "(", "\"", "\\", "n", "\"", ")", "with", "key", "value", "separator", "(", "\"", "=", "\"", ")", "join", "(", "md", "5s", ")", ")", ";", "}", "}" ]
[ "network", "enables", "istio", "to", "group", "endpoints", "resident", "in", "the", "same", "l3", "domainnetwork", "all", "endpoints", "in", "the", "same", "network", "are", "assumed", "to", "be", "directly", "reachable", "from", "one", "another", "when", "endpoints", "in", "different", "networks", "cannot", "reach", "each", "other", "directly", ",", "an", "istio", "gateway", "can", "be", "used", "to", "establish", "connectivity", "(", "usually", "using", "the", "auto", "passthrough", "mode", "in", "a", "gateway", "server", ")", "this", "is", "an", "advanced", "configuration", "used", "typically", "for", "spanning", "an", "istio", "mesh", "over", "multiple", "clusters", "<", "code", ">", "string", "network", "=", "4", ";", "<", "code", ">" ]
[ "public", "com", "google", "protobuf", "byte", "string", "get", "network", "bytes", "(", ")", "{", "java", "lang", "object", "ref", "=", "network", ";", "if", "(", "ref", "instanceof", "java", "lang", "string", ")", "{", "com", "google", "protobuf", "byte", "string", "b", "=", "com", "google", "protobuf", "byte", "string", "copy", "from", "utf", "8", "(", "(", "java", "lang", "string", ")", "ref", ")", ";", "network", "=", "b", ";", "return", "b", ";", "}", "else", "{", "return", "(", "com", "google", "protobuf", "byte", "string", ")", "ref", ";", "}", "}" ]
[ "removes", "old", "state", "files", "in", "index", "directory" ]
[ "public", "void", "cleanup", "index", "(", "index", "index", ",", "long", "current", "generation", ")", "{", "index", "metadata", "format", "cleanup", "old", "files", "(", "current", "generation", ",", "node", "env", "index", "paths", "(", "index", ")", ")", ";", "}" ]
[ "boolean", "parameters", "x", ",", "y", "are", "not", "setting", "a", "state", ",", "but", "performing", "a", "flip" ]
[ "public", "void", "flip", "(", "boolean", "x", ",", "boolean", "y", ")", "{", "super", "flip", "(", "x", ",", "y", ")", ";", "float", "[", "]", "vertices", "=", "sprite", "this", "vertices", ";", "if", "(", "x", ")", "{", "float", "temp", "=", "vertices", "[", "u1", "]", ";", "vertices", "[", "u1", "]", "=", "vertices", "[", "u3", "]", ";", "vertices", "[", "u3", "]", "=", "temp", ";", "temp", "=", "vertices", "[", "u2", "]", ";", "vertices", "[", "u2", "]", "=", "vertices", "[", "u4", "]", ";", "vertices", "[", "u4", "]", "=", "temp", ";", "}", "if", "(", "y", ")", "{", "float", "temp", "=", "vertices", "[", "v1", "]", ";", "vertices", "[", "v1", "]", "=", "vertices", "[", "v3", "]", ";", "vertices", "[", "v3", "]", "=", "temp", ";", "temp", "=", "vertices", "[", "v2", "]", ";", "vertices", "[", "v2", "]", "=", "vertices", "[", "v4", "]", ";", "vertices", "[", "v4", "]", "=", "temp", ";", "}", "}" ]
[ "returns", "the", "data", "of", "this", "symbol", "(", "we", "do", "not", "know", "how", "to", "interpret", "it", "yet", ")" ]
[ "public", "byte", "[", "]", "get", "data", "(", ")", "{", "return", "data", ";", "}" ]
[ "set", "the", "<", "code", ">", "resource", "blacklist", "request", "<", "code", ">", "to", "inform", "the", "<", "code", ">", "resource", "manager", "<", "code", ">", "about", "the", "blacklist", "additions", "and", "removals", "per", "the", "<", "code", ">", "application", "master", "<", "code", ">" ]
[ "public", "abstract", "void", "set", "resource", "blacklist", "request", "(", "resource", "blacklist", "request", "resource", "blacklist", "request", ")", ";" ]
[ "have", "the", "zk", "user", "create", "the", "root", "dir", "this", "logs", "out", "the", "zk", "user", "after", "and", "stops", "its", "curator", "instance", ",", "to", "avoid", "contamination" ]
[ "public", "void", "user", "zookeeper", "to", "create", "root", "(", ")", "throws", "throwable", "{", "system", "set", "property", "(", "\"", "curator", "-", "log", "-", "events", "\"", ",", "\"", "true", "\"", ")", ";", "curator", "service", "curator", "=", "null", ";", "login", "context", "login", "=", "login", "(", "zookeeper", "localhost", ",", "zookeeper", "client", "context", ",", "keytab", "zk", ")", ";", "try", "{", "log", "login", "details", "(", "zookeeper", ",", "login", ")", ";", "registry", "security", "set", "z", "k", "sasl", "client", "properties", "(", "zookeeper", ",", "zookeeper", "client", "context", ")", ";", "curator", "=", "start", "curator", "service", "instance", "(", "\"", "zk", "\"", ",", "true", ")", ";", "log", "info", "(", "curator", "to", "string", "(", ")", ")", ";", "add", "to", "teardown", "(", "curator", ")", ";", "curator", "zk", "mk", "path", "(", "\"", "/", "\"", ",", "create", "mode", "persistent", ",", "false", ",", "registry", "security", "world", "read", "write", "a", "c", "l", ")", ";", "z", "k", "path", "dumper", "path", "dumper", "=", "curator", "dump", "path", "(", "true", ")", ";", "log", "info", "(", "path", "dumper", "to", "string", "(", ")", ")", ";", "}", "finally", "{", "logout", "(", "login", ")", ";", "service", "operations", "stop", "(", "curator", ")", ";", "}", "}" ]
[ "add", "the", "corresponding", "files", "as", "non", "-", "header", ",", "non", "-", "source", "input", "files" ]
[ "public", "cc", "compilation", "helper", "add", "additional", "inputs", "(", "collection", "<", "artifact", ">", "inputs", ")", "{", "iterables", "add", "all", "(", "additional", "inputs", ",", "inputs", ")", ";", "return", "this", ";", "}" ]
[ "returns", "the", "{", "@", "link", "snapshot", "state", "}", "for", "the", "given", "snapshot", "returns", "{", "@", "code", "null", "}", "if", "there", "is", "no", "state", "for", "the", "snapshot" ]
[ "public", "snapshot", "state", "get", "snapshot", "state", "(", "final", "snapshot", "id", "snapshot", "id", ")", "{", "return", "snapshot", "states", "get", "(", "snapshot", "id", "get", "u", "u", "i", "d", "(", ")", ")", ";", "}" ]
[ "used", "to", "display", "an", "informational", "message", "to", "the", "user", "with", "a", "pop", "-", "up", "gui", "dialog", "also", "records", "the", "message", "to", "the", "logging", "system" ]
[ "public", "static", "void", "show", "info", "(", "object", "originator", ",", "component", "parent", ",", "string", "title", ",", "object", "message", ")", "{", "if", "(", "system", "utilities", "is", "in", "headless", "mode", "(", ")", ")", "{", "msg", "info", "(", "originator", ",", "message", ")", ";", "}", "else", "{", "error", "display", "display", "info", "message", "(", "error", "logger", ",", "originator", ",", "parent", ",", "title", ",", "message", ")", ";", "}", "}" ]
[ "calculate", "the", "hash", "value", "of", "a", "given", "string" ]
[ "public", "static", "string", "hash", "(", "string", "algorithm", ",", "string", "str", ")", "{", "return", "hash", "(", "algorithm", ",", "str", ",", "\"", "\"", ")", ";", "}" ]
[ "the", "list", "of", "array", "elements", "<", "code", ">", "repeated", "aapt", "pb", "array", "element", "element", "=", "1", ";", "<", "code", ">" ]
[ "public", "builder", "add", "element", "(", "com", "android", "aapt", "resources", "array", "element", "value", ")", "{", "copy", "on", "write", "(", ")", ";", "instance", "add", "element", "(", "value", ")", ";", "return", "this", ";", "}" ]
[ "get", "attribute", "integer" ]
[ "public", "integer", "get", "attribute", "integer", "(", ")", "{", "return", "attribute", "integer", ";", "}" ]
[ "test", "the", "basic", "functionality" ]
[ "public", "void", "test", "sync", "(", ")", "throws", "exception", "{", "if", "(", "is", "src", "not", "same", "as", "tgt", ")", "{", "init", "data", "(", "source", ")", ";", "}", "init", "data", "(", "target", ")", ";", "enable", "and", "create", "first", "snapshot", "(", ")", ";", "final", "fs", "shell", "shell", "=", "new", "fs", "shell", "(", "conf", ")", ";", "lsr", "source", "(", "\"", "before", "source", ":", "\"", ",", "shell", ",", "source", ")", ";", "lsr", "(", "\"", "before", "target", ":", "\"", ",", "shell", ",", "target", ")", ";", "/", "/", "make", "changes", "under", "target", "int", "num", "deleted", "modified", "=", "change", "data", "(", "target", ")", ";", "create", "second", "snapshot", "at", "target", "(", ")", ";", "snapshot", "diff", "report", "report", "=", "dfs", "get", "snapshot", "diff", "report", "(", "target", ",", "\"", "s", "2", "\"", ",", "\"", "s", "1", "\"", ")", ";", "system", "out", "println", "(", "report", ")", ";", "final", "dist", "cp", "sync", "dist", "cp", "sync", "=", "new", "dist", "cp", "sync", "(", "dist", "cp", "context", ",", "conf", ")", ";", "lsr", "(", "\"", "before", "sync", "target", ":", "\"", ",", "shell", ",", "target", ")", ";", "/", "/", "do", "the", "sync", "assert", "assert", "true", "(", "dist", "cp", "sync", "sync", "(", ")", ")", ";", "lsr", "(", "\"", "after", "sync", "target", ":", "\"", ",", "shell", ",", "target", ")", ";", "/", "/", "make", "sure", "the", "source", "path", "has", "been", "updated", "to", "the", "snapshot", "path", "final", "path", "spath", "=", "new", "path", "(", "source", ",", "hdfs", "constants", "dot", "snapshot", "dir", "+", "path", "separator", "+", "\"", "s", "1", "\"", ")", ";", "assert", "assert", "equals", "(", "spath", ",", "dist", "cp", "context", "get", "source", "paths", "(", ")", "get", "(", "0", ")", ")", ";", "/", "/", "build", "copy", "listing", "final", "path", "listing", "path", "=", "new", "path", "(", "\"", "/", "tmp", "/", "meta", "/", "file", "list", "seq", "\"", ")", ";", "copy", "listing", "listing", "=", "new", "simple", "copy", "listing", "(", "conf", ",", "new", "credentials", "(", ")", ",", "dist", "cp", "sync", ")", ";", "listing", "build", "listing", "(", "listing", "path", ",", "dist", "cp", "context", ")", ";", "map", "<", "text", ",", "copy", "listing", "file", "status", ">", "copy", "listing", "=", "get", "listing", "(", "listing", "path", ")", ";", "copy", "mapper", "copy", "mapper", "=", "new", "copy", "mapper", "(", ")", ";", "stub", "context", "stub", "context", "=", "new", "stub", "context", "(", "conf", ",", "null", ",", "0", ")", ";", "mapper", "<", "text", ",", "copy", "listing", "file", "status", ",", "text", ",", "text", ">", "context", "context", "=", "stub", "context", "get", "context", "(", ")", ";", "/", "/", "enable", "append", "context", "get", "configuration", "(", ")", "set", "boolean", "(", "dist", "cp", "option", "switch", "append", "get", "config", "label", "(", ")", ",", "true", ")", ";", "copy", "mapper", "setup", "(", "context", ")", ";", "for", "(", "map", "entry", "<", "text", ",", "copy", "listing", "file", "status", ">", "entry", ":", "copy", "listing", "entry", "set", "(", ")", ")", "{", "copy", "mapper", "map", "(", "entry", "get", "key", "(", ")", ",", "entry", "get", "value", "(", ")", ",", "context", ")", ";", "}", "lsr", "source", "(", "\"", "after", "mapper", "source", ":", "\"", ",", "shell", ",", "source", ")", ";", "lsr", "(", "\"", "after", "mapper", "target", ":", "\"", ",", "shell", ",", "target", ")", ";", "/", "/", "verify", "that", "we", "only", "list", "modified", "and", "created", "files", "/", "directories", "assert", "assert", "equals", "(", "num", "deleted", "modified", ",", "copy", "listing", "size", "(", ")", ")", ";", "/", "/", "verify", "that", "we", "only", "copied", "new", "appended", "data", "of", "f", "2", "and", "the", "new", "file", "f", "1", "assert", "assert", "equals", "(", "block", "size", "*", "3", ",", "stub", "context", "get", "reporter", "(", ")", "get", "counter", "(", "copy", "mapper", "counter", "bytescopied", ")", "get", "value", "(", ")", ")", ";", "/", "/", "verify", "the", "source", "and", "target", "now", "has", "the", "same", "structure", "verify", "copy", "(", "dfs", "get", "file", "status", "(", "spath", ")", ",", "dfs", "get", "file", "status", "(", "target", ")", ",", "false", ")", ";", "}" ]
[ "marks", "the", "container", "to", "be", "launched", "only", "if", "it", "was", "not", "launched" ]
[ "boolean", "mark", "launched", "(", ")", "{", "return", "container", "already", "launched", "compare", "and", "set", "(", "false", ",", "true", ")", ";", "}" ]
[ "convert", "the", "given", "object", "to", "string", "with", "each", "line", "indented", "by", "4", "spaces", "(", "except", "the", "first", "line", ")" ]
[ "private", "string", "to", "indented", "string", "(", "object", "o", ")", "{", "if", "(", "o", "=", "=", "null", ")", "{", "return", "\"", "null", "\"", ";", "}", "return", "o", "to", "string", "(", ")", "replace", "(", "\"", "\\", "n", "\"", ",", "\"", "\\", "n", "\"", ")", ";", "}" ]
[ "return", "the", "{", "@", "link", "http", "message", "converter", "http", "message", "converters", "}", "to", "be", "used", "for", "response", "body", "conversion" ]
[ "list", "<", "http", "message", "converter", "<", "?", ">", ">", "message", "converters", "(", ")", ";" ]
[ "returns", "<", "code", ">", "true", "<", "code", ">", "if", "the", "given", "method", "is", "{", "@", "link", "argument", "matcher", "#", "matches", "(", "object", ")", "}" ]
[ "private", "static", "boolean", "is", "matches", "method", "(", "method", "method", ")", "{", "if", "(", "method", "get", "parameter", "types", "(", ")", "length", "!", "=", "1", ")", "{", "return", "false", ";", "}", "if", "(", "method", "is", "bridge", "(", ")", ")", "{", "return", "false", ";", "}", "return", "\"", "matches", "\"", "equals", "(", "method", "get", "name", "(", ")", ")", ";", "}" ]
[ "add", "several", "fields", "to", "run", "the", "query", "against", "with", "a", "specific", "boost" ]
[ "public", "query", "string", "query", "builder", "fields", "(", "map", "<", "string", ",", "float", ">", "fields", ")", "{", "for", "(", "float", "field", "boost", ":", "fields", "values", "(", ")", ")", "{", "check", "negative", "boost", "(", "field", "boost", ")", ";", "}", "this", "fields", "and", "weights", "put", "all", "(", "fields", ")", ";", "return", "this", ";", "}" ]
[ "extract", "a", "date", "from", "a", "string" ]
[ "public", "static", "final", "calendar", "parse", "(", "string", "date", "str", ",", "int", "order", ")", "throws", "calendar", "parser", "exception", "{", "return", "parse", "(", "date", "str", ",", "order", ",", "true", ")", ";", "}" ]
[ "set", "the", "value", "of", "an", "attribute", "for", "a", "path" ]
[ "public", "void", "set", "x", "attr", "(", "path", "path", ",", "string", "x", "attr", "name", ",", "byte", "[", "]", "value", ",", "enum", "set", "<", "x", "attr", "set", "flag", ">", "flag", ")", "throws", "i", "o", "exception", "{", "path", "absolute", "path", "=", "make", "absolute", "(", "path", ")", ";", "perform", "auth", "check", "(", "absolute", "path", ",", "wasb", "authorization", "operations", "write", ",", "\"", "set", "x", "attr", "\"", ",", "absolute", "path", ")", ";", "string", "key", "=", "path", "to", "key", "(", "absolute", "path", ")", ";", "file", "metadata", "metadata", ";", "try", "{", "metadata", "=", "store", "retrieve", "metadata", "(", "key", ")", ";", "}", "catch", "(", "i", "o", "exception", "ex", ")", "{", "throwable", "inner", "exception", "=", "native", "azure", "file", "system", "helper", "check", "for", "azure", "storage", "exception", "(", "ex", ")", ";", "if", "(", "inner", "exception", "instanceof", "storage", "exception", "&", "&", "native", "azure", "file", "system", "helper", "is", "file", "not", "found", "exception", "(", "(", "storage", "exception", ")", "inner", "exception", ")", ")", "{", "throw", "new", "file", "not", "found", "exception", "(", "\"", "file", "\"", "+", "path", "+", "\"", "doesn", "'", "t", "exists", "\"", ")", ";", "}", "throw", "ex", ";", "}", "if", "(", "metadata", "=", "=", "null", ")", "{", "throw", "new", "file", "not", "found", "exception", "(", "\"", "file", "doesn", "'", "t", "exist", ":", "\"", "+", "path", ")", ";", "}", "boolean", "x", "attr", "exists", "=", "store", "retrieve", "attribute", "(", "key", ",", "x", "attr", "name", ")", "!", "=", "null", ";", "x", "attr", "set", "flag", "validate", "(", "x", "attr", "name", ",", "x", "attr", "exists", ",", "flag", ")", ";", "store", "store", "attribute", "(", "key", ",", "x", "attr", "name", ",", "value", ")", ";", "}" ]
[ "returns", "the", "generated", "rsa", "private", "key" ]
[ "public", "private", "key", "key", "(", ")", "{", "return", "key", ";", "}" ]
[ "resizes", "reservations", "based", "on", "currently", "available", "resources" ]
[ "private", "resource", "calculate", "reservation", "to", "plan", "proportion", "(", "resource", "calculator", "resc", "calculator", ",", "resource", "available", "plan", "resources", ",", "resource", "total", "reservation", "resources", ",", "resource", "reservation", "resources", ")", "{", "return", "resources", "multiply", "(", "available", "plan", "resources", ",", "resources", "ratio", "(", "resc", "calculator", ",", "reservation", "resources", ",", "total", "reservation", "resources", ")", ")", ";", "}" ]
[ "return", "the", "{", "@", "link", "configurable", "conversion", "service", "}", "used", "when", "performing", "type", "conversions", "on", "properties", "the", "configurable", "nature", "of", "the", "returned", "conversion", "service", "allows", "for", "the", "convenient", "addition", "and", "removal", "of", "individual", "{", "@", "code", "converter", "}", "instances", ":", "<", "pre", "class", "=", "\"", "code", "\"", ">", "configurable", "conversion", "service", "cs", "=", "env", "get", "conversion", "service", "(", ")", ";", "cs", "add", "converter", "(", "new", "foo", "converter", "(", ")", ")", ";" ]
[ "configurable", "conversion", "service", "get", "conversion", "service", "(", ")", ";" ]
[ "returns", "the", "data", "type", "access", "portion", "of", "this", "variable", "offset", "as", "a", "string" ]
[ "public", "string", "get", "data", "type", "display", "text", "(", ")", "{", "list", "<", "object", ">", "objects", "=", "get", "objects", "(", "false", ")", ";", "label", "string", "label", "string", "=", "(", "label", "string", ")", "objects", "get", "(", "0", ")", ";", "return", "label", "string", "to", "string", "(", ")", ";", "}" ]
[ "short", "array", "merger", "test" ]
[ "public", "void", "test", "short", "array", "merger", "(", ")", "{", "short", "[", "]", "array", "one", "=", "{", "1", ",", "2", "}", ";", "short", "[", "]", "array", "two", "=", "{", "2", ",", "34", "}", ";", "short", "[", "]", "result", "=", "merger", "factory", "get", "merger", "(", "short", "[", "]", "class", ")", "merge", "(", "array", "one", ",", "array", "two", ",", "null", ")", ";", "assertions", "assert", "equals", "(", "4", ",", "result", "length", ")", ";", "double", "[", "]", "merged", "result", "=", "{", "1", ",", "2", ",", "2", ",", "34", "}", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "merged", "result", "length", ";", "i", "+", "+", ")", "{", "assertions", "assert", "equals", "(", "merged", "result", "[", "i", "]", ",", "result", "[", "i", "]", ",", "0", "0", ")", ";", "}", "result", "=", "merger", "factory", "get", "merger", "(", "short", "[", "]", "class", ")", "merge", "(", "null", ")", ";", "assertions", "assert", "equals", "(", "0", ",", "result", "length", ")", ";", "result", "=", "merger", "factory", "get", "merger", "(", "short", "[", "]", "class", ")", "merge", "(", "null", ",", "null", ")", ";", "assertions", "assert", "equals", "(", "0", ",", "result", "length", ")", ";", "}" ]
[ "set", "the", "operand", "text", "and", "attributes" ]
[ "private", "void", "set", "operand", "attributes", "(", "int", "op", "index", ",", "string", "operand", "text", ")", "{", "operand", "labels", "[", "op", "index", "]", "set", "text", "(", "operand", "text", ")", ";", "operand", "labels", "[", "op", "index", "]", "set", "foreground", "(", "get", "operand", "color", "(", "op", "index", ")", ")", ";", "if", "(", "active", "index", "=", "=", "op", "index", ")", "{", "operand", "labels", "[", "op", "index", "]", "set", "border", "(", "etched", "border", ")", ";", "operand", "labels", "[", "op", "index", "]", "set", "background", "(", "edit", "references", "provider", "highlight", "color", ")", ";", "operand", "labels", "[", "op", "index", "]", "set", "opaque", "(", "true", ")", ";", "}", "else", "{", "operand", "labels", "[", "op", "index", "]", "set", "background", "(", "get", "parent", "(", ")", "get", "background", "(", ")", ")", ";", "operand", "labels", "[", "op", "index", "]", "set", "border", "(", "empty", "border", ")", ";", "operand", "labels", "[", "op", "index", "]", "set", "opaque", "(", "false", ")", ";", "}", "}" ]
[ "this", "is", "a", "generic", "method", "for", "displaying", "the", "contents", "of", "the", "error", "buffer", "to", "the", "user" ]
[ "void", "show", "resolve", "errors", "(", ")", "{", "if", "(", "error", "buf", "length", "(", ")", ">", "0", ")", "{", "try", "{", "swing", "utilities", "invoke", "and", "wait", "(", "new", "runnable", "(", ")", "{", "@", "override", "public", "void", "run", "(", ")", "{", "string", "title", "=", "get", "conflict", "type", "(", ")", "+", "\"", "merge", "errors", "\"", ";", "string", "msg", "=", "error", "buf", "to", "string", "(", ")", ";", "read", "text", "dialog", "dialog", "=", "new", "read", "text", "dialog", "(", "title", ",", "msg", ")", ";", "plugin", "tool", "merge", "tool", "=", "merge", "manager", "get", "merge", "tool", "(", ")", ";", "merge", "manager", "get", "merge", "tool", "(", ")", "show", "dialog", "(", "dialog", ",", "merge", "tool", "get", "active", "window", "(", ")", ")", ";", "}", "}", ")", ";", "}", "catch", "(", "interrupted", "exception", "e", ")", "{", "throw", "new", "assert", "exception", "(", "e", ")", ";", "}", "catch", "(", "invocation", "target", "exception", "e", ")", "{", "throw", "new", "assert", "exception", "(", "e", ")", ";", "}", "}", "}" ]
[ "{", "@", "inherit", "doc", "}", "the", "default", "implementation", "does", "nothing" ]
[ "@", "override", "public", "void", "exit", "named", "value", "expression", "(", "sql", "base", "parser", "named", "value", "expression", "context", "ctx", ")", "{", "}" ]
[ "returns", "an", "input", "stream", "for", "the", "given", "test", "class", "and", "sub", "-", "path" ]
[ "public", "static", "input", "stream", "open", "resource", "(", "class", "<", "?", ">", "test", "class", ",", "string", "sub", "path", ")", "{", "return", "test", "class", "get", "resource", "as", "stream", "(", "\"", "/", "\"", "+", "sub", "path", ")", ";", "}" ]
[ "get", "the", "index", "table", "for", "a", "specified", "index", "table", "record" ]
[ "static", "index", "table", "get", "index", "table", "(", "d", "b", "handle", "db", ",", "table", "record", "index", "table", "record", ")", "throws", "i", "o", "exception", "{", "string", "name", "=", "index", "table", "record", "get", "name", "(", ")", ";", "table", "primary", "table", "=", "db", "get", "table", "(", "name", ")", ";", "if", "(", "primary", "table", "=", "=", "null", ")", "{", "throw", "new", "assert", "exception", "(", "\"", "table", "not", "found", ":", "\"", "+", "name", ")", ";", "}", "field", "key", "field", "type", "=", "index", "table", "record", "get", "schema", "(", ")", "get", "key", "field", "type", "(", ")", ";", "if", "(", "key", "field", "type", "instanceof", "index", "field", ")", "{", "return", "new", "field", "index", "table", "(", "primary", "table", ",", "index", "table", "record", ")", ";", "}", "throw", "new", "assert", "exception", "(", "\"", "unexpected", "index", "field", "type", ":", "\"", "+", "key", "field", "type", "get", "class", "(", ")", "get", "name", "(", ")", ")", ";", "}" ]
[ "returns", "the", "jar", "containing", "source", "files", "derived", "from", "the", "aidl", "files", "will", "be", "null", "if", "there", "are", "no", "idl", "srcs" ]
[ "public", "artifact", "get", "idl", "source", "jar", "(", ")", "{", "return", "idl", "source", "jar", ";", "}" ]
[ "use", "get", "state", "(", ")", "instead" ]
[ "public", "string", "get", "queue", "state", "(", ")", "{", "return", "super", "get", "state", "(", ")", "to", "string", "(", ")", ";", "}" ]
[ "write", "a", "transaction", "to", "the", "stream", "the", "serialization", "format", "is", ":", "the", "opcode", "(", "byte", ")", "the", "transaction", "id", "(", "long", ")", "the", "actual", "writables", "for", "the", "transaction" ]
[ "public", "void", "write", "raw", "(", "byte", "[", "]", "bytes", ",", "int", "offset", ",", "int", "length", ")", "throws", "i", "o", "exception", "{", "double", "buf", "write", "raw", "(", "bytes", ",", "offset", ",", "length", ")", ";", "}" ]
[ "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", "\"", ")", ";", "}" ]
[ "merges", "the", "options", "part", "of", "{", "@", "code", "create", "table", "}", "statement" ]
[ "public", "map", "<", "string", ",", "string", ">", "merge", "options", "(", "merging", "strategy", "merging", "strategy", ",", "map", "<", "string", ",", "string", ">", "source", "options", ",", "map", "<", "string", ",", "string", ">", "derived", "options", ")", "{", "map", "<", "string", ",", "string", ">", "options", "=", "new", "hash", "map", "<", ">", "(", ")", ";", "if", "(", "merging", "strategy", "!", "=", "merging", "strategy", "excluding", ")", "{", "options", "put", "all", "(", "source", "options", ")", ";", "}", "derived", "options", "for", "each", "(", "(", "key", ",", "value", ")", "-", ">", "{", "if", "(", "merging", "strategy", "!", "=", "merging", "strategy", "overwriting", "&", "&", "options", "contains", "key", "(", "key", ")", ")", "{", "throw", "new", "validation", "exception", "(", "string", "format", "(", "\"", "there", "already", "exists", "an", "option", "[", "'", "%", "s", "'", "-", ">", "'", "%", "s", "'", "]", "in", "the", "\"", "+", "\"", "base", "table", "you", "might", "want", "to", "specify", "excluding", "options", "or", "overwriting", "options", "\"", ",", "key", ",", "options", "get", "(", "key", ")", ")", ")", ";", "}", "options", "put", "(", "key", ",", "value", ")", ";", "}", ")", ";", "return", "options", ";", "}" ]
[ "returns", "whether", "the", "target", "has", "transitive", "sources", "requiring", "python", "2", "if", "the", "target", "has", "a", "py", "provider", ",", "the", "value", "from", "that", "provider", "is", "used", "otherwise", ",", "we", "default", "to", "false" ]
[ "public", "static", "boolean", "get", "has", "py", "2", "only", "sources", "(", "transitive", "info", "collection", "target", ")", "throws", "eval", "exception", "{", "if", "(", "has", "modern", "provider", "(", "target", ")", ")", "{", "return", "get", "modern", "provider", "(", "target", ")", "get", "has", "py", "2", "only", "sources", "(", ")", ";", "}", "else", "if", "(", "has", "legacy", "provider", "(", "target", ")", ")", "{", "return", "py", "struct", "utils", "get", "has", "py", "2", "only", "sources", "(", "get", "legacy", "provider", "(", "target", ")", ")", ";", "}", "else", "{", "return", "false", ";", "}", "}" ]
[ "ignore", "the", "given", "dependency", "interface", "for", "autowiring", "this", "will", "typically", "be", "used", "by", "application", "contexts", "to", "register", "dependencies", "that", "are", "resolved", "in", "other", "ways", ",", "like", "bean", "factory", "through", "bean", "factory", "aware", "or", "application", "context", "through", "application", "context", "aware", "by", "default", ",", "only", "the", "bean", "factory", "aware", "interface", "is", "ignored", "for", "further", "types", "to", "ignore", ",", "invoke", "this", "method", "for", "each", "type" ]
[ "void", "ignore", "dependency", "interface", "(", "class", "<", "?", ">", "ifc", ")", ";" ]
[ "gets", "the", "context", "for", "the", "given", "event" ]
[ "private", "subscriber", "exception", "context", "context", "(", "object", "event", ")", "{", "return", "new", "subscriber", "exception", "context", "(", "bus", ",", "event", ",", "target", ",", "method", ")", ";", "}" ]
[ "maps", "only", "source", "registers" ]
[ "abstract", "public", "void", "map", "source", "registers", "(", "register", "mapper", "mapper", ")", ";" ]
[ "make", "the", "distance", "of", "node", "a", "at", "least", "as", "far", "as", "node", "b", "by", "adding", "edges", "from", "all", "inputs", "of", "node", "b", "to", "node", "a" ]
[ "void", "make", "as", "far", "as", "(", "exec", "node", "<", "?", ">", "a", ",", "exec", "node", "<", "?", ">", "b", ")", "{", "topology", "node", "node", "a", "=", "get", "or", "create", "topology", "node", "(", "a", ")", ";", "topology", "node", "node", "b", "=", "get", "or", "create", "topology", "node", "(", "b", ")", ";", "for", "(", "topology", "node", "input", ":", "node", "b", "inputs", ")", "{", "link", "(", "input", "exec", "node", ",", "node", "a", "exec", "node", ")", ";", "}", "}" ]
[ "wait", "until", "the", "cluster", "is", "active", "and", "running" ]
[ "public", "void", "wait", "active", "(", ")", "throws", "i", "o", "exception", "{", "for", "(", "int", "index", "=", "0", ";", "index", "<", "namenodes", "size", "(", ")", ";", "index", "+", "+", ")", "{", "int", "failed", "count", "=", "0", ";", "while", "(", "true", ")", "{", "try", "{", "wait", "active", "(", "index", ")", ";", "break", ";", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "failed", "count", "+", "+", ";", "/", "/", "cached", "rpc", "connection", "to", "namenode", ",", "if", "any", ",", "is", "expected", "to", "fail", "once", "if", "(", "failed", "count", ">", "1", ")", "{", "log", "warn", "(", "\"", "tried", "wait", "active", "(", ")", "\"", "+", "failed", "count", "+", "\"", "time", "(", "s", ")", "and", "failed", ",", "giving", "up", "\"", "+", "string", "utils", "stringify", "exception", "(", "e", ")", ")", ";", "throw", "e", ";", "}", "}", "}", "}", "log", "info", "(", "\"", "cluster", "is", "active", "\"", ")", ";", "}" ]
[ "the", "largest", "integer", "allowed", "for", "this", "xml", "attribute", "only", "makes", "sense", "if", "the", "format", "includes", "format", "flags", ":", ":", "integer", "<", "code", ">", "optional", "int", "3", "2", "max", "int", "=", "3", ";", "<", "code", ">" ]
[ "public", "builder", "set", "max", "int", "(", "int", "value", ")", "{", "copy", "on", "write", "(", ")", ";", "instance", "set", "max", "int", "(", "value", ")", ";", "return", "this", ";", "}" ]
[ "this", "implementation", "checks", "for", "{", "@", "link", "order", "@", "order", "}", "or", "{", "@", "link", "javax", "annotation", "priority", "@", "priority", "}", "on", "various", "kinds", "of", "elements", ",", "in", "addition", "to", "the", "{", "@", "link", "org", "springframework", "core", "ordered", "}", "check", "in", "the", "superclass" ]
[ "protected", "integer", "find", "order", "(", "object", "obj", ")", "{", "integer", "order", "=", "super", "find", "order", "(", "obj", ")", ";", "if", "(", "order", "!", "=", "null", ")", "{", "return", "order", ";", "}", "return", "find", "order", "from", "annotation", "(", "obj", ")", ";", "}" ]
[ "returns", "the", "value", "associated", "with", "the", "given", "config", "option", "as", "an", "integer" ]
[ "public", "int", "get", "integer", "(", "config", "option", "<", "integer", ">", "config", "option", ")", "{", "return", "get", "optional", "(", "config", "option", ")", "or", "else", "get", "(", "config", "option", ":", ":", "default", "value", ")", ";", "}" ]
[ "get", "integer", "prop" ]
[ "public", "integer", "get", "integer", "prop", "(", ")", "{", "return", "integer", "prop", "or", "else", "(", "null", ")", ";", "}" ]
[ "returns", "a", "array", "of", "resource", "files", "if", "this", "resource", "file", "is", "a", "directory", "otherwise", "return", "null" ]
[ "public", "resource", "file", "[", "]", "list", "files", "(", ")", "{", "return", "resource", "list", "files", "(", ")", ";", "}" ]
[ "get", "the", "unique", "symbol", "that", "is", "assigned", "an", "rvalue", "matched", "by", "the", "rvalue", "matcher", "in", "node", "rvalue", "matchers", "can", "match", "anything", "that", "can", "be", "assigned", "to", "a", "symbol", ",", "and", "may", "be", "specialized", "based", "on", "the", "type", "of", "the", "node", "or", "the", "type", "of", "the", "value", "that", "is", "being", "assigned", "for", "example", ",", "table", "scan", "nodes", "assign", "column", "handles", "to", "symbols", "and", "aggregation", "nodes", "assign", "function", "calls", "to", "symbols", "the", "assigned", "symbol", "is", "identified", "by", "matching", "the", "value", "on", "the", "right", "side", "of", "the", "assignment", ";", "the", "rvalue", "if", "no", "match", "is", "found", "in", "the", "node", ",", "get", "assigned", "symbol", "must", "return", "optional", "empty", "(", ")" ]
[ "optional", "<", "variable", "reference", "expression", ">", "get", "assigned", "variable", "(", "plan", "node", "node", ",", "session", "session", ",", "metadata", "metadata", ",", "symbol", "aliases", "symbol", "aliases", ")", ";" ]
[ "initialize", "the", "capacity", "information", "of", "the", "tenant", "if", "the", "quota", "is", "reached", ",", "the", "capacity", "will", "be", "automatically", "expanded", "to", "reduce", "the", "operation", "and", "maintenance", "cost" ]
[ "public", "boolean", "init", "tenant", "capacity", "(", "string", "tenant", ",", "integer", "quota", ",", "integer", "max", "size", ",", "integer", "max", "aggr", "count", ",", "integer", "max", "aggr", "size", ")", "{", "boolean", "insert", "success", "=", "insert", "tenant", "capacity", "(", "tenant", ",", "quota", ",", "max", "size", ",", "max", "aggr", "count", ",", "max", "aggr", "size", ")", ";", "if", "(", "quota", "!", "=", "null", ")", "{", "return", "insert", "success", ";", "}", "auto", "expansion", "(", "null", ",", "tenant", ")", ";", "return", "insert", "success", ";", "}" ]
[ "programmatically", "move", "the", "wizard", "back", "one", "panel", "simulates", "the", "user", "clicking", "on", "the", "'", "back", "'", "button", "returns", "true", "if", "not", "on", "the", "first", "panel" ]
[ "public", "boolean", "back", "(", ")", "{", "if", "(", "back", "button", "is", "enabled", "(", ")", ")", "{", "try", "{", "set", "current", "panel", "(", "panel", "mgr", "get", "previous", "panel", "(", ")", ")", ";", "}", "catch", "(", "illegal", "panel", "state", "exception", "e", ")", "{", "if", "(", "!", "handle", "illegal", "state", "exception", "(", "e", ",", "false", ")", ")", "{", "return", "false", ";", "}", "}", "string", "msg", "=", "panel", "mgr", "get", "status", "message", "(", ")", ";", "if", "(", "msg", "!", "=", "null", ")", "{", "set", "status", "message", "(", "msg", ")", ";", "}", "return", "true", ";", "}", "return", "false", ";", "}" ]
[ "transfer", "the", "received", "file", "to", "the", "given", "destination", "file", "the", "default", "implementation", "simply", "copies", "the", "file", "input", "stream" ]
[ "default", "void", "transfer", "to", "(", "path", "dest", ")", "throws", "i", "o", "exception", ",", "illegal", "state", "exception", "{", "file", "copy", "utils", "copy", "(", "get", "input", "stream", "(", ")", ",", "files", "new", "output", "stream", "(", "dest", ")", ")", ";", "}" ]
[ "creates", "a", "failing", "license", "check", "encapsulating", "the", "specified", "remote", "cluster", "license", "info" ]
[ "public", "static", "license", "check", "failure", "(", "final", "remote", "cluster", "license", "info", "remote", "cluster", "license", "info", ")", "{", "return", "new", "license", "check", "(", "remote", "cluster", "license", "info", ")", ";", "}" ]
[ "set", "optional", "builder", "parameter" ]
[ "public", "b", "opt", "(", "@", "nonnull", "final", "string", "key", ",", "@", "nonnull", "final", "string", "value", ")", "{", "mandatory", "keys", "remove", "(", "key", ")", ";", "options", "set", "(", "key", ",", "value", ")", ";", "return", "get", "this", "builder", "(", ")", ";", "}" ]
[ "returns", "the", "annotations", "table", "of", "a", "single", "runtime", "-", "visible", "annotation", "on", "a", "program", "element" ]
[ "public", "annotation", "java", "[", "]", "get", "annotations", "(", ")", "{", "return", "annotations", ";", "}" ]
[ "execute", "a", "{", "@", "link", "file", "system", "#", "rename", "(", "path", ",", "path", ")", "}", ",", "and", "verify", "that", "the", "outcome", "was", "as", "expected", "there", "is", "no", "preflight", "checking", "of", "arguments", ";", "everything", "is", "left", "to", "the", "rename", "(", ")", "command" ]
[ "public", "static", "void", "assert", "rename", "outcome", "(", "file", "system", "fs", ",", "path", "source", ",", "path", "dest", ",", "boolean", "expected", "result", ")", "throws", "i", "o", "exception", "{", "boolean", "result", "=", "fs", "rename", "(", "source", ",", "dest", ")", ";", "if", "(", "expected", "result", "!", "=", "result", ")", "{", "fail", "(", "string", "format", "(", "\"", "expected", "rename", "(", "%", "s", ",", "%", "s", ")", "to", "return", "%", "b", ",", "\"", "+", "\"", "but", "result", "was", "%", "b", "\"", ",", "source", ",", "dest", ",", "expected", "result", ",", "result", ")", ")", ";", "}", "}" ]
[ "gets", "the", "rotation", "in", "radians" ]
[ "public", "float", "get", "rotation", "(", ")", "{", "if", "(", "m", "detector", "get", "pointer", "count", "(", ")", "<", "2", ")", "{", "return", "0", ";", "}", "else", "{", "float", "start", "delta", "x", "=", "m", "detector", "get", "start", "x", "(", ")", "[", "1", "]", "-", "m", "detector", "get", "start", "x", "(", ")", "[", "0", "]", ";", "float", "start", "delta", "y", "=", "m", "detector", "get", "start", "y", "(", ")", "[", "1", "]", "-", "m", "detector", "get", "start", "y", "(", ")", "[", "0", "]", ";", "float", "current", "delta", "x", "=", "m", "detector", "get", "current", "x", "(", ")", "[", "1", "]", "-", "m", "detector", "get", "current", "x", "(", ")", "[", "0", "]", ";", "float", "current", "delta", "y", "=", "m", "detector", "get", "current", "y", "(", ")", "[", "1", "]", "-", "m", "detector", "get", "current", "y", "(", ")", "[", "0", "]", ";", "float", "start", "angle", "=", "(", "float", ")", "math", "atan", "2", "(", "start", "delta", "y", ",", "start", "delta", "x", ")", ";", "float", "current", "angle", "=", "(", "float", ")", "math", "atan", "2", "(", "current", "delta", "y", ",", "current", "delta", "x", ")", ";", "return", "current", "angle", "-", "start", "angle", ";", "}", "}" ]
[ "makes", "sure", "that", "no", "job", "is", "on", "the", "job", "manager", "any", "more", "from", "any", "previous", "tests", "that", "use", "the", "same", "mini", "cluster", "otherwise", ",", "missing", "slots", "may", "happen" ]
[ "public", "void", "set", "client", "and", "ensure", "no", "job", "is", "lingering", "(", ")", "throws", "exception", "{", "client", "=", "flink", "get", "cluster", "client", "(", ")", ";", "wait", "until", "no", "job", "is", "running", "(", "client", ")", ";", "}" ]
[ "finds", "the", "index", "for", "a", "given", "key" ]
[ "private", "int", "find", "key", "(", "long", "key", ")", "{", "int", "hashcode", "=", "(", "(", "int", ")", "key", "&", "0x", "7fffffff", ")", "%", "capacity", ";", "int", "p", "=", "indexer", "first", "(", "hashcode", ")", ";", "while", "(", "p", "!", "=", "-", "1", ")", "{", "if", "(", "keys", "[", "p", "]", "=", "=", "key", ")", "{", "return", "p", ";", "}", "p", "=", "indexer", "next", "(", "p", ")", ";", "}", "return", "-", "1", ";", "}" ]
[ "get", "the", "current", "list", "or", "ranges", "that", "are", "configured", "on", "this", "aggregation" ]
[ "public", "list", "<", "range", ">", "get", "ranges", "(", ")", "{", "return", "collections", "unmodifiable", "list", "(", "ranges", ")", ";", "}" ]
[ "sends", "the", "given", "g", "r", "p", "c", "frame", "to", "the", "client" ]
[ "private", "void", "send", "grpc", "frame", "(", "channel", "handler", "context", "ctx", ",", "send", "grpc", "frame", "command", "cmd", ",", "channel", "promise", "promise", ")", "throws", "http", "2", "exception", "{", "perf", "mark", "start", "task", "(", "\"", "netty", "server", "handler", "send", "grpc", "frame", "\"", ",", "cmd", "stream", "(", ")", "tag", "(", ")", ")", ";", "perf", "mark", "link", "in", "(", "cmd", "get", "link", "(", ")", ")", ";", "try", "{", "if", "(", "cmd", "end", "stream", "(", ")", ")", "{", "close", "stream", "when", "done", "(", "promise", ",", "cmd", "stream", "(", ")", "id", "(", ")", ")", ";", "}", "/", "/", "call", "the", "base", "class", "to", "write", "the", "http", "/", "2", "data", "frame", "encoder", "(", ")", "write", "data", "(", "ctx", ",", "cmd", "stream", "(", ")", "id", "(", ")", ",", "cmd", "content", "(", ")", ",", "0", ",", "cmd", "end", "stream", "(", ")", ",", "promise", ")", ";", "}", "finally", "{", "perf", "mark", "stop", "task", "(", "\"", "netty", "server", "handler", "send", "grpc", "frame", "\"", ",", "cmd", "stream", "(", ")", "tag", "(", ")", ")", ";", "}", "}" ]
[ "is", "lockable", "boolean" ]
[ "public", "boolean", "is", "lockable", "(", ")", "{", "return", "lockable", ";", "}" ]
[ "returns", "artifacts", "needed", "to", "run", "the", "executable", "for", "this", "target" ]
[ "public", "nested", "set", "<", "artifact", ">", "get", "files", "to", "run", "(", ")", "{", "return", "files", "to", "run", ";", "}" ]
[ "returns", "the", "list", "of", "desired", "authentication", "methods" ]
[ "list", "<", "socks", "5", "auth", "method", ">", "auth", "methods", "(", ")", ";" ]
[ "helper", "to", "deal", "with", "{", "@", "code", "wide", "}" ]
[ "private", "int", "parse", "wide", "(", "int", "offset", ",", "visitor", "visitor", ")", "{", "int", "opcode", "=", "bytes", "get", "unsigned", "byte", "(", "offset", "+", "1", ")", ";", "int", "idx", "=", "bytes", "get", "unsigned", "short", "(", "offset", "+", "2", ")", ";", "switch", "(", "opcode", ")", "{", "case", "byte", "ops", "iload", ":", "{", "visitor", "visit", "local", "(", "byte", "ops", "iload", ",", "offset", ",", "4", ",", "idx", ",", "type", "int", ",", "0", ")", ";", "return", "4", ";", "}", "case", "byte", "ops", "lload", ":", "{", "visitor", "visit", "local", "(", "byte", "ops", "iload", ",", "offset", ",", "4", ",", "idx", ",", "type", "long", ",", "0", ")", ";", "return", "4", ";", "}", "case", "byte", "ops", "fload", ":", "{", "visitor", "visit", "local", "(", "byte", "ops", "iload", ",", "offset", ",", "4", ",", "idx", ",", "type", "float", ",", "0", ")", ";", "return", "4", ";", "}", "case", "byte", "ops", "dload", ":", "{", "visitor", "visit", "local", "(", "byte", "ops", "iload", ",", "offset", ",", "4", ",", "idx", ",", "type", "double", ",", "0", ")", ";", "return", "4", ";", "}", "case", "byte", "ops", "aload", ":", "{", "visitor", "visit", "local", "(", "byte", "ops", "iload", ",", "offset", ",", "4", ",", "idx", ",", "type", "object", ",", "0", ")", ";", "return", "4", ";", "}", "case", "byte", "ops", "istore", ":", "{", "visitor", "visit", "local", "(", "byte", "ops", "istore", ",", "offset", ",", "4", ",", "idx", ",", "type", "int", ",", "0", ")", ";", "return", "4", ";", "}", "case", "byte", "ops", "lstore", ":", "{", "visitor", "visit", "local", "(", "byte", "ops", "istore", ",", "offset", ",", "4", ",", "idx", ",", "type", "long", ",", "0", ")", ";", "return", "4", ";", "}", "case", "byte", "ops", "fstore", ":", "{", "visitor", "visit", "local", "(", "byte", "ops", "istore", ",", "offset", ",", "4", ",", "idx", ",", "type", "float", ",", "0", ")", ";", "return", "4", ";", "}", "case", "byte", "ops", "dstore", ":", "{", "visitor", "visit", "local", "(", "byte", "ops", "istore", ",", "offset", ",", "4", ",", "idx", ",", "type", "double", ",", "0", ")", ";", "return", "4", ";", "}", "case", "byte", "ops", "astore", ":", "{", "visitor", "visit", "local", "(", "byte", "ops", "istore", ",", "offset", ",", "4", ",", "idx", ",", "type", "object", ",", "0", ")", ";", "return", "4", ";", "}", "case", "byte", "ops", "ret", ":", "{", "visitor", "visit", "local", "(", "opcode", ",", "offset", ",", "4", ",", "idx", ",", "type", "return", "address", ",", "0", ")", ";", "return", "4", ";", "}", "case", "byte", "ops", "iinc", ":", "{", "int", "value", "=", "bytes", "get", "short", "(", "offset", "+", "4", ")", ";", "visitor", "visit", "local", "(", "opcode", ",", "offset", ",", "6", ",", "idx", ",", "type", "int", ",", "value", ")", ";", "return", "6", ";", "}", "default", ":", "{", "visitor", "visit", "invalid", "(", "byte", "ops", "wide", ",", "offset", ",", "1", ")", ";", "return", "1", ";", "}", "}", "}" ]
[ "returns", "the", "head", "of", "the", "pending", "queue", ",", "or", "{", "@", "code", "null", "}", "if", "empty" ]
[ "private", "flow", "controlled", "peek", "(", ")", "{", "return", "pending", "write", "queue", "peek", "(", ")", ";", "}" ]
[ "{", "@", "inherit", "doc", "}", "this", "implementation", "returns", "the", "hash", "code", "of", "{", "@", "link", "multiset", "#", "entry", "set", "(", ")", "}" ]
[ "public", "final", "int", "hash", "code", "(", ")", "{", "return", "entry", "set", "(", ")", "hash", "code", "(", ")", ";", "}" ]
[ "return", "an", "array", "of", "the", "last", "plugin", "events", "fired", "event", "manager", "maps", "the", "event", "class", "to", "the", "last", "event", "fired" ]
[ "public", "plugin", "event", "[", "]", "get", "last", "events", "(", ")", "{", "return", "last", "events", "by", "type", "values", "(", ")", "to", "array", "(", "new", "plugin", "event", "[", "last", "events", "by", "type", "size", "(", ")", "]", ")", ";", "}" ]
[ "removes", "record", "of", "running", "snapshot", "from", "cluster", "state", "and", "notifies", "the", "listener", "when", "this", "action", "is", "complete", "this", "method", "is", "only", "used", "when", "the", "snapshot", "fails", "for", "some", "reason", "during", "normal", "operation", "the", "snapshot", "repository", "will", "remove", "the", "{", "@", "link", "snapshots", "in", "progress", "entry", "}", "from", "the", "cluster", "state", "once", "it", "'", "s", "done", "finalizing", "the", "snapshot" ]
[ "private", "void", "remove", "failed", "snapshot", "from", "cluster", "state", "(", "snapshot", "snapshot", ",", "exception", "failure", ",", "@", "nullable", "repository", "data", "repository", "data", ")", "{", "assert", "failure", "!", "=", "null", ":", "\"", "failure", "must", "be", "supplied", "\"", ";", "cluster", "service", "submit", "state", "update", "task", "(", "\"", "remove", "snapshot", "metadata", "\"", ",", "new", "cluster", "state", "update", "task", "(", ")", "{", "@", "override", "public", "cluster", "state", "execute", "(", "cluster", "state", "current", "state", ")", "{", "final", "cluster", "state", "updated", "state", "=", "state", "without", "snapshot", "(", "current", "state", ",", "snapshot", ")", ";", "/", "/", "now", "check", "if", "there", "are", "any", "delete", "operations", "that", "refer", "to", "the", "just", "failed", "snapshot", "and", "remove", "the", "snapshot", "from", "them", "return", "update", "with", "snapshots", "(", "updated", "state", ",", "null", ",", "deletions", "without", "snapshots", "(", "updated", "state", "custom", "(", "snapshot", "deletions", "in", "progress", "type", ",", "snapshot", "deletions", "in", "progress", "empty", ")", ",", "collections", "singleton", "list", "(", "snapshot", "get", "snapshot", "id", "(", ")", ")", ",", "snapshot", "get", "repository", "(", ")", ")", ")", ";", "}", "@", "override", "public", "void", "on", "failure", "(", "string", "source", ",", "exception", "e", ")", "{", "logger", "warn", "(", "(", ")", "-", ">", "new", "parameterized", "message", "(", "\"", "[", "{", "}", "]", "failed", "to", "remove", "snapshot", "metadata", "\"", ",", "snapshot", ")", ",", "e", ")", ";", "fail", "snapshot", "completion", "listeners", "(", "snapshot", ",", "new", "snapshot", "exception", "(", "snapshot", ",", "\"", "failed", "to", "remove", "snapshot", "from", "cluster", "state", "\"", ",", "e", ")", ")", ";", "fail", "all", "listeners", "on", "master", "fail", "over", "(", "e", ")", ";", "}", "@", "override", "public", "void", "on", "no", "longer", "master", "(", "string", "source", ")", "{", "failure", "add", "suppressed", "(", "new", "snapshot", "exception", "(", "snapshot", ",", "\"", "no", "longer", "master", "\"", ")", ")", ";", "fail", "snapshot", "completion", "listeners", "(", "snapshot", ",", "failure", ")", ";", "fail", "all", "listeners", "on", "master", "fail", "over", "(", "new", "not", "master", "exception", "(", "source", ")", ")", ";", "}", "@", "override", "public", "void", "cluster", "state", "processed", "(", "string", "source", ",", "cluster", "state", "old", "state", ",", "cluster", "state", "new", "state", ")", "{", "fail", "snapshot", "completion", "listeners", "(", "snapshot", ",", "failure", ")", ";", "if", "(", "repository", "data", "!", "=", "null", ")", "{", "run", "next", "queued", "operation", "(", "repository", "data", ",", "snapshot", "get", "repository", "(", ")", ",", "true", ")", ";", "}", "}", "}", ")", ";", "}" ]
[ "returns", "the", "associated", "key", "type" ]
[ "public", "class", "<", "k", ">", "key", "type", "(", ")", "{", "return", "key", "type", ";", "}" ]
[ "callback", "on", "job", "execution", "finished", ",", "successfully", "or", "unsuccessfully", "it", "is", "only", "called", "back", "when", "you", "call", "{", "@", "code", "execute", "(", ")", "}", "instead", "of", "{", "@", "code", "execute", "async", "(", ")", "}", "methods", "of", "execution", "environments", "exactly", "one", "of", "the", "passed", "parameters", "is", "null", ",", "respectively", "for", "failure", "or", "success" ]
[ "void", "on", "job", "executed", "(", "@", "nullable", "job", "execution", "result", "job", "execution", "result", ",", "@", "nullable", "throwable", "throwable", ")", ";" ]
[ "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", "\"", ")", ";", "}" ]
[ "asserts", "that", "an", "extractor", "consumes", "valid", "input", "data", "successfully", "under", "the", "conditions", "specified", "by", "{", "@", "code", "simulation", "config", "}", "the", "output", "of", "the", "extractor", "is", "compared", "against", "prerecorded", "dump", "files", "whose", "names", "are", "derived", "from", "the", "{", "@", "code", "file", "}", "parameter", "as", "specified", "in", "the", "docs", "for", "{", "@", "link", "assertion", "config", "#", "dump", "files", "prefix", "}" ]
[ "public", "static", "void", "assert", "behavior", "(", "extractor", "factory", "factory", ",", "string", "file", ",", "simulation", "config", "simulation", "config", ")", "throws", "i", "o", "exception", "{", "assert", "behavior", "(", "factory", ",", "file", ",", "new", "assertion", "config", "builder", "(", ")", "build", "(", ")", ",", "simulation", "config", ")", ";", "}" ]
[ "load", "ssl", "properties", "from", "the", "ssl", "configuration" ]
[ "private", "void", "load", "s", "s", "l", "configuration", "(", ")", "throws", "i", "o", "exception", "{", "if", "(", "ssl", "conf", "=", "=", "null", ")", "{", "return", ";", "}", "needs", "client", "auth", "=", "ssl", "conf", "get", "boolean", "(", "s", "s", "l", "factory", "ssl", "server", "need", "client", "auth", ",", "s", "s", "l", "factory", "ssl", "server", "need", "client", "auth", "default", ")", ";", "key", "store", "=", "ssl", "conf", "get", "trimmed", "(", "s", "s", "l", "factory", "ssl", "server", "keystore", "location", ")", ";", "if", "(", "key", "store", "=", "=", "null", "|", "|", "key", "store", "is", "empty", "(", ")", ")", "{", "throw", "new", "i", "o", "exception", "(", "string", "format", "(", "\"", "property", "%", "s", "not", "specified", "\"", ",", "s", "s", "l", "factory", "ssl", "server", "keystore", "location", ")", ")", ";", "}", "key", "store", "password", "=", "get", "password", "string", "(", "ssl", "conf", ",", "s", "s", "l", "factory", "ssl", "server", "keystore", "password", ")", ";", "if", "(", "key", "store", "password", "=", "=", "null", ")", "{", "throw", "new", "i", "o", "exception", "(", "string", "format", "(", "\"", "property", "%", "s", "not", "specified", "\"", ",", "s", "s", "l", "factory", "ssl", "server", "keystore", "password", ")", ")", ";", "}", "key", "store", "type", "=", "ssl", "conf", "get", "(", "s", "s", "l", "factory", "ssl", "server", "keystore", "type", ",", "s", "s", "l", "factory", "ssl", "server", "keystore", "type", "default", ")", ";", "key", "password", "=", "get", "password", "string", "(", "ssl", "conf", ",", "s", "s", "l", "factory", "ssl", "server", "keystore", "keypassword", ")", ";", "trust", "store", "=", "ssl", "conf", "get", "(", "s", "s", "l", "factory", "ssl", "server", "truststore", "location", ")", ";", "trust", "store", "password", "=", "get", "password", "string", "(", "ssl", "conf", ",", "s", "s", "l", "factory", "ssl", "server", "truststore", "password", ")", ";", "trust", "store", "type", "=", "ssl", "conf", "get", "(", "s", "s", "l", "factory", "ssl", "server", "truststore", "type", ",", "s", "s", "l", "factory", "ssl", "server", "truststore", "type", "default", ")", ";", "exclude", "ciphers", "=", "ssl", "conf", "get", "(", "s", "s", "l", "factory", "ssl", "server", "exclude", "cipher", "list", ")", ";", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "item", "type", "item", "type", "(", ")", "{", "return", "item", "type", "type", "string", "id", "item", ";", "}" ]
[ "returns", "a", "new", "{", "@", "code", "type", "resolver", "}", "with", "{", "@", "code", "variable", "}", "mapping", "to", "{", "@", "code", "type", "}" ]
[ "type", "resolver", "where", "(", "map", "<", "type", "variable", "key", ",", "?", "extends", "type", ">", "mappings", ")", "{", "return", "new", "type", "resolver", "(", "type", "table", "where", "(", "mappings", ")", ")", ";", "}" ]
[ "sets", "the", "phrase", "slop", "for", "this", "query" ]
[ "public", "void", "set", "slop", "(", "int", "s", ")", "{", "slop", "=", "s", ";", "}" ]
[ "set", "whether", "the", "containers", "that", "are", "started", "by", "this", "client", ",", "and", "are", "still", "running", "should", "be", "stopped", "when", "the", "client", "stops", "by", "default", ",", "the", "feature", "should", "be", "enabled", "however", ",", "containers", "will", "be", "stopped", "only", "when", "service", "is", "stopped", "i", "e", "after", "{", "@", "link", "n", "m", "client", "#", "stop", "(", ")", "}" ]
[ "public", "abstract", "void", "cleanup", "running", "containers", "on", "stop", "(", "boolean", "enabled", ")", ";" ]
[ "test", "finding", "resources", "via", "dependency", "class", "loader" ]
[ "public", "void", "test", "dependency", "class", "loader", "(", ")", "throws", "exception", "{", "/", "/", "test", "data", "has", ":", "foo", "3", "depends", "on", "foo", "2", ",", "foo", "1", ";", "foo", "2", "depends", "on", "foo", "1", "/", "/", "(", "thus", "find", "resources", "from", "foo", "3", "can", "find", "foo", "1", "resources", "via", "2", "dependency", "paths", ")", "plugin", "wrapper", "p", "=", "jenkins", "get", "plugin", "manager", "(", ")", "get", "plugin", "(", "\"", "foo", "3", "\"", ")", ";", "string", "res", ";", "/", "/", "in", "the", "current", "impl", ",", "the", "dependencies", "are", "the", "parent", "class", "loader", "so", "resources", "/", "/", "are", "found", "there", "before", "checking", "the", "plugin", "itself", "adjust", "the", "expected", "results", "/", "/", "below", "if", "this", "is", "ever", "changed", "to", "check", "the", "plugin", "first", "enumeration", "<", "url", ">", "en", "=", "p", "class", "loader", "get", "resources", "(", "\"", "test", "-", "resource", "\"", ")", ";", "for", "(", "int", "i", "=", "0", ";", "en", "has", "more", "elements", "(", ")", ";", "i", "+", "+", ")", "{", "res", "=", "en", "next", "element", "(", ")", "to", "string", "(", ")", ";", "if", "(", "i", "<", "2", ")", "assert", "true", "(", "\"", "in", "current", "impl", ",", "\"", "+", "res", "+", "\"", "should", "be", "foo", "1", "or", "foo", "2", "\"", ",", "res", "contains", "(", "\"", "/", "foo", "1", "/", "\"", ")", "|", "|", "res", "contains", "(", "\"", "/", "foo", "2", "/", "\"", ")", ")", ";", "else", "assert", "true", "(", "\"", "in", "current", "impl", ",", "\"", "+", "res", "+", "\"", "should", "be", "foo", "3", "\"", ",", "res", "contains", "(", "\"", "/", "foo", "3", "/", "\"", ")", ")", ";", "}", "res", "=", "p", "class", "loader", "get", "resource", "(", "\"", "test", "-", "resource", "\"", ")", "to", "string", "(", ")", ";", "assert", "true", "(", "\"", "in", "current", "impl", ",", "\"", "+", "res", "+", "\"", "should", "be", "foo", "1", "or", "foo", "2", "\"", ",", "res", "contains", "(", "\"", "/", "foo", "1", "/", "\"", ")", "|", "|", "res", "contains", "(", "\"", "/", "foo", "2", "/", "\"", ")", ")", ";", "}" ]
[ "test", "the", "property", "'", "wrapped", "array", "'" ]
[ "public", "void", "wrapped", "array", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "wrapped", "array", "}" ]
[ "rewrite", "logical", "filter", "rewrite", "logic", ":", "1", "if", "a", "filter", "references", "a", "correlated", "field", "in", "its", "filter", "condition", ",", "rewrite", "the", "filter", "references", "only", "non", "-", "correlated", "fields", ",", "and", "the", "condition", "references", "correlated", "fields", "will", "be", "push", "to", "it", "'", "s", "output", "2", "if", "filter", "does", "not", "reference", "correlated", "variables", ",", "simply", "rewrite", "the", "filter", "condition", "using", "new", "input" ]
[ "public", "frame", "decorrelate", "rel", "(", "logical", "filter", "rel", ")", "{", "final", "rel", "node", "old", "input", "=", "rel", "get", "input", "(", ")", ";", "frame", "frame", "=", "get", "invoke", "(", "old", "input", ")", ";", "if", "(", "frame", "=", "=", "null", ")", "{", "/", "/", "if", "input", "has", "not", "been", "rewritten", ",", "do", "not", "rewrite", "this", "rel", "return", "null", ";", "}", "/", "/", "conditions", "reference", "only", "correlated", "fields", "final", "list", "<", "rex", "node", ">", "cor", "conditions", "=", "new", "array", "list", "<", ">", "(", ")", ";", "/", "/", "conditions", "do", "not", "reference", "any", "correlated", "fields", "final", "list", "<", "rex", "node", ">", "non", "cor", "conditions", "=", "new", "array", "list", "<", ">", "(", ")", ";", "/", "/", "conditions", "reference", "correlated", "fields", ",", "but", "not", "supported", "now", "final", "list", "<", "rex", "node", ">", "unsupported", "cor", "conditions", "=", "new", "array", "list", "<", ">", "(", ")", ";", "analyze", "cor", "conditions", "(", "cm", "map", "sub", "query", "node", "to", "cor", "set", "get", "(", "rel", ")", ",", "rel", "get", "condition", "(", ")", ",", "rex", "builder", ",", "max", "cnf", "node", "count", ",", "cor", "conditions", ",", "non", "cor", "conditions", ",", "unsupported", "cor", "conditions", ")", ";", "assert", "unsupported", "cor", "conditions", "is", "empty", "(", ")", ";", "final", "rex", "node", "remaining", "condition", "=", "rex", "util", "compose", "conjunction", "(", "rex", "builder", ",", "non", "cor", "conditions", ",", "false", ")", ";", "/", "/", "using", "logical", "filter", "create", "instead", "of", "rel", "builder", "filter", "to", "create", "filter", "/", "/", "because", "rel", "builder", "filter", "method", "does", "not", "have", "variables", "set", "arg", "final", "logical", "filter", "new", "filter", "=", "logical", "filter", "create", "(", "frame", "r", ",", "remaining", "condition", ",", "com", "google", "common", "collect", "immutable", "set", "copy", "of", "(", "rel", "get", "variables", "set", "(", ")", ")", ")", ";", "/", "/", "adds", "input", "'", "s", "correlation", "condition", "if", "(", "frame", "c", "!", "=", "null", ")", "{", "cor", "conditions", "add", "(", "frame", "c", ")", ";", "}", "final", "rex", "node", "cor", "condition", "=", "rex", "util", "compose", "conjunction", "(", "rex", "builder", ",", "cor", "conditions", ",", "true", ")", ";", "/", "/", "filter", "does", "not", "change", "the", "input", "ordering", "/", "/", "all", "cor", "vars", "produced", "by", "filter", "will", "have", "the", "same", "output", "positions", "in", "the", "input", "rel", "return", "new", "frame", "(", "rel", ",", "new", "filter", ",", "cor", "condition", ",", "frame", "old", "to", "new", "outputs", ")", ";", "}" ]
[ "creates", "a", "new", "initializing", "shard", "the", "shard", "will", "have", "its", "own", "unique", "data", "path" ]
[ "protected", "index", "shard", "new", "shard", "(", "boolean", "primary", ")", "throws", "i", "o", "exception", "{", "return", "new", "shard", "(", "primary", ",", "settings", "empty", ")", ";", "}" ]
[ "returns", "all", "edges", "in", "this", "graph" ]
[ "set", "<", "endpoint", "pair", "<", "n", ">", ">", "edges", "(", ")", ";", "/", "/", "/", "/", "graph", "properties", "/", "/" ]
[ "returns", "the", "view", "file", "system", "type" ]
[ "string", "get", "type", "(", ")", "{", "return", "fs", "constants", "viewfs", "type", ";", "}" ]
[ "test", "the", "property", "'", "name", "'" ]
[ "public", "void", "name", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "name", "}" ]
[ "get", "photo", "urls" ]
[ "public", "set", "<", "string", ">", "get", "photo", "urls", "(", ")", "{", "return", "photo", "urls", ";", "}" ]
[ "static", "method", "only", "whitelisted", "as", "a", "static" ]
[ "public", "static", "float", "static", "add", "floats", "test", "(", "float", "x", ",", "float", "y", ")", "{", "return", "x", "+", "y", ";", "}" ]
[ "returns", "the", "object", "that", "represents", "all", "y", "-", "labels", "of", "the", "radar", "chart" ]
[ "public", "y", "axis", "get", "y", "axis", "(", ")", "{", "return", "m", "y", "axis", ";", "}" ]
[ "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", "\"", ")", ";", "}" ]