Datasets:

Anonymous2023

/

KGSum

like 0

[ "continues", "a", "join", "transformation", "and", "defines", "the", "fields", "of", "the", "second", "join", "{", "@", "link", "data", "set", "}", "that", "should", "be", "used", "as", "join", "keys", "the", "resulting", "{", "@", "link", "default", "join", "}", "wraps", "each", "pair", "of", "joining", "elements", "into", "a", "{", "@", "link", "tuple", "2", "}", ",", "with", "the", "element", "of", "the", "first", "input", "being", "the", "first", "field", "of", "the", "tuple", "and", "the", "element", "of", "the", "second", "input", "being", "the", "second", "field", "of", "the", "tuple" ]

[ "public", "default", "join", "<", "i1", ",", "i2", ">", "equal", "to", "(", "string", "fields", ")", "{", "return", "create", "default", "join", "(", "new", "keys", "expression", "keys", "<", ">", "(", "fields", ",", "input", "2", "get", "type", "(", ")", ")", ")", ";", "}" ]

[ "get", "a", "json", "serializer", "for", "this", "class" ]

[ "private", "static", "json", "serialization", "<", "success", "data", ">", "serializer", "(", ")", "{", "return", "new", "json", "serialization", "<", ">", "(", "success", "data", "class", ",", "false", ",", "true", ")", ";", "}" ]

[ "tests", "that", "creating", "tags", "with", "different", "comments", "(", "same", "name", ")", "causes", "a", "conflict", ",", "and", "that", "we", "can", "add", "the", "correct", "one", "to", "the", "result" ]

[ "public", "void", "test", "create", "tags", "same", "name", "different", "comment", "conflict", "(", ")", "throws", "exception", "{", "mtf", "initialize", "(", "notepad", ",", "new", "program", "modifier", "listener", "(", ")", "{", "@", "override", "public", "void", "modify", "latest", "(", "program", "d", "b", "program", ")", "throws", "exception", "{", "create", "tag", "(", "program", ",", "tag", "name", "a", ",", "\"", "comment", "a", "\"", ")", ";", "}", "@", "override", "public", "void", "modify", "private", "(", "program", "d", "b", "program", ")", "throws", "exception", "{", "create", "tag", "(", "program", ",", "tag", "name", "a", ",", "\"", "comment", "b", "\"", ")", ";", "}", "}", ")", ";", "execute", "merge", "(", "ask", "user", ")", ";", "int", "conflicts", "=", "get", "tag", "conflict", "count", "(", ")", ";", "assert", "true", "(", "conflicts", "=", "=", "1", ")", ";", "choose", "function", "tag", "button", "(", "my", "button", ",", "false", ")", ";", "wait", "for", "merge", "completion", "(", ")", ";", "/", "/", "get", "the", "result", "program", "and", "check", "that", "we", "have", ":", "/", "/", "1", "the", "tag", "exists", "in", "result", "assert", "true", "(", "is", "tag", "in", "program", "(", "tag", "name", "a", ",", "mtf", "get", "result", "program", "(", ")", ")", ")", ";", "assert", "true", "(", "get", "tag", "comment", "(", "tag", "name", "a", ",", "mtf", "get", "result", "program", "(", ")", ")", "equals", "(", "\"", "comment", "b", "\"", ")", ")", ";", "}" ]

[ "should", "be", "called", "to", "ensure", "counter", "values", "are", "made", "visible", "across", "threads", "the", "playback", "thread", "should", "call", "this", "method", "after", "updating", "the", "counter", "values", "any", "other", "thread", "should", "call", "this", "method", "before", "reading", "the", "counters" ]

[ "public", "synchronized", "void", "ensure", "updated", "(", ")", "{", "/", "/", "do", "nothing", "the", "use", "of", "synchronized", "ensures", "a", "memory", "barrier", "should", "another", "thread", "also", "/", "/", "call", "this", "method", "}" ]

[ "should", "the", "node", "transport", "stats", "be", "returned" ]

[ "public", "nodes", "stats", "request", "builder", "set", "transport", "(", "boolean", "transport", ")", "{", "add", "or", "remove", "metric", "(", "transport", ",", "nodes", "stats", "request", "metric", "transport", ")", ";", "return", "this", ";", "}" ]

[ "parses", "the", "configuration", "to", "get", "the", "number", "of", "slots", "and", "validates", "the", "value" ]

[ "public", "static", "int", "get", "slot", "(", "configuration", "configuration", ")", "{", "int", "slots", "=", "configuration", "get", "integer", "(", "task", "manager", "options", "num", "task", "slots", ",", "1", ")", ";", "/", "/", "we", "need", "this", "because", "many", "configs", "have", "been", "written", "with", "a", "\"", "-", "1", "\"", "entry", "if", "(", "slots", "=", "=", "-", "1", ")", "{", "slots", "=", "1", ";", "}", "configuration", "parser", "utils", "check", "config", "parameter", "(", "slots", ">", "=", "1", ",", "slots", ",", "task", "manager", "options", "num", "task", "slots", "key", "(", ")", ",", "\"", "number", "of", "task", "slots", "must", "be", "at", "least", "one", "\"", ")", ";", "return", "slots", ";", "}" ]

[ "generate", "and", "display", "the", "instruction", "for", "the", "current", "program", "location" ]

[ "protected", "void", "location", "changed", "(", "program", "location", "loc", ")", "{", "/", "/", "we", "only", "want", "to", "update", "if", ":", "/", "/", "1", ")", "we", "have", "a", "valid", "location", ",", "/", "/", "2", ")", "the", "location", "is", "different", "than", "the", "last", "location", "we", "processed", ",", "and", "/", "/", "todo", ":", "*", "*", "note", ":", "this", "step", "is", "believed", "to", "be", "a", "bug", "-", "-", "we", "should", "only", "be", "/", "/", "getting", "one", "location", "change", "at", "a", "time", ",", "not", "two", "/", "/", "3", ")", "the", "display", "is", "visible", "if", "(", "loc", "=", "=", "null", "|", "|", "loc", "equals", "(", "last", "updated", "location", ")", "|", "|", "!", "display", "component", "is", "visible", "(", ")", ")", "{", "return", ";", "}", "disassemble", "location", "(", "loc", ")", ";", "}" ]

[ "set", "maximum", "errors", "to", "tolerate", "before", "disk", "balancer", "step", "fails" ]

[ "void", "set", "max", "disk", "errors", "(", "long", "max", "disk", "errors", ")", ";" ]

[ "returns", "the", "point", "at", "which", "the", "state", "was", "instantiated" ]

[ "public", "sequence", "number", "get", "entry", "point", "(", ")", "{", "return", "pcode", "entry", ";", "}" ]

[ "returns", "a", "map", "of", "all", "registered", "{", "@", "link", "auth", "headers", "provider", "}", "s" ]

[ "public", "immutable", "map", "<", "string", ",", "auth", "headers", "provider", ">", "get", "auth", "headers", "providers", "map", "(", ")", "{", "return", "auth", "headers", "provider", "map", ";", "}" ]

[ "returns", "an", "immutable", "map", "containing", "the", "given", "entries", ",", "in", "order" ]

[ "public", "static", "<", "k", ",", "v", ">", "immutable", "map", "<", "k", ",", "v", ">", "of", "(", "k", "k", "1", ",", "v", "v", "1", ",", "k", "k", "2", ",", "v", "v", "2", ")", "{", "return", "regular", "immutable", "map", "from", "entries", "(", "entry", "of", "(", "k", "1", ",", "v", "1", ")", ",", "entry", "of", "(", "k", "2", ",", "v", "2", ")", ")", ";", "}" ]

[ "gets", "an", "asset", "file" ]

[ "public", "fi", "get", "(", "string", "path", ")", "{", "return", "get", "(", "path", ",", "false", ")", ";", "}" ]

[ "return", "whether", "the", "character", "encoding", "has", "been", "set", "if", "{", "@", "code", "false", "}", ",", "{", "@", "link", "#", "get", "character", "encoding", "(", ")", "}", "will", "return", "a", "default", "encoding", "value" ]

[ "public", "boolean", "is", "charset", "(", ")", "{", "return", "this", "charset", ";", "}" ]

[ "test", "the", "property", "'", "attribute", "string", "'" ]

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

[ "gets", "the", "value", "of", "the", "bit", "at", "the", "given", "index" ]

[ "public", "static", "boolean", "get", "(", "int", "[", "]", "bits", ",", "int", "idx", ")", "{", "int", "array", "idx", "=", "idx", ">", ">", "5", ";", "int", "bit", "=", "1", "<", "<", "(", "idx", "&", "0x", "1f", ")", ";", "return", "(", "bits", "[", "array", "idx", "]", "&", "bit", ")", "!", "=", "0", ";", "}" ]

[ "test", "a", "cluster", "with", "even", "distribution", ",", "then", "three", "nodes", "are", "added", "to", "the", "cluster", ",", "runs", "balancer", "with", "two", "of", "the", "nodes", "in", "the", "include", "list" ]

[ "public", "void", "test", "balancer", "with", "include", "list", "with", "ports", "(", ")", "throws", "exception", "{", "final", "configuration", "conf", "=", "new", "hdfs", "configuration", "(", ")", ";", "init", "conf", "(", "conf", ")", ";", "do", "test", "(", "conf", ",", "new", "long", "[", "]", "{", "capacity", ",", "capacity", "}", ",", "new", "string", "[", "]", "{", "rack0", ",", "rack1", "}", ",", "capacity", ",", "rack2", ",", "new", "port", "number", "based", "nodes", "(", "3", ",", "0", ",", "1", ")", ",", "false", ",", "false", ")", ";", "}" ]

[ "returns", "true", "if", "this", "task", "scheduler", "is", "in", "the", "process", "of", "running", "a", "task", "or", "has", "a", "pending", "task" ]

[ "public", "synchronized", "boolean", "is", "busy", "(", ")", "{", "return", "task", "thread", "!", "=", "null", "|", "|", "scheduled", "task", "!", "=", "null", ";", "}" ]

[ "returns", "integer", "value", "of", "big", "integer", "or", "integer", "max", "value", "if", "does", "not", "fit" ]

[ "static", "int", "big", "integer", "to", "int", "(", "pdb", "applicator", "my", "applicator", ",", "big", "integer", "big", ")", "{", "try", "{", "return", "big", "int", "value", "exact", "(", ")", ";", "}", "catch", "(", "arithmetic", "exception", "e", ")", "{", "string", "msg", "=", "\"", "big", "integer", "value", "greater", "than", "max", "integer", ":", "\"", "+", "big", ";", "pdb", "log", "message", "(", "msg", ")", ";", "my", "applicator", "append", "log", "msg", "(", "msg", ")", ";", "return", "integer", "max", "value", ";", "}", "}" ]

