docstring_tokens
list
code_tokens
list
[ "parses", "information", "to", "determine", "the", "version", "of", "{", "@", "link", "abstract", "type", "program", "interface", "}", "to", "create" ]
[ "public", "abstract", "type", "program", "interface", "parse", "(", "abstract", "pdb", "pdb", ",", "task", "monitor", "monitor", ")", "throws", "i", "o", "exception", ",", "pdb", "exception", ",", "cancelled", "exception", "{", "abstract", "type", "program", "interface", "type", "program", "interface", ";", "int", "version", "number", "size", "=", "abstract", "type", "program", "interface", "get", "version", "number", "size", "(", ")", ";", "int", "stream", "number", "=", "get", "stream", "number", "(", ")", ";", "pdb", "byte", "reader", "reader", "=", "pdb", "get", "reader", "for", "stream", "number", "(", "stream", "number", ",", "0", ",", "version", "number", "size", ",", "monitor", ")", ";", "if", "(", "reader", "get", "limit", "(", ")", "<", "version", "number", "size", ")", "{", "return", "null", ";", "}", "int", "version", "number", "=", "abstract", "type", "program", "interface", "deserialize", "version", "number", "(", "reader", ")", ";", "/", "/", "todo", ":", "we", "do", "not", "know", "where", "the", "line", "should", "be", "drawn", "for", "each", "of", "these", "/", "/", "abstract", "type", "program", "interface", "instantiations", "had", "a", "ti50", "id", "that", "was", "not", "an", "800", "/", "/", "instead", "of", "a", "500", "also", "believe", "that", "ti42", "id", "was", "seen", "to", "have", "500", "rest", "is", "guess", "/", "/", "until", "we", "can", "validate", "with", "real", "data", "switch", "(", "version", "number", ")", "{", "case", "ti20", "id", ":", "case", "ti40", "id", ":", "case", "ti41", "id", ":", "type", "program", "interface", "=", "new", "type", "program", "interface", "2", "0", "0", "(", "pdb", ",", "get", "category", "(", ")", ",", "stream", "number", ")", ";", "break", ";", "case", "ti42", "id", ":", "case", "ti50dep", "id", ":", "type", "program", "interface", "=", "new", "type", "program", "interface", "5", "0", "0", "(", "pdb", ",", "get", "category", "(", ")", ",", "stream", "number", ")", ";", "break", ";", "case", "ti50", "id", ":", "case", "ti70", "id", ":", "case", "ti80", "id", ":", "type", "program", "interface", "=", "new", "type", "program", "interface", "8", "0", "0", "(", "pdb", ",", "get", "category", "(", ")", ",", "stream", "number", ")", ";", "break", ";", "default", ":", "throw", "new", "pdb", "exception", "(", "\"", "unknown", "tpi", "version", ":", "\"", "+", "version", "number", ")", ";", "}", "return", "type", "program", "interface", ";", "}" ]
[ "converts", "this", "report", "to", "a", "map", "the", "returned", "map", "is", "mutable", ",", "and", "changes", "to", "it", "do", "not", "reflect", "back", "into", "this", "report" ]
[ "public", "map", "<", "long", ",", "set", "<", "string", ">", ">", "to", "map", "(", ")", "{", "return", "deep", "copy", "(", "id", "2paths", ")", ";", "}" ]
[ "end", "to", "end", "test", "for", "get", "with", "body", "we", "test", "it", "explicitly", "as", "it", "is", "not", "supported", "out", "of", "the", "box", "by", "{", "@", "link", "org", "apache", "http", "client", "http", "client", "}", "exercises", "the", "test", "http", "server", "ability", "to", "send", "back", "whatever", "body", "it", "received" ]
[ "public", "void", "test", "get", "with", "body", "(", ")", "throws", "exception", "{", "body", "test", "(", "\"", "get", "\"", ")", ";", "}" ]
[ "initialize", "the", "rule", "with", "the", "scheduler" ]
[ "public", "abstract", "boolean", "initialize", "(", "resource", "scheduler", "scheduler", ")", "throws", "i", "o", "exception", ";" ]
[ "test", "inline", "additional", "properties" ]
[ "public", "void", "test", "inline", "additional", "properties", "(", "map", "<", "string", ",", "string", ">", "param", ")", "throws", "api", "exception", "{", "test", "inline", "additional", "properties", "with", "http", "info", "(", "param", ")", ";", "}" ]
[ "sets", "the", "relocation", "offset", "to", "the", "new", "specified", "value" ]
[ "public", "void", "set", "offset", "(", "long", "offset", ")", "{", "this", "r", "offset", "=", "offset", ";", "}" ]
[ "returns", "a", "funnel", "that", "extracts", "the", "bytes", "from", "a", "{", "@", "code", "byte", "}", "array" ]
[ "public", "static", "funnel", "<", "byte", "[", "]", ">", "byte", "array", "funnel", "(", ")", "{", "return", "byte", "array", "funnel", "instance", ";", "}" ]
[ "performs", "auto", "merge", "of", "functions", "followed", "by", "merge", "of", "function", "conflicts" ]
[ "private", "void", "merge", "functions", "(", "task", "monitor", "monitor", ")", "throws", "program", "conflict", "exception", ",", "memory", "access", "exception", ",", "cancelled", "exception", "{", "display", "initial", "phase", "message", "(", "functions", "phase", ",", "\"", "merge", "of", "function", "changes", "\"", ")", ";", "listing", "merger", "[", "]", "mergers", "=", "new", "listing", "merger", "[", "]", "{", "function", "merger", "}", ";", "auto", "merge", "(", "mergers", ",", "monitor", ")", ";", "merge", "manager", "show", "progress", "icon", "(", "false", ")", ";", "merge", "conflicts", "(", "mergers", ",", "monitor", ")", ";", "function", "merger", "merge", "thunks", "(", "merge", "panel", ",", "conflict", "option", ",", "monitor", ")", ";", "merge", "manager", "show", "progress", "icon", "(", "true", ")", ";", "remove", "bottom", "component", "(", ")", ";", "merge", "manager", "set", "completed", "(", "functions", "phase", ")", ";", "function", "merger", "dispose", "(", ")", ";", "}" ]
[ "set", "stderr", "for", "the", "shell", "script" ]
[ "public", "final", "void", "stderr", "(", "path", "stderr", "dir", ",", "string", "std", "err", "file", ")", "throws", "i", "o", "exception", "{", "if", "(", "!", "stderr", "dir", "is", "absolute", "(", ")", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "stdout", "path", "must", "be", "absolute", "\"", ")", ";", "}", "redirect", "std", "err", "=", "true", ";", "set", "std", "err", "(", "new", "path", "(", "stderr", "dir", ",", "std", "err", "file", ")", ")", ";", "}" ]
[ "create", "a", "tree", "using", "the", "values", "'", "natural", "ordering" ]
[ "public", "static", "<", "k", ",", "v", "extends", "comparable", "<", "v", ">", ">", "tree", "value", "sorted", "map", "<", "k", ",", "v", ">", "create", "with", "natural", "order", "(", ")", "{", "comparator", "<", "v", ">", "natural", "=", "comparator", "natural", "order", "(", ")", ";", "return", "new", "tree", "value", "sorted", "map", "<", ">", "(", "natural", ")", ";", "}" ]
[ "checks", "that", "multiple", "levels", "of", "nested", "includes", "where", "a", "node", "is", "both", "directly", "and", "transitively", "included", "in", "root", "by", "{", "@", "code", "include", "in", "root", "}", "and", "a", "chain", "of", "{", "@", "code", "include", "in", "parent", "}", "does", "not", "lead", "to", "duplicate", "fields", "on", "the", "root", "document" ]
[ "public", "void", "test", "multiple", "levels", "include", "root", "1", "(", ")", "throws", "exception", "{", "mapper", "service", "mapper", "service", "=", "create", "mapper", "service", "(", "mapping", "(", "b", "-", ">", "{", "}", ")", ")", ";", "string", "mapping", "=", "strings", "to", "string", "(", "x", "content", "factory", "json", "builder", "(", ")", "start", "object", "(", ")", "start", "object", "(", "mapper", "service", "single", "mapping", "name", ")", "start", "object", "(", "\"", "properties", "\"", ")", "start", "object", "(", "\"", "nested", "1", "\"", ")", "field", "(", "\"", "type", "\"", ",", "\"", "nested", "\"", ")", "field", "(", "\"", "include", "in", "root", "\"", ",", "true", ")", "field", "(", "\"", "include", "in", "parent", "\"", ",", "true", ")", "start", "object", "(", "\"", "properties", "\"", ")", "start", "object", "(", "\"", "nested", "2", "\"", ")", "field", "(", "\"", "type", "\"", ",", "\"", "nested", "\"", ")", "field", "(", "\"", "include", "in", "root", "\"", ",", "true", ")", "field", "(", "\"", "include", "in", "parent", "\"", ",", "true", ")", "end", "object", "(", ")", "end", "object", "(", ")", "end", "object", "(", ")", "end", "object", "(", ")", "end", "object", "(", ")", "end", "object", "(", ")", ")", ";", "merge", "reason", "merge", "reason", "=", "random", "from", "(", "merge", "reason", "mapping", "update", ",", "merge", "reason", "index", "template", ")", ";", "mapper", "service", "merge", "(", "mapper", "service", "single", "mapping", "name", ",", "new", "compressed", "x", "content", "(", "mapping", ")", ",", "merge", "reason", ")", ";", "document", "mapper", "doc", "mapper", "=", "mapper", "service", "document", "mapper", "(", ")", ";", "parsed", "document", "doc", "=", "doc", "mapper", "parse", "(", "new", "source", "to", "parse", "(", "\"", "test", "\"", ",", "\"", "1", "\"", ",", "bytes", "reference", "bytes", "(", "x", "content", "factory", "json", "builder", "(", ")", "start", "object", "(", ")", "start", "array", "(", "\"", "nested", "1", "\"", ")", "start", "object", "(", ")", "start", "array", "(", "\"", "nested", "2", "\"", ")", "start", "object", "(", ")", "field", "(", "\"", "foo", "\"", ",", "\"", "bar", "\"", ")", "end", "object", "(", ")", "end", "array", "(", ")", "end", "object", "(", ")", "end", "array", "(", ")", "end", "object", "(", ")", ")", ",", "x", "content", "type", "json", ")", ")", ";", "final", "collection", "<", "indexable", "field", ">", "fields", "=", "doc", "root", "doc", "(", ")", "get", "fields", "(", ")", ";", "assert", "that", "(", "fields", "size", "(", ")", ",", "equal", "to", "(", "new", "hash", "set", "<", ">", "(", "fields", ")", "size", "(", ")", ")", ")", ";", "}" ]
[ "builds", "a", "list", "of", "{", "@", "link", "path", "}", "that", "represents", "ancestors", "from", "a", "string", "like", "\"", "foobarzot", "\"" ]
[ "private", "list", "<", "path", ">", "build", "parent", "path", "(", "string", "path", "list", ",", "int", "rest", "size", ")", "{", "list", "<", "path", ">", "r", "=", "new", "array", "list", "<", ">", "(", ")", ";", "string", "tokenizer", "tokens", "=", "new", "string", "tokenizer", "(", "path", "list", ",", "\"", "/", "\"", ")", ";", "int", "total", "=", "tokens", "count", "tokens", "(", ")", ";", "int", "current", "=", "1", ";", "while", "(", "tokens", "has", "more", "tokens", "(", ")", ")", "{", "string", "token", "=", "tokens", "next", "token", "(", ")", ";", "r", "add", "(", "new", "path", "(", "create", "back", "ref", "(", "total", "-", "current", "+", "rest", "size", ")", ",", "token", ",", "true", ",", "0", ",", "true", ",", "0", ")", ")", ";", "current", "+", "+", ";", "}", "return", "r", ";", "}" ]
[ "calculates", "the", "crc", "3", "2", "based", "on", "info", "gathered", "from", "a", "given", "p", "n", "g", "chunk" ]
[ "private", "byte", "[", "]", "calculate", "c", "r", "c", "3", "2", "(", "p", "n", "g", "chunk", "chunk", ")", "{", "crc32", "checksum", "=", "new", "crc32", "(", ")", ";", "checksum", "update", "(", "byte", "buffer", "allocate", "(", "4", "+", "chunk", "get", "length", "(", ")", ")", "put", "int", "(", "chunk", "get", "chunk", "i", "d", "(", ")", ")", "put", "(", "chunk", "get", "data", "(", ")", ")", "array", "(", ")", ")", ";", "long", "result", "=", "checksum", "get", "value", "(", ")", ";", "return", "byte", "buffer", "allocate", "(", "4", ")", "put", "int", "(", "(", "int", ")", "result", ")", "array", "(", ")", ";", "}" ]
[ "gets", "registered", "principal", "resolvers" ]
[ "collection", "<", "principal", "resolver", ">", "get", "registered", "principal", "resolvers", "(", ")", ";" ]
[ "test", "the", "property", "'", "array", "of", "string", "'" ]
[ "public", "void", "array", "of", "string", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "array", "of", "string", "}" ]
[ "returns", "the", "expected", "metric", "id", "for", "a", "given", "metric", "name", "by", "default", "the", "metric", "name", "without", "any", "modifications", "is", "returned" ]
[ "string", "get", "expected", "id", "for", "metric", "name", "(", "final", "string", "metric", "name", ")", "{", "return", "metric", "name", ";", "}" ]
[ "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", "whether", "the", "parameter", "is", "declared", "with", "the", "given", "annotation", "type" ]
[ "public", "<", "a", "extends", "annotation", ">", "boolean", "has", "parameter", "annotation", "(", "class", "<", "a", ">", "annotation", "type", ")", "{", "return", "(", "get", "parameter", "annotation", "(", "annotation", "type", ")", "!", "=", "null", ")", ";", "}" ]
[ "all", "implementations", "must", "call", "this", "method", "before", "writing", "to", "the", "provided", "stdout", "stderr", "or", "to", "any", "of", "the", "output", "file", "locations", "this", "method", "is", "used", "to", "coordinate", "-", "implementations", "must", "throw", "an", "{", "@", "link", "interrupted", "exception", "}", "for", "all", "but", "one", "caller" ]
[ "void", "lock", "output", "files", "(", ")", "throws", "interrupted", "exception", ";" ]
[ "the", "i", "pv", "4", "entries" ]
[ "public", "map", "<", "string", ",", "inet", "4", "address", ">", "inet", "4", "entries", "(", ")", "{", "return", "inet", "4", "entries", ";", "}" ]
[ "overridden", "to", "focus", "the", "text", "field", "if", "request", "focus", "(", ")", "is", "called", "on", "this", "panel" ]
[ "public", "void", "request", "focus", "(", ")", "{", "filter", "field", "request", "focus", "(", ")", ";", "}" ]
[ "constructs", "a", "new", "{", "@", "link", "#", "evaluator", "}", ",", "so", "call", "before", "injecting", "a", "transformer", "into", "it", "!" ]
[ "public", "void", "initialize", "(", "boolean", "keep", "edges", ")", "{", "this", "differencer", "=", "get", "recording", "differencer", "(", ")", ";", "this", "evaluator", "=", "get", "memoizing", "evaluator", "(", "get", "sky", "function", "map", "(", ")", ",", "differencer", ",", "progress", "receiver", ",", "graph", "inconsistency", "receiver", ",", "event", "filter", ",", "keep", "edges", ")", ";", "this", "driver", "=", "get", "build", "driver", "(", "evaluator", ")", ";", "}" ]
[ "test", "for", "the", "case", "when", "the", "following", "submit", "application", "and", "administer", "queue", "a", "c", "ls", "are", "defined", ":", "root", ":", "(", "none", ")", "d", ":", "(", "all", ")", "d1", ":", "(", "none", ")", "expected", "result", ":", "access", "to", "d1", "will", "be", "permitted", "by", "root", "d", ",", "so", "the", "user", "will", "be", "able", "to", "access", "queues", "d", "and", "d1" ]
[ "public", "void", "test", "queue", "acl", "restricted", "root", "and", "d", "1", "(", ")", "throws", "i", "o", "exception", "{", "update", "config", "with", "d", "and", "d", "1", "queues", "(", "none", "acl", ",", "all", "acl", ",", "none", "acl", ")", ";", "check", "access", "(", "false", ",", "true", ",", "true", ")", ";", "}" ]
[ "tests", "{", "@", "link", "task", "counter", "}", "'", "s", "{", "@", "link", "task", "counter", "committed", "heap", "bytes", "}", "the", "test", "consists", "of", "running", "a", "low", "-", "memory", "job", "which", "consumes", "less", "heap", "memory", "and", "then", "running", "a", "high", "-", "memory", "job", "which", "consumes", "more", "heap", "memory", ",", "and", "then", "ensuring", "that", "committed", "heap", "bytes", "of", "low", "-", "memory", "job", "is", "smaller", "than", "that", "of", "the", "high", "-", "memory", "job" ]
[ "public", "void", "test", "heap", "usage", "counter", "(", ")", "throws", "exception", "{", "job", "conf", "conf", "=", "new", "job", "conf", "(", ")", ";", "/", "/", "create", "a", "local", "filesystem", "handle", "file", "system", "file", "system", "=", "file", "system", "get", "local", "(", "conf", ")", ";", "/", "/", "define", "test", "root", "directories", "path", "root", "dir", "=", "new", "path", "(", "system", "get", "property", "(", "\"", "test", "build", "data", "\"", ",", "\"", "/", "tmp", "\"", ")", ")", ";", "path", "test", "root", "dir", "=", "new", "path", "(", "root", "dir", ",", "\"", "test", "heap", "usage", "counter", "\"", ")", ";", "/", "/", "cleanup", "the", "test", "root", "directory", "file", "system", "delete", "(", "test", "root", "dir", ",", "true", ")", ";", "/", "/", "set", "the", "current", "working", "directory", "file", "system", "set", "working", "directory", "(", "test", "root", "dir", ")", ";", "file", "system", "delete", "on", "exit", "(", "test", "root", "dir", ")", ";", "/", "/", "create", "a", "mini", "cluster", "using", "the", "local", "file", "system", "mini", "m", "r", "cluster", "mr", "cluster", "=", "new", "mini", "m", "r", "cluster", "(", "1", ",", "file", "system", "get", "uri", "(", ")", "to", "string", "(", ")", ",", "1", ")", ";", "try", "{", "conf", "=", "mr", "cluster", "create", "job", "conf", "(", ")", ";", "job", "client", "job", "client", "=", "new", "job", "client", "(", "conf", ")", ";", "/", "/", "define", "job", "input", "path", "in", "dir", "=", "new", "path", "(", "test", "root", "dir", ",", "\"", "in", "\"", ")", ";", "/", "/", "create", "input", "data", "create", "words", "file", "(", "in", "dir", ",", "conf", ")", ";", "/", "/", "configure", "and", "run", "a", "low", "memory", "job", "which", "will", "run", "without", "loading", "the", "/", "/", "jvm", "'", "s", "heap", "running", "job", "low", "mem", "job", "=", "run", "heap", "usage", "test", "job", "(", "conf", ",", "test", "root", "dir", ",", "\"", "-", "xms", "3", "2m", "-", "xmx", "1", "g", "\"", ",", "0", ",", "0", ",", "file", "system", ",", "job", "client", ",", "in", "dir", ")", ";", "job", "i", "d", "low", "mem", "job", "i", "d", "=", "low", "mem", "job", "get", "i", "d", "(", ")", ";", "long", "low", "mem", "job", "map", "heap", "usage", "=", "get", "task", "counter", "usage", "(", "job", "client", ",", "low", "mem", "job", "i", "d", ",", "1", ",", "0", ",", "task", "type", "map", ")", ";", "system", "out", "println", "(", "\"", "job", "1", "(", "low", "memory", "job", ")", "map", "task", "heap", "usage", ":", "\"", "+", "low", "mem", "job", "map", "heap", "usage", ")", ";", "long", "low", "mem", "job", "reduce", "heap", "usage", "=", "get", "task", "counter", "usage", "(", "job", "client", ",", "low", "mem", "job", "i", "d", ",", "1", ",", "0", ",", "task", "type", "reduce", ")", ";", "system", "out", "println", "(", "\"", "job", "1", "(", "low", "memory", "job", ")", "reduce", "task", "heap", "usage", ":", "\"", "+", "low", "mem", "job", "reduce", "heap", "usage", ")", ";", "/", "/", "configure", "and", "run", "a", "high", "memory", "job", "which", "will", "load", "the", "jvm", "'", "s", "heap", "running", "job", "high", "mem", "job", "=", "run", "heap", "usage", "test", "job", "(", "conf", ",", "test", "root", "dir", ",", "\"", "-", "xms", "3", "2m", "-", "xmx", "1", "g", "\"", ",", "low", "mem", "job", "map", "heap", "usage", "+", "256", "*", "1024", "*", "1024", ",", "low", "mem", "job", "reduce", "heap", "usage", "+", "256", "*", "1024", "*", "1024", ",", "file", "system", ",", "job", "client", ",", "in", "dir", ")", ";", "job", "i", "d", "high", "mem", "job", "i", "d", "=", "high", "mem", "job", "get", "i", "d", "(", ")", ";", "long", "high", "mem", "job", "map", "heap", "usage", "=", "get", "task", "counter", "usage", "(", "job", "client", ",", "high", "mem", "job", "i", "d", ",", "1", ",", "0", ",", "task", "type", "map", ")", ";", "system", "out", "println", "(", "\"", "job", "2", "(", "high", "memory", "job", ")", "map", "task", "heap", "usage", ":", "\"", "+", "high", "mem", "job", "map", "heap", "usage", ")", ";", "long", "high", "mem", "job", "reduce", "heap", "usage", "=", "get", "task", "counter", "usage", "(", "job", "client", ",", "high", "mem", "job", "i", "d", ",", "1", ",", "0", ",", "task", "type", "reduce", ")", ";", "system", "out", "println", "(", "\"", "job", "2", "(", "high", "memory", "job", ")", "reduce", "task", "heap", "usage", ":", "\"", "+", "high", "mem", "job", "reduce", "heap", "usage", ")", ";", "assert", "true", "(", "\"", "incorrect", "map", "heap", "usage", "reported", "by", "the", "map", "task", "\"", ",", "low", "mem", "job", "map", "heap", "usage", "<", "high", "mem", "job", "map", "heap", "usage", ")", ";", "assert", "true", "(", "\"", "incorrect", "reduce", "heap", "usage", "reported", "by", "the", "reduce", "task", "\"", ",", "low", "mem", "job", "reduce", "heap", "usage", "<", "high", "mem", "job", "reduce", "heap", "usage", ")", ";", "}", "finally", "{", "/", "/", "shutdown", "the", "mr", "cluster", "mr", "cluster", "shutdown", "(", ")", ";", "try", "{", "file", "system", "delete", "(", "test", "root", "dir", ",", "true", ")", ";", "}", "catch", "(", "i", "o", "exception", "ioe", ")", "{", "}", "}", "}" ]
[ "a", "main", "method", "for", "testing", "the", "splash", "panel" ]
[ "public", "static", "void", "main", "(", "string", "[", "]", "args", ")", "{", "j", "frame", "frame", "=", "new", "j", "frame", "(", ")", ";", "frame", "set", "title", "(", "\"", "animation", "\"", ")", ";", "frame", "set", "size", "(", "800", ",", "600", ")", ";", "dimension", "screen", "size", "=", "toolkit", "get", "default", "toolkit", "(", ")", "get", "screen", "size", "(", ")", ";", "dimension", "frame", "size", "=", "frame", "get", "size", "(", ")", ";", "frame", "set", "location", "(", "(", "screen", "size", "width", "-", "frame", "size", "width", ")", "/", "2", ",", "(", "screen", "size", "height", "-", "frame", "size", "height", ")", "/", "2", ")", ";", "sprite", "sprite", "=", "new", "clip", "sprite", "(", "new", "constant", "color", "(", "color", "white", ")", ",", "new", "constant", "color", "(", "color", "light", "gray", ")", ",", "new", "circle", "sprite", "(", "true", ",", "new", "linear", "int", "(", "200", ",", "600", ",", "new", "sine", "timing", "(", "2345l", ",", "0l", ")", ")", ",", "new", "linear", "int", "(", "200", ",", "400", ",", "new", "sine", "timing", "(", "3210l", ",", "0l", ")", ")", ",", "new", "constant", "int", "(", "150", ")", ")", ",", "new", "color", "sprite", "(", "new", "constant", "color", "(", "color", "gray", ")", ",", "new", "font", "sprite", "(", "new", "constant", "font", "(", "new", "font", "(", "\"", "sansserif", "\"", ",", "font", "bold", ",", "90", ")", ")", ",", "new", "text", "sprite", "(", "new", "constant", "string", "(", "\"", "pro", "guard", "\"", ")", ",", "new", "constant", "int", "(", "200", ")", ",", "new", "constant", "int", "(", "300", ")", ")", ")", ")", ")", ";", "splash", "panel", "panel", "=", "new", "splash", "panel", "(", "sprite", ",", "0", "5", ")", ";", "panel", "set", "background", "(", "color", "white", ")", ";", "frame", "get", "content", "pane", "(", ")", "add", "(", "panel", ")", ";", "frame", "set", "default", "close", "operation", "(", "j", "frame", "exit", "on", "close", ")", ";", "frame", "set", "visible", "(", "true", ")", ";", "panel", "start", "(", ")", ";", "}" ]
[ "test", "to", "check", "the", "bytes", "read", "from", "buffer", "statistic", "value", "from", "abfs", "input", "stream" ]
[ "public", "void", "test", "bytes", "read", "from", "buffer", "statistic", "(", ")", "{", "describe", "(", "\"", "testing", "bytes", "read", "from", "buffer", "statistics", "value", "in", "abfs", "input", "stream", "\"", ")", ";", "abfs", "input", "stream", "statistics", "impl", "abfs", "input", "stream", "statistics", "=", "new", "abfs", "input", "stream", "statistics", "impl", "(", ")", ";", "/", "/", "increment", "the", "bytes", "read", "from", "buffer", "value", "for", "(", "int", "i", "=", "0", ";", "i", "<", "operations", ";", "i", "+", "+", ")", "{", "abfs", "input", "stream", "statistics", "bytes", "read", "from", "buffer", "(", "1", ")", ";", "}", "/", "*", "*", "since", "we", "incremented", "the", "bytes", "read", "from", "buffer", "operations", "times", ",", "this", "*", "should", "be", "the", "expected", "value", "*", "/", "assert", "equals", "(", "\"", "mismatch", "in", "bytes", "read", "from", "buffer", "value", "\"", ",", "operations", ",", "abfs", "input", "stream", "statistics", "get", "bytes", "read", "from", "buffer", "(", ")", ")", ";", "}" ]
[ "returns", "a", "predicate", "that", "evaluates", "to", "true", "for", "rule", "classes", "that", "are", "allowed", "labels", "in", "this", "attribute", "with", "warning", "if", "this", "is", "not", "a", "label", "or", "label", "-", "list", "attribute", ",", "the", "returned", "predicate", "always", "evaluates", "to", "true" ]
[ "public", "predicate", "<", "rule", "class", ">", "get", "allowed", "rule", "classes", "warning", "predicate", "(", ")", "{", "return", "allowed", "rule", "classes", "for", "labels", "warning", "as", "predicate", "of", "rule", "class", "(", ")", ";", "}" ]
[ "create", "a", "new", "{", "@", "link", "config", "def", "}", "instance", "containing", "the", "configurations", "defined", "by", "converter", "config", "this", "can", "be", "called", "by", "subclasses" ]
[ "public", "static", "config", "def", "new", "config", "def", "(", ")", "{", "return", "new", "config", "def", "(", ")", "define", "(", "type", "config", ",", "type", "string", ",", "config", "def", "no", "default", "value", ",", "in", "(", "converter", "type", "key", "get", "name", "(", ")", ",", "converter", "type", "value", "get", "name", "(", ")", ",", "converter", "type", "header", "get", "name", "(", ")", ")", ",", "importance", "low", ",", "type", "doc", ")", ";", "}" ]
[ "deletes", "a", "pet" ]
[ "public", "void", "delete", "pet", "test", "(", ")", "throws", "api", "exception", "{", "/", "/", "long", "pet", "id", "=", "null", ";", "/", "/", "string", "api", "key", "=", "null", ";", "/", "/", "api", "delete", "pet", "(", "pet", "id", ",", "api", "key", ")", ";", "/", "/", "todo", ":", "test", "validations", "}" ]
[ "test", "the", "property", "'", "1", "2", "3number", "'" ]
[ "public", "void", "1", "2", "3number", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "1", "2", "3number", "}" ]
[ "called", "when", "the", "offload", "buffer", "has", "been", "partially", "emptied" ]
[ "default", "void", "on", "offload", "buffer", "emptying", "(", ")", "{", "}" ]
[ "returns", "the", "size", "in", "bytes", "of", "the", "given", "(", "e", "-", ")", "ac", "-", "3", "syncframe" ]
[ "public", "static", "int", "parse", "ac", "3", "syncframe", "size", "(", "byte", "[", "]", "data", ")", "{", "if", "(", "data", "length", "<", "6", ")", "{", "return", "c", "length", "unset", ";", "}", "/", "/", "parse", "the", "bitstream", "id", "for", "ac", "-", "3", "and", "e", "-", "ac", "-", "3", "(", "see", "subsections", "4", "3", ",", "e", "1", "2", "and", "e", "1", "3", "1", "6", ")", "boolean", "is", "eac", "3", "=", "(", "(", "data", "[", "5", "]", "&", "0x", "f", "8", ")", ">", ">", "3", ")", ">", "10", ";", "if", "(", "is", "eac", "3", ")", "{", "int", "frmsiz", "=", "(", "data", "[", "2", "]", "&", "0x", "0", "7", ")", "<", "<", "8", ";", "/", "/", "most", "significant", "3", "bits", "frmsiz", "|", "=", "data", "[", "3", "]", "&", "0x", "f", "f", ";", "/", "/", "least", "significant", "8", "bits", "return", "(", "frmsiz", "+", "1", ")", "*", "2", ";", "/", "/", "see", "frmsiz", "in", "subsection", "e", "1", "3", "1", "3", "}", "else", "{", "int", "fscod", "=", "(", "data", "[", "4", "]", "&", "0x", "c", "0", ")", ">", ">", "6", ";", "int", "frmsizecod", "=", "data", "[", "4", "]", "&", "0x", "3", "f", ";", "return", "get", "ac", "3", "syncframe", "size", "(", "fscod", ",", "frmsizecod", ")", ";", "}", "}" ]
[ "check", "for", "any", "data", "member", "in", "the", "composite", "with", "the", "specified", "name", "other", "than", "the", "component", "at", "the", "specified", "index" ]
[ "protected", "boolean", "name", "exists", "elsewhere", "(", "string", "name", ",", "int", "row", "index", ")", "{", "if", "(", "name", "!", "=", "null", ")", "{", "int", "num", "components", "=", "get", "num", "components", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "row", "index", "&", "&", "i", "<", "num", "components", ";", "i", "+", "+", ")", "{", "if", "(", "name", "equals", "(", "get", "component", "(", "i", ")", "get", "field", "name", "(", ")", ")", ")", "{", "return", "true", ";", "}", "}", "for", "(", "int", "i", "=", "row", "index", "+", "1", ";", "i", "<", "num", "components", ";", "i", "+", "+", ")", "{", "if", "(", "name", "equals", "(", "get", "component", "(", "i", ")", "get", "field", "name", "(", ")", ")", ")", "{", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}" ]
[ "gets", "the", "setting", "indicating", "if", "byte", "differences", "are", "currently", "being", "ignored" ]
[ "public", "boolean", "is", "ignoring", "byte", "diffs", "(", ")", "{", "return", "ignore", "byte", "diffs", ";", "}" ]
[ "test", "the", "dfs", "datanode", "failed", "volumes", "tolerated", "key", "configuration", "option", ",", "ie", "the", "dn", "tolerates", "a", "failed", "-", "to", "-", "use", "scenario", "during", "its", "start", "-", "up" ]
[ "public", "void", "test", "valid", "volumes", "at", "startup", "(", ")", "throws", "exception", "{", "assume", "not", "windows", "(", ")", ";", "/", "/", "make", "sure", "no", "d", "ns", "are", "running", "cluster", "shutdown", "data", "nodes", "(", ")", ";", "/", "/", "bring", "up", "a", "datanode", "with", "two", "default", "data", "dirs", ",", "but", "with", "one", "bad", "one", "conf", "set", "int", "(", "d", "f", "s", "config", "keys", "dfs", "datanode", "failed", "volumes", "tolerated", "key", ",", "1", ")", ";", "/", "/", "we", "use", "subdirectories", "0", "and", "1", "in", "order", "to", "have", "only", "a", "single", "/", "/", "data", "dir", "'", "s", "parent", "inject", "a", "failure", "file", "tld", "=", "new", "file", "(", "mini", "d", "f", "s", "cluster", "get", "base", "directory", "(", ")", ",", "\"", "bad", "data", "\"", ")", ";", "file", "data", "dir", "1", "=", "new", "file", "(", "tld", ",", "\"", "data", "1", "\"", ")", ";", "file", "data", "dir", "1", "actual", "=", "new", "file", "(", "data", "dir", "1", ",", "\"", "1", "\"", ")", ";", "data", "dir", "1", "actual", "mkdirs", "(", ")", ";", "/", "/", "force", "an", "ioe", "to", "occur", "on", "one", "of", "the", "dfs", "data", "dir", "file", "data", "dir", "2", "=", "new", "file", "(", "tld", ",", "\"", "data", "2", "\"", ")", ";", "prepare", "dir", "to", "fail", "(", "data", "dir", "2", ")", ";", "file", "data", "dir", "2", "actual", "=", "new", "file", "(", "data", "dir", "2", ",", "\"", "2", "\"", ")", ";", "/", "/", "start", "one", "dn", ",", "with", "manually", "managed", "dn", "dir", "conf", "set", "(", "d", "f", "s", "config", "keys", "dfs", "datanode", "data", "dir", "key", ",", "data", "dir", "1", "actual", "get", "path", "(", ")", "+", "\"", ",", "\"", "+", "data", "dir", "2", "actual", "get", "path", "(", ")", ")", ";", "cluster", "start", "data", "nodes", "(", "conf", ",", "1", ",", "false", ",", "null", ",", "null", ")", ";", "cluster", "wait", "active", "(", ")", ";", "try", "{", "assert", "true", "(", "\"", "the", "dn", "should", "have", "started", "up", "fine", "\"", ",", "cluster", "is", "data", "node", "up", "(", ")", ")", ";", "data", "node", "dn", "=", "cluster", "get", "data", "nodes", "(", ")", "get", "(", "0", ")", ";", "string", "si", "=", "data", "node", "test", "utils", "get", "f", "s", "dataset", "(", "dn", ")", "get", "storage", "info", "(", ")", ";", "assert", "true", "(", "\"", "the", "dn", "should", "have", "started", "with", "this", "directory", "\"", ",", "si", "contains", "(", "data", "dir", "1", "actual", "get", "path", "(", ")", ")", ")", ";", "assert", "false", "(", "\"", "the", "dn", "shouldn", "'", "t", "have", "a", "bad", "directory", "\"", ",", "si", "contains", "(", "data", "dir", "2", "actual", "get", "path", "(", ")", ")", ")", ";", "}", "finally", "{", "cluster", "shutdown", "data", "nodes", "(", ")", ";", "file", "util", "chmod", "(", "data", "dir", "2", "to", "string", "(", ")", ",", "\"", "755", "\"", ")", ";", "}", "}" ]
[ "writes", "the", "given", "lines", "of", "text", "to", "this", "sink", "with", "each", "line", "(", "including", "the", "last", ")", "terminated", "with", "the", "operating", "system", "'", "s", "default", "line", "separator", "this", "method", "is", "equivalent", "to", "{", "@", "code", "write", "lines", "(", "lines", ",", "system", "get", "property", "(", "\"", "line", "separator", "\"", ")", ")", "}" ]
[ "public", "void", "write", "lines", "(", "iterable", "<", "?", "extends", "char", "sequence", ">", "lines", ")", "throws", "i", "o", "exception", "{", "write", "lines", "(", "lines", ",", "system", "get", "property", "(", "\"", "line", "separator", "\"", ")", ")", ";", "}" ]
[ "get", "the", "description", "of", "the", "namenode", "to", "monitor" ]
[ "public", "string", "get", "namenode", "desc", "(", ")", "{", "if", "(", "namenode", "id", "!", "=", "null", "&", "&", "!", "namenode", "id", "is", "empty", "(", ")", ")", "{", "return", "nameservice", "id", "+", "\"", "-", "\"", "+", "namenode", "id", "+", "\"", ":", "\"", "+", "service", "address", ";", "}", "else", "{", "return", "nameservice", "id", "+", "\"", ":", "\"", "+", "service", "address", ";", "}", "}" ]
[ "set", "the", "specified", "value", "as", "current", "property", "value" ]
[ "void", "set", "property", "value", "(", "property", "value", "pv", ")", "throws", "beans", "exception", ";" ]
[ "if", "set", ",", "will", "enable", "scrolling", "of", "the", "search", "request" ]
[ "public", "search", "scroll", "request", "scroll", "(", "scroll", "scroll", ")", "{", "this", "scroll", "=", "scroll", ";", "return", "this", ";", "}" ]
[ "used", "in", "painless", "scripting" ]
[ "public", "static", "object", "process", "(", "object", "unit", ",", "object", "number", "of", "units", ",", "object", "timestamp", ",", "zone", "id", "zone", "id", ")", "{", "if", "(", "unit", "=", "=", "null", "|", "|", "number", "of", "units", "=", "=", "null", "|", "|", "timestamp", "=", "=", "null", ")", "{", "return", "null", ";", "}", "if", "(", "unit", "instanceof", "string", "=", "=", "false", ")", "{", "throw", "new", "sql", "illegal", "argument", "exception", "(", "\"", "a", "string", "is", "required", ";", "received", "[", "{", "}", "]", "\"", ",", "unit", ")", ";", "}", "part", "date", "part", "field", "=", "part", "resolve", "(", "(", "string", ")", "unit", ")", ";", "if", "(", "date", "part", "field", "=", "=", "null", ")", "{", "list", "<", "string", ">", "similar", "=", "part", "find", "similar", "(", "(", "string", ")", "unit", ")", ";", "if", "(", "similar", "is", "empty", "(", ")", ")", "{", "throw", "new", "sql", "illegal", "argument", "exception", "(", "\"", "a", "value", "of", "{", "}", "or", "their", "aliases", "is", "required", ";", "received", "[", "{", "}", "]", "\"", ",", "part", "values", "(", ")", ",", "unit", ")", ";", "}", "else", "{", "throw", "new", "sql", "illegal", "argument", "exception", "(", "\"", "received", "value", "[", "{", "}", "]", "is", "not", "valid", "date", "part", "to", "add", ";", "\"", "+", "\"", "did", "you", "mean", "{", "}", "?", "\"", ",", "unit", ",", "similar", ")", ";", "}", "}", "if", "(", "number", "of", "units", "instanceof", "number", "=", "=", "false", ")", "{", "throw", "new", "sql", "illegal", "argument", "exception", "(", "\"", "a", "number", "is", "required", ";", "received", "[", "{", "}", "]", "\"", ",", "number", "of", "units", ")", ";", "}", "if", "(", "timestamp", "instanceof", "zoned", "date", "time", "=", "=", "false", ")", "{", "throw", "new", "sql", "illegal", "argument", "exception", "(", "\"", "a", "date", "/", "datetime", "is", "required", ";", "received", "[", "{", "}", "]", "\"", ",", "timestamp", ")", ";", "}", "return", "date", "part", "field", "add", "(", "(", "(", "zoned", "date", "time", ")", "timestamp", ")", "with", "zone", "same", "instant", "(", "zone", "id", ")", ",", "(", "(", "number", ")", "number", "of", "units", ")", "int", "value", "(", ")", ")", ";", "}" ]
[ "disable", "erasure", "coding", "policy" ]
[ "public", "void", "disable", "erasure", "coding", "policy", "(", "string", "ec", "policy", "name", ")", "throws", "i", "o", "exception", "{", "dfs", "disable", "erasure", "coding", "policy", "(", "ec", "policy", "name", ")", ";", "}" ]
[ "the", "name", "of", "the", "enumflag", "as", "a", "reference", "enumsflag", "items", "are", "generated", "as", "id", "resource", "values", "<", "code", ">", "optional", "aapt", "pb", "reference", "name", "=", "3", ";", "<", "code", ">" ]
[ "private", "void", "clear", "name", "(", ")", "{", "name", "=", "null", ";", "bit", "field", "0", "=", "(", "bit", "field", "0", "&", "~", "0x", "0", "0", "0", "0", "0", "0", "0", "4", ")", ";", "}" ]
[ "register", "a", "listener", "that", "will", "be", "called", "when", "this", "model", "visibility", "state", "has", "changed", "the", "listener", "will", "contribute", "to", "this", "model", "'", "s", "hash", "code", "state", "per", "the", "{", "@", "link", "com", "airbnb", "epoxy", "epoxy", "attribute", "option", "#", "do", "not", "hash", "}", "rules" ]
[ "public", "generate", "default", "layout", "method", "on", "visibility", "state", "changed", "(", "on", "model", "visibility", "state", "changed", "listener", "<", "generate", "default", "layout", "method", ",", "object", ">", "listener", ")", "{", "on", "mutation", "(", ")", ";", "this", "on", "model", "visibility", "state", "changed", "listener", "epoxy", "generated", "model", "=", "listener", ";", "return", "this", ";", "}" ]
[ "returns", "a", "predicate", "that", "evaluates", "to", "{", "@", "code", "true", "}", "if", "the", "object", "reference", "being", "tested", "is", "a", "member", "of", "the", "given", "collection", "it", "does", "not", "defensively", "copy", "the", "collection", "passed", "in", ",", "so", "future", "changes", "to", "it", "will", "alter", "the", "behavior", "of", "the", "predicate", "this", "method", "can", "technically", "accept", "any", "{", "@", "code", "collection", "<", "?", ">", "}", ",", "but", "using", "a", "typed", "collection", "helps", "prevent", "bugs", "this", "approach", "doesn", "'", "t", "block", "any", "potential", "users", "since", "it", "is", "always", "possible", "to", "use", "{", "@", "code", "predicates", "<", "object", ">", "in", "(", ")", "}" ]
[ "public", "static", "<", "t", ">", "predicate", "<", "t", ">", "in", "(", "collection", "<", "?", "extends", "t", ">", "target", ")", "{", "return", "new", "in", "predicate", "<", "t", ">", "(", "target", ")", ";", "}" ]
[ "returns", "filesitems", "with", "the", "specified", "name", "or", "null", "if", "fileitem", "not", "found", "within", "this", "folder" ]
[ "public", "repository", "file", "get", "file", "(", "string", "file", "name", ")", "{", "synchronized", "(", "file", "system", ")", "{", "repository", "file", "rf", "=", "file", "map", "get", "(", "file", "name", ")", ";", "if", "(", "rf", "!", "=", "null", ")", "{", "return", "rf", ";", "}", "if", "(", "file", "system", "file", "exists", "(", "get", "pathname", "(", ")", ",", "file", "name", ")", ")", "{", "try", "{", "rf", "=", "new", "repository", "file", "(", "repository", ",", "file", "system", ",", "this", ",", "file", "name", ")", ";", "file", "map", "put", "(", "file", "name", ",", "rf", ")", ";", "return", "rf", ";", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "log", "error", "(", "\"", "repository", "'", "\"", "+", "repository", "get", "name", "(", ")", "+", "\"", "'", "file", "error", ":", "\"", "+", "e", "get", "message", "(", ")", "+", "\"", "\\", "n", "\"", "+", "make", "pathname", "(", "get", "pathname", "(", ")", ",", "file", "name", ")", ")", ";", "}", "}", "return", "null", ";", "}", "}" ]
[ "returns", "the", "hashed", "index", "for", "the", "given", "key" ]
[ "private", "int", "hash", "index", "(", "int", "key", ")", "{", "/", "/", "the", "array", "lengths", "are", "always", "a", "power", "of", "two", ",", "so", "we", "can", "use", "a", "bitmask", "to", "stay", "inside", "the", "array", "bounds", "return", "hash", "code", "(", "key", ")", "&", "mask", ";", "}" ]
[ "enabledisable", "contrast", "mode" ]
[ "public", "void", "set", "contrast", "mode", "(", "final", "boolean", "is", "contrast", "mode", ")", "{", "this", "is", "contrast", "mode", "=", "is", "contrast", "mode", ";", "}" ]
[ "returns", "the", "duration", "of", "the", "specified", "chunk" ]
[ "public", "long", "get", "chunk", "duration", "us", "(", "int", "chunk", "index", ")", "{", "return", "(", "chunk", "index", "=", "=", "chunk", "count", "-", "1", ")", "?", "last", "chunk", "duration", "us", ":", "chunk", "start", "times", "us", "[", "chunk", "index", "+", "1", "]", "-", "chunk", "start", "times", "us", "[", "chunk", "index", "]", ";", "}" ]
[ "look", "up", "an", "external", "rest", "api" ]
[ "public", "string", "lookup", "external", "rest", "a", "p", "i", "(", "string", "user", ",", "string", "service", "class", ",", "string", "instance", ",", "string", "api", ")", "throws", "i", "o", "exception", "{", "string", "qualified", "=", "qualify", "user", "(", "user", ")", ";", "string", "path", "=", "service", "path", "(", "qualified", ",", "service", "class", ",", "instance", ")", ";", "string", "rest", "a", "p", "i", "=", "resolve", "external", "rest", "a", "p", "i", "(", "api", ",", "path", ")", ";", "if", "(", "rest", "a", "p", "i", "=", "=", "null", ")", "{", "throw", "new", "path", "not", "found", "exception", "(", "path", "+", "\"", "api", "\"", "+", "api", ")", ";", "}", "return", "rest", "a", "p", "i", ";", "}" ]
[ "set", "the", "given", "plain", "text", "and", "html", "text", "as", "alternatives", ",", "offering", "both", "options", "to", "the", "email", "client", "requires", "multipart", "mode", "<", "b", ">", "note", ":", "<", "b", ">", "invoke", "{", "@", "link", "#", "add", "inline", "}", "after", "{", "@", "code", "set", "text", "}", ";", "else", ",", "mail", "readers", "might", "not", "be", "able", "to", "resolve", "inline", "references", "correctly" ]
[ "public", "void", "set", "text", "(", "string", "plain", "text", ",", "string", "html", "text", ")", "throws", "messaging", "exception", "{", "assert", "not", "null", "(", "plain", "text", ",", "\"", "plain", "text", "must", "not", "be", "null", "\"", ")", ";", "assert", "not", "null", "(", "html", "text", ",", "\"", "html", "text", "must", "not", "be", "null", "\"", ")", ";", "mime", "multipart", "message", "body", "=", "new", "mime", "multipart", "(", "multipart", "subtype", "alternative", ")", ";", "get", "main", "part", "(", ")", "set", "content", "(", "message", "body", ",", "content", "type", "alternative", ")", ";", "/", "/", "create", "the", "plain", "text", "part", "of", "the", "message", "mime", "body", "part", "plain", "text", "part", "=", "new", "mime", "body", "part", "(", ")", ";", "set", "plain", "text", "to", "mime", "part", "(", "plain", "text", "part", ",", "plain", "text", ")", ";", "message", "body", "add", "body", "part", "(", "plain", "text", "part", ")", ";", "/", "/", "create", "the", "html", "text", "part", "of", "the", "message", "mime", "body", "part", "html", "text", "part", "=", "new", "mime", "body", "part", "(", ")", ";", "set", "html", "text", "to", "mime", "part", "(", "html", "text", "part", ",", "html", "text", ")", ";", "message", "body", "add", "body", "part", "(", "html", "text", "part", ")", ";", "}" ]
[ "return", "the", "parcelable", "in", "cache" ]
[ "public", "static", "<", "t", ">", "t", "get", "parcelable", "(", "@", "non", "null", "final", "string", "key", ",", "@", "non", "null", "final", "parcelable", "creator", "<", "t", ">", "creator", ")", "{", "return", "get", "parcelable", "(", "key", ",", "creator", ",", "get", "default", "cache", "double", "utils", "(", ")", ")", ";", "}" ]
[ "test", "the", "property", "'", "class", "name", "'" ]
[ "public", "void", "class", "name", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "class", "name", "}" ]
[ "whether", "the", "node", "has", "been", "logically", "removed" ]
[ "static", "boolean", "is", "node", "removed", "(", "long", "node", ",", "allocator", "space", "allocator", ")", "{", "if", "(", "node", "=", "=", "nil", "node", ")", "{", "return", "false", ";", "}", "chunk", "chunk", "=", "space", "allocator", "get", "chunk", "by", "id", "(", "space", "utils", "get", "chunk", "id", "by", "address", "(", "node", ")", ")", ";", "int", "offset", "in", "chunk", "=", "space", "utils", "get", "chunk", "offset", "by", "address", "(", "node", ")", ";", "memory", "segment", "segment", "=", "chunk", "get", "memory", "segment", "(", "offset", "in", "chunk", ")", ";", "int", "offset", "in", "byte", "buffer", "=", "chunk", "get", "offset", "in", "segment", "(", "offset", "in", "chunk", ")", ";", "return", "get", "node", "status", "(", "segment", ",", "offset", "in", "byte", "buffer", ")", "=", "=", "node", "status", "remove", ";", "}" ]
[ "asynchronous", "version", "of", "{", "@", "link", "abstract", "dao", "#", "insert", "(", "object", ")", "}" ]
[ "public", "async", "operation", "insert", "(", "object", "entity", ",", "int", "flags", ")", "{", "return", "enqueue", "entity", "operation", "(", "operation", "type", "insert", ",", "entity", ",", "flags", ")", ";", "}" ]
[ "returns", "the", "next", "captured", "outbound", "message", "event" ]
[ "string", "next", "inbound", "event", "(", ")", ";" ]
[ "paint", "the", "element" ]
[ "private", "void", "paint", "(", "paint", "event", "e", ")", "{", "/", "*", "*", "draw", "the", "top", "two", "lines", "of", "the", "tab", ",", "same", "for", "selected", ",", "hover", "and", "*", "default", "*", "/", "rectangle", "bounds", "=", "get", "bounds", "(", ")", ";", "e", "gc", "set", "foreground", "(", "widget", "normal", "shadow", ")", ";", "e", "gc", "draw", "line", "(", "0", ",", "0", ",", "bounds", "width", "-", "1", ",", "0", ")", ";", "e", "gc", "set", "foreground", "(", "list", "background", ")", ";", "e", "gc", "draw", "line", "(", "0", ",", "1", ",", "bounds", "width", "-", "1", ",", "1", ")", ";", "/", "*", "draw", "the", "fill", "in", "the", "tab", "*", "/", "if", "(", "selected", ")", "{", "e", "gc", "set", "background", "(", "list", "background", ")", ";", "e", "gc", "fill", "rectangle", "(", "0", ",", "2", ",", "bounds", "width", ",", "bounds", "height", "-", "1", ")", ";", "}", "else", "if", "(", "hover", "&", "&", "tab", "is", "indented", "(", ")", ")", "{", "e", "gc", "set", "background", "(", "indented", "hover", "background", ")", ";", "e", "gc", "fill", "rectangle", "(", "0", ",", "2", ",", "bounds", "width", "-", "1", ",", "bounds", "height", "-", "1", ")", ";", "}", "else", "if", "(", "hover", ")", "{", "e", "gc", "set", "foreground", "(", "hover", "gradient", "start", ")", ";", "e", "gc", "set", "background", "(", "hover", "gradient", "end", ")", ";", "e", "gc", "fill", "gradient", "rectangle", "(", "0", ",", "2", ",", "bounds", "width", "-", "1", ",", "bounds", "height", "-", "1", ",", "true", ")", ";", "}", "else", "if", "(", "tab", "is", "indented", "(", ")", ")", "{", "e", "gc", "set", "background", "(", "indented", "default", "background", ")", ";", "e", "gc", "fill", "rectangle", "(", "0", ",", "2", ",", "bounds", "width", "-", "1", ",", "bounds", "height", "-", "1", ")", ";", "}", "else", "{", "e", "gc", "set", "background", "(", "element", "background", ")", ";", "e", "gc", "fill", "rectangle", "(", "0", ",", "2", ",", "bounds", "width", "-", "1", ",", "bounds", "height", "-", "1", ")", ";", "/", "/", "e", "gc", "set", "background", "(", "default", "gradient", "end", ")", ";", "/", "/", "e", "gc", "fill", "gradient", "rectangle", "(", "0", ",", "2", ",", "bounds", "width", "-", "1", ",", "bounds", "height", "-", "1", ",", "true", ")", ";", "}", "if", "(", "!", "selected", ")", "{", "e", "gc", "set", "foreground", "(", "widget", "normal", "shadow", ")", ";", "e", "gc", "draw", "line", "(", "bounds", "width", "-", "1", ",", "1", ",", "bounds", "width", "-", "1", ",", "bounds", "height", "+", "1", ")", ";", "}", "/", "*", "*", "add", "indent", "left", "pixels", "to", "the", "left", "as", "a", "margin", "*", "/", "int", "text", "indent", "=", "indent", "left", ";", "font", "metrics", "fm", "=", "e", "gc", "get", "font", "metrics", "(", ")", ";", "int", "height", "=", "fm", "get", "height", "(", ")", ";", "int", "text", "middle", "=", "(", "bounds", "height", "-", "height", ")", "/", "2", ";", "if", "(", "tab", "get", "image", "(", ")", "!", "=", "null", ")", "{", "/", "*", "draw", "the", "icon", "for", "the", "selected", "tab", "*", "/", "if", "(", "tab", "is", "indented", "(", ")", ")", "{", "text", "indent", "=", "text", "indent", "+", "indent", "left", ";", "}", "else", "{", "text", "indent", "=", "text", "indent", "-", "3", ";", "}", "image", "image", "=", "d", "beaver", "icons", "get", "image", "(", "tab", "get", "image", "(", ")", ")", ";", "if", "(", "selected", "|", "|", "hover", ")", "{", "e", "gc", "draw", "image", "(", "image", ",", "text", "indent", ",", "text", "middle", "-", "1", ")", ";", "}", "else", "{", "e", "gc", "draw", "image", "(", "get", "grayed", "image", "(", "image", ")", ",", "text", "indent", ",", "text", "middle", "-", "1", ")", ";", "}", "text", "indent", "=", "text", "indent", "+", "image", "get", "bounds", "(", ")", "width", "+", "4", ";", "}", "else", "if", "(", "tab", "is", "indented", "(", ")", ")", "{", "text", "indent", "=", "text", "indent", "+", "indent", "left", ";", "}", "/", "*", "draw", "the", "text", "*", "/", "e", "gc", "set", "foreground", "(", "widget", "foreground", ")", ";", "if", "(", "selected", ")", "{", "/", "*", "selected", "tab", "is", "bold", "font", "*", "/", "e", "gc", "set", "font", "(", "j", "face", "resources", "get", "font", "registry", "(", ")", "get", "bold", "(", "j", "face", "resources", "default", "font", ")", ")", ";", "}", "e", "gc", "draw", "text", "(", "tab", "get", "text", "(", ")", ",", "text", "indent", ",", "text", "middle", ",", "true", ")", ";", "if", "(", "(", "(", "tabbed", "folder", "list", ")", "get", "parent", "(", ")", ")", "focus", "&", "&", "selected", ")", "{", "/", "*", "draw", "a", "line", "if", "the", "tab", "has", "focus", "*", "/", "point", "point", "=", "e", "gc", "text", "extent", "(", "tab", "get", "text", "(", ")", ")", ";", "e", "gc", "draw", "line", "(", "text", "indent", ",", "bounds", "height", "-", "4", ",", "text", "indent", "+", "point", "x", ",", "bounds", "height", "-", "4", ")", ";", "}", "/", "*", "draw", "the", "bottom", "line", "on", "the", "tab", "for", "selected", "and", "default", "*", "/", "if", "(", "!", "hover", ")", "{", "e", "gc", "set", "foreground", "(", "list", "background", ")", ";", "e", "gc", "draw", "line", "(", "0", ",", "bounds", "height", "-", "1", ",", "bounds", "width", "-", "2", ",", "bounds", "height", "-", "1", ")", ";", "}", "}" ]
[ "move", "the", "cursor", "to", "the", "front", "of", "this", "row", "set", ",", "just", "before", "the", "first", "row" ]
[ "void", "before", "first", "(", ")", "throws", "invalid", "result", "set", "access", "exception", ";" ]
[ "indicate", "that", "the", "test", "run", "has", "started", "this", "should", "be", "called", "after", "all", "filtering", "has", "been", "completed" ]
[ "public", "void", "test", "run", "started", "(", "description", "top", "level", "description", ")", "{", "mark", "children", "as", "pending", "(", "top", "level", "description", ")", ";", "}" ]
[ "associates", "the", "given", "value", "with", "every", "index", "from", "start", "to", "end", "(", "inclusive", ")", "any", "previous", "associates", "are", "overwritten" ]
[ "public", "void", "paint", "range", "(", "address", "start", "addr", ",", "address", "end", "addr", ",", "field", "value", ")", "{", "lock", "acquire", "(", ")", ";", "try", "{", "last", "start", "=", "start", "addr", ";", "last", "end", "=", "end", "addr", ";", "last", "value", "=", "value", ";", "last", "range", "=", "null", ";", "if", "(", "start", "addr", "compare", "to", "(", "end", "addr", ")", ">", "0", ")", "throw", "new", "illegal", "argument", "exception", "(", ")", ";", "+", "+", "mod", "count", ";", "for", "(", "key", "range", "range", ":", "addr", "map", "get", "key", "ranges", "(", "start", "addr", ",", "end", "addr", ",", "true", ")", ")", "{", "paint", "range", "(", "range", "min", "key", ",", "range", "max", "key", ",", "value", ")", ";", "}", "}", "finally", "{", "lock", "release", "(", ")", ";", "}", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "void", "visit", "move", "insn", "(", "normal", "ssa", "insn", "insn", ")", "{", "add", "to", "uses", "(", "insn", ")", ";", "}" ]
[ "renames", "an", "existing", "map", "directory" ]
[ "public", "static", "void", "rename", "(", "file", "system", "fs", ",", "string", "old", "name", ",", "string", "new", "name", ")", "throws", "i", "o", "exception", "{", "path", "old", "dir", "=", "new", "path", "(", "old", "name", ")", ";", "path", "new", "dir", "=", "new", "path", "(", "new", "name", ")", ";", "if", "(", "!", "fs", "rename", "(", "old", "dir", ",", "new", "dir", ")", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "could", "not", "rename", "\"", "+", "old", "dir", "+", "\"", "to", "\"", "+", "new", "dir", ")", ";", "}", "}" ]
[ "default", ":", "-", "1" ]
[ "public", "builder", "set", "queue", "size", "per", "handler", "(", "int", "queue", "size", "per", "handler", ")", "{", "this", "queue", "size", "per", "handler", "=", "queue", "size", "per", "handler", ";", "return", "this", ";", "}" ]
[ "get", "the", "sum", "of", "each", "subcluster", "statistics" ]
[ "private", "long", "[", "]", "get", "aggregate", "stats", "(", ")", "throws", "exception", "{", "long", "[", "]", "individual", "data", "=", "new", "long", "[", "10", "]", ";", "for", "(", "string", "nameservice", ":", "cluster", "get", "nameservices", "(", ")", ")", "{", "namenode", "context", "n", "=", "cluster", "get", "namenode", "(", "nameservice", ",", "null", ")", ";", "d", "f", "s", "client", "client", "=", "n", "get", "client", "(", ")", ";", "client", "protocol", "client", "protocol", "=", "client", "get", "namenode", "(", ")", ";", "long", "[", "]", "data", "=", "client", "protocol", "get", "stats", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "data", "length", ";", "i", "+", "+", ")", "{", "individual", "data", "[", "i", "]", "+", "=", "data", "[", "i", "]", ";", "}", "}", "return", "individual", "data", ";", "}" ]
[ "returns", "a", "new", "path", "fragment", "that", "is", "a", "sub", "fragment", "of", "this", "one", "the", "sub", "fragment", "begins", "at", "the", "specified", "<", "code", ">", "begin", "index", "<", "code", ">", "segment", "and", "ends", "at", "the", "segment", "at", "index", "<", "code", ">", "end", "index", "-", "1", "<", "code", ">", "thus", "the", "number", "of", "segments", "in", "the", "new", "path", "fragment", "is", "<", "code", ">", "end", "index", "-", "begin", "index", "<", "code", ">", "this", "operation", "is", "o", "(", "n", ")", "on", "the", "length", "of", "the", "string" ]
[ "public", "path", "fragment", "sub", "fragment", "(", "int", "begin", "index", ",", "int", "end", "index", ")", "{", "if", "(", "begin", "index", "<", "0", "|", "|", "begin", "index", ">", "end", "index", ")", "{", "throw", "new", "index", "out", "of", "bounds", "exception", "(", "string", "format", "(", "\"", "path", ":", "%", "s", ",", "begin", "index", ":", "%", "d", "end", "index", ":", "%", "d", "\"", ",", "to", "string", "(", ")", ",", "begin", "index", ",", "end", "index", ")", ")", ";", "}", "return", "sub", "fragment", "impl", "(", "begin", "index", ",", "end", "index", ")", ";", "}" ]
[ "test", "what", "happens", "when", "an", "impl", "struct", "contains", "a", "field", "who", "'", "s", "db", "datatype", "has", "the", "same", "datatype", "name", "as", "the", "impl", "struct", "the", "embedded", "db", "struct", "needs", "to", "be", "empty", "and", "default", "sized", "(", "1", "byte", ")", ",", "and", "the", "outer", "impl", "struct", "needs", "to", "be", "bigger", "currently", "the", "dtm", "resolve", "(", ")", "will", "ignore", "the", "conflict", "handlers", "attempt", "to", "replace", "since", "it", "will", "result", "in", "cyclic", "dependency", "issue", "it", "will", "instead", "rename", "the", "new", "structure", "as", "a", "conflict", "with", "its", "field", "refering", "to", "the", "original", "structure", "this", "situation", "happens", "in", "dwarf", "when", "there", "is", "a", "base", "class", "and", "a", "derived", "class", "that", "have", "the", "same", "name", "they", "are", "in", "different", "namespaces", ",", "but", "during", "compilation", "gcc", "was", "told", "to", "-", "feliminate", "-", "unused", "-", "debug", "-", "symbols", "which", "results", "in", "the", "die", "records", "for", "the", "structs", "being", "placed", "in", "the", "root", "namespace", "see", "gdtsd", "-", "351" ]
[ "public", "void", "test", "d", "t", "m", "incorrect", "overwrite", "(", ")", "{", "data", "type", "x", "=", "data", "mgr", "add", "data", "type", "(", "new", "structure", "data", "type", "(", "root", "c", "p", ",", "\"", "x", "\"", ",", "1", ")", ",", "null", ")", ";", "structure", "data", "type", "x", "2", "=", "new", "structure", "data", "type", "(", "root", "c", "p", ",", "\"", "x", "\"", ",", "4", ")", ";", "x", "2", "replace", "at", "offset", "(", "0", ",", "x", ",", "1", ",", "\"", "f", "1", "\"", ",", "null", ")", ";", "structure", "x", "3", "=", "(", "structure", ")", "data", "mgr", "resolve", "(", "x", "2", ",", "data", "type", "conflict", "handler", "replace", "handler", ")", ";", "assert", "equals", "(", "\"", "x", "conflict", "\"", ",", "x", "3", "get", "name", "(", ")", ")", ";", "data", "type", "component", "dtc", "=", "x", "3", "get", "component", "(", "0", ")", ";", "data", "type", "dtc", "d", "t", "=", "dtc", "get", "data", "type", "(", ")", ";", "assert", "equals", "(", "\"", "f", "1", "\"", ",", "dtc", "get", "field", "name", "(", ")", ")", ";", "assert", "equals", "(", "\"", "x", "\"", ",", "dtc", "d", "t", "get", "name", "(", ")", ")", ";", "/", "/", "undefined", "field", "is", "current", "behavior", "}" ]
[ "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", "\"", ")", ";", "}" ]
[ "highlights", "any", "y", "-", "value", "at", "the", "given", "x", "-", "value", "in", "the", "given", "data", "set", "provide", "-", "1", "as", "the", "data", "set", "index", "to", "undo", "all", "highlighting" ]
[ "public", "void", "highlight", "value", "(", "float", "x", ",", "float", "y", ",", "int", "data", "set", "index", ",", "boolean", "call", "listener", ")", "{", "highlight", "value", "(", "x", ",", "y", ",", "data", "set", "index", ",", "-", "1", ",", "call", "listener", ")", ";", "}" ]
[ "post", "fakeoutercomposite", "test", "serialization", "of", "object", "with", "outer", "number", "type" ]
[ "default", "response", "entity", "<", "outer", "composite", ">", "fake", "outer", "composite", "serialize", "(", "@", "api", "param", "(", "value", "=", "\"", "input", "composite", "as", "post", "body", "\"", ")", "@", "valid", "@", "request", "body", "(", "required", "=", "false", ")", "outer", "composite", "body", ")", "{", "return", "get", "delegate", "(", ")", "fake", "outer", "composite", "serialize", "(", "body", ")", ";", "}" ]
[ "pulls", "out", "the", "value", "of", "the", "equate", "given", "the", "formatted", "equate", "name", "the", "value", "stored", "in", "the", "equate", "info", "is", "a", "decimal" ]
[ "public", "static", "long", "get", "equate", "value", "from", "formatted", "name", "(", "string", "formatted", "equate", "name", ")", "{", "if", "(", "formatted", "equate", "name", "starts", "with", "(", "datatype", "tag", ")", ")", "{", "return", "long", "parse", "long", "(", "formatted", "equate", "name", "split", "(", "format", "delimiter", ")", "[", "2", "]", ")", ";", "}", "return", "-", "1", ";", "}" ]
[ "auxiliary", "method", "to", "read", "the", "length", "of", "an", "upcoming", "data", "chunk", "from", "an", "input", "stream" ]
[ "static", "int", "read", "length", "(", "input", "stream", "input", "stream", ")", "throws", "i", "o", "exception", "{", "byte", "[", "]", "buf", "=", "new", "byte", "[", "4", "]", ";", "int", "bytes", "read", "=", "0", ";", "while", "(", "bytes", "read", "<", "4", ")", "{", "final", "int", "read", "=", "input", "stream", "read", "(", "buf", ",", "bytes", "read", ",", "4", "-", "bytes", "read", ")", ";", "if", "(", "read", "<", "0", ")", "{", "throw", "new", "e", "o", "f", "exception", "(", "\"", "read", "an", "incomplete", "length", "\"", ")", ";", "}", "bytes", "read", "+", "=", "read", ";", "}", "bytes", "read", "=", "buf", "[", "0", "]", "&", "0xff", ";", "bytes", "read", "|", "=", "(", "buf", "[", "1", "]", "&", "0xff", ")", "<", "<", "8", ";", "bytes", "read", "|", "=", "(", "buf", "[", "2", "]", "&", "0xff", ")", "<", "<", "16", ";", "bytes", "read", "|", "=", "(", "buf", "[", "3", "]", "&", "0xff", ")", "<", "<", "24", ";", "return", "bytes", "read", ";", "}" ]
[ "try", "to", "come", "up", "with", "a", "good", "temp", "directory", "for", "different", "filesystems" ]
[ "public", "static", "path", "temp", "dir", "for", "staging", "(", "file", "system", "fs", ",", "configuration", "conf", ")", "{", "string", "fallback", "path", "=", "fs", "get", "scheme", "(", ")", "equals", "(", "\"", "file", "\"", ")", "?", "system", "get", "property", "(", "java", "io", "tmpdir", ")", ":", "filesystem", "temp", "path", ";", "return", "fs", "make", "qualified", "(", "new", "path", "(", "conf", "get", "trimmed", "(", "fs", "s3a", "committer", "staging", "tmp", "path", ",", "fallback", "path", ")", ")", ")", ";", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "boolean", "equals", "(", "object", "obj", ")", "{", "if", "(", "this", "=", "=", "obj", ")", "return", "true", ";", "else", "if", "(", "obj", "!", "=", "null", "&", "&", "obj", "instanceof", "arithmetic", "progression", ")", "{", "final", "arithmetic", "progression", "that", "=", "(", "arithmetic", "progression", ")", "obj", ";", "if", "(", "this", "symbol", "!", "=", "that", "symbol", ")", "throw", "new", "illegal", "argument", "exception", "(", "\"", "this", "symbol", "!", "=", "that", "symbol", ",", "this", "=", "\"", "+", "this", "+", "\"", ",", "that", "=", "\"", "+", "that", ")", ";", "return", "this", "value", "=", "=", "that", "value", "&", "&", "this", "delta", "=", "=", "that", "delta", "&", "&", "this", "limit", "=", "=", "that", "limit", ";", "}", "throw", "new", "illegal", "argument", "exception", "(", "obj", "=", "=", "null", "?", "\"", "obj", "=", "=", "null", "\"", ":", "\"", "obj", "get", "class", "(", ")", "=", "\"", "+", "obj", "get", "class", "(", ")", ")", ";", "}" ]
[ "set", "the", "maximum", "split", "size" ]
[ "public", "static", "void", "set", "max", "input", "split", "size", "(", "job", "job", ",", "long", "size", ")", "{", "job", "get", "configuration", "(", ")", "set", "long", "(", "split", "maxsize", ",", "size", ")", ";", "}" ]
[ "returns", "a", "key", "for", "building", "a", "file", "value", "for", "the", "given", "root", "-", "relative", "path" ]
[ "public", "static", "key", "key", "(", "rooted", "path", "rooted", "path", ")", "{", "return", "key", "create", "(", "rooted", "path", ")", ";", "}" ]
[ "a", "utility", "function", "which", "generates", "the", "\"", "deps", "\"", "clause", "for", "a", "build", "file", "rule", "from", "a", "list", "of", "targets" ]
[ "protected", "static", "string", "deps", "(", "string", "dep", "targets", ")", "{", "string", "builder", "buf", "=", "new", "string", "builder", "(", ")", ";", "buf", "append", "(", "\"", "deps", "=", "[", "\"", ")", ";", "string", "sep", "=", "\"", "'", "\"", ";", "for", "(", "string", "dep", ":", "dep", "targets", ")", "{", "buf", "append", "(", "sep", ")", ";", "buf", "append", "(", "dep", ")", ";", "buf", "append", "(", "\"", "'", "\"", ")", ";", "sep", "=", "\"", ",", "'", "\"", ";", "}", "buf", "append", "(", "\"", "]", "\"", ")", ";", "return", "buf", "to", "string", "(", ")", ";", "}" ]
[ "required", ":", "the", "port", "on", "which", "the", "proxy", "should", "listen", "for", "incoming", "connections", "<", "code", ">", "istio", "networking", "v", "1alpha", "3", "port", "port", "=", "1", ";", "<", "code", ">" ]
[ "public", "com", "alibaba", "nacos", "istio", "model", "port", "get", "port", "(", ")", "{", "return", "port", "=", "=", "null", "?", "com", "alibaba", "nacos", "istio", "model", "port", "get", "default", "instance", "(", ")", ":", "port", ";", "}" ]
[ "find", "the", "fields", "constant", "that", "matches", "field", "id", ",", "or", "null", "if", "its", "not", "found" ]
[ "public", "static", "fields", "find", "by", "thrift", "id", "(", "int", "field", "id", ")", "{", "switch", "(", "field", "id", ")", "{", "case", "1", ":", "/", "/", "error", "return", "error", ";", "case", "2", ":", "/", "/", "error", "time", "secs", "return", "error", "time", "secs", ";", "default", ":", "return", "null", ";", "}", "}" ]
[ "wraps", "a", "gl", "interface", "in", "another", "gl", "interface" ]
[ "gl", "wrap", "(", "gl", "gl", ")", ";" ]
[ "ports", "{", "@", "link", "android", "view", "view", "compat", "#", "set", "accessibility", "heading", "}", "into", "components", "world", "however", ",", "since", "the", "aforementioned", "view", "compat", "'", "s", "method", "is", "available", "only", "on", "api", "19", "and", "above", ",", "calling", "this", "method", "on", "lower", "a", "p", "is", "will", "have", "no", "effect", "on", "the", "legit", "versions", ",", "on", "the", "other", "hand", ",", "calling", "this", "method", "will", "lead", "to", "the", "component", "being", "treated", "as", "a", "heading", "the", "accessibility", "heading", "property", "allows", "accessibility", "services", "to", "help", "users", "navigate", "directly", "from", "one", "heading", "to", "the", "next", "see", "<", "a", "href", "=", "\"", "https", ":", "developer", "android", "comreferenceandroidsupportv", "4viewaccessibility", "accessibility", "node", "info", "compat", "#", "setheading", "\"", ">", "https", ":", "developer", "android", "comreferenceandroid", "supportv", "4viewaccessibility", "accessibility", "node", "info", "compat", "#", "setheading", "for", "more", "information", "default", ":", "false" ]
[ "public", "t", "accessibility", "heading", "(", "boolean", "is", "heading", ")", "{", "m", "component", "get", "or", "create", "common", "props", "(", ")", "accessibility", "heading", "(", "is", "heading", ")", ";", "return", "get", "this", "(", ")", ";", "}" ]
[ "starts", "a", "new", "infinite", "stream", "of", "dns", "server", "addresses", "this", "method", "is", "invoked", "by", "{", "@", "link", "dns", "name", "resolver", "}", "on", "every", "uncached", "{", "@", "link", "dns", "name", "resolver", "#", "resolve", "(", "string", ")", "}", "or", "{", "@", "link", "dns", "name", "resolver", "#", "resolve", "all", "(", "string", ")", "}" ]
[ "public", "abstract", "dns", "server", "address", "stream", "stream", "(", ")", ";" ]
[ "set", "the", "{", "@", "link", "conversion", "service", "}", "to", "use", "to", "convert", "the", "original", "message", "payload", "or", "headers" ]
[ "public", "void", "set", "conversion", "service", "(", "conversion", "service", "conversion", "service", ")", "{", "this", "conversion", "service", "=", "conversion", "service", ";", "}" ]
[ "compare", "two", "flash", "maps", "and", "prefer", "the", "one", "that", "specifies", "a", "target", "url", "path", "or", "has", "more", "target", "url", "parameters", "before", "comparing", "flash", "map", "instances", "ensure", "that", "they", "match", "a", "given", "request" ]
[ "public", "int", "compare", "to", "(", "flash", "map", "other", ")", "{", "int", "this", "url", "path", "=", "(", "this", "target", "request", "path", "!", "=", "null", "?", "1", ":", "0", ")", ";", "int", "other", "url", "path", "=", "(", "other", "target", "request", "path", "!", "=", "null", "?", "1", ":", "0", ")", ";", "if", "(", "this", "url", "path", "!", "=", "other", "url", "path", ")", "{", "return", "other", "url", "path", "-", "this", "url", "path", ";", "}", "else", "{", "return", "other", "target", "request", "params", "size", "(", ")", "-", "this", "target", "request", "params", "size", "(", ")", ";", "}", "}" ]
[ "configure", "a", "time", "limit", "(", "in", "milliseconds", ")", "for", "the", "maximum", "amount", "of", "a", "time", "allowed", "when", "sending", "messages", "to", "a", "web", "socket", "session", "or", "writing", "to", "an", "http", "response", "when", "sock", "j", "s", "fallback", "option", "are", "in", "use", "in", "general", "web", "socket", "servers", "expect", "that", "messages", "to", "a", "single", "web", "socket", "session", "are", "sent", "from", "a", "single", "thread", "at", "a", "time", "this", "is", "automatically", "guaranteed", "when", "using", "{", "@", "code", "@", "enable", "web", "socket", "message", "broker", "}", "configuration", "if", "message", "sending", "is", "slow", ",", "or", "at", "least", "slower", "than", "rate", "of", "messages", "sending", ",", "subsequent", "messages", "are", "buffered", "until", "either", "the", "{", "@", "code", "send", "time", "limit", "}", "or", "the", "{", "@", "code", "send", "buffer", "size", "limit", "}", "are", "reached", "at", "which", "point", "the", "session", "state", "is", "cleared", "and", "an", "attempt", "is", "made", "to", "close", "the", "session", "note", "that", "the", "session", "time", "limit", "is", "checked", "only", "on", "attempts", "to", "send", "additional", "messages", "so", "if", "only", "a", "single", "message", "is", "sent", "and", "it", "hangs", ",", "the", "session", "will", "not", "time", "out", "until", "another", "message", "is", "sent", "or", "the", "underlying", "physical", "socket", "times", "out", "so", "this", "is", "not", "a", "replacement", "for", "web", "socket", "server", "or", "http", "connection", "timeout", "but", "is", "rather", "intended", "to", "control", "the", "extent", "of", "buffering", "of", "unsent", "messages", "note", "that", "closing", "the", "session", "may", "not", "succeed", "in", "actually", "closing", "the", "physical", "socket", "and", "may", "also", "hang", "this", "is", "true", "especially", "when", "using", "blocking", "io", "such", "as", "the", "bio", "connector", "in", "tomcat", "that", "is", "used", "by", "default", "on", "tomcat", "7", "therefore", "it", "is", "recommended", "to", "ensure", "the", "server", "is", "using", "non", "-", "blocking", "io", "such", "as", "tomcat", "'", "s", "nio", "connector", "that", "is", "used", "by", "default", "on", "tomcat", "8", "if", "you", "must", "use", "blocking", "io", "consider", "customizing", "os", "-", "level", "tcp", "settings", ",", "for", "example", "{", "@", "code", "procsysnetipv", "4tcp", "retries", "2", "}", "on", "linux", "the", "default", "value", "is", "10", "seconds", "(", "i", "e", "10", "1000", ")" ]
[ "public", "web", "socket", "transport", "registration", "set", "send", "time", "limit", "(", "int", "time", "limit", ")", "{", "this", "send", "time", "limit", "=", "time", "limit", ";", "return", "this", ";", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "long", "get", "physical", "memory", "size", "(", ")", "{", "read", "proc", "mem", "info", "file", "(", ")", ";", "return", "(", "ram", "size", "-", "hardware", "corrupt", "size", "-", "(", "huge", "pages", "total", "*", "huge", "page", "size", ")", ")", "*", "1024", ";", "}" ]
[ "get", "date", "time" ]
[ "public", "offset", "date", "time", "get", "date", "time", "(", ")", "{", "return", "date", "time", ";", "}" ]
[ "specify", "whether", "this", "factory", "bean", "should", "expose", "an", "unconfigurable", "decorator", "for", "the", "created", "executor", "default", "is", "\"", "false", "\"", ",", "exposing", "the", "raw", "executor", "as", "bean", "reference", "switch", "this", "flag", "to", "\"", "true", "\"", "to", "strictly", "prevent", "clients", "from", "modifying", "the", "executor", "'", "s", "configuration" ]
[ "public", "void", "set", "expose", "unconfigurable", "executor", "(", "boolean", "expose", "unconfigurable", "executor", ")", "{", "this", "expose", "unconfigurable", "executor", "=", "expose", "unconfigurable", "executor", ";", "}" ]
[ "return", "the", "density", "of", "screen" ]
[ "public", "static", "float", "get", "screen", "density", "(", ")", "{", "return", "resources", "get", "system", "(", ")", "get", "display", "metrics", "(", ")", "density", ";", "}" ]
[ "returns", "the", "type" ]
[ "public", "string", "get", "type", "(", "clazz", "clazz", ")", "{", "return", "clazz", "get", "string", "(", "u", "2type", "index", ")", ";", "}" ]
[ "await", "termination", "on", "the", "main", "thread", "since", "the", "grpc", "library", "uses", "daemon", "threads" ]
[ "private", "void", "block", "until", "shutdown", "(", ")", "throws", "interrupted", "exception", "{", "if", "(", "server", "!", "=", "null", ")", "{", "server", "await", "termination", "(", ")", ";", "}", "}" ]
[ "get", "all", "instance", "from", "input", "clusters" ]
[ "public", "list", "<", "instance", ">", "srv", "i", "ps", "(", "list", "<", "string", ">", "clusters", ")", "{", "if", "(", "collection", "utils", "is", "empty", "(", "clusters", ")", ")", "{", "clusters", "=", "new", "array", "list", "<", ">", "(", ")", ";", "clusters", "add", "all", "(", "cluster", "map", "key", "set", "(", ")", ")", ";", "}", "return", "all", "i", "ps", "(", "clusters", ")", ";", "}" ]
[ "starting", "a", "name", "with", "underscore", ",", "so", "that", "the", "user", "cannot", "access", "this", "function", "directly", "through", "a", "script", "it", "is", "only", "used", "within", "predefined", "painless", "functions" ]
[ "public", "int", "get", "doc", "id", "(", ")", "{", "return", "doc", "id", ";", "}" ]
[ "always", "serialize", "this", "parameter", ",", "no", "matter", "its", "value" ]
[ "public", "parameter", "<", "t", ">", "always", "serialize", "(", ")", "{", "this", "serializer", "check", "=", "(", "id", ",", "ic", ",", "v", ")", "-", ">", "true", ";", "return", "this", ";", "}" ]
[ "returns", "the", "name", "of", "the", "corrupted", "file" ]
[ "public", "string", "get", "file", "(", ")", "{", "return", "filename", ";", "}" ]
[ "returns", "{", "@", "code", "true", "}", "if", "the", "exclusion", "{", "@", "link", "pattern", "}", "at", "index", "{", "@", "code", "pattern", "index", "}", "matches", "the", "supplied", "candidate", "{", "@", "code", "string", "}" ]
[ "protected", "boolean", "matches", "exclusion", "(", "string", "candidate", ",", "int", "pattern", "index", ")", "{", "matcher", "matcher", "=", "this", "compiled", "exclusion", "patterns", "[", "pattern", "index", "]", "matcher", "(", "candidate", ")", ";", "return", "matcher", "matches", "(", ")", ";", "}" ]
[ "add", "a", "new", "saved", "jdbc", "connection", "configuration" ]
[ "public", "void", "do", "post", "(", "http", "servlet", "request", "request", ",", "http", "servlet", "response", "response", ")", "throws", "servlet", "exception", ",", "i", "o", "exception", "{", "if", "(", "!", "has", "valid", "c", "s", "r", "f", "token", "(", "request", ")", ")", "{", "respond", "c", "s", "r", "f", "error", "(", "response", ")", ";", "return", ";", "}", "if", "(", "logger", "is", "debug", "enabled", "(", ")", ")", "{", "logger", "debug", "(", "\"", "do", "post", "connection", ":", "{", "}", "\"", ",", "request", "get", "parameter", "(", "\"", "connection", "name", "\"", ")", ")", ";", "}", "database", "configuration", "jdbc", "config", "=", "get", "jdbc", "configuration", "(", "request", ")", ";", "response", "set", "character", "encoding", "(", "\"", "utf", "-", "8", "\"", ")", ";", "response", "set", "header", "(", "\"", "content", "-", "type", "\"", ",", "\"", "application", "/", "json", "\"", ")", ";", "if", "(", "jdbc", "config", "get", "connection", "name", "(", ")", "=", "=", "null", ")", "{", "response", "send", "error", "(", "http", "status", "sc", "bad", "request", ",", "\"", "connection", "name", "is", "required", "!", "\"", ")", ";", "response", "flush", "buffer", "(", ")", ";", "return", ";", "}", "if", "(", "!", "validate", "input", "(", "jdbc", "config", "get", "connection", "name", "(", ")", ",", "conn", "name", "pattern", ")", ")", "{", "logger", "warn", "(", "\"", "invalid", "connection", "name", ":", "{", "}", "\"", ",", "jdbc", "config", "get", "connection", "name", "(", ")", ")", ";", "response", "send", "error", "(", "http", "status", "sc", "bad", "request", ",", "\"", "connection", "name", "is", "invalid", "expecting", "[", "a", "-", "z", "a", "-", "z0", "-", "9", "-", "]", "\"", ")", ";", "response", "flush", "buffer", "(", ")", ";", "return", ";", "}", "if", "(", "!", "validate", "input", "(", "\"", "\"", "+", "jdbc", "config", "get", "database", "port", "(", ")", ",", "database", "port", "pattern", ")", ")", "{", "logger", "warn", "(", "\"", "invalid", "database", "port", ":", "{", "}", "\"", ",", "jdbc", "config", "get", "database", "port", "(", ")", ")", ";", "response", "send", "error", "(", "http", "status", "sc", "bad", "request", ",", "\"", "database", "port", "invalid", "expecting", "numeric", "values", "only", "\"", ")", ";", "response", "flush", "buffer", "(", ")", ";", "return", ";", "}", "database", "configuration", "saved", "conn", "=", "database", "utils", "get", "saved", "connection", "(", "jdbc", "config", "get", "connection", "name", "(", ")", ")", ";", "if", "(", "saved", "conn", "!", "=", "null", ")", "{", "response", "send", "error", "(", "http", "status", "sc", "bad", "request", ",", "\"", "connection", "with", "name", "\"", "+", "jdbc", "config", "get", "connection", "name", "(", ")", "+", "\"", "already", "exists", "!", "\"", ")", ";", "response", "flush", "buffer", "(", ")", ";", "return", ";", "}", "if", "(", "jdbc", "config", "get", "database", "password", "(", ")", "!", "=", "null", ")", "{", "/", "/", "logger", "debug", "(", "\"", "saved", "connection", "command", ":", ":", "post", ":", ":", "password", ":", ":", "{", "}", "\"", ",", "jdbc", "config", "get", "database", "password", "(", ")", ")", ";", "jdbc", "config", "set", "database", "password", "(", "database", "utils", "encrypt", "(", "jdbc", "config", "get", "database", "password", "(", ")", ")", ")", ";", "}", "database", "utils", "add", "to", "saved", "connections", "(", "jdbc", "config", ")", ";", "try", "{", "response", "set", "character", "encoding", "(", "\"", "utf", "-", "8", "\"", ")", ";", "response", "set", "header", "(", "\"", "content", "-", "type", "\"", ",", "\"", "application", "/", "json", "\"", ")", ";", "write", "saved", "connection", "response", "(", "response", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "logger", "error", "(", "\"", "exception", "while", "loading", "settings", "{", "}", "\"", ",", "e", ")", ";", "}", "}" ]
[ "retrieves", "a", "string", "representing", "the", "state", "of", "the", "job", "queue", "intended", "for", "debugging" ]
[ "public", "@", "non", "null", "string", "get", "debug", "info", "(", ")", "{", "atomic", "reference", "<", "string", ">", "result", "=", "new", "atomic", "reference", "<", ">", "(", ")", ";", "count", "down", "latch", "latch", "=", "new", "count", "down", "latch", "(", "1", ")", ";", "run", "on", "executor", "(", "(", ")", "-", ">", "{", "result", "set", "(", "job", "controller", "get", "debug", "info", "(", ")", ")", ";", "latch", "count", "down", "(", ")", ";", "}", ")", ";", "try", "{", "boolean", "finished", "=", "latch", "await", "(", "10", ",", "time", "unit", "seconds", ")", ";", "if", "(", "finished", ")", "{", "return", "result", "get", "(", ")", ";", "}", "else", "{", "return", "\"", "timed", "out", "waiting", "for", "job", "info", "\"", ";", "}", "}", "catch", "(", "interrupted", "exception", "e", ")", "{", "log", "w", "(", "tag", ",", "\"", "failed", "to", "retrieve", "job", "info", "\"", ",", "e", ")", ";", "return", "\"", "failed", "to", "retrieve", "job", "info", "\"", ";", "}", "}" ]
[ "validates", "the", "header", "of", "the", "first", "batch", "and", "returns", "batch", "size" ]
[ "public", "integer", "first", "batch", "size", "(", ")", "{", "if", "(", "buffer", "remaining", "(", ")", "<", "header", "size", "up", "to", "magic", ")", "return", "null", ";", "return", "new", "byte", "buffer", "log", "input", "stream", "(", "buffer", ",", "integer", "max", "value", ")", "next", "batch", "size", "(", ")", ";", "}" ]
[ "add", "a", "snapshot" ]
[ "public", "snapshot", "add", "snapshot", "(", "snapshot", "manager", "snapshot", "manager", ",", "string", "name", ",", "final", "lease", "manager", "lease", "manager", ",", "long", "mtime", ")", "throws", "snapshot", "exception", "{", "return", "get", "directory", "snapshottable", "feature", "(", ")", "add", "snapshot", "(", "this", ",", "snapshot", "manager", ",", "name", ",", "lease", "manager", ",", "mtime", ")", ";", "}" ]
[ "create", "old", "-", "language", "file", "for", "the", "specified", "language" ]
[ "public", "static", "void", "create", "old", "language", "file", "(", "language", "lang", ",", "file", "file", ")", "throws", "i", "o", "exception", ",", "language", "not", "found", "exception", "{", "language", "service", "language", "service", "=", "default", "language", "service", "get", "language", "service", "(", ")", ";", "if", "(", "lang", "instanceof", "old", "language", ")", "{", "throw", "new", "language", "not", "found", "exception", "(", "\"", "can", "'", "t", "create", "an", "old", "langauge", "file", "from", "an", "old", "language", "\"", ")", ";", "}", "language", "description", "language", "description", "=", "language", "service", "get", "language", "description", "(", "lang", "get", "language", "i", "d", "(", ")", ")", ";", "element", "root", "=", "new", "element", "(", "\"", "language", "\"", ")", ";", "root", "set", "attribute", "(", "\"", "version", "\"", ",", "integer", "to", "string", "(", "lang", "get", "version", "(", ")", ")", ")", ";", "root", "set", "attribute", "(", "\"", "endian", "\"", ",", "lang", "is", "big", "endian", "(", ")", "?", "\"", "big", "\"", ":", "\"", "little", "\"", ")", ";", "root", "add", "content", "(", "get", "description", "element", "(", "language", "description", ")", ")", ";", "for", "(", "compiler", "spec", "description", "cs", ":", "lang", "get", "compatible", "compiler", "spec", "descriptions", "(", ")", ")", "{", "element", "compiler", "element", "=", "new", "element", "(", "\"", "compiler", "\"", ")", ";", "compiler", "element", "set", "attribute", "(", "\"", "name", "\"", ",", "cs", "get", "compiler", "spec", "name", "(", ")", ")", ";", "compiler", "element", "set", "attribute", "(", "\"", "id", "\"", ",", "cs", "get", "compiler", "spec", "i", "d", "(", ")", "get", "id", "as", "string", "(", ")", ")", ";", "root", "add", "content", "(", "compiler", "element", ")", ";", "}", "root", "add", "content", "(", "get", "spaces", "element", "(", "lang", ")", ")", ";", "root", "add", "content", "(", "get", "registers", "element", "(", "lang", ")", ")", ";", "document", "doc", "=", "new", "document", "(", "root", ")", ";", "file", "output", "stream", "out", "=", "new", "file", "output", "stream", "(", "file", ")", ";", "x", "m", "l", "outputter", "xml", "=", "new", "generic", "x", "m", "l", "outputter", "(", ")", ";", "xml", "output", "(", "doc", ",", "out", ")", ";", "out", "close", "(", ")", ";", "}" ]
[ "checks", "if", "this", "instance", "and", "the", "given", "instance", "share", "the", "same", "repositories", "by", "checking", "that", "this", "instances", "'", "repositories", "and", "the", "repositories", "in", "{", "@", "code", "other", "}", "are", "equal", "or", "only", "differ", "in", "their", "values", "of", "{", "@", "link", "repository", "metadata", "#", "generation", "(", ")", "}", "and", "{", "@", "link", "repository", "metadata", "#", "pending", "generation", "(", ")", "}" ]
[ "public", "boolean", "equals", "ignore", "generations", "(", "@", "nullable", "repositories", "metadata", "other", ")", "{", "if", "(", "other", "=", "=", "null", ")", "{", "return", "false", ";", "}", "if", "(", "other", "repositories", "size", "(", ")", "!", "=", "repositories", "size", "(", ")", ")", "{", "return", "false", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "repositories", "size", "(", ")", ";", "i", "+", "+", ")", "{", "if", "(", "repositories", "get", "(", "i", ")", "equals", "ignore", "generations", "(", "other", "repositories", "get", "(", "i", ")", ")", "=", "=", "false", ")", "{", "return", "false", ";", "}", "}", "return", "true", ";", "}" ]