docstring_tokens
list
code_tokens
list
[ "returns", "an", "{", "@", "code", "unsigned", "long", "}", "holding", "the", "value", "of", "the", "specified", "{", "@", "code", "string", "}", ",", "parsed", "as", "an", "unsigned", "{", "@", "code", "long", "}", "value", "in", "the", "specified", "radix" ]
[ "public", "static", "unsigned", "long", "value", "of", "(", "string", "string", ",", "int", "radix", ")", "{", "return", "from", "long", "bits", "(", "unsigned", "longs", "parse", "unsigned", "long", "(", "string", ",", "radix", ")", ")", ";", "}" ]
[ "copies", "an", "iterable", "'", "s", "elements", "into", "an", "array" ]
[ "public", "static", "<", "t", ">", "t", "[", "]", "to", "array", "(", "iterable", "<", "?", "extends", "t", ">", "iterable", ",", "class", "<", "t", ">", "type", ")", "{", "return", "to", "array", "(", "iterable", ",", "object", "arrays", "new", "array", "(", "type", ",", "0", ")", ")", ";", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "boolean", "next", "(", ")", "throws", "s", "q", "l", "exception", "{", "return", "(", "counter", ">", "100000", ")", ";", "}" ]
[ "returns", "an", "address", "range", "iterator", "over", "all", "occupied", "ranges", "whose", "from", "address", "falls", "within", "the", "range", "start", "addr", "to", "end", "addr" ]
[ "public", "address", "range", "iterator", "get", "address", "ranges", "(", "address", "start", "addr", ",", "address", "end", "addr", ")", "{", "return", "new", "range", "iterator", "(", "start", "addr", ",", "end", "addr", ")", ";", "}" ]
[ "guaranteed", "to", "throw", "an", "exception", "and", "leave", "the", "map", "unmodified" ]
[ "public", "final", "v", "put", "(", "k", "k", ",", "v", "v", ")", "{", "throw", "new", "unsupported", "operation", "exception", "(", ")", ";", "}" ]
[ "deep", "comparison", "of", "array", "of", "<", "code", ">", "float", "<", "code", ">", "length", "and", "all", "values", "are", "compared", "the", "method", "{", "@", "link", "#", "append", "(", "float", ",", "float", ")", "}", "is", "used" ]
[ "public", "equals", "builder", "append", "(", "float", "[", "]", "lhs", ",", "float", "[", "]", "rhs", ")", "{", "if", "(", "!", "is", "equals", ")", "{", "return", "this", ";", "}", "if", "(", "lhs", "=", "=", "rhs", ")", "{", "return", "this", ";", "}", "if", "(", "lhs", "=", "=", "null", "|", "|", "rhs", "=", "=", "null", ")", "{", "this", "set", "equals", "(", "false", ")", ";", "return", "this", ";", "}", "if", "(", "lhs", "length", "!", "=", "rhs", "length", ")", "{", "this", "set", "equals", "(", "false", ")", ";", "return", "this", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "lhs", "length", "&", "&", "is", "equals", ";", "+", "+", "i", ")", "{", "append", "(", "lhs", "[", "i", "]", ",", "rhs", "[", "i", "]", ")", ";", "}", "return", "this", ";", "}" ]
[ "retrieve", "the", "amount", "of", "the", "total", "items", "in", "the", "urv", "for", "display", "that", "will", "be", "including", "all", "data", "items", "as", "well", "as", "the", "decorative", "items" ]
[ "public", "int", "get", "item", "count", "(", ")", "{", "return", "get", "adapter", "item", "count", "(", ")", "+", "total", "additional", "items", "(", ")", ";", "}" ]
[ "process", "a", "{", "@", "link", "stream", "record", "}", "from", "the", "right", "stream", "whenever", "a", "{", "@", "link", "stream", "record", "}", "arrives", "at", "the", "right", "stream", ",", "it", "will", "get", "added", "to", "the", "right", "buffer", "possible", "join", "candidates", "for", "that", "element", "will", "be", "looked", "up", "from", "the", "left", "buffer", "and", "if", "the", "pair", "lies", "within", "the", "user", "defined", "boundaries", ",", "it", "gets", "passed", "to", "the", "{", "@", "link", "process", "join", "function", "}" ]
[ "public", "void", "process", "element", "2", "(", "stream", "record", "<", "t2", ">", "record", ")", "throws", "exception", "{", "process", "element", "(", "record", ",", "right", "buffer", ",", "left", "buffer", ",", "-", "upper", "bound", ",", "-", "lower", "bound", ",", "false", ")", ";", "}" ]
[ "updates", "this", "hasher", "with", "the", "given", "bytes" ]
[ "protected", "void", "update", "(", "byte", "[", "]", "b", ")", "{", "update", "(", "b", ",", "0", ",", "b", "length", ")", ";", "}" ]
[ "deletes", "a", "pet", "<", "b", ">", "200", "<", "b", ">", "-", "successful", "operation", "<", "b", ">", "400", "<", "b", ">", "-", "invalid", "pet", "value" ]
[ "public", "void", "delete", "pet", "(", "long", "pet", "id", ",", "map", "<", "string", ",", "object", ">", "params", ")", "throws", "i", "o", "exception", "{", "delete", "pet", "for", "http", "response", "(", "pet", "id", ",", "params", ")", ";", "}" ]
[ "retrieves", "the", "value", "in", "queue", "without", "removing", "it", "indexing", "is", "from", "the", "front", "to", "back", ",", "zero", "based", "therefore", "get", "(", "0", ")", "is", "the", "same", "as", "{", "@", "link", "#", "first", "(", ")", "}" ]
[ "public", "long", "get", "(", "int", "index", ")", "{", "if", "(", "index", "<", "0", ")", "throw", "new", "index", "out", "of", "bounds", "exception", "(", "\"", "index", "can", "'", "t", "be", "<", "0", ":", "\"", "+", "index", ")", ";", "if", "(", "index", ">", "=", "size", ")", "throw", "new", "index", "out", "of", "bounds", "exception", "(", "\"", "index", "can", "'", "t", "be", ">", "=", "size", ":", "\"", "+", "index", "+", "\"", ">", "=", "\"", "+", "size", ")", ";", "final", "long", "[", "]", "values", "=", "this", "values", ";", "int", "i", "=", "head", "+", "index", ";", "if", "(", "i", ">", "=", "values", "length", ")", "{", "i", "-", "=", "values", "length", ";", "}", "return", "values", "[", "i", "]", ";", "}" ]
[ "returns", "{", "@", "code", "true", "}", "if", "the", "bounds", "of", "{", "@", "code", "other", "}", "do", "not", "extend", "outside", "the", "bounds", "of", "this", "range", "examples", ":", "{", "@", "code", "[", "3", "6", "]", "}", "encloses", "{", "@", "code", "[", "4", "5", "]", "}", "{", "@", "code", "(", "3", "6", ")", "}", "encloses", "{", "@", "code", "(", "3", "6", ")", "}", "{", "@", "code", "[", "3", "6", "]", "}", "encloses", "{", "@", "code", "[", "4", "4", ")", "}", "(", "even", "though", "the", "latter", "is", "empty", ")", "{", "@", "code", "(", "3", "6", "]", "}", "does", "not", "enclose", "{", "@", "code", "[", "3", "6", "]", "}", "{", "@", "code", "[", "4", "5", "]", "}", "does", "not", "enclose", "{", "@", "code", "(", "3", "6", ")", "}", "(", "even", "though", "it", "contains", "every", "value", "contained", "by", "the", "latter", "range", ")", "{", "@", "code", "[", "3", "6", "]", "}", "does", "not", "enclose", "{", "@", "code", "(", "1", "1", "]", "}", "(", "even", "though", "it", "contains", "every", "value", "contained", "by", "the", "latter", "range", ")", "note", "that", "if", "{", "@", "code", "a", "encloses", "(", "b", ")", "}", ",", "then", "{", "@", "code", "b", "contains", "(", "v", ")", "}", "implies", "{", "@", "code", "a", "contains", "(", "v", ")", "}", ",", "but", "as", "the", "last", "two", "examples", "illustrate", ",", "the", "converse", "is", "not", "always", "true", "being", "reflexive", ",", "antisymmetric", "and", "transitive", ",", "the", "{", "@", "code", "encloses", "}", "relation", "defines", "a", "partial", "order", "over", "ranges", "there", "exists", "a", "unique", "{", "@", "linkplain", "range", "#", "all", "maximal", "}", "range", "according", "to", "this", "relation", ",", "and", "also", "numerous", "{", "@", "linkplain", "#", "is", "empty", "minimal", "}", "ranges", "enclosure", "also", "implies", "{", "@", "linkplain", "#", "is", "connected", "connectedness", "}" ]
[ "public", "boolean", "encloses", "(", "range", "<", "c", ">", "other", ")", "{", "return", "lower", "bound", "compare", "to", "(", "other", "lower", "bound", ")", "<", "=", "0", "&", "&", "upper", "bound", "compare", "to", "(", "other", "upper", "bound", ")", ">", "=", "0", ";", "}" ]
[ "creates", "a", "user", "account", "requires", "{", "@", "link", "jenkins", "#", "administer", "}" ]
[ "public", "user", "create", "account", "by", "admin", "(", "stapler", "request", "req", ",", "stapler", "response", "rsp", ",", "string", "add", "user", "view", ",", "string", "success", "view", ")", "throws", "i", "o", "exception", ",", "servlet", "exception", "{", "check", "permission", "(", "jenkins", "administer", ")", ";", "user", "u", "=", "create", "account", "(", "req", ",", "rsp", ",", "false", ",", "add", "user", "view", ")", ";", "if", "(", "u", "!", "=", "null", "&", "&", "success", "view", "!", "=", "null", ")", "{", "rsp", "send", "redirect", "(", "success", "view", ")", ";", "}", "return", "u", ";", "}" ]
[ "deletes", "the", "file", "underlying", "the", "given", "channel", "if", "the", "channel", "is", "still", "open", ",", "this", "call", "may", "fail" ]
[ "public", "static", "void", "delete", "channel", "(", "id", "channel", ")", "{", "if", "(", "channel", "!", "=", "null", ")", "{", "if", "(", "channel", "get", "path", "file", "(", ")", "exists", "(", ")", "&", "&", "!", "channel", "get", "path", "file", "(", ")", "delete", "(", ")", ")", "{", "log", "warn", "(", "\"", "i", "o", "manager", "failed", "to", "delete", "temporary", "file", "{", "}", "\"", ",", "channel", "get", "path", "(", ")", ")", ";", "}", "}", "}" ]
[ "verify", "that", "current", "user", "is", "the", "checkout", "user", "for", "this", "file" ]
[ "private", "void", "verify", "repo", "user", "(", "string", "case", "name", ")", "throws", "i", "o", "exception", "{", "if", "(", "versioned", "file", "system", "instanceof", "local", "file", "system", ")", "{", "return", ";", "/", "/", "rely", "on", "local", "project", "ownership", "}", "string", "repo", "user", "name", "=", "versioned", "file", "system", "get", "user", "name", "(", ")", ";", "if", "(", "repo", "user", "name", "=", "=", "null", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "file", "\"", "+", "case", "name", "+", "\"", "not", "permitted", "(", "not", "connected", ")", "\"", ")", ";", "}", "item", "checkout", "status", "checkout", "status", "=", "get", "checkout", "status", "(", ")", ";", "if", "(", "checkout", "status", "=", "=", "null", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "file", "not", "checked", "out", "\"", ")", ";", "}", "string", "checkout", "user", "name", "=", "checkout", "status", "get", "user", "(", ")", ";", "if", "(", "!", "repo", "user", "name", "equals", "(", "checkout", "user", "name", ")", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "file", "\"", "+", "case", "name", "+", "\"", "not", "permitted", "-", "checkout", "user", "'", "\"", "+", "checkout", "user", "name", "+", "\"", "'", "differs", "from", "repository", "user", "'", "\"", "+", "repo", "user", "name", "+", "\"", "'", "\"", ")", ";", "}", "}" ]
[ "equivalent", "to", "calling", ":", "actions", "click", "(", "element", ")", "send", "keys", "(", "keys", "to", "send", ")", "this", "method", "is", "different", "from", "{", "@", "link", "web", "element", "#", "send", "keys", "(", "char", "sequence", ")", "}", "-", "see", "{", "@", "link", "#", "send", "keys", "(", "char", "sequence", ")", "}", "for", "details", "how" ]
[ "public", "actions", "send", "keys", "(", "web", "element", "target", ",", "char", "sequence", "keys", ")", "{", "if", "(", "is", "building", "actions", "(", ")", ")", "{", "action", "add", "action", "(", "new", "send", "keys", "action", "(", "json", "keyboard", ",", "json", "mouse", ",", "(", "locatable", ")", "target", ",", "keys", ")", ")", ";", "}", "return", "focus", "in", "ticks", "(", "target", ")", "send", "keys", "in", "ticks", "(", "keys", ")", ";", "}" ]
[ "tests", "to", "ensure", "each", "of", "the", "block", "replication", "parameters", "can", "be", "passed", "updated", "successfully" ]
[ "public", "void", "test", "params", "can", "be", "reconfigured", "(", ")", "throws", "reconfiguration", "exception", "{", "assert", "equals", "(", "8", ",", "bm", "get", "max", "replication", "streams", "(", ")", ")", ";", "assert", "equals", "(", "10", ",", "bm", "get", "replication", "streams", "hard", "limit", "(", ")", ")", ";", "assert", "equals", "(", "12", ",", "bm", "get", "blocks", "repl", "work", "multiplier", "(", ")", ")", ";", "cluster", "get", "name", "node", "(", ")", "reconfigure", "property", "impl", "(", "d", "f", "s", "config", "keys", "dfs", "namenode", "replication", "max", "streams", "key", ",", "\"", "20", "\"", ")", ";", "cluster", "get", "name", "node", "(", ")", "reconfigure", "property", "impl", "(", "d", "f", "s", "config", "keys", "dfs", "namenode", "replication", "streams", "hard", "limit", "key", ",", "\"", "22", "\"", ")", ";", "cluster", "get", "name", "node", "(", ")", "reconfigure", "property", "impl", "(", "d", "f", "s", "config", "keys", "dfs", "namenode", "replication", "work", "multiplier", "per", "iteration", ",", "\"", "24", "\"", ")", ";", "assert", "equals", "(", "20", ",", "bm", "get", "max", "replication", "streams", "(", ")", ")", ";", "assert", "equals", "(", "22", ",", "bm", "get", "replication", "streams", "hard", "limit", "(", ")", ")", ";", "assert", "equals", "(", "24", ",", "bm", "get", "blocks", "repl", "work", "multiplier", "(", ")", ")", ";", "}" ]
[ "closes", "the", "stream" ]
[ "public", "void", "close", "(", ")", "{", "try", "{", "super", "close", "(", ")", ";", "}", "catch", "(", "i", "o", "exception", "ioe", ")", "{", "/", "/", "does", "not", "happen", "throwables", "propagate", "(", "ioe", ")", ";", "}", "}" ]
[ "gets", "failure", "view" ]
[ "public", "view", "get", "failure", "view", "(", "final", "class", "type", ")", "{", "return", "get", "view", "(", "type", "get", "simple", "name", "(", ")", ")", "get", "value", "(", ")", ";", "}" ]
[ "server", "key", "computed", "from", "the", "client", "password", "using", "the", "scram", "algorithm" ]
[ "public", "byte", "[", "]", "server", "key", "(", ")", "{", "return", "server", "key", ";", "}" ]
[ "the", "specification", "of", "this", "method", "matches", "that", "of", "{", "@", "link", "file", "context", "#", "rename", "snapshot", "(", "path", ",", "string", ",", "string", ")", "}" ]
[ "public", "void", "rename", "snapshot", "(", "final", "path", "path", ",", "final", "string", "snapshot", "old", "name", ",", "final", "string", "snapshot", "new", "name", ")", "throws", "i", "o", "exception", "{", "throw", "new", "unsupported", "operation", "exception", "(", "get", "class", "(", ")", "get", "simple", "name", "(", ")", "+", "\"", "doesn", "'", "t", "support", "rename", "snapshot", "\"", ")", ";", "}" ]
[ "returns", "the", "currently", "set", "task", "monitor" ]
[ "public", "task", "monitor", "get", "task", "monitor", "(", ")", "{", "return", "monitor", ";", "}" ]
[ "create", "the", "main", "panel" ]
[ "private", "j", "panel", "create", "panel", "(", "string", "prompt", ")", "{", "j", "panel", "panel", "=", "new", "j", "panel", "(", "new", "border", "layout", "(", ")", ")", ";", "panel", "set", "border", "(", "border", "factory", "create", "empty", "border", "(", "10", ",", "10", ",", "10", ",", "10", ")", ")", ";", "label", "=", "new", "g", "d", "label", "(", "prompt", ")", ";", "number", "input", "field", "=", "new", "integer", "text", "field", "(", "12", ")", ";", "number", "input", "field", "add", "change", "listener", "(", "e", "-", ">", "update", "o", "k", "button", "enablement", "(", ")", ")", ";", "/", "/", "actually", "assemble", "the", "parts", "into", "a", "status", "panel", "panel", "add", "(", "label", ",", "border", "layout", "west", ")", ";", "panel", "add", "(", "number", "input", "field", "get", "component", "(", ")", ",", "border", "layout", "center", ")", ";", "return", "panel", ";", "}" ]
[ "get", "the", "total", "number", "of", "job", "submissions", "in", "the", "cluster" ]
[ "public", "int", "get", "total", "job", "submissions", "(", ")", "{", "return", "total", "job", "submissions", ";", "}" ]
[ "method", ":", "string", "mod", "operator", ",", "return", "0", "~", "(", "mod", "-", "1", ")" ]
[ "public", "static", "int", "string", "mod", "(", "string", "string", ",", "int", "mod", ")", "{", "int", "hash", "code", "=", "0", ";", "if", "(", "string", "!", "=", "null", ")", "{", "hash", "code", "=", "string", "hash", "code", "(", ")", ";", "if", "(", "hash", "code", "<", "0", ")", "{", "hash", "code", "=", "math", "abs", "(", "hash", "code", ")", ";", "hash", "code", "=", "hash", "code", "<", "0", "?", "0", ":", "hash", "code", ";", "}", "}", "return", "hash", "code", "%", "(", "mod", ">", "0", "?", "mod", ":", "1", ")", ";", "}" ]
[ "return", "true", "if", "the", "given", "character", "is", "mapped", "to", "a", "supported", "entity", "reference" ]
[ "public", "boolean", "is", "mapped", "to", "reference", "(", "char", "character", ",", "string", "encoding", ")", "{", "return", "(", "convert", "to", "reference", "(", "character", ",", "encoding", ")", "!", "=", "null", ")", ";", "}" ]
[ "patch", "a", "configuration", "to", "declare", "this", "the", "dt", "provider", "for", "a", "filesystem", "built", "off", "the", "given", "configuration", "the", "abfs", "filesystem", "still", "needs", "to", "come", "up", "with", "security", "enabled" ]
[ "public", "static", "configuration", "use", "classic", "d", "t", "manager", "(", "configuration", "conf", ")", "{", "conf", "set", "boolean", "(", "fs", "azure", "enable", "delegation", "token", ",", "true", ")", ";", "conf", "set", "(", "fs", "azure", "delegation", "token", "provider", "type", ",", "classic", "delegation", "token", "manager", "name", ")", ";", "return", "conf", ";", "}" ]
[ "test", "the", "property", "'", "array", "array", "of", "model", "'" ]
[ "public", "void", "array", "array", "of", "model", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "array", "array", "of", "model", "}" ]
[ "bytes", "to", "parcelable" ]
[ "public", "static", "<", "t", ">", "t", "bytes", "2", "parcelable", "(", "final", "byte", "[", "]", "bytes", ",", "final", "parcelable", "creator", "<", "t", ">", "creator", ")", "{", "if", "(", "bytes", "=", "=", "null", ")", "return", "null", ";", "parcel", "parcel", "=", "parcel", "obtain", "(", ")", ";", "parcel", "unmarshall", "(", "bytes", ",", "0", ",", "bytes", "length", ")", ";", "parcel", "set", "data", "position", "(", "0", ")", ";", "t", "result", "=", "creator", "create", "from", "parcel", "(", "parcel", ")", ";", "parcel", "recycle", "(", ")", ";", "return", "result", ";", "}" ]
[ "adds", "a", "sort", "builder" ]
[ "public", "search", "source", "builder", "sort", "(", "sort", "builder", "<", "?", ">", "sort", ")", "{", "if", "(", "sorts", "=", "=", "null", ")", "{", "sorts", "=", "new", "array", "list", "<", ">", "(", ")", ";", "}", "sorts", "add", "(", "sort", ")", ";", "return", "this", ";", "}" ]
[ "sets", "the", "increment", "applied", "to", "the", "ticker", "whenever", "it", "is", "queried", "the", "default", "behavior", "is", "to", "auto", "increment", "by", "zero", "i", "e", ":", "the", "ticker", "is", "left", "unchanged", "when", "queried" ]
[ "public", "fake", "ticker", "set", "auto", "increment", "step", "(", "java", "time", "duration", "auto", "increment", "step", ")", "{", "return", "set", "auto", "increment", "step", "(", "auto", "increment", "step", "to", "nanos", "(", ")", ",", "time", "unit", "nanoseconds", ")", ";", "}" ]
[ "returns", "the", "count", "of", "{", "@", "code", "node", "}", "'", "s", "incoming", "edges", "(", "equal", "to", "{", "@", "code", "predecessors", "(", "node", ")", "size", "(", ")", "}", ")", "in", "a", "directed", "graph", "in", "an", "undirected", "graph", ",", "returns", "the", "{", "@", "link", "#", "degree", "(", "object", ")", "}", "if", "the", "count", "is", "greater", "than", "{", "@", "code", "integer", "max", "value", "}", ",", "returns", "{", "@", "code", "integer", "max", "value", "}" ]
[ "int", "in", "degree", "(", "n", "node", ")", ";" ]
[ "execute", "post", "http", "response" ]
[ "public", "static", "http", "response", "execute", "post", "(", "final", "string", "url", ",", "final", "string", "entity", ",", "final", "map", "<", "string", ",", "object", ">", "parameters", ")", "{", "return", "execute", "post", "(", "url", ",", "null", ",", "null", ",", "entity", ",", "parameters", ")", ";", "}" ]
[ "emits", "random", "words", "sequence", "of", "desired", "size", "note", "that", "the", "desired", "output", "size", "is", "passed", "as", "the", "value", "parameter", "to", "this", "map" ]
[ "public", "void", "map", "(", "null", "writable", "key", ",", "long", "writable", "value", ",", "context", "context", ")", "throws", "i", "o", "exception", ",", "interrupted", "exception", "{", "/", "/", "todo", "control", "the", "extra", "data", "written", "/", "/", "todo", "should", "the", "key", "\\", "tvalue", "\\", "n", "be", "considered", "for", "measuring", "size", "?", "/", "/", "can", "counters", "like", "bytes", "written", "be", "used", "?", "what", "will", "be", "the", "value", "of", "/", "/", "such", "counters", "in", "local", "job", "runner", "?", "for", "(", "long", "bytes", "=", "value", "get", "(", ")", ";", "bytes", ">", "0", ";", ")", "{", "string", "random", "key", "=", "rtg", "get", "random", "word", "(", ")", ";", "string", "random", "value", "=", "rtg", "get", "random", "word", "(", ")", ";", "context", "write", "(", "new", "text", "(", "random", "key", ")", ",", "new", "text", "(", "random", "value", ")", ")", ";", "bytes", "-", "=", "(", "random", "value", "get", "bytes", "(", "charset", "u", "t", "f", "8", ")", "length", "+", "random", "key", "get", "bytes", "(", "charset", "u", "t", "f", "8", ")", "length", ")", ";", "}", "}" ]
[ "connect", "to", "the", "server", "over", "web", "socket" ]
[ "mono", "<", "r", "socket", "requester", ">", "connect", "web", "socket", "(", "uri", "uri", ")", ";" ]
[ "convert", "byte", "array", "containing", "srid", "+", "wkb", "geometry", "into", "geometry", "object" ]
[ "public", "geometry", "from", "w", "k", "b", "(", "byte", "[", "]", "bytes", ")", "{", "if", "(", "bytes", "=", "=", "null", ")", "{", "return", "null", ";", "}", "try", "(", "byte", "array", "input", "stream", "input", "stream", "=", "new", "byte", "array", "input", "stream", "(", "bytes", ")", ")", "{", "/", "/", "read", "srid", "byte", "[", "]", "srid", "bytes", "=", "new", "byte", "[", "4", "]", ";", "input", "stream", "read", "(", "srid", "bytes", ")", ";", "int", "srid", "=", "byte", "order", "values", "get", "int", "(", "srid", "bytes", ",", "byte", "order", ")", ";", "/", "/", "prepare", "geometry", "factory", "geometry", "factory", "geometry", "factory", "=", "new", "geometry", "factory", "(", "precision", "model", ",", "srid", ",", "coordinate", "sequence", "factory", ")", ";", "/", "/", "read", "geometry", "w", "k", "b", "reader", "wkb", "reader", "=", "new", "w", "k", "b", "reader", "(", "geometry", "factory", ")", ";", "geometry", "geometry", "=", "wkb", "reader", "read", "(", "new", "input", "stream", "in", "stream", "(", "input", "stream", ")", ")", ";", "return", "geometry", ";", "}", "catch", "(", "i", "o", "exception", "|", "parse", "exception", "e", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "e", ")", ";", "}", "}" ]
[ "constructs", "a", "list", "item", "with", "instances", "of", "this", "class", "representing", "the", "contents", "of", "the", "given", "array", "of", "sections", ",", "adding", "it", "to", "the", "given", "map", "section" ]
[ "public", "static", "void", "add", "map", "(", "section", "[", "]", "sections", ",", "mixed", "item", "section", "map", "section", ")", "{", "if", "(", "sections", "=", "=", "null", ")", "{", "throw", "new", "null", "pointer", "exception", "(", "\"", "sections", "=", "=", "null", "\"", ")", ";", "}", "if", "(", "map", "section", "items", "(", ")", "size", "(", ")", "!", "=", "0", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "map", "section", "items", "(", ")", "size", "(", ")", "!", "=", "0", "\"", ")", ";", "}", "array", "list", "<", "map", "item", ">", "items", "=", "new", "array", "list", "<", "map", "item", ">", "(", "50", ")", ";", "for", "(", "section", "section", ":", "sections", ")", "{", "item", "type", "current", "type", "=", "null", ";", "item", "first", "item", "=", "null", ";", "item", "last", "item", "=", "null", ";", "int", "count", "=", "0", ";", "for", "(", "item", "item", ":", "section", "items", "(", ")", ")", "{", "item", "type", "type", "=", "item", "item", "type", "(", ")", ";", "if", "(", "type", "!", "=", "current", "type", ")", "{", "if", "(", "count", "!", "=", "0", ")", "{", "items", "add", "(", "new", "map", "item", "(", "current", "type", ",", "section", ",", "first", "item", ",", "last", "item", ",", "count", ")", ")", ";", "}", "current", "type", "=", "type", ";", "first", "item", "=", "item", ";", "count", "=", "0", ";", "}", "last", "item", "=", "item", ";", "count", "+", "+", ";", "}", "if", "(", "count", "!", "=", "0", ")", "{", "/", "/", "add", "a", "map", "item", "for", "the", "final", "items", "in", "the", "section", "items", "add", "(", "new", "map", "item", "(", "current", "type", ",", "section", ",", "first", "item", ",", "last", "item", ",", "count", ")", ")", ";", "}", "else", "if", "(", "section", "=", "=", "map", "section", ")", "{", "/", "/", "add", "a", "map", "item", "for", "the", "self", "-", "referential", "section", "items", "add", "(", "new", "map", "item", "(", "map", "section", ")", ")", ";", "}", "}", "map", "section", "add", "(", "new", "uniform", "list", "item", "<", "map", "item", ">", "(", "item", "type", "type", "map", "list", ",", "items", ")", ")", ";", "}" ]
[ "validate", "that", "the", "settings", "that", "are", "required", "to", "be", "identical", "between", "the", "leader", "and", "follower", "index", "are", "in", "fact", "equal" ]
[ "private", "static", "void", "validate", "settings", "(", "final", "settings", "leader", "index", "settings", ",", "final", "settings", "follower", "index", "settings", ")", "{", "/", "/", "make", "a", "copy", ",", "remove", "settings", "that", "are", "allowed", "to", "be", "different", ",", "and", "then", "compare", "if", "the", "settings", "are", "equal", "final", "settings", "leader", "settings", "=", "filter", "(", "leader", "index", "settings", ")", ";", "final", "settings", "follower", "settings", "=", "filter", "(", "follower", "index", "settings", ")", ";", "if", "(", "leader", "settings", "equals", "(", "follower", "settings", ")", "=", "=", "false", ")", "{", "final", "string", "message", "=", "string", "format", "(", "locale", "root", ",", "\"", "the", "leader", "index", "settings", "[", "%", "s", "]", "and", "follower", "index", "settings", "[", "%", "s", "]", "must", "be", "identical", "\"", ",", "leader", "settings", ",", "follower", "settings", ")", ";", "throw", "new", "illegal", "argument", "exception", "(", "message", ")", ";", "}", "}" ]
[ "copies", "num", "floats", "floats", "from", "src", "starting", "at", "offset", "to", "dst", "dst", "is", "assumed", "to", "be", "a", "direct", "{", "@", "link", "buffer", "}", "the", "method", "will", "crash", "if", "that", "is", "not", "the", "case", "the", "position", "and", "limit", "of", "the", "buffer", "are", "ignored", ",", "the", "copy", "is", "placed", "at", "position", "0", "in", "the", "buffer", "after", "the", "copying", "process", "the", "position", "of", "the", "buffer", "is", "set", "to", "0", "and", "its", "limit", "is", "set", "to", "num", "floats", "4", "if", "it", "is", "a", "byte", "buffer", "and", "num", "floats", "if", "it", "is", "a", "float", "buffer", "in", "case", "the", "buffer", "is", "neither", "a", "byte", "buffer", "nor", "a", "float", "buffer", "the", "limit", "is", "not", "set", "this", "is", "an", "expert", "method", ",", "use", "at", "your", "own", "risk" ]
[ "public", "static", "void", "copy", "(", "float", "[", "]", "src", ",", "buffer", "dst", ",", "int", "num", "floats", ",", "int", "offset", ")", "{", "float", "buffer", "float", "buffer", "=", "as", "float", "buffer", "(", "dst", ")", ";", "float", "buffer", "clear", "(", ")", ";", "dst", "position", "(", "0", ")", ";", "float", "buffer", "put", "(", "src", ",", "offset", ",", "num", "floats", ")", ";", "dst", "position", "(", "0", ")", ";", "if", "(", "dst", "instanceof", "byte", "buffer", ")", "dst", "limit", "(", "num", "floats", "<", "<", "2", ")", ";", "else", "dst", "limit", "(", "num", "floats", ")", ";", "}" ]
[ "delete", "fake", ":", "fake", "endpoint", "to", "test", "group", "parameters", "(", "optional", ")", "fake", "endpoint", "to", "test", "group", "parameters", "(", "optional", ")" ]
[ "default", "response", "entity", "<", "void", ">", "test", "group", "parameters", "(", "@", "not", "null", "@", "api", "param", "(", "value", "=", "\"", "required", "string", "in", "group", "parameters", "\"", ",", "required", "=", "true", ")", "@", "valid", "@", "request", "param", "(", "value", "=", "\"", "required", "string", "group", "\"", ",", "required", "=", "true", ")", "integer", "required", "string", "group", ",", "@", "api", "param", "(", "value", "=", "\"", "required", "boolean", "in", "group", "parameters", "\"", ",", "required", "=", "true", ")", "@", "request", "header", "(", "value", "=", "\"", "required", "boolean", "group", "\"", ",", "required", "=", "true", ")", "boolean", "required", "boolean", "group", ",", "@", "not", "null", "@", "api", "param", "(", "value", "=", "\"", "required", "integer", "in", "group", "parameters", "\"", ",", "required", "=", "true", ")", "@", "valid", "@", "request", "param", "(", "value", "=", "\"", "required", "int", "6", "4", "group", "\"", ",", "required", "=", "true", ")", "long", "required", "int", "6", "4", "group", ",", "@", "api", "param", "(", "value", "=", "\"", "string", "in", "group", "parameters", "\"", ")", "@", "valid", "@", "request", "param", "(", "value", "=", "\"", "string", "group", "\"", ",", "required", "=", "false", ")", "integer", "string", "group", ",", "@", "api", "param", "(", "value", "=", "\"", "boolean", "in", "group", "parameters", "\"", ")", "@", "request", "header", "(", "value", "=", "\"", "boolean", "group", "\"", ",", "required", "=", "false", ")", "boolean", "boolean", "group", ",", "@", "api", "param", "(", "value", "=", "\"", "integer", "in", "group", "parameters", "\"", ")", "@", "valid", "@", "request", "param", "(", "value", "=", "\"", "int", "6", "4", "group", "\"", ",", "required", "=", "false", ")", "long", "int", "6", "4", "group", ")", "{", "return", "new", "response", "entity", "<", ">", "(", "http", "status", "not", "implemented", ")", ";", "}" ]
[ "provides", "access", "to", "the", "{", "@", "code", "close", "status", "}", "with", "which", "the", "session", "is", "closed", "either", "locally", "or", "remotely", ",", "or", "completes", "empty", "if", "the", "session", "ended", "without", "a", "status" ]
[ "mono", "<", "close", "status", ">", "close", "status", "(", ")", ";", "/", "/", "web", "socket", "message", "factory", "methods" ]
[ "find", "the", "fields", "constant", "that", "matches", "name", ",", "or", "null", "if", "its", "not", "found" ]
[ "public", "static", "fields", "find", "by", "name", "(", "string", "name", ")", "{", "return", "by", "name", "get", "(", "name", ")", ";", "}" ]
[ "a", "map", "of", "document", "matchers", "allowing", "callers", "to", "selectively", "use", "only", "some", "of", "the", "documents", "in", "a", "yaml", "resource", "in", "yaml", "documents", "are", "separated", "by", "{", "@", "code", "-", "-", "-", "}", "lines", ",", "and", "each", "document", "is", "converted", "to", "properties", "before", "the", "match", "is", "made", "e", "g", "<", "pre", "class", "=", "\"", "code", "\"", ">", "environment", ":", "dev", "url", ":", "https", ":", "dev", "bar", "com", "name", ":", "developer", "setup", "-", "-", "-", "environment", ":", "prod", "url", ":", "https", ":", "foo", "bar", "com", "name", ":", "my", "cool", "app", "when", "mapped", "with", "<", "pre", "class", "=", "\"", "code", "\"", ">", "set", "document", "matchers", "(", "properties", "-", ">", "(", "\"", "prod", "\"", "equals", "(", "properties", "get", "property", "(", "\"", "environment", "\"", ")", ")", "?", "match", "status", "found", ":", "match", "status", "not", "found", ")", ")", ";", "would", "end", "up", "as", "<", "pre", "class", "=", "\"", "code", "\"", ">", "environment", "=", "prod", "url", "=", "https", ":", "foo", "bar", "com", "name", "=", "my", "cool", "app" ]
[ "public", "void", "set", "document", "matchers", "(", "document", "matcher", "matchers", ")", "{", "this", "document", "matchers", "=", "arrays", "as", "list", "(", "matchers", ")", ";", "}" ]
[ "set", "the", "user", "'", "s", "chronology", "(", "calendar", "system", ")" ]
[ "public", "void", "set", "chronology", "(", "@", "nullable", "chronology", "chronology", ")", "{", "this", "chronology", "=", "chronology", ";", "}" ]
[ "get", "prefix", "integer" ]
[ "public", "integer", "get", "prefix", "integer", "(", ")", "{", "return", "prefix", "integer", ";", "}" ]
[ "retrieve", "the", "value", "this", "method", "returns", "the", "value", "if", "it", "has", "been", "set", "via", "{", "@", "link", "#", "set", "(", "object", ")", "}", ",", "throws", "an", "{", "@", "link", "java", "util", "concurrent", "execution", "exception", "}", "if", "an", "exception", "has", "been", "set", "via", "{", "@", "link", "#", "set", "exception", "(", "throwable", ")", "}", ",", "or", "throws", "a", "{", "@", "link", "java", "util", "concurrent", "cancellation", "exception", "}", "if", "the", "future", "has", "been", "cancelled" ]
[ "public", "t", "get", "(", ")", "throws", "interrupted", "exception", ",", "execution", "exception", "{", "return", "this", "settable", "task", "get", "(", ")", ";", "}" ]
[ "helper", "for", "{", "@", "link", "#", "encode", "output", "}", ",", "which", "writes", "out", "the", "given", "size", "value", ",", "annotating", "it", "as", "well", "(", "if", "annotations", "are", "enabled", ")" ]
[ "private", "static", "void", "encode", "size", "(", "dex", "file", "file", ",", "annotated", "output", "out", ",", "string", "label", ",", "int", "size", ")", "{", "if", "(", "out", "annotates", "(", ")", ")", "{", "out", "annotate", "(", "string", "format", "(", "\"", "%", "-", "2", "1s", "%", "0", "8x", "\"", ",", "label", "+", "\"", "size", ":", "\"", ",", "size", ")", ")", ";", "}", "out", "write", "uleb", "1", "2", "8", "(", "size", ")", ";", "}" ]
[ "return", "the", "specific", "message", "source", "that", "resolves", "messages", "with", "respect", "to", "this", "theme" ]
[ "message", "source", "get", "message", "source", "(", ")", ";" ]
[ "get", "one", "byte", "from", "memory", "at", "the", "current", "position", "plus", "offset" ]
[ "public", "byte", "get", "byte", "(", "int", "offset", ")", "throws", "memory", "access", "exception", "{", "/", "/", "check", "external", "to", "code", "units", "owned", "bytes", "if", "(", "offset", "<", "0", "|", "|", "offset", ">", "=", "bytes", "length", ")", "{", "if", "(", "program", "=", "=", "null", ")", "{", "throw", "new", "memory", "access", "exception", "(", "\"", "pseduo", "code", "unit", "has", "null", "program", "-", "memory", "request", "out", "of", "range", "\"", ")", ";", "}", "memory", "memory", "=", "program", "get", "memory", "(", ")", ";", "try", "{", "return", "memory", "get", "byte", "(", "address", "add", "(", "offset", ")", ")", ";", "}", "catch", "(", "address", "out", "of", "bounds", "exception", "e", ")", "{", "throw", "new", "memory", "access", "exception", "(", "e", "get", "message", "(", ")", ")", ";", "}", "}", "synchronized", "(", "this", ")", "{", "refresh", "if", "needed", "(", ")", ";", "return", "bytes", "[", "offset", "]", ";", "}", "}" ]
[ "validate", "that", "the", "notification", "times", "out", "after", "reaching", "mapreduce", "job", "end", "-", "notification", "timeout" ]
[ "public", "void", "test", "notification", "timeout", "(", ")", "throws", "interrupted", "exception", "{", "configuration", "conf", "=", "new", "configuration", "(", ")", ";", "/", "/", "reduce", "the", "timeout", "to", "1", "second", "conf", "set", "int", "(", "\"", "mapreduce", "job", "end", "-", "notification", "timeout", "\"", ",", "1000", ")", ";", "job", "status", "job", "status", "=", "create", "test", "job", "status", "(", "\"", "job", "20130313155005308", "0001", "\"", ",", "job", "status", "succeeded", ")", ";", "job", "conf", "job", "conf", "=", "create", "test", "job", "conf", "(", "conf", ",", "0", ",", "base", "url", "+", "\"", "delay", "\"", ")", ";", "long", "start", "time", "=", "system", "current", "time", "millis", "(", ")", ";", "job", "end", "notifier", "local", "runner", "notification", "(", "job", "conf", ",", "job", "status", ")", ";", "long", "elapsed", "time", "=", "system", "current", "time", "millis", "(", ")", "-", "start", "time", ";", "/", "/", "validate", "params", "assert", "equals", "(", "1", ",", "delay", "servlet", "called", "times", ")", ";", "/", "/", "make", "sure", "we", "timed", "out", "with", "time", "slightly", "above", "1", "second", "/", "/", "(", "default", "timeout", "is", "in", "terms", "of", "minutes", ",", "so", "we", "'", "ll", "catch", "the", "problem", ")", "assert", "true", "(", "elapsed", "time", "<", "2000", ")", ";", "}" ]
[ "sets", "optional", "minimum", "should", "match", "value", "to", "apply", "to", "the", "query" ]
[ "public", "match", "bool", "prefix", "query", "builder", "minimum", "should", "match", "(", "string", "minimum", "should", "match", ")", "{", "this", "minimum", "should", "match", "=", "minimum", "should", "match", ";", "return", "this", ";", "}" ]
[ "the", "name", "of", "the", "resource", "(", "in", "the", "form", "package", ":", "typename", ")", "<", "code", ">", "optional", "string", "resource", "name", "=", "1", ";", "<", "code", ">" ]
[ "public", "string", "get", "resource", "name", "(", ")", "{", "return", "instance", "get", "resource", "name", "(", ")", ";", "}" ]
[ "sets", "the", "origin", "in", "relation", "to", "the", "sprite", "'", "s", "position", "for", "scaling", "and", "rotation" ]
[ "public", "void", "set", "origin", "(", "float", "origin", "x", ",", "float", "origin", "y", ")", "{", "this", "origin", "x", "=", "origin", "x", ";", "this", "origin", "y", "=", "origin", "y", ";", "dirty", "=", "true", ";", "}" ]
[ "whether", "to", "propagate", "the", "query", "parameters", "of", "the", "current", "request", "through", "to", "the", "target", "redirect", "url", "default", "is", "{", "@", "code", "false", "}" ]
[ "public", "redirect", "view", "controller", "registration", "set", "keep", "query", "params", "(", "boolean", "propagate", ")", "{", "this", "redirect", "view", "set", "propagate", "query", "params", "(", "propagate", ")", ";", "return", "this", ";", "}" ]
[ "adds", "a", "number", "of", "occurrences", "of", "the", "specified", "element", "to", "this", "multiset" ]
[ "public", "int", "add", "(", "e", "element", ",", "int", "occurrences", ")", "{", "check", "not", "null", "(", "element", ")", ";", "if", "(", "occurrences", "=", "=", "0", ")", "{", "return", "count", "(", "element", ")", ";", "}", "collect", "preconditions", "check", "positive", "(", "occurrences", ",", "\"", "occurences", "\"", ")", ";", "while", "(", "true", ")", "{", "atomic", "integer", "existing", "counter", "=", "maps", "safe", "get", "(", "count", "map", ",", "element", ")", ";", "if", "(", "existing", "counter", "=", "=", "null", ")", "{", "existing", "counter", "=", "count", "map", "put", "if", "absent", "(", "element", ",", "new", "atomic", "integer", "(", "occurrences", ")", ")", ";", "if", "(", "existing", "counter", "=", "=", "null", ")", "{", "return", "0", ";", "}", "/", "/", "existing", "counter", "!", "=", "null", ":", "fall", "through", "to", "operate", "against", "the", "existing", "atomic", "integer", "}", "while", "(", "true", ")", "{", "int", "old", "value", "=", "existing", "counter", "get", "(", ")", ";", "if", "(", "old", "value", "!", "=", "0", ")", "{", "try", "{", "int", "new", "value", "=", "int", "math", "checked", "add", "(", "old", "value", ",", "occurrences", ")", ";", "if", "(", "existing", "counter", "compare", "and", "set", "(", "old", "value", ",", "new", "value", ")", ")", "{", "/", "/", "new", "value", "can", "'", "t", "=", "=", "0", ",", "so", "no", "need", "to", "check", "&", "remove", "return", "old", "value", ";", "}", "}", "catch", "(", "arithmetic", "exception", "overflow", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "overflow", "adding", "\"", "+", "occurrences", "+", "\"", "occurrences", "to", "a", "count", "of", "\"", "+", "old", "value", ")", ";", "}", "}", "else", "{", "/", "/", "in", "the", "case", "of", "a", "concurrent", "remove", ",", "we", "might", "observe", "a", "zero", "value", ",", "which", "means", "another", "/", "/", "thread", "is", "about", "to", "remove", "(", "element", ",", "existing", "counter", ")", "from", "the", "map", "rather", "than", "wait", ",", "/", "/", "we", "can", "just", "do", "that", "work", "here", "atomic", "integer", "new", "counter", "=", "new", "atomic", "integer", "(", "occurrences", ")", ";", "if", "(", "(", "count", "map", "put", "if", "absent", "(", "element", ",", "new", "counter", ")", "=", "=", "null", ")", "|", "|", "count", "map", "replace", "(", "element", ",", "existing", "counter", ",", "new", "counter", ")", ")", "{", "return", "0", ";", "}", "break", ";", "}", "}", "/", "/", "if", "we", "'", "re", "still", "here", ",", "there", "was", "a", "race", ",", "so", "just", "try", "again", "}", "}" ]
[ "blocks", "until", "the", "event", "becomes", "the", "signaled", "state", "this", "method", "blocks", "infinitely", "until", "a", "value", "is", "offered" ]
[ "public", "void", "block", "(", ")", "throws", "interrupted", "exception", "{", "synchronized", "(", "lock", ")", "{", "while", "(", "!", "signaled", ")", "lock", "wait", "(", ")", ";", "}", "}" ]
[ "generates", "a", "certificate", "signing", "request" ]
[ "static", "p", "k", "c", "s", "1", "0", "certification", "request", "generate", "c", "s", "r", "(", "key", "pair", "key", "pair", ",", "x", "5", "0", "0", "principal", "principal", ",", "general", "names", "san", "list", ")", "throws", "i", "o", "exception", ",", "operator", "creation", "exception", "{", "objects", "require", "non", "null", "(", "key", "pair", ",", "\"", "key", "-", "pair", "must", "not", "be", "null", "\"", ")", ";", "objects", "require", "non", "null", "(", "key", "pair", "get", "public", "(", ")", ",", "\"", "public", "-", "key", "must", "not", "be", "null", "\"", ")", ";", "objects", "require", "non", "null", "(", "principal", ",", "\"", "principal", "must", "not", "be", "null", "\"", ")", ";", "jca", "p", "k", "c", "s", "1", "0", "certification", "request", "builder", "builder", "=", "new", "jca", "p", "k", "c", "s", "1", "0", "certification", "request", "builder", "(", "principal", ",", "key", "pair", "get", "public", "(", ")", ")", ";", "if", "(", "san", "list", "!", "=", "null", ")", "{", "extensions", "generator", "ext", "gen", "=", "new", "extensions", "generator", "(", ")", ";", "ext", "gen", "add", "extension", "(", "extension", "subject", "alternative", "name", ",", "false", ",", "san", "list", ")", ";", "builder", "add", "attribute", "(", "p", "k", "c", "s", "object", "identifiers", "pkcs", "9", "at", "extension", "request", ",", "ext", "gen", "generate", "(", ")", ")", ";", "}", "return", "builder", "build", "(", "new", "jca", "content", "signer", "builder", "(", "\"", "s", "h", "a", "2", "5", "6with", "r", "s", "a", "\"", ")", "set", "provider", "(", "cert", "gen", "utils", "bc", "prov", ")", "build", "(", "key", "pair", "get", "private", "(", ")", ")", ")", ";", "}" ]
[ "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", "<", "b", ">", "200", "<", "b", ">", "-", "successful", "operation", "<", "b", ">", "400", "<", "b", ">", "-", "invalid", "id", "supplied", "<", "b", ">", "404", "<", "b", ">", "-", "order", "not", "found" ]
[ "public", "order", "get", "order", "by", "id", "(", "long", "order", "id", ")", "throws", "i", "o", "exception", "{", "http", "response", "response", "=", "get", "order", "by", "id", "for", "http", "response", "(", "order", "id", ")", ";", "type", "reference", "<", "order", ">", "type", "ref", "=", "new", "type", "reference", "<", "order", ">", "(", ")", "{", "}", ";", "return", "api", "client", "get", "object", "mapper", "(", ")", "read", "value", "(", "response", "get", "content", "(", ")", ",", "type", "ref", ")", ";", "}" ]
[ "gets", "accounts", "by", "user", "name" ]
[ "public", "stream", "<", "dynamo", "db", "web", "authn", "credential", "registration", ">", "get", "accounts", "by", "(", "final", "string", "username", ")", "{", "return", "get", "records", "by", "keys", "(", "dynamo", "db", "query", "builder", "builder", "(", ")", "operator", "(", "comparison", "operator", "eq", ")", "attribute", "value", "(", "list", "of", "(", "attribute", "value", "builder", "(", ")", "s", "(", "username", ")", "build", "(", ")", ")", ")", "key", "(", "column", "names", "principal", "get", "column", "name", "(", ")", ")", "build", "(", ")", ")", ";", "}" ]
[ "invoked", "when", "a", "bundle", "is", "added", "to", "{", "@", "link", "bundle", "host", "}" ]
[ "default", "void", "bundle", "added", "(", "ghidra", "bundle", "bundle", ")", "{", "/", "/", "}" ]
[ "set", "directories", "that", "cannot", "be", "removed", "unless", "empty", ",", "even", "by", "an", "administrator" ]
[ "string", "set", "protected", "directories", "(", "string", "protected", "dirs", "string", ")", "{", "if", "(", "protected", "dirs", "string", "=", "=", "null", ")", "{", "protected", "directories", "=", "new", "tree", "set", "<", ">", "(", ")", ";", "}", "else", "{", "protected", "directories", "=", "parse", "protected", "directories", "(", "protected", "dirs", "string", ")", ";", "}", "return", "joiner", "on", "(", "\"", ",", "\"", ")", "skip", "nulls", "(", ")", "join", "(", "protected", "directories", ")", ";", "}" ]
[ "returns", "the", "average", "time", "spent", "loading", "new", "values", "this", "is", "defined", "as", "{", "@", "code", "total", "load", "time", "(", "load", "success", "count", "+", "load", "exception", "count", ")", "}", "<", "b", ">", "note", ":", "<", "b", ">", "the", "values", "of", "the", "metrics", "are", "undefined", "in", "case", "of", "overflow", "(", "though", "it", "is", "guaranteed", "not", "to", "throw", "an", "exception", ")", "if", "you", "require", "specific", "handling", ",", "we", "recommend", "implementing", "your", "own", "stats", "collector" ]
[ "public", "double", "average", "load", "penalty", "(", ")", "{", "long", "total", "load", "count", "=", "saturated", "add", "(", "load", "success", "count", ",", "load", "exception", "count", ")", ";", "return", "(", "total", "load", "count", "=", "=", "0", ")", "?", "0", "0", ":", "(", "double", ")", "total", "load", "time", "/", "total", "load", "count", ";", "}" ]
[ "a", "timeout", "to", "wait", "if", "the", "index", "operation", "can", "'", "t", "be", "performed", "immediately", "defaults", "to", "{", "@", "code", "1m", "}" ]
[ "public", "final", "request", "timeout", "(", "time", "value", "timeout", ")", "{", "this", "timeout", "=", "timeout", ";", "return", "(", "request", ")", "this", ";", "}" ]
[ "get", "name", "number" ]
[ "public", "big", "decimal", "get", "name", "number", "(", ")", "{", "return", "name", "number", ";", "}" ]
[ "@", "t", "c", "description", ":", "nacos", "open", "a", "p", "i", ",", ",", "utf", "-", "8", "@", "test", "step", ":", "1", "2", "@", "expect", "result", ":" ]
[ "public", "void", "nacos", "open", "a", "p", "i", "search", "config", "2", "(", ")", "{", "http", "rest", "result", "<", "string", ">", "result", "=", "null", ";", "try", "{", "final", "string", "content", "=", "\"", "\"", ";", "boolean", "ret", "=", "iconfig", "publish", "config", "(", "data", "id", ",", "group", ",", "content", ")", ";", "assert", "assert", "true", "(", "ret", ")", ";", "thread", "sleep", "(", "time", "out", ")", ";", "map", "<", "string", ",", "string", ">", "params", "=", "new", "hash", "map", "<", ">", "(", ")", ";", "params", "put", "(", "\"", "data", "id", "\"", ",", "data", "id", ")", ";", "params", "put", "(", "\"", "group", "\"", ",", "group", ")", ";", "params", "put", "(", "\"", "page", "no", "\"", ",", "\"", "1", "\"", ")", ";", "params", "put", "(", "\"", "page", "size", "\"", ",", "\"", "10", "\"", ")", ";", "params", "put", "(", "\"", "search", "\"", ",", "\"", "accurate", "\"", ")", ";", "result", "=", "agent", "http", "get", "(", "config", "controller", "path", "+", "\"", "/", "\"", ",", "null", ",", "params", ",", "agent", "get", "encode", "(", ")", ",", "time", "out", ")", ";", "assert", "assert", "equals", "(", "http", "u", "r", "l", "connection", "http", "ok", ",", "result", "get", "code", "(", ")", ")", ";", "assert", "assert", "equals", "(", "1", ",", "jackson", "utils", "to", "obj", "(", "result", "get", "data", "(", ")", ")", "get", "(", "\"", "total", "count", "\"", ")", "int", "value", "(", ")", ")", ";", "assert", "assert", "equals", "(", "content", ",", "jackson", "utils", "to", "obj", "(", "result", "get", "data", "(", ")", ")", "get", "(", "\"", "page", "items", "\"", ")", "get", "(", "0", ")", "get", "(", "\"", "content", "\"", ")", "text", "value", "(", ")", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "assert", "fail", "(", ")", ";", "}", "}" ]
[ "get", "the", "number", "of", "streams", "to", "merge", "at", "once" ]
[ "public", "int", "get", "factor", "(", ")", "{", "return", "factor", ";", "}" ]
[ "sets", "the", "function", "calling", "convention", "for", "example", ",", "\"", "cdecl", "\"" ]
[ "public", "void", "set", "calling", "convention", "(", "string", "calling", "convention", ")", "{", "this", "calling", "convention", "=", "calling", "convention", ";", "}" ]
[ "appends", "the", "string", "representation", "of", "the", "specified", "{", "@", "code", "float", "}", "value", "the", "{", "@", "code", "float", "}", "value", "is", "converted", "to", "a", "string", "according", "to", "the", "rule", "defined", "by", "{", "@", "link", "string", "#", "value", "of", "(", "float", ")", "}" ]
[ "public", "string", "builder", "append", "(", "float", "f", ")", "{", "append", "0", "(", "float", "to", "string", "(", "f", ")", ")", ";", "return", "this", ";", "}" ]
[ "animates", "the", "drawing", "rendering", "of", "the", "chart", "on", "both", "x", "-", "and", "y", "-", "axis", "with", "the", "specified", "animation", "time", "if", "animate", "(", ")", "is", "called", ",", "no", "further", "calling", "of", "invalidate", "(", ")", "is", "necessary", "to", "refresh", "the", "chart", "animations", "only", "work", "for", "api", "level", "11", "(", "android", "3", "0", "x", ")", "and", "higher" ]
[ "public", "void", "animate", "x", "y", "(", "int", "duration", "millis", "x", ",", "int", "duration", "millis", "y", ")", "{", "m", "animator", "animate", "x", "y", "(", "duration", "millis", "x", ",", "duration", "millis", "y", ")", ";", "}" ]
[ "verify", "that", "if", "a", "given", "watcher", "doesn", "'", "t", "exist", ",", "the", "server", "properly", "returns", "an", "error", "code", "for", "it", "in", "our", "java", "client", "implementation", ",", "we", "check", "that", "a", "given", "watch", "exists", "at", "two", "points", ":", "1", ")", "before", "submitting", "the", "remove", "watches", "request", "2", ")", "after", "a", "successful", "server", "response", ",", "when", "the", "watcher", "needs", "to", "be", "removed", "since", "this", "can", "be", "racy", "(", "i", "e", "a", "watch", "can", "fire", "while", "a", "remove", "watches", "request", "is", "in", "-", "flight", ")", ",", "we", "need", "to", "verify", "that", "the", "watch", "was", "actually", "removed", "(", "i", "e", "from", "z", "k", "database", "and", "data", "tree", ")", "and", "return", "nowatcher", "if", "needed", "also", ",", "other", "implementations", "might", "not", "do", "a", "client", "side", "check", "before", "submitting", "a", "remove", "watches", "request", "if", "we", "don", "'", "t", "do", "a", "server", "side", "check", ",", "we", "would", "just", "return", "zok", "even", "if", "no", "watch", "was", "removed" ]
[ "public", "void", "test", "no", "watcher", "server", "exception", "(", "boolean", "use", "async", ")", "throws", "interrupted", "exception", ",", "i", "o", "exception", ",", "timeout", "exception", "{", "countdown", "watcher", "watcher", "=", "new", "countdown", "watcher", "(", ")", ";", "zoo", "keeper", "zk", "=", "spy", "(", "new", "zoo", "keeper", "(", "host", "port", ",", "connection", "timeout", ",", "watcher", ")", ")", ";", "my", "watch", "manager", "watch", "manager", "=", "new", "my", "watch", "manager", "(", "false", ",", "watcher", ")", ";", "do", "return", "(", "watch", "manager", ")", "when", "(", "zk", ")", "get", "watch", "manager", "(", ")", ";", "boolean", "nw", "=", "false", ";", "watcher", "wait", "for", "connected", "(", "connection", "timeout", ")", ";", "try", "{", "zk", "remove", "watches", "(", "\"", "/", "nowatchhere", "\"", ",", "watcher", ",", "watcher", "type", "data", ",", "false", ")", ";", "}", "catch", "(", "keeper", "exception", "nwe", ")", "{", "if", "(", "nwe", "code", "(", ")", "int", "value", "(", ")", "=", "=", "code", "nowatcher", "int", "value", "(", ")", ")", "{", "nw", "=", "true", ";", "}", "}", "assert", "that", "(", "\"", "server", "didn", "'", "t", "return", "nowatcher", "\"", ",", "watch", "manager", "last", "return", "code", ",", "is", "(", "code", "nowatcher", "int", "value", "(", ")", ")", ")", ";", "assert", "that", "(", "\"", "no", "watcher", "exception", "didn", "'", "t", "happen", "\"", ",", "nw", ",", "is", "(", "true", ")", ")", ";", "}" ]
[ "this", "implementation", "comes", "at", "a", "relatively", "high", "cost", "per", "invocation", "it", "should", "not", "be", "called", "repeatedly", "when", "it", "is", "clear", "that", "the", "value", "did", "not", "change", "currently", "this", "is", "only", "truly", "used", "to", "realize", "certain", "higher", "-", "level", "tests" ]
[ "public", "int", "size", "(", ")", "{", "if", "(", "all", "elements", "in", "cache", ")", "{", "return", "ordered", "cache", "size", "(", ")", ";", "}", "else", "{", "int", "count", "=", "0", ";", "try", "(", "final", "rocks", "bytes", "iterator", "iterator", "=", "ordered", "bytes", "iterator", "(", ")", ")", "{", "while", "(", "iterator", "has", "next", "(", ")", ")", "{", "iterator", "next", "(", ")", ";", "+", "+", "count", ";", "}", "}", "return", "count", ";", "}", "}" ]
[ "removes", "all", "key", "-", "value", "mappings", "from", "this", "sparse", "array" ]
[ "public", "void", "clear", "(", ")", "{", "int", "n", "=", "m", "size", ";", "object", "[", "]", "values", "=", "m", "values", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "n", ";", "i", "+", "+", ")", "{", "values", "[", "i", "]", "=", "null", ";", "}", "m", "size", "=", "0", ";", "m", "garbage", "=", "false", ";", "}" ]
[ "called", "after", "{", "@", "link", "application", "listener", "}", "create", "and", "resize", ",", "but", "before", "the", "game", "loop", "iteration" ]
[ "protected", "void", "start", "(", ")", "{", "}" ]
[ "helper", "method", "to", "configure", "the", "usernamepassword", "for", "basic", "auth", "or", "password", "oauth" ]
[ "public", "api", "client", "set", "credentials", "(", "string", "username", ",", "string", "password", ")", "{", "for", "(", "interceptor", "api", "authorization", ":", "api", "authorizations", "values", "(", ")", ")", "{", "if", "(", "api", "authorization", "instanceof", "http", "basic", "auth", ")", "{", "http", "basic", "auth", "basic", "auth", "=", "(", "http", "basic", "auth", ")", "api", "authorization", ";", "basic", "auth", "set", "credentials", "(", "username", ",", "password", ")", ";", "return", "this", ";", "}", "if", "(", "api", "authorization", "instanceof", "o", "auth", ")", "{", "o", "auth", "oauth", "=", "(", "o", "auth", ")", "api", "authorization", ";", "oauth", "get", "token", "request", "builder", "(", ")", "set", "username", "(", "username", ")", "set", "password", "(", "password", ")", ";", "return", "this", ";", "}", "}", "return", "this", ";", "}" ]
[ "sets", "word", "to", "be", "encoded" ]
[ "void", "set", "word", "(", "string", "in", ")", "{", "m", "in", "word", "=", "in", "to", "upper", "case", "(", ")", ";", ";", "m", "length", "=", "m", "in", "word", "length", "(", ")", ";", "}" ]
[ "test", "for", "a", "bug", "encountered", "during", "development", "of", "hadoop", "-", "8163", ":", "ensure", "base", "node", "(", ")", "should", "throw", "an", "exception", "if", "it", "has", "to", "retry", "more", "than", "3", "times", "to", "create", "any", "part", "of", "the", "path" ]
[ "public", "void", "test", "ensure", "base", "node", "fails", "(", ")", "throws", "exception", "{", "mockito", "do", "throw", "(", "new", "keeper", "exception", "connection", "loss", "exception", "(", ")", ")", "when", "(", "mock", "z", "k", ")", "create", "(", "mockito", "eq", "(", "zk", "parent", "name", ")", ",", "mockito", "<", "byte", "[", "]", ">", "any", "(", ")", ",", "mockito", "eq", "(", "ids", "open", "acl", "unsafe", ")", ",", "mockito", "eq", "(", "create", "mode", "persistent", ")", ")", ";", "try", "{", "elector", "ensure", "parent", "z", "node", "(", ")", ";", "assert", "fail", "(", "\"", "did", "not", "throw", "!", "\"", ")", ";", "}", "catch", "(", "i", "o", "exception", "ioe", ")", "{", "if", "(", "!", "(", "ioe", "get", "cause", "(", ")", "instanceof", "keeper", "exception", "connection", "loss", "exception", ")", ")", "{", "throw", "ioe", ";", "}", "}", "/", "/", "should", "have", "tried", "three", "times", "mockito", "verify", "(", "mock", "z", "k", ",", "mockito", "times", "(", "3", ")", ")", "create", "(", "mockito", "eq", "(", "zk", "parent", "name", ")", ",", "mockito", "<", "byte", "[", "]", ">", "any", "(", ")", ",", "mockito", "eq", "(", "ids", "open", "acl", "unsafe", ")", ",", "mockito", "eq", "(", "create", "mode", "persistent", ")", ")", ";", "}" ]
[ "post", "pet", ":", "add", "a", "new", "pet", "to", "the", "store" ]
[ "default", "response", "entity", "<", "void", ">", "add", "pet", "(", "@", "api", "param", "(", "value", "=", "\"", "pet", "object", "that", "needs", "to", "be", "added", "to", "the", "store", "\"", ",", "required", "=", "true", ")", "@", "valid", "@", "request", "body", "pet", "body", ")", "{", "return", "get", "delegate", "(", ")", "add", "pet", "(", "body", ")", ";", "}" ]
[ "returns", "the", "last", "key", "in", "this", "set" ]
[ "public", "short", "get", "last", "(", ")", "{", "if", "(", "root", "=", "=", "null", ")", "{", "return", "-", "1", ";", "}", "r", "b", "node", "node", "=", "root", ";", "while", "(", "node", "right", "!", "=", "null", ")", "{", "node", "=", "node", "right", ";", "}", "return", "node", "key", ";", "}" ]
[ "return", "a", "map", "of", "object", "file", "artifacts", "to", "associated", "l", "t", "o", "backend", "artifacts", "objects", "generated", "when", "lto", "backend", "actions", "are", "to", "be", "shared", "among", "different", "targets", "using", "this", "library", "this", "is", "the", "case", "when", "we", "opt", "not", "to", "perform", "the", "lto", "indexing", "step", ",", "such", "as", "when", "building", "tests", "with", "static", "linking", "thin", "l", "t", "o", "is", "otherwise", "too", "expensive", "when", "statically", "linking", "tests", ",", "due", "to", "the", "number", "of", "lto", "backends", "that", "can", "be", "generated", "for", "a", "single", "blaze", "test", "invocation" ]
[ "immutable", "map", "<", "artifact", ",", "lto", "backend", "artifacts", ">", "get", "shared", "non", "lto", "backends", "(", ")", ";" ]
[ "a", "function", "equivalent", "to", "the", "method", "reference", "{", "@", "code", "object", ":", ":", "to", "string", "}", ",", "for", "users", "not", "yet", "using", "java", "8", "the", "function", "simply", "invokes", "{", "@", "code", "to", "string", "}", "on", "its", "argument", "and", "returns", "the", "result", "it", "throws", "a", "{", "@", "link", "null", "pointer", "exception", "}", "on", "null", "input", "<", "b", ">", "warning", ":", "<", "b", ">", "the", "returned", "function", "may", "not", "be", "consistent", "with", "equals", "(", "as", "documented", "at", "{", "@", "link", "function", "#", "apply", "}", ")", "for", "example", ",", "this", "function", "yields", "different", "results", "for", "the", "two", "equal", "instances", "{", "@", "code", "immutable", "set", "of", "(", "1", ",", "2", ")", "}", "and", "{", "@", "code", "immutable", "set", "of", "(", "2", ",", "1", ")", "}", "<", "b", ">", "warning", ":", "<", "b", ">", "as", "with", "all", "function", "types", "in", "this", "package", ",", "avoid", "depending", "on", "the", "specific", "{", "@", "code", "equals", "}", ",", "{", "@", "code", "hash", "code", "}", "or", "{", "@", "code", "to", "string", "}", "behavior", "of", "the", "returned", "function", "a", "future", "migration", "to", "{", "@", "code", "java", "util", "function", "}", "will", "not", "preserve", "this", "behavior", "<", "b", ">", "for", "java", "8", "users", ":", "<", "b", ">", "use", "the", "method", "reference", "{", "@", "code", "object", ":", ":", "to", "string", "}", "instead", "in", "the", "future", ",", "when", "this", "class", "requires", "java", "8", ",", "this", "method", "will", "be", "deprecated", "see", "{", "@", "link", "function", "}", "for", "more", "important", "information", "about", "the", "java", "8", "transition" ]
[ "public", "static", "function", "<", "object", ",", "string", ">", "to", "string", "function", "(", ")", "{", "return", "to", "string", "function", "instance", ";", "}" ]
[ "subclasses", "must", "call", "this", "method", "after", "finishing", "character", "processing", ",", "in", "order", "to", "ensure", "that", "any", "unterminated", "line", "in", "the", "buffer", "is", "passed", "to", "{", "@", "link", "#", "handle", "line", "}" ]
[ "protected", "void", "finish", "(", ")", "throws", "i", "o", "exception", "{", "if", "(", "saw", "return", "|", "|", "line", "length", "(", ")", ">", "0", ")", "{", "finish", "line", "(", "false", ")", ";", "}", "}" ]
[ "check", "if", "identity", "is", "allowed", "to", "drop", "the", "specified", "schema", "in", "this", "catalog" ]
[ "default", "void", "check", "can", "drop", "schema", "(", "connector", "transaction", "handle", "transaction", "handle", ",", "connector", "identity", "identity", ",", "access", "control", "context", "context", ",", "string", "schema", "name", ")", "{", "deny", "drop", "schema", "(", "schema", "name", ")", ";", "}" ]
[ "moves", "current", "position", "until", "after", "the", "next", "end", "of", "string", "marker" ]
[ "public", "void", "skip", "next", "string", "(", ")", "throws", "i", "o", "exception", "{", "if", "(", "offset", ">", "=", "b", "length", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "tried", "to", "read", "nonexistent", "string", "from", "byte", "array", "\"", ")", ";", "}", "while", "(", "offset", "<", "b", "length", "&", "&", "b", "[", "offset", "]", "!", "=", "0x", "0", ")", "{", "+", "+", "offset", ";", "}", "+", "+", "offset", ";", "}" ]
[ "test", "the", "property", "'", "category", "'" ]
[ "public", "void", "category", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "category", "}" ]
[ "verify", "the", "support", "for", "decommissioning", "a", "datanode", "that", "is", "already", "dead", "under", "this", "scenario", "the", "datanode", "should", "immediately", "be", "marked", "as", "decommissioned" ]
[ "public", "void", "test", "decommission", "dead", "d", "n", "(", ")", "throws", "exception", "{", "logger", "log", "=", "logger", "get", "logger", "(", "datanode", "admin", "manager", "class", ")", ";", "log", "set", "level", "(", "level", "debug", ")", ";", "datanode", "i", "d", "dn", "i", "d", "=", "cluster", "get", "data", "nodes", "(", ")", "get", "(", "0", ")", "get", "datanode", "id", "(", ")", ";", "string", "dn", "name", "=", "dn", "i", "d", "get", "xfer", "addr", "(", ")", ";", "data", "node", "properties", "stopped", "d", "n", "=", "cluster", "stop", "data", "node", "(", "0", ")", ";", "d", "f", "s", "test", "util", "wait", "for", "datanode", "state", "(", "cluster", ",", "dn", "i", "d", "get", "datanode", "uuid", "(", ")", ",", "false", ",", "30000", ")", ";", "f", "s", "namesystem", "fsn", "=", "cluster", "get", "namesystem", "(", ")", ";", "final", "datanode", "manager", "dm", "=", "fsn", "get", "block", "manager", "(", ")", "get", "datanode", "manager", "(", ")", ";", "datanode", "descriptor", "dn", "descriptor", "=", "dm", "get", "datanode", "(", "dn", "i", "d", ")", ";", "decommission", "node", "(", "dn", "name", ")", ";", "dm", "refresh", "nodes", "(", "conf", ")", ";", "block", "manager", "test", "util", "recheck", "decommission", "state", "(", "dm", ")", ";", "/", "/", "block", "until", "the", "admin", "'", "s", "monitor", "updates", "the", "number", "of", "tracked", "nodes", "wait", "for", "decommissioned", "nodes", "(", "dm", "get", "datanode", "admin", "manager", "(", ")", ",", "0", ")", ";", "assert", "true", "(", "dn", "descriptor", "is", "decommissioned", "(", ")", ")", ";", "/", "/", "add", "the", "node", "back", "cluster", "restart", "data", "node", "(", "stopped", "d", "n", ",", "true", ")", ";", "cluster", "wait", "active", "(", ")", ";", "/", "/", "call", "refresh", "nodes", "on", "f", "s", "namesystem", "with", "empty", "exclude", "file", "to", "remove", "the", "/", "/", "datanode", "from", "decommissioning", "list", "and", "make", "it", "available", "again", "hosts", "file", "writer", "init", "exclude", "host", "(", "\"", "\"", ")", ";", "dm", "refresh", "nodes", "(", "conf", ")", ";", "}" ]
[ "create", "user", "this", "can", "only", "be", "done", "by", "the", "logged", "in", "user" ]
[ "public", "void", "create", "user", "(", "user", "user", ")", "throws", "api", "exception", "{", "object", "local", "var", "post", "body", "=", "user", ";", "/", "/", "verify", "the", "required", "parameter", "'", "user", "'", "is", "set", "if", "(", "user", "=", "=", "null", ")", "{", "throw", "new", "api", "exception", "(", "400", ",", "\"", "missing", "the", "required", "parameter", "'", "user", "'", "when", "calling", "create", "user", "\"", ")", ";", "}", "/", "/", "create", "path", "and", "map", "variables", "string", "local", "var", "path", "=", "\"", "/", "user", "\"", "replace", "all", "(", "\"", "\\", "\\", "{", "format", "\\", "\\", "}", "\"", ",", "\"", "json", "\"", ")", ";", "/", "/", "query", "params", "list", "<", "pair", ">", "local", "var", "query", "params", "=", "new", "array", "list", "<", "pair", ">", "(", ")", ";", "/", "/", "header", "params", "map", "<", "string", ",", "string", ">", "local", "var", "header", "params", "=", "new", "hash", "map", "<", "string", ",", "string", ">", "(", ")", ";", "/", "/", "form", "params", "map", "<", "string", ",", "string", ">", "local", "var", "form", "params", "=", "new", "hash", "map", "<", "string", ",", "string", ">", "(", ")", ";", "string", "[", "]", "local", "var", "content", "types", "=", "{", "}", ";", "string", "local", "var", "content", "type", "=", "local", "var", "content", "types", "length", ">", "0", "?", "local", "var", "content", "types", "[", "0", "]", ":", "\"", "application", "/", "json", "\"", ";", "if", "(", "local", "var", "content", "type", "starts", "with", "(", "\"", "multipart", "/", "form", "-", "data", "\"", ")", ")", "{", "/", "/", "file", "uploading", "multipart", "entity", "builder", "local", "var", "builder", "=", "multipart", "entity", "builder", "create", "(", ")", ";", "local", "var", "post", "body", "=", "local", "var", "builder", "build", "(", ")", ";", "}", "else", "{", "/", "/", "normal", "form", "params", "}", "try", "{", "string", "local", "var", "response", "=", "api", "invoker", "invoke", "a", "p", "i", "(", "base", "path", ",", "local", "var", "path", ",", "\"", "post", "\"", ",", "local", "var", "query", "params", ",", "local", "var", "post", "body", ",", "local", "var", "header", "params", ",", "local", "var", "form", "params", ",", "local", "var", "content", "type", ")", ";", "if", "(", "local", "var", "response", "!", "=", "null", ")", "{", "return", ";", "}", "else", "{", "return", ";", "}", "}", "catch", "(", "api", "exception", "ex", ")", "{", "throw", "ex", ";", "}", "}" ]
[ "gets", "the", "appropriate", "ghidra", "application", "layout", "for", "this", "headless", "analyzer", "the", "headless", "analyzer", "can", "be", "used", "in", "both", "\"", "normal", "\"", "mode", "and", "single", "jar", "mode", ",", "so", "we", "need", "to", "use", "the", "appropriate", "layout", "for", "either", "case" ]
[ "private", "static", "ghidra", "application", "layout", "get", "application", "layout", "(", ")", "throws", "i", "o", "exception", "{", "ghidra", "application", "layout", "layout", ";", "try", "{", "layout", "=", "new", "ghidra", "application", "layout", "(", ")", ";", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "layout", "=", "new", "ghidra", "jar", "application", "layout", "(", ")", ";", "}", "return", "layout", ";", "}" ]
[ "return", "the", "covariances", "as", "a", "map", "-", "not", "public", ",", "used", "for", "get", "property", "(", ")" ]
[ "protected", "map", "<", "string", ",", "hash", "map", "<", "string", ",", "double", ">", ">", "get", "covariances", "(", ")", "{", "return", "collections", "unmodifiable", "map", "(", "results", "covariances", ")", ";", "}" ]
[ "removes", "a", "listener", "of", "video", "events" ]
[ "void", "remove", "video", "listener", "(", "video", "listener", "listener", ")", ";" ]
[ "model", "tests", "for", "mixed", "properties", "and", "additional", "properties", "class" ]
[ "public", "void", "test", "mixed", "properties", "and", "additional", "properties", "class", "(", ")", "{", "/", "/", "todo", ":", "test", "mixed", "properties", "and", "additional", "properties", "class", "}" ]
[ "is", "the", "last", "block", "completed", "?" ]
[ "public", "boolean", "is", "last", "block", "complete", "(", ")", "{", "return", "is", "last", "block", "complete", ";", "}" ]
[ "return", "headers", "associated", "with", "the", "exception", "that", "should", "be", "added", "to", "the", "error", "response", ",", "e", "g", "\"", "allow", "\"", ",", "\"", "accept", "\"", ",", "etc", "the", "default", "implementation", "in", "this", "class", "returns", "an", "empty", "map" ]
[ "public", "map", "<", "string", ",", "string", ">", "get", "headers", "(", ")", "{", "return", "collections", "empty", "map", "(", ")", ";", "}" ]
[ "removes", "all", "data", "sets", "(", "and", "thereby", "entries", ")", "from", "the", "chart", "does", "not", "set", "the", "data", "object", "to", "null", "also", "refreshes", "the", "chart", "by", "calling", "invalidate", "(", ")" ]
[ "public", "void", "clear", "values", "(", ")", "{", "m", "data", "clear", "values", "(", ")", ";", "invalidate", "(", ")", ";", "}" ]
[ "get", "the", "namenode", "resolver", "for", "a", "subcluster" ]
[ "public", "active", "namenode", "resolver", "get", "namenode", "resolver", "(", ")", "{", "return", "this", "namenode", "resolver", ";", "}" ]
[ "mappings", "specified", "on", "this", "search", "request", "that", "override", "built", "in", "mappings" ]
[ "public", "map", "<", "string", ",", "object", ">", "runtime", "mappings", "(", ")", "{", "return", "collections", "unmodifiable", "map", "(", "runtime", "mappings", ")", ";", "}" ]
[ "assert", "that", "a", "map", "contains", "entries", ";", "that", "is", ",", "it", "must", "not", "be", "{", "@", "code", "null", "}", "and", "must", "contain", "at", "least", "one", "entry" ]
[ "public", "static", "void", "not", "empty", "(", "@", "nullable", "map", "<", "?", ",", "?", ">", "map", ")", "{", "not", "empty", "(", "map", ",", "\"", "[", "assertion", "failed", "]", "-", "this", "map", "must", "not", "be", "empty", ";", "it", "must", "contain", "at", "least", "one", "entry", "\"", ")", ";", "}" ]
[ "releases", "the", "component", "listener" ]
[ "public", "void", "release", "(", ")", "{", "released", "=", "true", ";", "player", "handler", "remove", "callbacks", "and", "messages", "(", "null", ")", ";", "}" ]
[ "returns", "true", "if", "the", "specified", "offset", "is", "a", "valid", "offset", "for", "this", "string", "table" ]
[ "public", "boolean", "is", "valid", "(", "long", "offset", ")", "{", "return", "(", "offset", ">", "=", "0", ")", "&", "&", "(", "offset", "<", "bytes", "length", ")", ";", "}" ]
[ "only", "valid", "if", "the", "image", "format", "is", "jpeg" ]
[ "public", "int", "get", "sample", "size", "(", ")", "{", "return", "m", "sample", "size", ";", "}" ]
[ "adds", "a", "new", "pair", "of", "attribute", "-", "value" ]
[ "public", "builder", "add", "attribute", "(", "string", "name", ",", "string", "value", ")", "{", "attributes", "put", "(", "name", ",", "value", ")", ";", "return", "this", ";", "}" ]