[ "get", "the", "job", "history", "file", "path", "for", "a", "given", "job", "id", "the", "job", "history", "file", "at", "this", "path", "may", "or", "may", "not", "be", "existing", "depending", "on", "the", "job", "completion", "state", "the", "file", "is", "present", "only", "for", "the", "completed", "jobs" ]

[ "public", "string", "get", "job", "history", "url", "(", "job", "i", "d", "job", "id", ")", "throws", "i", "o", "exception", ",", "interrupted", "exception", "{", "if", "(", "job", "history", "dir", "=", "=", "null", ")", "{", "job", "history", "dir", "=", "new", "path", "(", "client", "get", "job", "history", "dir", "(", ")", ")", ";", "}", "return", "new", "path", "(", "job", "history", "dir", ",", "job", "id", "to", "string", "(", ")", "+", "\"", "\"", "+", "ugi", "get", "short", "user", "name", "(", ")", ")", "to", "string", "(", ")", ";", "}" ]

[ "called", "when", "the", "value", "of", "{", "@", "link", "#", "is", "playing", "(", ")", "}", "changes" ]

[ "default", "void", "on", "is", "playing", "changed", "(", "boolean", "is", "playing", ")", "{", "}" ]

[ "returns", "the", "path", "relative", "to", "the", "context", "root", ",", "like", "\"", "foobarzot", "\"", "note", "no", "leading", "slash", "but", "trailing", "slash" ]

[ "string", "get", "url", "(", ")", ";" ]

[ "set", "the", "timeout", "to", "use", "for", "receive", "calls", "(", "in", "milliseconds", ")", "the", "default", "is", "{", "@", "link", "#", "receive", "timeout", "indefinite", "wait", "}", ",", "which", "indicates", "a", "blocking", "receive", "without", "timeout", "specify", "{", "@", "link", "#", "receive", "timeout", "no", "wait", "}", "(", "or", "any", "other", "negative", "value", ")", "to", "indicate", "that", "a", "receive", "operation", "should", "check", "if", "a", "message", "is", "immediately", "available", "without", "blocking" ]

[ "public", "void", "set", "receive", "timeout", "(", "long", "receive", "timeout", ")", "{", "this", "receive", "timeout", "=", "receive", "timeout", ";", "}" ]

[ "estimate", "of", "the", "number", "of", "bytes", "in", "the", "cache" ]

[ "public", "long", "get", "storage", "estimate", "bytes", "(", ")", "{", "return", "storage", "estimate", "bytes", ";", "}" ]

[ "converts", "the", "given", "set", "of", "vertices", "to", "a", "new", "set", "where", "any", "vertices", "that", "are", "part", "of", "a", "group", "are", "replaced", "with", "the", "outermost", "group", "containing", "it" ]

[ "public", "set", "<", "attributed", "vertex", ">", "convert", "to", "outermost", "vertices", "(", "set", "<", "attributed", "vertex", ">", "vertices", ")", "{", "set", "<", "attributed", "vertex", ">", "set", "=", "new", "hash", "set", "<", ">", "(", ")", ";", "for", "(", "attributed", "vertex", "v", ":", "vertices", ")", "{", "set", "add", "(", "get", "outermost", "vertex", "(", "v", ")", ")", ";", "}", "return", "set", ";", "}" ]

[ "declares", "the", "fragments", "required", "by", "this", "aspect", "for", "the", "configuration", "of", "the", "host", "machine", "this", "aspect", "'", "s", "actions", "execute", "on", "this", "is", "not", "the", "same", "as", "the", "aspect", "'", "s", "configuration", "the", "aspect", "'", "s", "configuration", "is", "its", "target", "configuration", ",", "which", "determines", "the", "platform", "it", "builds", "outputs", "for", "the", "actions", "created", "by", "this", "aspect", "run", "on", "a", "host", "machine", ",", "which", "is", "what", "the", "host", "configuration", "corresponds", "to", "in", "contrast", "to", "{", "@", "link", "#", "requires", "host", "configuration", "fragments", "(", "class", ")", "}", ",", "this", "method", "takes", "starlark", "module", "names", "of", "fragments", "instead", "of", "their", "classes" ]

[ "public", "config", "aware", "aspect", "builder", "requires", "host", "configuration", "fragments", "by", "starlark", "builtin", "name", "(", "collection", "<", "string", ">", "configuration", "fragment", "names", ")", "{", "aspect", "builder", "requires", "configuration", "fragments", "by", "starlark", "builtin", "name", "(", "host", "transition", "instance", ",", "configuration", "fragment", "names", ")", ";", "return", "this", ";", "}" ]

[ "find", "purchase", "order", "by", "id", "for", "valid", "response", "try", "integer", "i", "ds", "with", "value", "&", "lt", ";", "&", "#", "x", "3", "d", ";", "5", "or", "&", "gt", ";", "10", "other", "values", "will", "generated", "exceptions" ]

[ "public", "order", "get", "order", "by", "id", "(", "long", "order", "id", ")", "throws", "api", "exception", "{", "api", "response", "<", "order", ">", "local", "var", "response", "=", "get", "order", "by", "id", "with", "http", "info", "(", "order", "id", ")", ";", "return", "local", "var", "response", "get", "data", "(", ")", ";", "}" ]

[ "converts", "the", "given", "distance", "from", "the", "given", "distance", "unit", ",", "to", "the", "given", "distance", "unit" ]

[ "public", "static", "double", "convert", "(", "double", "distance", ",", "distance", "unit", "from", ",", "distance", "unit", "to", ")", "{", "if", "(", "from", "=", "=", "to", ")", "{", "return", "distance", ";", "}", "else", "{", "return", "distance", "*", "from", "meters", "/", "to", "meters", ";", "}", "}" ]

[ "check", "to", "see", "if", "a", "byte", "array", "is", "valid", "utf", "-", "8" ]

[ "public", "static", "void", "validate", "u", "t", "f", "8", "(", "byte", "[", "]", "utf", "8", ",", "int", "start", ",", "int", "len", ")", "throws", "malformed", "input", "exception", "{", "int", "count", "=", "start", ";", "int", "lead", "byte", "=", "0", ";", "int", "length", "=", "0", ";", "int", "state", "=", "lead", "byte", ";", "while", "(", "count", "<", "start", "+", "len", ")", "{", "int", "a", "byte", "=", "utf", "8", "[", "count", "]", "&", "0x", "f", "f", ";", "switch", "(", "state", ")", "{", "case", "lead", "byte", ":", "lead", "byte", "=", "a", "byte", ";", "length", "=", "bytes", "from", "u", "t", "f", "8", "[", "a", "byte", "]", ";", "switch", "(", "length", ")", "{", "case", "0", ":", "/", "/", "check", "for", "ascii", "if", "(", "lead", "byte", ">", "0x", "7", "f", ")", "throw", "new", "malformed", "input", "exception", "(", "count", ")", ";", "break", ";", "case", "1", ":", "if", "(", "lead", "byte", "<", "0x", "c", "2", "|", "|", "lead", "byte", ">", "0x", "d", "f", ")", "throw", "new", "malformed", "input", "exception", "(", "count", ")", ";", "state", "=", "trail", "byte", "1", ";", "break", ";", "case", "2", ":", "if", "(", "lead", "byte", "<", "0x", "e", "0", "|", "|", "lead", "byte", ">", "0x", "e", "f", ")", "throw", "new", "malformed", "input", "exception", "(", "count", ")", ";", "state", "=", "trail", "byte", "1", ";", "break", ";", "case", "3", ":", "if", "(", "lead", "byte", "<", "0x", "f", "0", "|", "|", "lead", "byte", ">", "0x", "f", "4", ")", "throw", "new", "malformed", "input", "exception", "(", "count", ")", ";", "state", "=", "trail", "byte", "1", ";", "break", ";", "default", ":", "/", "/", "too", "long", "!", "longest", "valid", "utf", "-", "8", "is", "4", "bytes", "(", "lead", "+", "three", ")", "/", "/", "or", "if", "<", "0", "we", "got", "a", "trail", "byte", "in", "the", "lead", "byte", "position", "throw", "new", "malformed", "input", "exception", "(", "count", ")", ";", "}", "/", "/", "switch", "(", "length", ")", "break", ";", "case", "trail", "byte", "1", ":", "if", "(", "lead", "byte", "=", "=", "0x", "f", "0", "&", "&", "a", "byte", "<", "0x", "9", "0", ")", "throw", "new", "malformed", "input", "exception", "(", "count", ")", ";", "if", "(", "lead", "byte", "=", "=", "0x", "f", "4", "&", "&", "a", "byte", ">", "0x", "8", "f", ")", "throw", "new", "malformed", "input", "exception", "(", "count", ")", ";", "if", "(", "lead", "byte", "=", "=", "0x", "e", "0", "&", "&", "a", "byte", "<", "0x", "a", "0", ")", "throw", "new", "malformed", "input", "exception", "(", "count", ")", ";", "if", "(", "lead", "byte", "=", "=", "0x", "e", "d", "&", "&", "a", "byte", ">", "0x", "9", "f", ")", "throw", "new", "malformed", "input", "exception", "(", "count", ")", ";", "/", "/", "falls", "through", "to", "regular", "trail", "-", "byte", "test", "!", "!", "case", "trail", "byte", ":", "if", "(", "a", "byte", "<", "0x", "8", "0", "|", "|", "a", "byte", ">", "0x", "b", "f", ")", "throw", "new", "malformed", "input", "exception", "(", "count", ")", ";", "if", "(", "-", "-", "length", "=", "=", "0", ")", "{", "state", "=", "lead", "byte", ";", "}", "else", "{", "state", "=", "trail", "byte", ";", "}", "break", ";", "default", ":", "break", ";", "}", "/", "/", "switch", "(", "state", ")", "count", "+", "+", ";", "}", "}" ]

[ "removes", "a", "target", "from", "the", "{", "@", "link", "package", "}", "under", "construction", "intended", "to", "be", "used", "only", "by", "{", "@", "link", "com", "google", "devtools", "build", "lib", "skyframe", "package", "function", "}", "to", "remove", "targets", "whose", "labels", "cross", "subpackage", "boundaries" ]

[ "void", "remove", "target", "(", "target", "target", ")", "{", "if", "(", "target", "get", "package", "(", ")", "=", "=", "pkg", ")", "{", "this", "targets", "remove", "(", "target", "get", "name", "(", ")", ")", ";", "}", "}" ]

[ "converts", "the", "specified", "xml", "element", "into", "a", "string" ]

[ "public", "static", "string", "to", "string", "(", "element", "root", ")", "{", "x", "m", "l", "outputter", "outputter", "=", "new", "generic", "x", "m", "l", "outputter", "(", ")", ";", "return", "outputter", "output", "string", "(", "root", ")", ";", "}" ]

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

[ "public", "int", "get", "previous", "offset", "(", ")", "{", "return", "previous", "offset", ";", "}" ]

[ "analyzing", "all", "the", "association", "models", "in", "the", "collection", "judge", "their", "association", "types", "if", "it", "'", "s", "one", "2one", "or", "many", "2one", "associations", ",", "add", "the", "foreign", "key", "column", "to", "the", "associated", "table", "if", "it", "'", "s", "many", "2many", "associations", ",", "create", "an", "intermediate", "join", "table" ]

[ "private", "void", "add", "associations", "(", "collection", "<", "associations", "model", ">", "associated", "models", ",", "s", "q", "lite", "database", "db", ",", "boolean", "force", ")", "{", "for", "(", "associations", "model", "association", "model", ":", "associated", "models", ")", "{", "if", "(", "const", "model", "many", "to", "one", "=", "=", "association", "model", "get", "association", "type", "(", ")", "|", "|", "const", "model", "one", "to", "one", "=", "=", "association", "model", "get", "association", "type", "(", ")", ")", "{", "add", "foreign", "key", "column", "(", "association", "model", "get", "table", "name", "(", ")", ",", "association", "model", "get", "associated", "table", "name", "(", ")", ",", "association", "model", "get", "table", "holds", "foreign", "key", "(", ")", ",", "db", ")", ";", "}", "else", "if", "(", "const", "model", "many", "to", "many", "=", "=", "association", "model", "get", "association", "type", "(", ")", ")", "{", "create", "intermediate", "table", "(", "association", "model", "get", "table", "name", "(", ")", ",", "association", "model", "get", "associated", "table", "name", "(", ")", ",", "db", ",", "force", ")", ";", "}", "}", "for", "(", "generic", "model", "generic", "model", ":", "get", "generic", "models", "(", ")", ")", "{", "create", "generic", "table", "(", "generic", "model", ",", "db", ",", "force", ")", ";", "}", "}" ]

[ "gets", "the", "default", "ghidra", "installation", "directory", "that", "'", "s", "defined", "in", "the", "preferences" ]

[ "public", "static", "file", "get", "ghidra", "default", "install", "dir", "(", ")", "{", "i", "preference", "store", "prefs", "=", "activator", "get", "default", "(", ")", "get", "preference", "store", "(", ")", ";", "string", "ghidra", "default", "install", "dir", "path", "=", "prefs", "get", "string", "(", "ghidra", "default", "install", "path", ")", ";", "if", "(", "ghidra", "default", "install", "dir", "path", "is", "empty", "(", ")", ")", "{", "return", "null", ";", "}", "return", "new", "file", "(", "ghidra", "default", "install", "dir", "path", ")", ";", "}" ]

[ "tests", "value", "serialization", "utils" ]

[ "public", "void", "test", "value", "serialization", "(", ")", "throws", "exception", "{", "type", "serializer", "<", "long", ">", "value", "serializer", "=", "long", "serializer", "instance", ";", "long", "expected", "value", "=", "long", "max", "value", "-", "1292929292l", ";", "byte", "[", "]", "serialized", "value", "=", "kv", "state", "serializer", "serialize", "value", "(", "expected", "value", ",", "value", "serializer", ")", ";", "long", "actual", "value", "=", "kv", "state", "serializer", "deserialize", "value", "(", "serialized", "value", ",", "value", "serializer", ")", ";", "assert", "equals", "(", "expected", "value", ",", "actual", "value", ")", ";", "}" ]

[ "max", "connection", "retries", "on", "socket", "time", "outs" ]

[ "public", "int", "get", "max", "retries", "on", "socket", "timeouts", "(", ")", "{", "return", "max", "retries", "on", "socket", "timeouts", ";", "}" ]

[ "set", "the", "type", "of", "this", "body", "this", "may", "alter", "the", "mass", "and", "velocity" ]

[ "public", "void", "set", "type", "(", "body", "type", "type", ")", "{", "jni", "set", "type", "(", "addr", ",", "type", "get", "value", "(", ")", ")", ";", "}", "/", "/", "@", "off", "/", "*", "jni", "inline", "b", "2", "body", "type", "get", "body", "type", "(", "int", "type", ")", "{", "switch", "(", "type", ")", "{", "case", "0", ":", "return", "b", "2", "static", "body", ";", "case", "1", ":", "return", "b", "2", "kinematic", "body", ";", "case", "2", ":", "return", "b", "2", "dynamic", "body", ";", "default", ":", "return", "b", "2", "static", "body", ";", "}", "}" ]

[ "write", "a", "printable", "representation", "of", "a", "byte", "array", "non", "-", "printable", "characters", "are", "hex", "escaped", "in", "the", "format", "\\", "\\", "x", "%", "02x", ",", "eg", ":", "\\", "x", "0", "0", "\\", "x", "0", "5", "etc", "this", "function", "is", "brought", "from", "org", "apache", "hadoop", "hbase", "util", "bytes" ]

[ "private", "static", "string", "to", "string", "(", "final", "byte", "[", "]", "b", ",", "int", "off", ",", "int", "len", ")", "{", "string", "builder", "result", "=", "new", "string", "builder", "(", ")", ";", "if", "(", "b", "=", "=", "null", ")", "return", "result", "to", "string", "(", ")", ";", "/", "/", "just", "in", "case", "we", "are", "passed", "a", "'", "len", "'", "that", "is", ">", "buffer", "length", "if", "(", "off", ">", "=", "b", "length", ")", "return", "result", "to", "string", "(", ")", ";", "if", "(", "off", "+", "len", ">", "b", "length", ")", "len", "=", "b", "length", "-", "off", ";", "for", "(", "int", "i", "=", "off", ";", "i", "<", "off", "+", "len", ";", "+", "+", "i", ")", "{", "int", "ch", "=", "b", "[", "i", "]", "&", "0x", "f", "f", ";", "if", "(", "ch", ">", "=", "'", "'", "&", "&", "ch", "<", "=", "'", "~", "'", "&", "&", "ch", "!", "=", "'", "\\", "\\", "'", ")", "{", "result", "append", "(", "(", "char", ")", "ch", ")", ";", "}", "else", "{", "result", "append", "(", "\"", "\\", "\\", "x", "\"", ")", ";", "result", "append", "(", "hex", "chars", "upper", "[", "ch", "/", "0x", "1", "0", "]", ")", ";", "result", "append", "(", "hex", "chars", "upper", "[", "ch", "%", "0x", "1", "0", "]", ")", ";", "}", "}", "return", "result", "to", "string", "(", ")", ";", "}" ]

[ "asynchronously", "gets", "a", "watch", "into", "the", "cluster", "see", "<", "a", "href", "=", "\"", "https", ":", "www", "elastic", "coguideenelasticsearchreferencecurrentwatcher", "-", "api", "-", "get", "-", "watch", "html", "\"", ">", "the", "docs", "for", "more" ]

[ "public", "cancellable", "get", "watch", "async", "(", "get", "watch", "request", "request", ",", "request", "options", "options", ",", "action", "listener", "<", "get", "watch", "response", ">", "listener", ")", "{", "return", "rest", "high", "level", "client", "perform", "request", "async", "and", "parse", "entity", "(", "request", ",", "watcher", "request", "converters", ":", ":", "get", "watch", ",", "options", ",", "get", "watch", "response", ":", ":", "from", "x", "content", ",", "listener", ",", "empty", "set", "(", ")", ")", ";", "}" ]

[ "get", "map", "integer" ]

[ "public", "map", "<", "string", ",", "integer", ">", "get", "map", "integer", "(", ")", "{", "return", "map", "integer", ";", "}" ]

[ "return", "current", "sequence", "number", "and", "then", "increase", "it", "by", "1" ]

[ "long", "get", "and", "inc", "current", "seqno", "(", ")", "{", "long", "old", "=", "this", "current", "seqno", ";", "this", "current", "seqno", "+", "+", ";", "return", "old", ";", "}" ]

[ "verify", "that", "we", "don", "'", "t", "see", "any", "state", "changeswatermarks", "when", "all", "active", "channels", "are", "unaligned", "earlier", "versions", "of", "the", "valve", "had", "a", "bug", "that", "would", "cause", "it", "to", "emit", "a", "{", "@", "code", "long", "max", "value", "}", "watermark", "in", "that", "case" ]

[ "public", "void", "test", "no", "output", "when", "all", "active", "channels", "are", "unaligned", "(", ")", "throws", "exception", "{", "status", "watermark", "output", "valve", "output", "=", "new", "status", "watermark", "output", "(", ")", ";", "status", "watermark", "valve", "valve", "=", "new", "status", "watermark", "valve", "(", "3", ")", ";", "valve", "input", "watermark", "(", "new", "watermark", "(", "10", ")", ",", "0", ",", "valve", "output", ")", ";", "valve", "input", "watermark", "(", "new", "watermark", "(", "7", ")", ",", "1", ",", "valve", "output", ")", ";", "/", "/", "make", "channel", "2", "active", ",", "it", "is", "now", "in", "\"", "catch", "up", "\"", "mode", "(", "unaligned", "watermark", ")", "valve", "input", "stream", "status", "(", "stream", "status", "idle", ",", "2", ",", "valve", "output", ")", ";", "assert", "equals", "(", "new", "watermark", "(", "7", ")", ",", "valve", "output", "pop", "last", "seen", "output", "(", ")", ")", ";", "assert", "equals", "(", "null", ",", "valve", "output", "pop", "last", "seen", "output", "(", ")", ")", ";", "/", "/", "make", "channel", "2", "active", "again", ",", "it", "is", "still", "unaligned", "valve", "input", "stream", "status", "(", "stream", "status", "active", ",", "2", ",", "valve", "output", ")", ";", "assert", "equals", "(", "null", ",", "valve", "output", "pop", "last", "seen", "output", "(", ")", ")", ";", "/", "/", "make", "channel", "0", "and", "1", "idle", ",", "now", "channel", "2", "is", "the", "only", "active", "channel", "but", "it", "'", "s", "unaligned", "valve", "input", "stream", "status", "(", "stream", "status", "idle", ",", "0", ",", "valve", "output", ")", ";", "valve", "input", "stream", "status", "(", "stream", "status", "idle", ",", "1", ",", "valve", "output", ")", ";", "/", "/", "we", "should", "not", "see", "any", "output", "assert", "equals", "(", "null", ",", "valve", "output", "pop", "last", "seen", "output", "(", ")", ")", ";", "}" ]

[ "order", "by", "tenant", "id", "(", "needs", "to", "be", "followed", "by", "{", "@", "link", "#", "asc", "(", ")", "}", "or", "{", "@", "link", "#", "desc", "(", ")", "}", ")" ]

[ "model", "query", "order", "by", "tenant", "id", "(", ")", ";" ]

[ "render", "the", "template", "with", "the", "given", "{", "@", "code", "name", "}", "using", "the", "given", "{", "@", "code", "model", "attributes", "}", "the", "model", "attributes", "are", "mapped", "under", "a", "{", "@", "linkplain", "org", "springframework", "core", "conventions", "#", "get", "variable", "name", "generated", "name", "}", "note", ":", "empty", "{", "@", "link", "collection", "collections", "}", "are", "not", "added", "to", "the", "model", "when", "using", "this", "method", "because", "we", "cannot", "correctly", "determine", "the", "true", "convention", "name" ]

[ "server", "response", "render", "(", "string", "name", ",", "object", "model", "attributes", ")", ";" ]

[ "true", "if", "the", "two", "items", "are", "the", "same", ",", "except", "that", "they", "come", "from", "a", "different", "source", "file" ]

[ "public", "boolean", "is", "equivalent", "(", "t", "o", "c", "item", "other", ")", "{", "if", "(", "this", "=", "=", "other", ")", "{", "return", "true", ";", "}", "if", "(", "other", "=", "=", "null", ")", "{", "return", "false", ";", "}", "if", "(", "get", "class", "(", ")", "!", "=", "other", "get", "class", "(", ")", ")", "{", "return", "false", ";", "}", "if", "(", "i", "d", "attribute", "=", "=", "null", ")", "{", "if", "(", "other", "i", "d", "attribute", "!", "=", "null", ")", "{", "return", "false", ";", "}", "}", "else", "if", "(", "!", "i", "d", "attribute", "equals", "(", "other", "i", "d", "attribute", ")", ")", "{", "return", "false", ";", "}", "if", "(", "sort", "preference", "=", "=", "null", ")", "{", "if", "(", "other", "sort", "preference", "!", "=", "null", ")", "{", "return", "false", ";", "}", "}", "else", "if", "(", "!", "sort", "preference", "equals", "(", "other", "sort", "preference", ")", ")", "{", "return", "false", ";", "}", "if", "(", "target", "attribute", "=", "=", "null", ")", "{", "if", "(", "other", "target", "attribute", "!", "=", "null", ")", "{", "return", "false", ";", "}", "}", "else", "if", "(", "!", "target", "attribute", "equals", "(", "other", "target", "attribute", ")", ")", "{", "return", "false", ";", "}", "if", "(", "text", "attribute", "=", "=", "null", ")", "{", "if", "(", "other", "text", "attribute", "!", "=", "null", ")", "{", "return", "false", ";", "}", "}", "else", "if", "(", "!", "text", "attribute", "equals", "(", "other", "text", "attribute", ")", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "obtain", "an", "{", "@", "link", "allocation", "}", "when", "the", "caller", "has", "finished", "with", "the", "{", "@", "link", "allocation", "}", ",", "it", "should", "be", "returned", "by", "calling", "{", "@", "link", "#", "release", "(", "allocation", ")", "}" ]

[ "allocation", "allocate", "(", ")", ";" ]

[ "allows", "the", "command", "to", "provide", "command", "-", "specific", "option", "defaults", "andor", "requirements", "this", "method", "is", "called", "after", "all", "command", "-", "line", "and", "rc", "file", "options", "have", "been", "parsed" ]

[ "default", "void", "edit", "options", "(", "options", "parser", "options", "parser", ")", "{", "}" ]

[ "return", "the", "priority", "of", "the", "job" ]

[ "public", "synchronized", "job", "priority", "get", "job", "priority", "(", ")", "{", "return", "job", "priority", "value", "of", "(", "super", "get", "priority", "(", ")", "name", "(", ")", ")", ";", "}" ]

[ "returns", "the", "value", "for", "this", "setting", "but", "falls", "back", "to", "the", "second", "provided", "settings", "object" ]

[ "public", "final", "t", "get", "(", "settings", "primary", ",", "settings", "secondary", ")", "{", "if", "(", "exists", "(", "primary", ")", ")", "{", "return", "get", "(", "primary", ")", ";", "}", "if", "(", "exists", "(", "secondary", ")", ")", "{", "return", "get", "(", "secondary", ")", ";", "}", "if", "(", "fallback", "setting", "=", "=", "null", ")", "{", "return", "get", "(", "primary", ")", ";", "}", "if", "(", "fallback", "setting", "exists", "(", "primary", ")", ")", "{", "return", "fallback", "setting", "get", "(", "primary", ")", ";", "}", "return", "fallback", "setting", "get", "(", "secondary", ")", ";", "}" ]

[ "return", "the", "view", "'", "s", "name", "should", "never", "be", "{", "@", "code", "null", "}", ",", "if", "the", "view", "was", "correctly", "configured" ]

[ "public", "string", "get", "bean", "name", "(", ")", "{", "return", "this", "bean", "name", ";", "}" ]

[ "get", "the", "hostname", "where", "the", "container", "runs" ]

[ "public", "string", "get", "host", "(", ")", "{", "throw", "new", "unsupported", "operation", "exception", "(", "\"", "subclass", "must", "implement", "this", "method", "\"", ")", ";", "}" ]

[ "obtain", "the", "cumulative", "cpu", "time", "since", "the", "system", "is", "on" ]

[ "public", "long", "get", "cumulative", "cpu", "time", "(", ")", "{", "return", "cumulative", "cpu", "time", "long", "value", "(", ")", ";", "}" ]

[ "sets", "the", "size", "of", "the", "central", "directory", "in", "bytes", "if", "the", "size", "is", "larger", "than", "0xffffffff", ",", "the", "file", "is", "set", "to", "zip", "6", "4", "mode", "see", "<", "a", "href", "=", "\"", "http", ":", "www", "pkware", "comdocumentscasestudies", "a", "p", "p", "n", "o", "t", "e", "txt", "\"", ">", "zip", "format", "section", "4", "4", "23" ]

[ "public", "void", "set", "central", "directory", "size", "(", "long", "central", "directory", "size", ")", "{", "this", "central", "directory", "size", "=", "central", "directory", "size", ";", "if", "(", "central", "directory", "size", ">", "0xffffffff", "l", ")", "{", "set", "zip", "6", "4", "(", "true", ")", ";", "}", "}" ]

[ "randomly", "adds", "fields", ",", "objects", ",", "or", "arrays", "to", "the", "provided", "builder", "the", "maximum", "depth", "is", "5" ]

[ "private", "static", "void", "add", "fields", "(", "random", "random", ",", "x", "content", "builder", "builder", ",", "int", "min", "num", "fields", ",", "int", "current", "depth", ")", "throws", "i", "o", "exception", "{", "int", "num", "fields", "=", "random", "int", "between", "(", "random", ",", "min", "num", "fields", ",", "5", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "num", "fields", ";", "i", "+", "+", ")", "{", "if", "(", "current", "depth", "<", "5", "&", "&", "random", "next", "int", "(", "100", ")", ">", "=", "70", ")", "{", "if", "(", "random", "next", "boolean", "(", ")", ")", "{", "builder", "start", "object", "(", "random", "strings", "random", "ascii", "letters", "of", "length", "between", "(", "random", ",", "6", ",", "10", ")", ")", ";", "add", "fields", "(", "random", ",", "builder", ",", "min", "num", "fields", ",", "current", "depth", "+", "1", ")", ";", "builder", "end", "object", "(", ")", ";", "}", "else", "{", "builder", "start", "array", "(", "random", "strings", "random", "ascii", "letters", "of", "length", "between", "(", "random", ",", "6", ",", "10", ")", ")", ";", "int", "num", "elements", "=", "random", "int", "between", "(", "random", ",", "1", ",", "5", ")", ";", "boolean", "object", "=", "random", "next", "boolean", "(", ")", ";", "int", "data", "type", "=", "-", "1", ";", "if", "(", "object", "=", "=", "false", ")", "{", "data", "type", "=", "random", "data", "type", "(", "random", ")", ";", "}", "for", "(", "int", "j", "=", "0", ";", "j", "<", "num", "elements", ";", "j", "+", "+", ")", "{", "if", "(", "object", ")", "{", "builder", "start", "object", "(", ")", ";", "add", "fields", "(", "random", ",", "builder", ",", "min", "num", "fields", ",", "5", ")", ";", "builder", "end", "object", "(", ")", ";", "}", "else", "{", "builder", "value", "(", "random", "field", "value", "(", "random", ",", "data", "type", ")", ")", ";", "}", "}", "builder", "end", "array", "(", ")", ";", "}", "}", "else", "{", "builder", "field", "(", "random", "strings", "random", "ascii", "letters", "of", "length", "between", "(", "random", ",", "6", ",", "10", ")", ",", "random", "field", "value", "(", "random", ",", "random", "data", "type", "(", "random", ")", ")", ")", ";", "}", "}", "}" ]

[ "add", "an", "annotation", "for", "the", "subsequent", "output", "any", "previously", "open", "annotation", "will", "be", "closed", "by", "this", "call", ",", "and", "the", "new", "annotation", "marks", "all", "subsequent", "output", "until", "another", "annotation", "call" ]

[ "public", "void", "annotate", "(", "string", "msg", ")", ";" ]

[ "return", "the", "fallback", "class", "loader", "to", "use", "when", "no", "class", "loader", "was", "specified", "and", "object", "input", "stream", "'", "s", "own", "default", "class", "loader", "failed", "the", "default", "implementation", "simply", "returns", "{", "@", "code", "null", "}", ",", "indicating", "that", "no", "specific", "fallback", "is", "available" ]

[ "protected", "class", "loader", "get", "fallback", "class", "loader", "(", ")", "throws", "i", "o", "exception", "{", "return", "null", ";", "}" ]

[ "returns", "all", "function", "tags", "associated", "with", "the", "given", "function", "id" ]

[ "set", "<", "function", "tag", ">", "get", "function", "tags", "by", "function", "i", "d", "(", "long", "function", "id", ")", "throws", "i", "o", "exception", "{", "set", "<", "function", "tag", ">", "tags", "=", "new", "hash", "set", "<", ">", "(", ")", ";", "record", "iterator", "function", "records", "=", "function", "tag", "mapping", "adapter", "get", "records", "by", "function", "i", "d", "(", "function", "id", ")", ";", "while", "(", "function", "records", "has", "next", "(", ")", ")", "{", "d", "b", "record", "mapping", "record", "=", "function", "records", "next", "(", ")", ";", "d", "b", "record", "tag", "record", "=", "function", "tag", "adapter", "get", "record", "(", "mapping", "record", "get", "long", "value", "(", "function", "tag", "mapping", "adapter", "tag", "id", "col", ")", ")", ";", "tags", "add", "(", "get", "function", "tag", "from", "cache", "(", "tag", "record", ")", ")", ";", "}", "return", "tags", ";", "}" ]

[ "remove", "the", "login", "method", "that", "is", "followed", "by", "a", "space", "from", "the", "username", "e", "g", "\"", "jack", "(", "auth", ":", "simple", ")", "\"", "{", "@", "literal", "-", ">", "}", "\"", "jack", "\"" ]

[ "public", "static", "string", "trim", "login", "method", "(", "string", "user", "name", ")", "{", "int", "space", "index", "=", "user", "name", "index", "of", "(", "'", "'", ")", ";", "if", "(", "space", "index", ">", "=", "0", ")", "{", "user", "name", "=", "user", "name", "substring", "(", "0", ",", "space", "index", ")", ";", "}", "return", "user", "name", ";", "}" ]

[ "register", "a", "{", "@", "link", "channel", "}", "with", "this", "{", "@", "link", "event", "loop", "}", "using", "a", "{", "@", "link", "channel", "future", "}", "the", "passed", "{", "@", "link", "channel", "future", "}", "will", "get", "notified", "once", "the", "registration", "was", "complete", "and", "also", "will", "get", "returned" ]

[ "channel", "future", "register", "(", "channel", "promise", "promise", ")", ";" ]

[ "receive", "verify", "data", ",", "find", "processor", "to", "process" ]

[ "public", "boolean", "on", "verify", "(", "distro", "data", "distro", "data", ")", "{", "string", "resource", "type", "=", "distro", "data", "get", "distro", "key", "(", ")", "get", "resource", "type", "(", ")", ";", "distro", "data", "processor", "data", "processor", "=", "distro", "component", "holder", "find", "data", "processor", "(", "resource", "type", ")", ";", "if", "(", "null", "=", "=", "data", "processor", ")", "{", "loggers", "distro", "warn", "(", "\"", "[", "distro", "]", "can", "'", "t", "find", "verify", "data", "process", "for", "received", "data", "{", "}", "\"", ",", "resource", "type", ")", ";", "return", "false", ";", "}", "return", "data", "processor", "process", "verify", "data", "(", "distro", "data", ")", ";", "}" ]

[ "the", "entries", "defined", "for", "this", "type", "<", "code", ">", "repeated", "aapt", "pb", "entry", "entry", "=", "3", ";", "<", "code", ">" ]

[ "public", "builder", "add", "entry", "(", "int", "index", ",", "com", "android", "aapt", "resources", "entry", "builder", "builder", "for", "value", ")", "{", "copy", "on", "write", "(", ")", ";", "instance", "add", "entry", "(", "index", ",", "builder", "for", "value", ")", ";", "return", "this", ";", "}" ]

[ "print", "a", "message", "as", "an", "error" ]

[ "private", "void", "error", "(", "string", "category", ",", "string", "message", ",", "object", "args", ")", "{", "println", "(", "\"", "error", ":", "%", "s", ":", "%", "s", "\"", ",", "category", ",", "string", "format", "(", "message", ",", "args", ")", ")", ";", "}" ]

[ "tests", "that", "connection", "success", "with", "the", "default", "tls", "version", "note", "that", "debug", "mode", "for", "javax", "net", "ssl", "can", "be", "enabled", "via", "{", "@", "code", "system", "set", "property", "(", "\"", "javax", "net", "debug", "\"", ",", "\"", "ssl", ":", "handshake", "\"", ")", ";", "}" ]

[ "public", "void", "test", "tls", "defaults", "(", "list", "<", "string", ">", "server", "protocols", ",", "list", "<", "string", ">", "client", "protocols", ")", "throws", "exception", "{", "/", "/", "create", "certificates", "for", "use", "by", "client", "and", "server", "add", "server", "cert", "to", "client", "truststore", "and", "vice", "versa", "cert", "stores", "server", "cert", "stores", "=", "new", "cert", "stores", "(", "true", ",", "\"", "server", "\"", ",", "\"", "localhost", "\"", ")", ";", "cert", "stores", "client", "cert", "stores", "=", "new", "cert", "stores", "(", "false", ",", "\"", "client", "\"", ",", "\"", "localhost", "\"", ")", ";", "map", "<", "string", ",", "object", ">", "ssl", "client", "configs", "=", "get", "trusting", "config", "(", "client", "cert", "stores", ",", "server", "cert", "stores", ",", "client", "protocols", ")", ";", "map", "<", "string", ",", "object", ">", "ssl", "server", "configs", "=", "get", "trusting", "config", "(", "server", "cert", "stores", ",", "client", "cert", "stores", ",", "server", "protocols", ")", ";", "nio", "echo", "server", "server", "=", "network", "test", "utils", "create", "echo", "server", "(", "listener", "name", "for", "security", "protocol", "(", "security", "protocol", "ssl", ")", ",", "security", "protocol", "ssl", ",", "new", "test", "security", "config", "(", "ssl", "server", "configs", ")", ",", "null", ",", "time", ")", ";", "selector", "selector", "=", "create", "client", "selector", "(", "ssl", "client", "configs", ")", ";", "string", "node", "=", "\"", "0", "\"", ";", "selector", "connect", "(", "node", ",", "new", "inet", "socket", "address", "(", "\"", "localhost", "\"", ",", "server", "port", "(", ")", ")", ",", "buffer", "size", ",", "buffer", "size", ")", ";", "if", "(", "is", "compatible", "(", "server", "protocols", ",", "client", "protocols", ")", ")", "{", "network", "test", "utils", "wait", "for", "channel", "ready", "(", "selector", ",", "node", ")", ";", "int", "msg", "sz", "=", "1024", "*", "1024", ";", "string", "message", "=", "test", "utils", "random", "string", "(", "msg", "sz", ")", ";", "selector", "send", "(", "new", "network", "send", "(", "node", ",", "byte", "buffer", "send", "size", "prefixed", "(", "byte", "buffer", "wrap", "(", "message", "get", "bytes", "(", ")", ")", ")", ")", ")", ";", "while", "(", "selector", "completed", "receives", "(", ")", "is", "empty", "(", ")", ")", "{", "selector", "poll", "(", "100l", ")", ";", "}", "int", "total", "bytes", "=", "msg", "sz", "+", "4", ";", "/", "/", "including", "4", "-", "byte", "size", "server", "wait", "for", "metric", "(", "\"", "incoming", "-", "byte", "\"", ",", "total", "bytes", ")", ";", "server", "wait", "for", "metric", "(", "\"", "outgoing", "-", "byte", "\"", ",", "total", "bytes", ")", ";", "server", "wait", "for", "metric", "(", "\"", "request", "\"", ",", "1", ")", ";", "server", "wait", "for", "metric", "(", "\"", "response", "\"", ",", "1", ")", ";", "}", "else", "{", "network", "test", "utils", "wait", "for", "channel", "close", "(", "selector", ",", "node", ",", "channel", "state", "state", "authentication", "failed", ")", ";", "server", "verify", "authentication", "metrics", "(", "0", ",", "1", ")", ";", "}", "}" ]

[ "pet", "status", "in", "the", "store" ]

[ "public", "string", "get", "status", "(", ")", "{", "if", "(", "status", "=", "=", "null", ")", "{", "return", "null", ";", "}", "return", "status", "value", "(", ")", ";", "}" ]

[ "adds", "a", "listener", "to", "the", "event", "dispatcher" ]

[ "public", "void", "add", "listener", "(", "handler", "event", "handler", ",", "bandwidth", "meter", "event", "listener", "event", "listener", ")", "{", "assertions", "check", "not", "null", "(", "event", "handler", ")", ";", "assertions", "check", "not", "null", "(", "event", "listener", ")", ";", "remove", "listener", "(", "event", "listener", ")", ";", "listeners", "add", "(", "new", "handler", "and", "listener", "(", "event", "handler", ",", "event", "listener", ")", ")", ";", "}" ]

[ "return", "the", "message", "inserts" ]

[ "public", "object", "[", "]", "get", "inserts", "(", ")", "{", "return", "this", "inserts", ";", "}" ]

[ "adds", "{", "@", "link", "extension", "}", "s", "that", "will", "be", "invoked", "with", "the", "other", "mountunmount", "binders", "can", "be", "used", "to", "add", "generic", "functionality", "(", "e", "g", "accessibility", ")", "to", "a", "render", "unit", "nb", ":", "this", "method", "should", "only", "be", "called", "while", "initially", "configuring", "the", "render", "unit", "see", "the", "class", "-", "level", "javadocs", "about", "immutability" ]

[ "public", "final", "void", "add", "mount", "unmount", "extensions", "(", "extension", "<", "?", ",", "?", "super", "mount", "content", ">", "extensions", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "extensions", "length", ";", "i", "+", "+", ")", "{", "add", "mount", "unmount", "extension", "(", "extensions", "[", "i", "]", ")", ";", "}", "}" ]

[ "creates", "a", "string", "representation", "of", "the", "byte", "array", "from", "the", "given", "offset", "to", "the", "end", "of", "the", "array", "(", "for", "parsing", "other", "info", "keys", ")" ]

[ "private", "static", "string", "parse", "remaining", "key", "(", "byte", "[", "]", "b", ",", "int", "offset", ")", "{", "return", "new", "string", "(", "b", ",", "offset", ",", "b", "length", "-", "offset", ",", "charset", "for", "name", "(", "\"", "utf", "-", "8", "\"", ")", ")", ";", "}" ]

[ "this", "is", "called", "when", "the", "{", "@", "link", "mount", "item", "}", "s", "mounted", "on", "this", "{", "@", "link", "mount", "state", "}", "need", "to", "be", "re", "-", "bound", "with", "the", "same", "component", "the", "common", "case", "here", "is", "a", "detachattach", "happens", "on", "the", "{", "@", "link", "litho", "view", "}", "that", "owns", "the", "mount", "state" ]

[ "void", "rebind", "(", ")", "{", "assert", "main", "thread", "(", ")", ";", "if", "(", "m", "layout", "outputs", "ids", "=", "=", "null", ")", "{", "return", ";", "}", "for", "(", "int", "i", "=", "0", ",", "size", "=", "m", "layout", "outputs", "ids", "length", ";", "i", "<", "size", ";", "i", "+", "+", ")", "{", "final", "mount", "item", "mount", "item", "=", "get", "item", "at", "(", "i", ")", ";", "if", "(", "mount", "item", "=", "=", "null", "|", "|", "mount", "item", "is", "bound", "(", ")", ")", "{", "continue", ";", "}", "final", "component", "component", "=", "get", "layout", "output", "(", "mount", "item", ")", "get", "component", "(", ")", ";", "final", "object", "content", "=", "mount", "item", "get", "content", "(", ")", ";", "bind", "component", "to", "content", "(", "mount", "item", ",", "component", ",", "content", ")", ";", "if", "(", "content", "instanceof", "view", "&", "&", "!", "(", "content", "instanceof", "component", "host", ")", "&", "&", "(", "(", "view", ")", "content", ")", "is", "layout", "requested", "(", ")", ")", "{", "final", "view", "view", "=", "(", "view", ")", "content", ";", "apply", "bounds", "to", "mount", "content", "(", "view", ",", "view", "get", "left", "(", ")", ",", "view", "get", "top", "(", ")", ",", "view", "get", "right", "(", ")", ",", "view", "get", "bottom", "(", ")", ",", "true", ")", ";", "}", "}", "}" ]

[ "return", "a", "local", "map", "spill", "index", "file", "created", "earlier" ]

[ "public", "path", "get", "spill", "index", "file", "(", "int", "spill", "number", ")", "throws", "i", "o", "exception", "{", "return", "l", "dir", "alloc", "get", "local", "path", "to", "read", "(", "string", "format", "(", "spill", "index", "file", "pattern", ",", "conf", "get", "(", "job", "context", "task", "attempt", "id", ")", ",", "spill", "number", ")", ",", "conf", ")", ";", "}" ]

[ "create", "a", "new", "resource", "by", "p", "o", "s", "ting", "the", "given", "object", "to", "the", "url", ",", "and", "returns", "the", "response", "as", "{", "@", "link", "response", "entity", "}", "the", "{", "@", "code", "request", "}", "parameter", "can", "be", "a", "{", "@", "link", "http", "entity", "}", "in", "order", "to", "add", "additional", "http", "headers", "to", "the", "request", "the", "body", "of", "the", "entity", ",", "or", "{", "@", "code", "request", "}", "itself", ",", "can", "be", "a", "{", "@", "link", "org", "springframework", "util", "multi", "value", "map", "multi", "value", "map", "}", "to", "create", "a", "multipart", "request", "the", "values", "in", "the", "{", "@", "code", "multi", "value", "map", "}", "can", "be", "any", "object", "representing", "the", "body", "of", "the", "part", ",", "or", "an", "{", "@", "link", "org", "springframework", "http", "http", "entity", "http", "entity", "}", "representing", "a", "part", "with", "body", "and", "headers" ]

[ "<", "t", ">", "response", "entity", "<", "t", ">", "post", "for", "entity", "(", "uri", "url", ",", "@", "nullable", "object", "request", ",", "class", "<", "t", ">", "response", "type", ")", "throws", "rest", "client", "exception", ";", "/", "/", "put" ]

[ "add", "namenodes", "to", "the", "static", "resolution", "list", "to", "avoid", "going", "through", "dns", "which", "can", "be", "really", "slow", "in", "some", "configurations" ]

[ "private", "void", "setup", "static", "host", "resolution", "(", "int", "name", "service", "id", "count", ",", "string", "hostname", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "name", "service", "id", "count", ";", "i", "+", "+", ")", "{", "net", "utils", "add", "static", "resolution", "(", "hostname", "+", "i", ",", "\"", "localhost", "\"", ")", ";", "}", "}" ]

[ "process", "the", "cluster", "request" ]

[ "cluster", "response", "<", "r", ">", "process", "request", "(", "cluster", "request", "<", "t", ">", "request", ")", ";" ]

[ "given", "the", "byte", "offset", "into", "a", "unit", ",", "get", "the", "column", "position" ]

[ "public", "int", "get", "column", "position", "(", "byte", "block", "block", ",", "int", "byte", "offset", ")", "{", "return", "0", ";", "}" ]

[ "endpoint", "to", "retrieve", "a", "product", "'", "s", "inventories" ]

[ "public", "int", "get", "product", "inventories", "(", ")", "{", "return", "5", ";", "}" ]

[ "register", "one", "or", "more", "{", "@", "link", "org", "springframework", "web", "bind", "annotation", "controller", "advice", "}", "instances", "to", "be", "used", "in", "tests", "(", "specified", "{", "@", "code", "class", "}", "will", "be", "turned", "into", "instance", ")", "normally", "{", "@", "code", "@", "controller", "advice", "}", "are", "auto", "-", "detected", "as", "long", "as", "they", "'", "re", "declared", "as", "spring", "beans", "however", "since", "the", "standalone", "setup", "does", "not", "load", "any", "spring", "config", ",", "they", "need", "to", "be", "registered", "explicitly", "here", "instead", "much", "like", "controllers" ]

[ "public", "standalone", "mock", "mvc", "builder", "set", "controller", "advice", "(", "object", "controller", "advice", ")", "{", "this", "controller", "advice", "=", "instantiate", "if", "necessary", "(", "controller", "advice", ")", ";", "return", "this", ";", "}" ]

[ "get", "the", "combined", "statuses", "of", "slice", "subtasks", ",", "merged", "with", "the", "given", "list", "of", "statuses" ]

[ "public", "bulk", "by", "scroll", "task", "status", "get", "status", "(", "list", "<", "bulk", "by", "scroll", "task", "status", "or", "exception", ">", "statuses", ")", "{", "/", "/", "we", "only", "have", "access", "to", "the", "statuses", "of", "requests", "that", "have", "finished", "so", "we", "return", "them", "if", "(", "statuses", "size", "(", ")", "!", "=", "results", "length", "(", ")", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "given", "number", "of", "statuses", "does", "not", "match", "amount", "of", "expected", "results", "\"", ")", ";", "}", "add", "results", "to", "list", "(", "statuses", ")", ";", "return", "new", "bulk", "by", "scroll", "task", "status", "(", "unmodifiable", "list", "(", "statuses", ")", ",", "task", "get", "reason", "cancelled", "(", ")", ")", ";", "}" ]

[ "supply", "a", "{", "@", "code", "map", "}", "of", "beans", "to", "be", "registered", "with", "the", "jmx", "{", "@", "code", "m", "bean", "server", "}", "the", "string", "keys", "are", "the", "basis", "for", "the", "creation", "of", "jmx", "object", "names", "by", "default", ",", "a", "jmx", "{", "@", "code", "object", "name", "}", "will", "be", "created", "straight", "from", "the", "given", "key", "this", "can", "be", "customized", "through", "specifying", "a", "custom", "{", "@", "code", "naming", "strategy", "}", "both", "bean", "instances", "and", "bean", "names", "are", "allowed", "as", "values", "bean", "instances", "are", "typically", "linked", "in", "through", "bean", "references", "bean", "names", "will", "be", "resolved", "as", "beans", "in", "the", "current", "factory", ",", "respecting", "lazy", "-", "init", "markers", "(", "that", "is", ",", "not", "triggering", "initialization", "of", "such", "beans", ")" ]

[ "public", "void", "set", "beans", "(", "map", "<", "string", ",", "object", ">", "beans", ")", "{", "this", "beans", "=", "beans", ";", "}" ]

[ "picks", "the", "table", "data", "to", "use", "for", "all", "future", "states", "(", "e", "g", ",", "filtering", ",", "sorting", ",", "etc", ")", "data", "can", "be", "reused", "if", "its", "filter", "is", "a", "superset", "of", "the", "pending", "filter", "likewise", ",", "if", "the", "pending", "filter", "is", "itself", "a", "superset", "of", "the", "current", "filter", ",", "then", "this", "code", "will", "walk", "backwards", ",", "starting", "at", "the", "current", "table", "data", ",", "until", "it", "finds", "either", "the", "root", "dataset", "or", "a", "child", "of", "the", "root", "whose", "filter", "is", "a", "superset", "of", "the", "pending", "filter", "reusing", "table", "data", "in", "this", "way", "has", "the", "potential", "to", "consume", "too", "much", "memory", "(", "in", "the", "case", "where", "the", "initial", "dataset", "is", "large", "and", "each", "subsequent", "filter", "is", "a", "subset", "of", "the", "previous", "filter", ",", "where", "each", "filter", "does", "'", "t", "significantly", "reduce", "the", "newly", "filtered", "dataset", "since", "much", "memory", "could", "be", "consumed", ",", "we", "provide", "an", "option", "in", "the", "tool", "to", "disable", "this", "reuse", "of", "filtered", "data", "when", "not", "in", "use", ",", "each", "filter", "change", "will", "perform", "a", "full", "refilter", "this", "is", "not", "an", "issue", "for", "tables", "with", "moderate", "to", "small", "-", "sized", "datasets" ]

[ "private", "table", "data", "<", "t", ">", "pick", "existing", "table", "data", "(", ")", "{", "if", "(", "disable", "sub", "filtering", ")", "{", "return", "model", "get", "all", "table", "data", "(", ")", ";", "}", "table", "data", "<", "t", ">", "start", "source", "data", "=", "get", "reusable", "filtered", "data", "(", ")", ";", "/", "/", "this", "may", "be", "filtered", "if", "(", "start", "source", "data", "=", "=", "null", ")", "{", "/", "/", "must", "use", "all", "data", "due", "to", "a", "new", "filter", "start", "source", "data", "=", "model", "get", "all", "table", "data", "(", ")", ";", "}", "table", "data", "<", "t", ">", "copy", "=", "start", "source", "data", "copy", "(", ")", ";", "return", "copy", ";", "}" ]

[ "returns", "an", "immutable", "set", "containing", "{", "@", "code", "element", "}", "preferred", "over", "{", "@", "link", "collections", "#", "singleton", "}", "for", "code", "consistency", ",", "{", "@", "code", "null", "}", "rejection", ",", "and", "because", "the", "return", "type", "conveys", "the", "immutability", "guarantee" ]

[ "public", "static", "<", "e", ">", "immutable", "set", "<", "e", ">", "of", "(", "e", "element", ")", "{", "return", "new", "singleton", "immutable", "set", "<", "e", ">", "(", "element", ")", ";", "}" ]

[ "configure", "implementation", "for", "intercepting", "point" ]

[ "public", "constructor", "point", "builder", "implement", "(", "final", "string", "class", "name", "of", "advice", ")", "{", "this", "class", "name", "of", "advice", "=", "class", "name", "of", "advice", ";", "return", "this", ";", "}" ]

[ "determine", "if", "the", "currently", "captured", "view", "is", "under", "the", "given", "point", "in", "the", "parent", "view", "'", "s", "coordinate", "system", "if", "there", "is", "no", "captured", "view", "this", "method", "will", "return", "false" ]

[ "public", "boolean", "is", "captured", "view", "under", "(", "int", "x", ",", "int", "y", ")", "{", "return", "is", "view", "under", "(", "m", "captured", "view", ",", "x", ",", "y", ")", ";", "}" ]

[ "computes", "the", "quantile", "values", "of", "the", "given", "dataset", ",", "performing", "the", "computation", "in", "-", "place" ]

[ "public", "map", "<", "integer", ",", "double", ">", "compute", "in", "place", "(", "double", "dataset", ")", "{", "check", "argument", "(", "dataset", "length", ">", "0", ",", "\"", "cannot", "calculate", "quantiles", "of", "an", "empty", "dataset", "\"", ")", ";", "if", "(", "contains", "na", "n", "(", "dataset", ")", ")", "{", "map", "<", "integer", ",", "double", ">", "nan", "map", "=", "new", "linked", "hash", "map", "<", ">", "(", ")", ";", "for", "(", "int", "index", ":", "indexes", ")", "{", "nan", "map", "put", "(", "index", ",", "na", "n", ")", ";", "}", "return", "unmodifiable", "map", "(", "nan", "map", ")", ";", "}", "/", "/", "calculate", "the", "quotients", "and", "remainders", "in", "the", "integer", "division", "x", "=", "k", "*", "(", "n", "-", "1", ")", "/", "q", ",", "i", "e", "/", "/", "index", "*", "(", "dataset", "length", "-", "1", ")", "/", "scale", "for", "each", "index", "in", "indexes", "for", "each", ",", "if", "there", "is", "no", "/", "/", "remainder", ",", "we", "can", "just", "select", "the", "value", "whose", "index", "in", "the", "sorted", "dataset", "equals", "the", "/", "/", "quotient", ";", "if", "there", "is", "a", "remainder", ",", "we", "interpolate", "between", "that", "and", "the", "next", "value", "int", "[", "]", "quotients", "=", "new", "int", "[", "indexes", "length", "]", ";", "int", "[", "]", "remainders", "=", "new", "int", "[", "indexes", "length", "]", ";", "/", "/", "the", "indexes", "to", "select", "in", "the", "worst", "case", ",", "we", "'", "ll", "need", "one", "each", "side", "of", "each", "quantile", "int", "[", "]", "required", "selections", "=", "new", "int", "[", "indexes", "length", "*", "2", "]", ";", "int", "required", "selections", "count", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "indexes", "length", ";", "i", "+", "+", ")", "{", "/", "/", "since", "index", "and", "(", "dataset", "length", "-", "1", ")", "are", "non", "-", "negative", "ints", ",", "their", "product", "can", "be", "/", "/", "expressed", "as", "a", "long", ",", "without", "risk", "of", "overflow", ":", "long", "numerator", "=", "(", "long", ")", "indexes", "[", "i", "]", "*", "(", "dataset", "length", "-", "1", ")", ";", "/", "/", "since", "scale", "is", "a", "positive", "int", ",", "index", "is", "in", "[", "0", ",", "scale", "]", ",", "and", "(", "dataset", "length", "-", "1", ")", "is", "a", "/", "/", "non", "-", "negative", "int", ",", "we", "can", "do", "long", "-", "arithmetic", "on", "index", "*", "(", "dataset", "length", "-", "1", ")", "/", "scale", "to", "/", "/", "get", "a", "rounded", "ratio", "and", "a", "remainder", "which", "can", "be", "expressed", "as", "ints", ",", "without", "risk", "of", "/", "/", "overflow", ":", "int", "quotient", "=", "(", "int", ")", "long", "math", "divide", "(", "numerator", ",", "scale", ",", "rounding", "mode", "down", ")", ";", "int", "remainder", "=", "(", "int", ")", "(", "numerator", "-", "(", "long", ")", "quotient", "*", "scale", ")", ";", "quotients", "[", "i", "]", "=", "quotient", ";", "remainders", "[", "i", "]", "=", "remainder", ";", "required", "selections", "[", "required", "selections", "count", "]", "=", "quotient", ";", "required", "selections", "count", "+", "+", ";", "if", "(", "remainder", "!", "=", "0", ")", "{", "required", "selections", "[", "required", "selections", "count", "]", "=", "quotient", "+", "1", ";", "required", "selections", "count", "+", "+", ";", "}", "}", "sort", "(", "required", "selections", ",", "0", ",", "required", "selections", "count", ")", ";", "select", "all", "in", "place", "(", "required", "selections", ",", "0", ",", "required", "selections", "count", "-", "1", ",", "dataset", ",", "0", ",", "dataset", "length", "-", "1", ")", ";", "map", "<", "integer", ",", "double", ">", "ret", "=", "new", "linked", "hash", "map", "<", ">", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "indexes", "length", ";", "i", "+", "+", ")", "{", "int", "quotient", "=", "quotients", "[", "i", "]", ";", "int", "remainder", "=", "remainders", "[", "i", "]", ";", "if", "(", "remainder", "=", "=", "0", ")", "{", "ret", "put", "(", "indexes", "[", "i", "]", ",", "dataset", "[", "quotient", "]", ")", ";", "}", "else", "{", "ret", "put", "(", "indexes", "[", "i", "]", ",", "interpolate", "(", "dataset", "[", "quotient", "]", ",", "dataset", "[", "quotient", "+", "1", "]", ",", "remainder", ",", "scale", ")", ")", ";", "}", "}", "return", "unmodifiable", "map", "(", "ret", ")", ";", "}" ]

[ "sets", "the", "space", "that", "is", "left", "out", "between", "stacked", "forms", "(", "with", "no", "label", ")" ]

[ "public", "void", "set", "stack", "space", "(", "float", "space", ")", "{", "m", "stack", "space", "=", "space", ";", "}" ]

[ "ensures", "that", "the", "selected", "state", "of", "the", "button", "matches", "<", "code", ">", "selected", "<", "code", ">", "note", ":", "this", "works", "for", "most", "toggle", "button", "implementations", "which", "are", "derived", "from", "abstract", "button", "and", "relay", "on", "{", "@", "link", "abstract", "button", "#", "is", "selected", "(", ")", "}", "and", "{", "@", "link", "abstract", "button", "#", "do", "click", "(", ")", "}", "for", "toggling", ",", "such", "as", ":", "{", "@", "link", "j", "check", "box", "}", "{", "@", "link", "j", "radio", "button", "}", "{", "@", "link", "empty", "border", "toggle", "button", "}" ]

[ "public", "static", "void", "set", "toggle", "button", "selected", "(", "abstract", "button", "button", ",", "boolean", "selected", ")", "{", "boolean", "is", "selected", "=", "button", "is", "selected", "(", ")", ";", "if", "(", "is", "selected", "!", "=", "selected", ")", "{", "press", "button", "(", "button", ")", ";", "}", "}" ]

[ "clears", "a", "bit", "at", "the", "given", "index" ]

[ "public", "void", "clear", "bit", "(", "int", "index", ")", "{", "set", "bit", "(", "index", ",", "false", ")", ";", "}" ]

[ "mark", "table", "as", "invalid", "subsequent", "table", "use", "may", "generate", "an", "exception" ]

[ "void", "invalidate", "(", ")", "{", "boolean", "is", "index", "table", "=", "table", "record", "get", "indexed", "column", "(", ")", ">", "=", "0", ";", "table", "record", "=", "null", ";", "root", "buffer", "id", "=", "-", "1", ";", "node", "mgr", "=", "null", ";", "+", "+", "mod", "count", ";", "if", "(", "!", "is", "index", "table", ")", "{", "db", "table", "deleted", "(", "this", ")", ";", "}", "}" ]

[ "gets", "current", "document", "revision" ]

[ "public", "string", "get", "current", "revision", "(", "final", "string", "id", ")", "{", "return", "db", "get", "current", "revision", "(", "id", ")", ";", "}" ]

[ "return", "true", "if", "this", "additional", "properties", "class", "object", "is", "equal", "to", "o" ]

[ "public", "boolean", "equals", "(", "object", "o", ")", "{", "if", "(", "this", "=", "=", "o", ")", "{", "return", "true", ";", "}", "if", "(", "o", "=", "=", "null", "|", "|", "get", "class", "(", ")", "!", "=", "o", "get", "class", "(", ")", ")", "{", "return", "false", ";", "}", "additional", "properties", "class", "additional", "properties", "class", "=", "(", "additional", "properties", "class", ")", "o", ";", "return", "objects", "equals", "(", "this", "map", "property", ",", "additional", "properties", "class", "map", "property", ")", "&", "&", "objects", "equals", "(", "this", "map", "of", "map", "property", ",", "additional", "properties", "class", "map", "of", "map", "property", ")", "&", "&", "objects", "equals", "(", "this", "anytype", "1", ",", "additional", "properties", "class", "anytype", "1", ")", "&", "&", "objects", "equals", "(", "this", "map", "with", "undeclared", "properties", "anytype", "1", ",", "additional", "properties", "class", "map", "with", "undeclared", "properties", "anytype", "1", ")", "&", "&", "objects", "equals", "(", "this", "map", "with", "undeclared", "properties", "anytype", "2", ",", "additional", "properties", "class", "map", "with", "undeclared", "properties", "anytype", "2", ")", "&", "&", "objects", "equals", "(", "this", "map", "with", "undeclared", "properties", "anytype", "3", ",", "additional", "properties", "class", "map", "with", "undeclared", "properties", "anytype", "3", ")", "&", "&", "objects", "equals", "(", "this", "empty", "map", ",", "additional", "properties", "class", "empty", "map", ")", "&", "&", "objects", "equals", "(", "this", "map", "with", "undeclared", "properties", "string", ",", "additional", "properties", "class", "map", "with", "undeclared", "properties", "string", ")", ";", "}" ]

[ "shared", "specification", "between", "beats", ",", "logstash", ",", "and", "ingest", "node" ]

[ "public", "void", "test", "json", "specification", "(", ")", "throws", "exception", "{", "object", "mapper", "mapper", "=", "new", "object", "mapper", "(", ")", ";", "json", "node", "root", "node", "=", "mapper", "read", "tree", "(", "this", "get", "class", "(", ")", "get", "resource", "as", "stream", "(", "\"", "/", "specification", "/", "tests", "json", "\"", ")", ")", ";", "iterator", "<", "json", "node", ">", "tests", "=", "root", "node", "elements", "(", ")", ";", "while", "(", "tests", "has", "next", "(", ")", ")", "{", "json", "node", "test", "=", "tests", "next", "(", ")", ";", "boolean", "skip", "=", "test", "path", "(", "\"", "skip", "\"", ")", "as", "boolean", "(", ")", ";", "if", "(", "!", "skip", ")", "{", "string", "name", "=", "test", "path", "(", "\"", "name", "\"", ")", "as", "text", "(", ")", ";", "logger", "debug", "(", "\"", "running", "json", "specification", ":", "\"", "+", "name", ")", ";", "string", "pattern", "=", "test", "path", "(", "\"", "tok", "\"", ")", "as", "text", "(", ")", ";", "string", "input", "=", "test", "path", "(", "\"", "msg", "\"", ")", "as", "text", "(", ")", ";", "string", "append", "=", "test", "path", "(", "\"", "append", "\"", ")", "as", "text", "(", ")", ";", "boolean", "fail", "=", "test", "path", "(", "\"", "fail", "\"", ")", "as", "boolean", "(", ")", ";", "iterator", "<", "map", "entry", "<", "string", ",", "json", "node", ">", ">", "expected", "=", "test", "path", "(", "\"", "expected", "\"", ")", "fields", "(", ")", ";", "list", "<", "string", ">", "expected", "keys", "=", "new", "array", "list", "<", ">", "(", ")", ";", "list", "<", "string", ">", "expected", "values", "=", "new", "array", "list", "<", ">", "(", ")", ";", "expected", "for", "each", "remaining", "(", "entry", "-", ">", "{", "expected", "keys", "add", "(", "entry", "get", "key", "(", ")", ")", ";", "expected", "values", "add", "(", "entry", "get", "value", "(", ")", "as", "text", "(", ")", ")", ";", "}", ")", ";", "if", "(", "fail", ")", "{", "assert", "fail", "(", "pattern", ",", "input", ")", ";", "}", "else", "{", "assert", "match", "(", "pattern", ",", "input", ",", "expected", "keys", ",", "expected", "values", ",", "append", ")", ";", "}", "}", "}", "}" ]

[ "inject", "all", "of", "the", "blocks", "returned", "from", "source", "f", "s", "dataset", "'", "s", "block", "reports", "into", "destination", "f", "s", "dataset" ]

[ "private", "void", "inject", "blocks", "from", "block", "report", "(", "simulated", "f", "s", "dataset", "source", "f", "s", "dataset", ",", "simulated", "f", "s", "dataset", "destination", "f", "s", "dataset", ")", "throws", "i", "o", "exception", "{", "for", "(", "map", "entry", "<", "datanode", "storage", ",", "block", "list", "as", "longs", ">", "ent", ":", "source", "f", "s", "dataset", "get", "block", "reports", "(", "bpid", ")", "entry", "set", "(", ")", ")", "{", "destination", "f", "s", "dataset", "inject", "blocks", "(", "bpid", ",", "ent", "get", "value", "(", ")", ")", ";", "}", "}" ]

[ "throws", "an", "{", "@", "code", "unsupported", "operation", "exception", "}" ]

[ "public", "builder", "<", "k", ",", "v", ">", "order", "entries", "by", "value", "(", "comparator", "<", "?", "super", "v", ">", "value", "comparator", ")", "{", "throw", "new", "unsupported", "operation", "exception", "(", "\"", "not", "available", "on", "immutable", "sorted", "map", "builder", "\"", ")", ";", "}" ]

[ "specify", "the", "advisor", "adapter", "registry", "to", "use", "default", "is", "the", "global", "advisor", "adapter", "registry" ]

[ "public", "void", "set", "advisor", "adapter", "registry", "(", "advisor", "adapter", "registry", "advisor", "adapter", "registry", ")", "{", "this", "advisor", "adapter", "registry", "=", "advisor", "adapter", "registry", ";", "}" ]

[ "sets", "a", "built", "-", "in", "timestamp", "extractor", "that", "converts", "an", "existing", "{", "@", "link", "long", "}", "or", "{", "@", "link", "types", "#", "sql", "timestamp", "}", "field", "into", "the", "rowtime", "attribute" ]

[ "public", "rowtime", "timestamps", "from", "field", "(", "string", "field", "name", ")", "{", "internal", "properties", "put", "string", "(", "rowtime", "timestamps", "type", ",", "rowtime", "timestamps", "type", "value", "from", "field", ")", ";", "internal", "properties", "put", "string", "(", "rowtime", "timestamps", "from", ",", "field", "name", ")", ";", "return", "this", ";", "}" ]

[ "creates", "a", "directory", "for", "the", "path", "represented", "by", "this", "file" ]

[ "public", "boolean", "mkdir", "(", ")", "{", "return", "resource", "mkdir", "(", ")", ";", "}" ]

[ "comprehensive", "correctness", "testing", "is", "done", "in", "the", "test", "quantile", "digest", "aggregation", "function", "and", "test", "t", "digest", "aggregation", "function" ]

[ "public", "void", "test", "statistical", "digest", "(", "string", "type", ")", "{", "assert", "query", "(", "format", "(", "\"", "select", "value", "at", "quantile", "(", "%", "s", "agg", "(", "cast", "(", "orderkey", "as", "double", ")", ")", ",", "0", "5e0", ")", ">", "0", "from", "lineitem", "\"", ",", "type", ")", ",", "\"", "select", "true", "\"", ")", ";", "assert", "query", "(", "format", "(", "\"", "select", "value", "at", "quantile", "(", "%", "s", "agg", "(", "cast", "(", "quantity", "as", "double", ")", ")", ",", "0", "5e0", ")", ">", "0", "from", "lineitem", "\"", ",", "type", ")", ",", "\"", "select", "true", "\"", ")", ";", "assert", "query", "(", "format", "(", "\"", "select", "value", "at", "quantile", "(", "%", "s", "agg", "(", "cast", "(", "quantity", "as", "double", ")", ")", ",", "0", "5e0", ")", ">", "0", "from", "lineitem", "\"", ",", "type", ")", ",", "\"", "select", "true", "\"", ")", ";", "assert", "query", "(", "format", "(", "\"", "select", "value", "at", "quantile", "(", "%", "s", "agg", "(", "cast", "(", "orderkey", "as", "double", ")", ",", "2", ")", ",", "0", "5e0", ")", ">", "0", "from", "lineitem", "\"", ",", "type", ")", ",", "\"", "select", "true", "\"", ")", ";", "assert", "query", "(", "format", "(", "\"", "select", "value", "at", "quantile", "(", "%", "s", "agg", "(", "cast", "(", "quantity", "as", "double", ")", ",", "3", ")", ",", "0", "5e0", ")", ">", "0", "from", "lineitem", "\"", ",", "type", ")", ",", "\"", "select", "true", "\"", ")", ";", "assert", "query", "(", "format", "(", "\"", "select", "value", "at", "quantile", "(", "%", "s", "agg", "(", "cast", "(", "quantity", "as", "double", ")", ",", "4", ")", ",", "0", "5e0", ")", ">", "0", "from", "lineitem", "\"", ",", "type", ")", ",", "\"", "select", "true", "\"", ")", ";", "assert", "query", "(", "format", "(", "\"", "select", "value", "at", "quantile", "(", "%", "s", "agg", "(", "cast", "(", "orderkey", "as", "double", ")", ",", "2", ",", "0", "0001e0", ")", ",", "0", "5e0", ")", ">", "0", "from", "lineitem", "\"", ",", "type", ")", ",", "\"", "select", "true", "\"", ")", ";", "assert", "query", "(", "format", "(", "\"", "select", "value", "at", "quantile", "(", "%", "s", "agg", "(", "cast", "(", "quantity", "as", "double", ")", ",", "3", ",", "0", "0001e0", ")", ",", "0", "5e0", ")", ">", "0", "from", "lineitem", "\"", ",", "type", ")", ",", "\"", "select", "true", "\"", ")", ";", "assert", "query", "(", "format", "(", "\"", "select", "value", "at", "quantile", "(", "%", "s", "agg", "(", "cast", "(", "quantity", "as", "double", ")", ",", "4", ",", "0", "0001e0", ")", ",", "0", "5e0", ")", ">", "0", "from", "lineitem", "\"", ",", "type", ")", ",", "\"", "select", "true", "\"", ")", ";", "}" ]

[ "searches", "for", "a", "vertex", "with", "a", "matching", "id", "and", "returns", "it" ]

[ "public", "job", "vertex", "find", "vertex", "by", "i", "d", "(", "job", "vertex", "i", "d", "id", ")", "{", "return", "this", "task", "vertices", "get", "(", "id", ")", ";", "}" ]

[ "collects", "and", "processes", "all", "the", "rule", "and", "attribute", "documentation", "in", "input", "dirs", "and", "generates", "the", "build", "encyclopedia", "into", "the", "output", "dir" ]

[ "public", "abstract", "void", "generate", "documentation", "(", "list", "<", "string", ">", "input", "dirs", ",", "string", "output", "dir", ",", "string", "deny", "list", ")", "throws", "build", "encyclopedia", "doc", "exception", ",", "i", "o", "exception", ";" ]

[ "set", "the", "matrix", "to", "a", "rotation", "matrix", "between", "two", "vectors" ]

[ "public", "matrix", "4", "set", "to", "rotation", "(", "final", "float", "x", "1", ",", "final", "float", "y", "1", ",", "final", "float", "z", "1", ",", "final", "float", "x", "2", ",", "final", "float", "y", "2", ",", "final", "float", "z", "2", ")", "{", "return", "set", "(", "quat", "set", "from", "cross", "(", "x", "1", ",", "y", "1", ",", "z", "1", ",", "x", "2", ",", "y", "2", ",", "z", "2", ")", ")", ";", "}" ]

[ "executes", "the", "given", "spawn", ",", "possibly", "asynchronously", ",", "and", "returns", "a", "spawn", "continuation", "to", "represent", "the", "execution", "otherwise", "all", "requirements", "from", "{", "@", "link", "#", "exec", "}", "apply" ]

[ "default", "spawn", "continuation", "begin", "execution", "(", "spawn", "spawn", ",", "action", "execution", "context", "action", "execution", "context", ")", "throws", "interrupted", "exception", "{", "try", "{", "return", "spawn", "continuation", "immediate", "(", "exec", "(", "spawn", ",", "action", "execution", "context", ")", ")", ";", "}", "catch", "(", "exec", "exception", "e", ")", "{", "return", "spawn", "continuation", "failed", "with", "exec", "exception", "(", "e", ")", ";", "}", "}" ]

[ "a", "sensible", "definition", "of", "{", "@", "link", "#", "head", "map", "(", "object", ")", "}", "in", "terms", "of", "{", "@", "link", "#", "head", "map", "(", "object", ",", "boolean", ")", "}", "if", "you", "override", "{", "@", "code", "head", "map", "(", "k", ",", "boolean", ")", "}", ",", "you", "may", "wish", "to", "override", "{", "@", "code", "head", "map", "}", "to", "forward", "to", "this", "implementation" ]

[ "protected", "sorted", "map", "<", "k", ",", "v", ">", "standard", "head", "map", "(", "k", "to", "key", ")", "{", "return", "head", "map", "(", "to", "key", ",", "false", ")", ";", "}" ]