Datasets:
Anonymous2023
/
KGSum

Dataset card Data Studio Files Community
docstring_tokens
list
code_tokens
list
[ "returns", "the", "version", "of", "the", "current", "snapshot", "'", "s", "written", "binary", "format" ]
[ "int", "get", "current", "version", "(", ")", ";" ]
[ "get", "namespace", "number" ]
[ "public", "big", "decimal", "get", "namespace", "number", "(", ")", "{", "return", "namespace", "number", ";", "}" ]
[ "get", "the", "specified", "field", "the", "object", "returned", "must", "not", "be", "modified" ]
[ "field", "get", "field", "(", "int", "column", "index", ")", "{", "return", "field", "values", "[", "column", "index", "]", ";", "}" ]
[ "returns", "any", "linker", "scripts", "found", "in", "the", "\"", "deps", "\"", "attribute", "of", "the", "rule" ]
[ "list", "<", "artifact", ">", "get", "linker", "scripts", "(", ")", "{", "return", "rule", "context", "get", "prerequisite", "artifacts", "(", "\"", "deps", "\"", ")", "filter", "(", "cpp", "file", "types", "linker", "script", ")", "list", "(", ")", ";", "}" ]
[ "comparable", "argument", "greater", "than", "the", "given", "value", "see", "examples", "in", "javadoc", "for", "{", "@", "link", "additional", "matchers", "}", "class" ]
[ "public", "static", "<", "t", "extends", "comparable", "<", "t", ">", ">", "t", "gt", "(", "t", "value", ")", "{", "report", "matcher", "(", "new", "greater", "than", "<", "t", ">", "(", "value", ")", ")", ";", "return", "null", ";", "}" ]
[ "return", "a", "version", "of", "this", "token", "filter", "factory", "appropriate", "for", "synonym", "parsing", "filters", "that", "should", "not", "be", "applied", "to", "synonyms", "(", "for", "example", ",", "those", "that", "produce", "multiple", "tokens", ")", "should", "throw", "an", "exception" ]
[ "default", "token", "filter", "factory", "get", "synonym", "filter", "(", ")", "{", "return", "this", ";", "}" ]
[ "{", "@", "inherit", "doc", "}", "if", "the", "given", "path", "is", "a", "symlink", ",", "the", "path", "will", "be", "resolved", "to", "a", "target", "path", "and", "it", "will", "get", "the", "resolved", "path", "'", "s", "file", "status", "object", "it", "will", "not", "be", "represented", "as", "a", "symlink", "and", "is", "directory", "api", "returns", "true", "if", "the", "resolved", "path", "is", "a", "directory", ",", "false", "otherwise" ]
[ "public", "file", "status", "get", "file", "status", "(", "path", "f", ")", "throws", "i", "o", "exception", ",", "unresolved", "link", "exception", "{", "hdfs", "file", "status", "fi", "=", "dfs", "get", "file", "info", "(", "get", "uri", "path", "(", "f", ")", ")", ";", "if", "(", "fi", "!", "=", "null", ")", "{", "return", "fi", "make", "qualified", "(", "get", "uri", "(", ")", ",", "f", ")", ";", "}", "else", "{", "throw", "new", "file", "not", "found", "exception", "(", "\"", "file", "does", "not", "exist", ":", "\"", "+", "f", "to", "string", "(", ")", ")", ";", "}", "}" ]
[ "materializes", "a", "single", "virtual", "input", "inside", "the", "given", "execroot", "when", "materializing", "inputs", "under", "a", "new", "sandbox", "exec", "root", ",", "we", "can", "expect", "the", "input", "to", "not", "exist", ",", "but", "we", "cannot", "make", "the", "same", "assumption", "for", "the", "non", "-", "sandboxed", "exec", "root", "therefore", ",", "we", "may", "need", "to", "delete", "existing", "files" ]
[ "private", "static", "void", "materialize", "virtual", "input", "(", "virtual", "action", "input", "input", ",", "path", "execroot", ",", "boolean", "is", "exec", "root", "sandboxed", ")", "throws", "i", "o", "exception", "{", "if", "(", "input", "instanceof", "empty", "action", "input", ")", "{", "/", "/", "todo", "(", "b", "/", "150963503", ")", ":", "we", "can", "turn", "this", "into", "an", "unreachable", "code", "path", "when", "the", "old", "/", "/", "!", "delay", "virtual", "input", "materialization", "code", "path", "is", "deleted", "return", ";", "}", "path", "output", "path", "=", "execroot", "get", "relative", "(", "input", "get", "exec", "path", "(", ")", ")", ";", "if", "(", "is", "exec", "root", "sandboxed", ")", "{", "atomically", "write", "virtual", "input", "(", "input", ",", "output", "path", ",", "/", "/", "when", "2", "actions", "try", "to", "atomically", "create", "the", "same", "virtual", "input", ",", "they", "need", "to", "have", "a", "/", "/", "different", "suffix", "for", "the", "temporary", "file", "in", "order", "to", "avoid", "racy", "write", "to", "the", "same", "one", "\"", "sandbox", "\"", "+", "temp", "file", "uniquifier", "for", "virtual", "input", "writes", "increment", "and", "get", "(", ")", ")", ";", "return", ";", "}", "if", "(", "output", "path", "exists", "(", ")", ")", "{", "output", "path", "delete", "(", ")", ";", "}", "output", "path", "get", "parent", "directory", "(", ")", "create", "directory", "and", "parents", "(", ")", ";", "write", "virtual", "input", "to", "(", "input", ",", "output", "path", ")", ";", "}" ]
[ "make", "the", "table" ]
[ "public", "boolean", "make", "table", "(", "program", "program", ",", "int", "start", ",", "int", "end", ",", "boolean", "auto", "label", ")", "{", "return", "make", "table", "(", "program", ",", "start", ",", "end", ",", "true", ",", "auto", "label", ")", ";", "}" ]
[ "both", "traditional", "space", "quota", "and", "the", "storage", "type", "quota", "for", "ssd", "are", "set", "and", "traditional", "space", "quota", "is", "exceeded", "but", "ssd", "quota", "is", "not", "exceeded" ]
[ "public", "void", "test", "quota", "by", "storage", "type", "and", "traditional", "quota", "exception", "3", "(", ")", "throws", "exception", "{", "test", "quota", "by", "storage", "type", "or", "traditional", "quota", "exceeded", "case", "(", "4", "*", "replication", ",", "5", ",", "5", ",", "replication", ")", ";", "}" ]
[ "enable", "checking", "of", "hash", "mismatches", "for", "files", "with", "the", "same", "name" ]
[ "public", "zip", "filter", "builder", "set", "check", "hash", "mismatch", "mode", "(", "check", "hash", "mismatch", "mode", "mode", ")", "{", "this", "check", "hash", "mismatch", "=", "mode", ";", "return", "this", ";", "}" ]
[ "a", "sensible", "definition", "of", "{", "@", "link", "#", "retain", "all", "}", "in", "terms", "of", "{", "@", "link", "#", "iterator", "}", ",", "using", "the", "iterator", "'", "s", "{", "@", "code", "remove", "}", "method", "if", "you", "override", "{", "@", "link", "#", "iterator", "}", ",", "you", "may", "wish", "to", "override", "{", "@", "link", "#", "retain", "all", "}", "to", "forward", "to", "this", "implementation" ]
[ "protected", "boolean", "standard", "retain", "all", "(", "collection", "<", "?", ">", "collection", ")", "{", "return", "iterators", "retain", "all", "(", "iterator", "(", ")", ",", "collection", ")", ";", "}" ]
[ "set", "the", "path", "that", "this", "tag", "should", "apply", "can", "be", "a", "bean", "(", "e", "g", "\"", "person", "\"", ")", "to", "get", "global", "errors", ",", "or", "a", "bean", "property", "(", "e", "g", "\"", "person", "name", "\"", ")", "to", "get", "field", "errors", "(", "also", "supporting", "nested", "fields", "and", "\"", "person", "na", "\"", "mappings", ")", "\"", "person", "\"", "will", "return", "all", "errors", "for", "the", "specified", "bean", ",", "both", "global", "and", "field", "errors" ]
[ "public", "void", "set", "path", "(", "string", "path", ")", "{", "this", "path", "=", "path", ";", "}" ]
[ "verifies", "that", "multiple", "j", "m", "x", "reporters", "can", "be", "started", "on", "the", "same", "machine", "and", "register", "metrics", "at", "the", "m", "bean", "server" ]
[ "public", "void", "test", "port", "conflict", "handling", "(", ")", "throws", "exception", "{", "reporter", "setup", "reporter", "setup", "1", "=", "reporter", "setup", "for", "reporter", "(", "\"", "test", "1", "\"", ",", "new", "j", "m", "x", "reporter", "(", "\"", "9020", "-", "9035", "\"", ")", ")", ";", "reporter", "setup", "reporter", "setup", "2", "=", "reporter", "setup", "for", "reporter", "(", "\"", "test", "2", "\"", ",", "new", "j", "m", "x", "reporter", "(", "\"", "9020", "-", "9035", "\"", ")", ")", ";", "metric", "registry", "impl", "reg", "=", "new", "metric", "registry", "impl", "(", "metric", "registry", "configuration", "default", "metric", "registry", "configuration", "(", ")", ",", "arrays", "as", "list", "(", "reporter", "setup", "1", ",", "reporter", "setup", "2", ")", ")", ";", "task", "manager", "metric", "group", "mg", "=", "new", "task", "manager", "metric", "group", "(", "reg", ",", "\"", "host", "\"", ",", "\"", "tm", "\"", ")", ";", "list", "<", "metric", "reporter", ">", "reporters", "=", "reg", "get", "reporters", "(", ")", ";", "assert", "true", "(", "reporters", "size", "(", ")", "=", "=", "2", ")", ";", "metric", "reporter", "rep", "1", "=", "reporters", "get", "(", "0", ")", ";", "metric", "reporter", "rep", "2", "=", "reporters", "get", "(", "1", ")", ";", "gauge", "<", "integer", ">", "g", "1", "=", "new", "gauge", "<", "integer", ">", "(", ")", "{", "@", "override", "public", "integer", "get", "value", "(", ")", "{", "return", "1", ";", "}", "}", ";", "gauge", "<", "integer", ">", "g", "2", "=", "new", "gauge", "<", "integer", ">", "(", ")", "{", "@", "override", "public", "integer", "get", "value", "(", ")", "{", "return", "2", ";", "}", "}", ";", "rep", "1", "notify", "of", "added", "metric", "(", "g", "1", ",", "\"", "rep", "1", "\"", ",", "new", "front", "metric", "group", "<", ">", "(", "create", "reporter", "scoped", "settings", "(", "0", ")", ",", "mg", ")", ")", ";", "rep", "2", "notify", "of", "added", "metric", "(", "g", "2", ",", "\"", "rep", "2", "\"", ",", "new", "front", "metric", "group", "<", ">", "(", "create", "reporter", "scoped", "settings", "(", "0", ")", ",", "mg", ")", ")", ";", "m", "bean", "server", "m", "bean", "server", "=", "management", "factory", "get", "platform", "m", "bean", "server", "(", ")", ";", "object", "name", "object", "name", "1", "=", "new", "object", "name", "(", "jmx", "domain", "prefix", "+", "\"", "taskmanager", "rep", "1", "\"", ",", "j", "m", "x", "reporter", "generate", "jmx", "table", "(", "mg", "get", "all", "variables", "(", ")", ")", ")", ";", "object", "name", "object", "name", "2", "=", "new", "object", "name", "(", "jmx", "domain", "prefix", "+", "\"", "taskmanager", "rep", "2", "\"", ",", "j", "m", "x", "reporter", "generate", "jmx", "table", "(", "mg", "get", "all", "variables", "(", ")", ")", ")", ";", "assert", "equals", "(", "1", ",", "m", "bean", "server", "get", "attribute", "(", "object", "name", "1", ",", "\"", "value", "\"", ")", ")", ";", "assert", "equals", "(", "2", ",", "m", "bean", "server", "get", "attribute", "(", "object", "name", "2", ",", "\"", "value", "\"", ")", ")", ";", "rep", "1", "notify", "of", "removed", "metric", "(", "g", "1", ",", "\"", "rep", "1", "\"", ",", "null", ")", ";", "rep", "1", "notify", "of", "removed", "metric", "(", "g", "2", ",", "\"", "rep", "2", "\"", ",", "null", ")", ";", "mg", "close", "(", ")", ";", "reg", "shutdown", "(", ")", "get", "(", ")", ";", "}" ]
[ "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", "list", "subtype", "model", "view", "model", "on", "visibility", "state", "changed", "(", "on", "model", "visibility", "state", "changed", "listener", "<", "list", "subtype", "model", "view", "model", ",", "list", "subtype", "model", "view", ">", "listener", ")", "{", "on", "mutation", "(", ")", ";", "this", "on", "model", "visibility", "state", "changed", "listener", "epoxy", "generated", "model", "=", "listener", ";", "return", "this", ";", "}" ]
[ "gets", "kv", "timeout" ]
[ "public", "duration", "get", "kv", "timeout", "(", ")", "{", "return", "beans", "new", "duration", "(", "properties", "get", "kv", "timeout", "(", ")", ")", ";", "}" ]
[ "returns", "a", "read", "-", "only", "buffer", "that", "shares", "its", "content", "with", "this", "buffer", "the", "returned", "buffer", "is", "guaranteed", "to", "be", "a", "new", "instance", ",", "even", "this", "buffer", "is", "read", "-", "only", "itself", "the", "new", "buffer", "'", "s", "position", ",", "limit", ",", "capacity", "and", "mark", "are", "the", "same", "as", "this", "buffer", "'", "s", "the", "new", "buffer", "shares", "its", "content", "with", "this", "buffer", ",", "which", "means", "this", "buffer", "'", "s", "change", "of", "content", "will", "be", "visible", "to", "the", "new", "buffer", "the", "two", "buffer", "'", "s", "position", ",", "limit", "and", "mark", "are", "independent" ]
[ "public", "abstract", "int", "buffer", "as", "read", "only", "buffer", "(", ")", ";" ]
[ "update", "an", "existing", "pet" ]
[ "public", "void", "update", "pet", "(", "pet", "body", ",", "api", "client", "auth", "info", "auth", "info", ",", "handler", "<", "async", "result", "<", "void", ">", ">", "result", "handler", ")", "{", "object", "local", "var", "body", "=", "body", ";", "/", "/", "verify", "the", "required", "parameter", "'", "body", "'", "is", "set", "if", "(", "body", "=", "=", "null", ")", "{", "result", "handler", "handle", "(", "api", "exception", "fail", "(", "400", ",", "\"", "missing", "the", "required", "parameter", "'", "body", "'", "when", "calling", "update", "pet", "\"", ")", ")", ";", "return", ";", "}", "/", "/", "create", "path", "and", "map", "variables", "string", "local", "var", "path", "=", "\"", "/", "pet", "\"", ";", "/", "/", "query", "params", "list", "<", "pair", ">", "local", "var", "query", "params", "=", "new", "array", "list", "<", ">", "(", ")", ";", "/", "/", "header", "params", "multi", "map", "local", "var", "header", "params", "=", "multi", "map", "case", "insensitive", "multi", "map", "(", ")", ";", "/", "/", "cookie", "params", "multi", "map", "local", "var", "cookie", "params", "=", "multi", "map", "case", "insensitive", "multi", "map", "(", ")", ";", "/", "/", "form", "params", "/", "/", "todo", ":", "sending", "files", "within", "multipart", "/", "form", "-", "data", "is", "not", "supported", "yet", "(", "because", "of", "vertx", "web", "-", "client", ")", "map", "<", "string", ",", "object", ">", "local", "var", "form", "params", "=", "new", "hash", "map", "<", ">", "(", ")", ";", "string", "[", "]", "local", "var", "accepts", "=", "{", "}", ";", "string", "[", "]", "local", "var", "content", "types", "=", "{", "\"", "application", "/", "json", "\"", ",", "\"", "application", "/", "xml", "\"", "}", ";", "string", "[", "]", "local", "var", "auth", "names", "=", "new", "string", "[", "]", "{", "\"", "petstore", "auth", "\"", "}", ";", "api", "client", "invoke", "a", "p", "i", "(", "local", "var", "path", ",", "\"", "put", "\"", ",", "local", "var", "query", "params", ",", "local", "var", "body", ",", "local", "var", "header", "params", ",", "local", "var", "cookie", "params", ",", "local", "var", "form", "params", ",", "local", "var", "accepts", ",", "local", "var", "content", "types", ",", "local", "var", "auth", "names", ",", "auth", "info", ",", "null", ",", "result", "handler", ")", ";", "}" ]
[ "determine", "if", "the", "{", "@", "link", "#", "watch", "}", "is", "defined", "if", "not", ",", "then", "we", "should", "always", "delete", "the", "watch" ]
[ "boolean", "is", "watch", "defined", "(", ")", "{", "return", "watch", "!", "=", "null", ";", "}" ]
[ "projects", "a", "pair", "of", "joined", "elements", "to", "a", "{", "@", "link", "tuple", "}", "with", "the", "previously", "selected", "fields", "requires", "the", "classes", "of", "the", "fields", "of", "the", "resulting", "tuples" ]
[ "public", "<", "t0", ">", "project", "join", "<", "i1", ",", "i2", ",", "tuple", "1", "<", "t0", ">", ">", "project", "tuple", "1", "(", ")", "{", "type", "information", "<", "?", ">", "[", "]", "f", "types", "=", "extract", "field", "types", "(", "field", "indexes", ")", ";", "tuple", "type", "info", "<", "tuple", "1", "<", "t0", ">", ">", "t", "type", "=", "new", "tuple", "type", "info", "<", "tuple", "1", "<", "t0", ">", ">", "(", "f", "types", ")", ";", "return", "new", "project", "join", "<", "i1", ",", "i2", ",", "tuple", "1", "<", "t0", ">", ">", "(", "this", "ds", "1", ",", "this", "ds", "2", ",", "this", "keys", "1", ",", "this", "keys", "2", ",", "this", "hint", ",", "this", "field", "indexes", ",", "this", "is", "field", "in", "first", ",", "t", "type", ",", "this", ")", ";", "}" ]
[ "called", "when", "occur", "exception" ]
[ "void", "handle", "method", "exception", "(", "class", "clazz", ",", "method", "method", ",", "object", "[", "]", "all", "arguments", ",", "class", "<", "?", ">", "[", "]", "parameter", "types", ",", "throwable", "t", ")", ";" ]
[ "determines", "if", "the", "supplied", "class", "object", "represents", "an", "array", "class" ]
[ "static", "public", "boolean", "is", "array", "(", "class", "c", ")", "{", "return", "reflection", "cache", "get", "type", "(", "c", ")", "is", "array", "(", ")", ";", "}" ]
[ "exit", "the", "jvm", "this", "is", "method", "can", "be", "overridden", "for", "testing", ",", "throwing", "an", "exception", "instead", "any", "subclassed", "method", "must", "raise", "an", "{", "@", "code", "exit", "exception", "}", "instancesubclass", "the", "service", "launcher", "code", "assumes", "that", "after", "this", "method", "is", "invoked", ",", "no", "other", "code", "in", "the", "same", "method", "is", "called" ]
[ "protected", "void", "exit", "(", "int", "exit", "code", ",", "string", "message", ")", "{", "exit", "util", "terminate", "(", "exit", "code", ",", "message", ")", ";", "}" ]
[ "whether", "this", "status", "code", "is", "in", "the", "http", "series", "{", "@", "link", "org", "springframework", "http", "http", "status", "series", "#", "redirection", "}", "this", "is", "a", "shortcut", "for", "checking", "the", "value", "of", "{", "@", "link", "#", "series", "(", ")", "}" ]
[ "public", "boolean", "is", "3xx", "redirection", "(", ")", "{", "return", "(", "series", "(", ")", "=", "=", "series", "redirection", ")", ";", "}" ]
[ "the", "timestamp", "in", "milliseconds", "when", "the", "shard", "became", "unassigned", ",", "based", "on", "system", "current", "time", "millis", "(", ")", "note", ",", "we", "use", "timestamp", "here", "since", "we", "want", "to", "make", "sure", "its", "preserved", "across", "node", "serializations" ]
[ "public", "long", "get", "unassigned", "time", "in", "millis", "(", ")", "{", "return", "this", "unassigned", "time", "millis", ";", "}" ]
[ "set", "the", "value", "for", "the", "prepared", "statement", "'", "s", "specified", "parameter", "position", "using", "the", "passed", "in", "value", "and", "type", "this", "method", "can", "be", "overridden", "by", "sub", "-", "classes", "if", "needed" ]
[ "protected", "void", "do", "set", "value", "(", "prepared", "statement", "ps", ",", "int", "parameter", "position", ",", "int", "arg", "type", ",", "object", "arg", "value", ")", "throws", "s", "q", "l", "exception", "{", "statement", "creator", "utils", "set", "parameter", "value", "(", "ps", ",", "parameter", "position", ",", "arg", "type", ",", "arg", "value", ")", ";", "}" ]
[ "creates", "a", "{", "@", "link", "char", "stream", "}", "given", "a", "{", "@", "link", "string", "}" ]
[ "public", "static", "code", "point", "char", "stream", "from", "string", "(", "string", "s", ")", "{", "return", "from", "string", "(", "s", ",", "int", "stream", "unknown", "source", "name", ")", ";", "}" ]
[ "returns", "the", "maximum", "number", "of", "bytes", "that", "this", "buffer", "can", "store" ]
[ "int", "get", "buffer", "size", "(", ")", "{", "return", "buffer", "size", ";", "}" ]
[ "adds", "a", "normalized", "key", "containing", "a", "normalized", "order", "of", "magnitude", "of", "the", "given", "record", "2", "bits", "determine", "the", "sign", "(", "negative", ",", "zero", ",", "positive", ")", ",", "33", "bits", "determine", "the", "magnitude", "this", "method", "adds", "at", "most", "5", "bytes", "that", "contain", "information" ]
[ "public", "void", "put", "normalized", "key", "(", "big", "decimal", "record", ",", "memory", "segment", "target", ",", "int", "offset", ",", "int", "len", ")", "{", "final", "long", "signum", "=", "record", "signum", "(", ")", ";", "/", "/", "order", "of", "magnitude", "/", "/", "smallest", ":", "/", "/", "scale", "=", "integer", "max", ",", "precision", "=", "1", "=", ">", "smallest", "magnitude", "/", "/", "largest", ":", "/", "/", "scale", "=", "integer", "min", ",", "precision", "=", "integer", "max", "=", ">", "largest", "magnitude", "final", "long", "mag", "=", "(", "(", "long", ")", "record", "scale", "(", ")", ")", "-", "(", "(", "long", ")", "record", "precision", "(", ")", ")", "+", "1", ";", "/", "/", "normalize", "value", "range", ":", "from", "0", "to", "(", "smallest", "magnitude", "+", "-", "1", "*", "largest", "magnitude", ")", "final", "long", "norm", "mag", "=", "-", "1l", "*", "largest", "magnitude", "+", "mag", ";", "/", "/", "normalize", "value", "range", "dependent", "on", "sign", ":", "/", "/", "0", "to", "(", "smallest", "magnitude", "+", "-", "1", "*", "largest", "magnitude", ")", "/", "/", "or", "(", "smallest", "magnitude", "+", "-", "1", "*", "largest", "magnitude", ")", "to", "0", "/", "/", "-", "-", ">", "uses", "at", "most", "33", "bit", "(", "5", "least", "-", "significant", "bytes", ")", "long", "sign", "norm", "mag", "=", "signum", "<", "0", "?", "norm", "mag", ":", "(", "smallest", "magnitude", "+", "-", "1l", "*", "largest", "magnitude", "-", "norm", "mag", ")", ";", "/", "/", "zero", "has", "no", "magnitude", "/", "/", "set", "3", "4th", "bit", "to", "flag", "zero", "if", "(", "signum", "=", "=", "0", ")", "{", "sign", "norm", "mag", "=", "0l", ";", "sign", "norm", "mag", "|", "=", "(", "1l", "<", "<", "34", ")", ";", "}", "/", "/", "set", "3", "5th", "bit", "to", "flag", "positive", "sign", "else", "if", "(", "signum", ">", "0", ")", "{", "sign", "norm", "mag", "|", "=", "(", "1l", "<", "<", "35", ")", ";", "}", "/", "/", "add", "5", "least", "-", "significant", "bytes", "that", "contain", "value", "to", "target", "for", "(", "int", "i", "=", "0", ";", "i", "<", "5", "&", "&", "len", ">", "0", ";", "i", "+", "+", ",", "len", "-", "-", ")", "{", "final", "byte", "b", "=", "(", "byte", ")", "(", "sign", "norm", "mag", ">", ">", ">", "(", "8", "*", "(", "4", "-", "i", ")", ")", ")", ";", "target", "put", "(", "offset", "+", "+", ",", "b", ")", ";", "}", "}" ]
[ "returns", "the", "length" ]
[ "public", "int", "get", "length", "(", ")", "{", "return", "this", "length", ";", "}" ]
[ "gets", "the", "base", "address", "of", "the", "dyld", "cache", "this", "is", "where", "the", "cache", "should", "be", "loaded", "in", "memory" ]
[ "public", "long", "get", "base", "address", "(", ")", "{", "return", "base", "address", ";", "}" ]
[ "decodes", "the", "payload" ]
[ "private", "static", "result", "<", "?", ">", "decode", "payload", "(", "channel", "handler", "context", "ctx", ",", "byte", "buf", "buffer", ",", "mqtt", "message", "type", "message", "type", ",", "int", "bytes", "remaining", "in", "variable", "part", ",", "object", "variable", "header", ")", "{", "switch", "(", "message", "type", ")", "{", "case", "connect", ":", "return", "decode", "connection", "payload", "(", "buffer", ",", "(", "mqtt", "connect", "variable", "header", ")", "variable", "header", ")", ";", "case", "subscribe", ":", "return", "decode", "subscribe", "payload", "(", "buffer", ",", "bytes", "remaining", "in", "variable", "part", ")", ";", "case", "suback", ":", "return", "decode", "suback", "payload", "(", "buffer", ",", "bytes", "remaining", "in", "variable", "part", ")", ";", "case", "unsubscribe", ":", "return", "decode", "unsubscribe", "payload", "(", "buffer", ",", "bytes", "remaining", "in", "variable", "part", ")", ";", "case", "unsuback", ":", "return", "decode", "unsub", "ack", "payload", "(", "ctx", ",", "buffer", ",", "bytes", "remaining", "in", "variable", "part", ")", ";", "case", "publish", ":", "return", "decode", "publish", "payload", "(", "buffer", ",", "bytes", "remaining", "in", "variable", "part", ")", ";", "default", ":", "/", "/", "unknown", "payload", ",", "no", "byte", "consumed", "return", "new", "result", "<", "object", ">", "(", "null", ",", "0", ")", ";", "}", "}" ]
[ "move", "the", "iterator", "to", "the", "next", "memory", "block", "the", "next", "memory", "block", "starts", "at", "the", "first", "element", "that", "was", "not", "in", "the", "block", "before", "a", "special", "case", "is", "when", "no", "record", "was", "in", "the", "block", "before", ",", "which", "happens", "when", "this", "function", "is", "invoked", "two", "times", "directly", "in", "a", "sequence", ",", "without", "calling", "has", "next", "(", ")", "or", "next", "in", "between", "then", "the", "block", "moves", "one", "element" ]
[ "public", "boolean", "next", "block", "(", ")", "throws", "i", "o", "exception", ";" ]
[ "reads", "a", "note", "back", "from", "{", "@", "linkplain", "#", "encode", "to", "(", "output", "stream", ")", "its", "encoded", "form", "}" ]
[ "public", "static", "console", "note", "read", "from", "(", "data", "input", "stream", "in", ")", "throws", "i", "o", "exception", ",", "class", "not", "found", "exception", "{", "try", "{", "byte", "[", "]", "preamble", "=", "new", "byte", "[", "preamble", "length", "]", ";", "in", "read", "fully", "(", "preamble", ")", ";", "if", "(", "!", "arrays", "equals", "(", "preamble", ",", "preamble", ")", ")", "return", "null", ";", "/", "/", "not", "a", "valid", "preamble", "data", "input", "stream", "decoded", "=", "new", "data", "input", "stream", "(", "base", "6", "4", "get", "decoder", "(", ")", "wrap", "(", "in", ")", ")", ";", "int", "mac", "sz", "=", "-", "decoded", "read", "int", "(", ")", ";", "byte", "[", "]", "mac", ";", "int", "sz", ";", "if", "(", "mac", "sz", ">", "0", ")", "{", "/", "/", "new", "format", "mac", "=", "new", "byte", "[", "mac", "sz", "]", ";", "decoded", "read", "fully", "(", "mac", ")", ";", "sz", "=", "decoded", "read", "int", "(", ")", ";", "if", "(", "sz", "<", "0", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "corrupt", "stream", "\"", ")", ";", "}", "}", "else", "{", "mac", "=", "null", ";", "sz", "=", "-", "mac", "sz", ";", "}", "byte", "[", "]", "buf", "=", "new", "byte", "[", "sz", "]", ";", "decoded", "read", "fully", "(", "buf", ")", ";", "byte", "[", "]", "postamble", "=", "new", "byte", "[", "postamble", "length", "]", ";", "in", "read", "fully", "(", "postamble", ")", ";", "if", "(", "!", "arrays", "equals", "(", "postamble", ",", "postamble", ")", ")", "return", "null", ";", "/", "/", "not", "a", "valid", "postamble", "if", "(", "!", "insecure", ")", "{", "if", "(", "mac", "=", "=", "null", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "refusing", "to", "deserialize", "unsigned", "note", "from", "an", "old", "log", "\"", ")", ";", "}", "else", "if", "(", "!", "mac", "check", "mac", "(", "buf", ",", "mac", ")", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "mac", "mismatch", "\"", ")", ";", "}", "}", "jenkins", "jenkins", "=", "jenkins", "get", "instance", "or", "null", "(", ")", ";", "try", "(", "object", "input", "stream", "ois", "=", "new", "object", "input", "stream", "ex", "(", "new", "g", "z", "i", "p", "input", "stream", "(", "new", "byte", "array", "input", "stream", "(", "buf", ")", ")", ",", "jenkins", "!", "=", "null", "?", "jenkins", "plugin", "manager", "uber", "class", "loader", ":", "console", "note", "class", "get", "class", "loader", "(", ")", ",", "class", "filter", "default", ")", ")", "{", "return", "get", "console", "note", "(", "ois", ")", ";", "}", "}", "catch", "(", "error", "e", ")", "{", "/", "/", "for", "example", ",", "bogus", "'", "sz", "'", "can", "result", "in", "out", "of", "memory", "error", "/", "/", "package", "that", "up", "as", "i", "o", "exception", "so", "that", "the", "caller", "won", "'", "t", "fatally", "die", "throw", "new", "i", "o", "exception", "(", "e", ")", ";", "}", "}" ]
[ "skips", "scaling", "list", "data", "(", ")", "see", "h", "265hevc", "(", "2014", ")", "7", "3", "4" ]
[ "private", "static", "void", "skip", "scaling", "list", "(", "parsable", "nal", "unit", "bit", "array", "bit", "array", ")", "{", "for", "(", "int", "size", "id", "=", "0", ";", "size", "id", "<", "4", ";", "size", "id", "+", "+", ")", "{", "for", "(", "int", "matrix", "id", "=", "0", ";", "matrix", "id", "<", "6", ";", "matrix", "id", "+", "=", "size", "id", "=", "=", "3", "?", "3", ":", "1", ")", "{", "if", "(", "!", "bit", "array", "read", "bit", "(", ")", ")", "{", "/", "/", "scaling", "list", "pred", "mode", "flag", "[", "size", "id", "]", "[", "matrix", "id", "]", "/", "/", "scaling", "list", "pred", "matrix", "id", "delta", "[", "size", "id", "]", "[", "matrix", "id", "]", "bit", "array", "read", "unsigned", "exp", "golomb", "coded", "int", "(", ")", ";", "}", "else", "{", "int", "coef", "num", "=", "min", "(", "64", ",", "1", "<", "<", "(", "4", "+", "(", "size", "id", "<", "<", "1", ")", ")", ")", ";", "if", "(", "size", "id", ">", "1", ")", "{", "/", "/", "scaling", "list", "dc", "coef", "minus", "8", "[", "size", "id", "-", "2", "]", "[", "matrix", "id", "]", "bit", "array", "read", "signed", "exp", "golomb", "coded", "int", "(", ")", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "coef", "num", ";", "i", "+", "+", ")", "{", "bit", "array", "read", "signed", "exp", "golomb", "coded", "int", "(", ")", ";", "/", "/", "scaling", "list", "delta", "coef", "}", "}", "}", "}", "}" ]
[ "get", "map", "integer" ]
[ "public", "map", "<", "string", ",", "integer", ">", "get", "map", "integer", "(", ")", "{", "return", "map", "integer", ";", "}" ]
[ "create", "a", "configuration", "with", "a", "specific", "provider" ]
[ "private", "configuration", "create", "provider", "configuration", "(", "final", "string", "provider", "option", ")", "{", "configuration", "conf", "=", "new", "configuration", "(", "false", ")", ";", "conf", "set", "(", "aws", "credentials", "provider", ",", "provider", "option", ")", ";", "return", "conf", ";", "}" ]
[ "checks", "that", "we", "return", "the", "right", "error", "if", "diskbalancer", "is", "not", "enabled" ]
[ "public", "void", "test", "disk", "balancer", "disabled", "(", ")", "throws", "exception", "{", "configuration", "conf", "=", "new", "hdfs", "configuration", "(", ")", ";", "conf", "set", "boolean", "(", "d", "f", "s", "config", "keys", "dfs", "disk", "balancer", "enabled", ",", "false", ")", ";", "restart", "data", "node", "(", ")", ";", "test", "mover", "block", "mover", "=", "new", "test", "mover", "(", "cluster", "get", "data", "nodes", "(", ")", "get", "(", "0", ")", "get", "f", "s", "dataset", "(", ")", ")", ";", "disk", "balancer", "balancer", "=", "new", "disk", "balancer", "builder", "(", "conf", ")", "set", "mover", "(", "block", "mover", ")", "build", "(", ")", ";", "thrown", "expect", "(", "disk", "balancer", "exception", "class", ")", ";", "thrown", "expect", "(", "new", "disk", "balancer", "result", "verifier", "(", "disk", "balancer", "exception", "result", "disk", "balancer", "not", "enabled", ")", ")", ";", "balancer", "query", "work", "status", "(", ")", ";", "}" ]
[ "writes", "a", "{", "@", "code", "string", "}", "as", "specified", "by", "{", "@", "link", "data", "output", "stream", "#", "write", "chars", "(", "string", ")", "}", ",", "except", "each", "character", "is", "written", "using", "little", "-", "endian", "byte", "order" ]
[ "public", "void", "write", "chars", "(", "string", "s", ")", "throws", "i", "o", "exception", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "s", "length", "(", ")", ";", "i", "+", "+", ")", "{", "write", "char", "(", "s", "char", "at", "(", "i", ")", ")", ";", "}", "}" ]
[ "return", "true", "if", "this", "big", "cat", "object", "is", "equal", "to", "o" ]
[ "public", "boolean", "equals", "(", "object", "o", ")", "{", "if", "(", "this", "=", "=", "o", ")", "{", "return", "true", ";", "}", "if", "(", "o", "=", "=", "null", "|", "|", "get", "class", "(", ")", "!", "=", "o", "get", "class", "(", ")", ")", "{", "return", "false", ";", "}", "big", "cat", "big", "cat", "=", "(", "big", "cat", ")", "o", ";", "return", "objects", "equals", "(", "this", "kind", ",", "big", "cat", "kind", ")", "&", "&", "super", "equals", "(", "o", ")", ";", "}" ]
[ "test", "inline", "additional", "properties", "<", "b", ">", "200", "<", "b", ">", "-", "successful", "operation" ]
[ "public", "void", "test", "inline", "additional", "properties", "(", "map", "<", "string", ",", "string", ">", "param", ",", "map", "<", "string", ",", "object", ">", "params", ")", "throws", "i", "o", "exception", "{", "test", "inline", "additional", "properties", "for", "http", "response", "(", "param", ",", "params", ")", ";", "}" ]
[ "provides", "a", "new", "instance", "from", "the", "state", "handler", "pool", "that", "is", "initialized", "with", "the", "information", "from", "the", "state", "handler", "currently", "held", "by", "the", "component", "tree", "once", "the", "state", "updates", "have", "been", "applied", "and", "we", "are", "back", "in", "the", "main", "thread", "the", "state", "handler", "gets", "released", "to", "the", "pool" ]
[ "public", "synchronized", "state", "handler", "acquire", "state", "handler", "(", ")", "{", "return", "state", "handler", "create", "new", "instance", "(", "m", "state", "handler", ")", ";", "}" ]
[ "get", "array", "of", "string" ]
[ "public", "list", "<", "string", ">", "get", "array", "of", "string", "(", ")", "{", "return", "array", "of", "string", ";", "}" ]
[ "parsing", "nacos", "configuration", "content" ]
[ "public", "list", "<", "property", "source", "<", "?", ">", ">", "parse", "nacos", "data", "(", "string", "config", "name", ",", "string", "config", "value", ",", "string", "extension", ")", "throws", "i", "o", "exception", "{", "if", "(", "string", "utils", "is", "empty", "(", "config", "value", ")", ")", "{", "return", "collections", "empty", "list", "(", ")", ";", "}", "if", "(", "string", "utils", "is", "empty", "(", "extension", ")", ")", "{", "extension", "=", "this", "get", "file", "extension", "(", "config", "name", ")", ";", "}", "for", "(", "property", "source", "loader", "property", "source", "loader", ":", "property", "source", "loaders", ")", "{", "if", "(", "!", "can", "load", "file", "extension", "(", "property", "source", "loader", ",", "extension", ")", ")", "{", "continue", ";", "}", "nacos", "byte", "array", "resource", "nacos", "byte", "array", "resource", "=", "new", "nacos", "byte", "array", "resource", "(", "config", "value", "get", "bytes", "(", ")", ",", "config", "name", ")", ";", "nacos", "byte", "array", "resource", "set", "filename", "(", "get", "file", "name", "(", "config", "name", ",", "extension", ")", ")", ";", "list", "<", "property", "source", "<", "?", ">", ">", "property", "source", "list", "=", "property", "source", "loader", "load", "(", "config", "name", ",", "nacos", "byte", "array", "resource", ")", ";", "if", "(", "collection", "utils", "is", "empty", "(", "property", "source", "list", ")", ")", "{", "return", "collections", "empty", "list", "(", ")", ";", "}", "return", "property", "source", "list", "stream", "(", ")", "filter", "(", "objects", ":", ":", "non", "null", ")", "map", "(", "property", "source", "-", ">", "{", "if", "(", "property", "source", "instanceof", "enumerable", "property", "source", ")", "{", "string", "[", "]", "property", "names", "=", "(", "(", "enumerable", "property", "source", ")", "property", "source", ")", "get", "property", "names", "(", ")", ";", "if", "(", "property", "names", "!", "=", "null", "&", "&", "property", "names", "length", ">", "0", ")", "{", "map", "<", "string", ",", "object", ">", "map", "=", "new", "linked", "hash", "map", "<", ">", "(", ")", ";", "arrays", "stream", "(", "property", "names", ")", "for", "each", "(", "name", "-", ">", "{", "map", "put", "(", "name", ",", "property", "source", "get", "property", "(", "name", ")", ")", ";", "}", ")", ";", "return", "new", "origin", "tracked", "map", "property", "source", "(", "property", "source", "get", "name", "(", ")", ",", "map", ",", "true", ")", ";", "}", "}", "return", "property", "source", ";", "}", ")", "collect", "(", "collectors", "to", "list", "(", ")", ")", ";", "}", "return", "collections", "empty", "list", "(", ")", ";", "}" ]
[ "generate", "a", "path", "name", "for", "a", "test", "file", "under", "the", "given", "directory" ]
[ "static", "file", "get", "file", "name", "for", "disk", "io", "check", "(", "file", "dir", ",", "int", "iteration", "count", ")", "{", "if", "(", "iteration", "count", "<", "disk", "io", "max", "iterations", ")", "{", "/", "/", "use", "file", "names", "of", "the", "format", "prefix", "001", "by", "default", "return", "new", "file", "(", "dir", ",", "disk", "io", "file", "prefix", "+", "string", "format", "(", "\"", "%", "0", "3d", "\"", ",", "iteration", "count", ")", ")", ";", "}", "else", "{", "/", "/", "if", "the", "first", "few", "checks", "then", "fail", ",", "try", "using", "a", "randomly", "generated", "/", "/", "file", "name", "return", "new", "file", "(", "dir", ",", "disk", "io", "file", "prefix", "+", "uuid", "random", "u", "u", "i", "d", "(", ")", ")", ";", "}", "}" ]
[ "if", "the", "value", "is", "an", "item", ",", "this", "is", "set", "<", "code", ">", "optional", "aapt", "pb", "item", "item", "=", "4", ";", "<", "code", ">" ]
[ "private", "void", "set", "item", "(", "com", "android", "aapt", "resources", "item", "builder", "builder", "for", "value", ")", "{", "item", "=", "builder", "for", "value", "build", "(", ")", ";", "bit", "field", "0", "|", "=", "0x", "0", "0", "0", "0", "0", "0", "0", "8", ";", "}" ]
[ "returns", "the", "blaze", "directories", "object", "for", "this", "runtime" ]
[ "public", "blaze", "directories", "get", "directories", "(", ")", "{", "return", "directories", ";", "}" ]
[ "returns", "the", "median", "absolute", "deviation", "statistic", "computed", "for", "this", "aggregation" ]
[ "double", "get", "median", "absolute", "deviation", "(", ")", ";" ]
[ "sets", "the", "file", "filter" ]
[ "public", "void", "set", "file", "filter", "(", "ghidra", "file", "filter", "filter", ")", "{", "this", "filter", "=", "filter", ";", "}" ]
[ "returns", "the", "id", "of", "the", "task", "this", "result", "belongs", "to" ]
[ "public", "execution", "attempt", "i", "d", "get", "i", "d", "(", ")", "{", "return", "this", "execution", "id", ";", "}" ]
[ "get", "the", "safe", "path", "strings", "for", "a", "list", "of", "paths", "to", "use", "in", "the", "build", "variables" ]
[ "private", "static", "nested", "set", "<", "string", ">", "get", "safe", "path", "strings", "(", "list", "<", "path", "fragment", ">", "paths", ")", "{", "/", "/", "using", "immutable", "set", "first", "to", "remove", "duplicates", ",", "then", "nested", "set", "for", "smaller", "memory", "footprint", "return", "nested", "set", "builder", "wrap", "(", "order", "stable", "order", ",", "iterables", "transform", "(", "immutable", "set", "copy", "of", "(", "paths", ")", ",", "path", "fragment", ":", ":", "get", "safe", "path", "string", ")", ")", ";", "}" ]
[ "return", "the", "type", "name", "as", "actually", "specified", "for", "this", "particular", "value", ",", "if", "any" ]
[ "public", "string", "get", "specified", "type", "name", "(", ")", "{", "return", "this", "specified", "type", "name", ";", "}" ]
[ "replace", "field", "configuration", "in", "{", "@", "code", "indices", "create", "}", "with", "scripts", "that", "load", "from", "the", "source" ]
[ "public", "boolean", "modify", "sections", "(", "list", "<", "executable", "section", ">", "executables", ")", "{", "for", "(", "executable", "section", "section", ":", "executables", ")", "{", "if", "(", "false", "=", "=", "(", "section", "instanceof", "do", "section", ")", ")", "{", "continue", ";", "}", "do", "section", "do", "section", "=", "(", "do", "section", ")", "section", ";", "string", "api", "=", "do", "section", "get", "api", "call", "section", "(", ")", "get", "api", "(", ")", ";", "switch", "(", "api", ")", "{", "case", "\"", "indices", "create", "\"", ":", "if", "(", "false", "=", "=", "modify", "create", "index", "(", "do", "section", "get", "api", "call", "section", "(", ")", ")", ")", "{", "return", "false", ";", "}", "break", ";", "case", "\"", "search", "\"", ":", "case", "\"", "async", "search", "submit", "\"", ":", "if", "(", "false", "=", "=", "modify", "search", "(", "do", "section", "get", "api", "call", "section", "(", ")", ")", ")", "{", "return", "false", ";", "}", "break", ";", "case", "\"", "bulk", "\"", ":", "if", "(", "false", "=", "=", "handle", "bulk", "(", "do", "section", "get", "api", "call", "section", "(", ")", ")", ")", "{", "return", "false", ";", "}", "break", ";", "case", "\"", "index", "\"", ":", "if", "(", "false", "=", "=", "handle", "index", "(", "do", "section", "get", "api", "call", "section", "(", ")", ")", ")", "{", "return", "false", ";", "}", "break", ";", "default", ":", "continue", ";", "}", "}", "return", "true", ";", "}" ]
[ "tests", "that", "{", "@", "link", "resource", "manager", "options", "#", "slot", "request", "timeout", "}", "is", "preferred", "over", "{", "@", "link", "job", "manager", "options", "#", "slot", "request", "timeout", "}", "if", "set" ]
[ "public", "void", "test", "prefer", "legacy", "slot", "request", "timeout", "(", ")", "throws", "exception", "{", "final", "long", "legacy", "slot", "idle", "timeout", "=", "42", ";", "final", "configuration", "configuration", "=", "new", "configuration", "(", ")", ";", "configuration", "set", "long", "(", "resource", "manager", "options", "slot", "request", "timeout", ",", "legacy", "slot", "idle", "timeout", ")", ";", "configuration", "set", "long", "(", "job", "manager", "options", "slot", "request", "timeout", ",", "300000l", ")", ";", "final", "slot", "manager", "configuration", "slot", "manager", "configuration", "=", "slot", "manager", "configuration", "from", "configuration", "(", "configuration", ",", "worker", "resource", "spec", "zero", ")", ";", "assert", "that", "(", "slot", "manager", "configuration", "get", "slot", "request", "timeout", "(", ")", "to", "milliseconds", "(", ")", ",", "is", "(", "equal", "to", "(", "legacy", "slot", "idle", "timeout", ")", ")", ")", ";", "}" ]
[ "returns", "all", "bytes", "that", "have", "been", "read", "from", "this", "socket" ]
[ "public", "synchronized", "byte", "string", "bytes", "read", "(", ")", "{", "return", "bytes", "read", "read", "byte", "string", "(", ")", ";", "}" ]
[ "check", "if", "the", "given", "array", "contains", "the", "given", "value", "(", "with", "case", "-", "insensitive", "comparison", ")" ]
[ "public", "static", "boolean", "contains", "ignore", "case", "(", "string", "[", "]", "array", ",", "string", "value", ")", "{", "for", "(", "string", "str", ":", "array", ")", "{", "if", "(", "value", "=", "=", "null", "&", "&", "str", "=", "=", "null", ")", "{", "return", "true", ";", "}", "if", "(", "value", "!", "=", "null", "&", "&", "value", "equals", "ignore", "case", "(", "str", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]
[ "returns", "the", "entry", "associated", "with", "this", "value", "reference", ",", "or", "{", "@", "code", "null", "}", "if", "this", "value", "reference", "is", "independent", "of", "any", "entry" ]
[ "reference", "entry", "<", "k", ",", "v", ">", "get", "entry", "(", ")", ";" ]
[ "set", "the", "value", "of", "a", "field", "validates", "the", "value", ",", "throwing", "a", "{", "@", "link", "data", "exception", "}", "if", "it", "does", "not", "match", "the", "field", "'", "s", "{", "@", "link", "schema", "}" ]
[ "public", "struct", "put", "(", "field", "field", ",", "object", "value", ")", "{", "if", "(", "null", "=", "=", "field", ")", "throw", "new", "data", "exception", "(", "\"", "field", "cannot", "be", "null", "\"", ")", ";", "connect", "schema", "validate", "value", "(", "field", "name", "(", ")", ",", "field", "schema", "(", ")", ",", "value", ")", ";", "values", "[", "field", "index", "(", ")", "]", "=", "value", ";", "return", "this", ";", "}" ]
[ "registers", "a", "task", "without", "parent", "task" ]
[ "public", "task", "register", "(", "string", "type", ",", "string", "action", ",", "task", "aware", "request", "request", ")", "{", "map", "<", "string", ",", "string", ">", "headers", "=", "new", "hash", "map", "<", ">", "(", ")", ";", "long", "header", "size", "=", "0", ";", "long", "max", "size", "=", "max", "header", "size", "get", "bytes", "(", ")", ";", "thread", "context", "thread", "context", "=", "thread", "pool", "get", "thread", "context", "(", ")", ";", "for", "(", "string", "key", ":", "task", "headers", ")", "{", "string", "http", "header", "=", "thread", "context", "get", "header", "(", "key", ")", ";", "if", "(", "http", "header", "!", "=", "null", ")", "{", "header", "size", "+", "=", "key", "length", "(", ")", "*", "2", "+", "http", "header", "length", "(", ")", "*", "2", ";", "if", "(", "header", "size", ">", "max", "size", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "request", "exceeded", "the", "maximum", "size", "of", "task", "headers", "\"", "+", "max", "header", "size", ")", ";", "}", "headers", "put", "(", "key", ",", "http", "header", ")", ";", "}", "}", "task", "task", "=", "request", "create", "task", "(", "task", "id", "generator", "increment", "and", "get", "(", ")", ",", "type", ",", "action", ",", "request", "get", "parent", "task", "(", ")", ",", "headers", ")", ";", "objects", "require", "non", "null", "(", "task", ")", ";", "assert", "task", "get", "parent", "task", "id", "(", ")", "equals", "(", "request", "get", "parent", "task", "(", ")", ")", ":", "\"", "request", "[", "\"", "+", "request", "+", "\"", "]", "didn", "'", "t", "preserve", "it", "parent", "task", "id", "\"", ";", "if", "(", "logger", "is", "trace", "enabled", "(", ")", ")", "{", "logger", "trace", "(", "\"", "register", "{", "}", "[", "{", "}", "]", "[", "{", "}", "]", "[", "{", "}", "]", "\"", ",", "task", "get", "id", "(", ")", ",", "type", ",", "action", ",", "task", "get", "description", "(", ")", ")", ";", "}", "if", "(", "task", "instanceof", "cancellable", "task", ")", "{", "register", "cancellable", "task", "(", "task", ")", ";", "}", "else", "{", "task", "previous", "task", "=", "tasks", "put", "(", "task", "get", "id", "(", ")", ",", "task", ")", ";", "assert", "previous", "task", "=", "=", "null", ";", "}", "return", "task", ";", "}" ]
[ "add", "simple", "fall", "-", "through", "which", "sets", "noflow", "context", "value", "on", "next", "instruction", "(", "consumes", "2", "-", "bytes", ")" ]
[ "public", "void", "add", "bytes", "fallthrough", "set", "no", "flow", "context", "(", "string", "addr", ",", "int", "ctx", "val", ")", "throws", "memory", "access", "exception", "{", "add", "instruction", "words", "(", "addr", "(", "addr", ")", ",", "(", "short", ")", "(", "0xd", "9", "0", "0", "|", "(", "ctx", "val", "&", "0xf", ")", "|", "0x", "1", "0", ")", ")", ";", "/", "/", "nfctx", "i", "}" ]
[ "reads", "this", "message", "from", "the", "given", "readable", "this", "will", "overwrite", "all", "relevant", "fields", "with", "information", "from", "the", "byte", "buffer" ]
[ "void", "read", "(", "readable", "readable", ",", "short", "version", ")", ";" ]
[ "get", "a", "detailed", "description", "of", "the", "database" ]
[ "public", "optional", "<", "string", ">", "get", "detailed", "description", "(", ")", "{", "return", "optional", "of", "nullable", "(", "comment", ")", ";", "}" ]
[ "the", "total", "number", "of", "nodes", "that", "the", "operation", "was", "carried", "on" ]
[ "public", "int", "get", "total", "(", ")", "{", "return", "total", ";", "}" ]
[ "returns", "a", "string", "description", "of", "this", "handler" ]
[ "public", "string", "to", "string", "(", ")", ";" ]
[ "returns", "the", "string", "value", "for", "the", "given", "key", "the", "value", "should", "only", "have", "one", "item", "use", "{", "@", "link", "#", "get", "multi", "parameter", "(", "string", ")", "}", "instead", "if", "want", "to", "get", "multiple", "values", "parameter", "if", "the", "key", "does", "not", "exist", "it", "will", "return", "null" ]
[ "public", "string", "get", "(", "string", "key", ")", "{", "add", "to", "defaults", "(", "key", ",", "null", ")", ";", "unrequested", "parameters", "remove", "(", "key", ")", ";", "if", "(", "!", "data", "contains", "key", "(", "key", ")", ")", "{", "return", "null", ";", "}", "preconditions", "check", "state", "(", "data", "get", "(", "key", ")", "size", "(", ")", "=", "=", "1", ",", "\"", "key", "%", "s", "should", "has", "only", "one", "value", "\"", ",", "key", ")", ";", "return", "(", "string", ")", "data", "get", "(", "key", ")", "to", "array", "(", ")", "[", "0", "]", ";", "}" ]
[ "obtain", "a", "default", "work", "manager", "to", "delegate", "to", "called", "if", "no", "explicit", "work", "manager", "or", "work", "manager", "jndi", "name", "has", "been", "specified", "the", "default", "implementation", "returns", "a", "{", "@", "link", "simple", "task", "work", "manager", "}", "can", "be", "overridden", "in", "subclasses" ]
[ "protected", "work", "manager", "get", "default", "work", "manager", "(", ")", "{", "return", "new", "simple", "task", "work", "manager", "(", ")", ";", "}" ]
[ "execution", "graph", "is", "exposed", "to", "make", "it", "easier", "to", "rework", "tests", "to", "be", "based", "on", "the", "new", "scheduler", "execution", "graph", "is", "expected", "to", "be", "used", "only", "for", "state", "check", "yet", "at", "the", "moment", ",", "before", "all", "the", "actions", "are", "factored", "out", "from", "execution", "graph", "and", "its", "sub", "-", "components", ",", "some", "actions", "may", "still", "be", "performed", "directly", "on", "it" ]
[ "public", "execution", "graph", "get", "execution", "graph", "(", ")", "{", "return", "execution", "graph", ";", "}" ]
[ "simplifies", "a", "list", "of", "terms", "and", "combines", "them", "into", "an", "or", "modifies", "the", "list", "in", "place", "the", "simplified", "expression", "returns", "unknown", "values", "as", "is", "(", "not", "as", "false", ")" ]
[ "public", "rex", "node", "simplify", "ors", "(", "list", "<", "rex", "node", ">", "terms", ")", "{", "ensure", "paranoid", "off", "(", ")", ";", "return", "simplify", "ors", "(", "terms", ",", "unknown", ")", ";", "}" ]
[ "post", "pet", "{", "pet", "id", "}", ":", "updates", "a", "pet", "in", "the", "store", "with", "form", "data" ]
[ "default", "response", "entity", "<", "void", ">", "update", "pet", "with", "form", "(", "@", "api", "param", "(", "value", "=", "\"", "id", "of", "pet", "that", "needs", "to", "be", "updated", "\"", ",", "required", "=", "true", ")", "@", "path", "variable", "(", "\"", "pet", "id", "\"", ")", "long", "pet", "id", ",", "@", "api", "param", "(", "value", "=", "\"", "updated", "name", "of", "the", "pet", "\"", ")", "@", "valid", "@", "request", "part", "(", "value", "=", "\"", "name", "\"", ",", "required", "=", "false", ")", "string", "name", ",", "@", "api", "param", "(", "value", "=", "\"", "updated", "status", "of", "the", "pet", "\"", ")", "@", "valid", "@", "request", "part", "(", "value", "=", "\"", "status", "\"", ",", "required", "=", "false", ")", "string", "status", ")", "{", "return", "new", "response", "entity", "<", ">", "(", "http", "status", "not", "implemented", ")", ";", "}" ]
[ "updates", "the", "unassigned", "info", "and", "recovery", "source", "on", "the", "current", "unassigned", "shard" ]
[ "shard", "routing", "update", "unassigned", "(", "unassigned", "info", "unassigned", "info", ",", "recovery", "source", "recovery", "source", ",", "routing", "changes", "observer", "changes", ")", ";" ]
[ "gets", "the", "{", "@", "code", "boolean", "}", "value" ]
[ "public", "boolean", "get", "value", "(", ")", "{", "return", "(", "get", "int", "bits", "(", ")", "=", "=", "0", ")", "?", "false", ":", "true", ";", "}" ]
[ "register", "a", "listener", "that", "will", "be", "called", "when", "this", "model", "visibility", "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", "test", "field", "prop", "text", "prop", "view", "model", "on", "visibility", "changed", "(", "on", "model", "visibility", "changed", "listener", "<", "test", "field", "prop", "text", "prop", "view", "model", ",", "test", "field", "prop", "text", "prop", "view", ">", "listener", ")", "{", "on", "mutation", "(", ")", ";", "this", "on", "model", "visibility", "changed", "listener", "epoxy", "generated", "model", "=", "listener", ";", "return", "this", ";", "}" ]
[ "test", "that", "an", "asynchronous", "request", "will", "eventually", "return", "the", "right", "offset" ]
[ "public", "void", "test", "blocking", "(", ")", "throws", "exception", "{", "future", "record", "metadata", "future", "=", "new", "future", "record", "metadata", "(", "async", "request", "(", "base", "offset", ",", "null", ",", "50l", ")", ",", "rel", "offset", ",", "record", "batch", "no", "timestamp", ",", "0l", ",", "0", ",", "0", ",", "time", "system", ")", ";", "assert", "equals", "(", "base", "offset", "+", "rel", "offset", ",", "future", "get", "(", ")", "offset", "(", ")", ")", ";", "}" ]
[ "flush", "any", "buffer", "and", "close", "the", "output", "file", "use", "this", "method", "if", "the", "operation", "is", "successful" ]
[ "public", "long", "finalize", "file", "(", ")", "throws", "i", "o", "exception", "{", "flush", "auxiliar", "(", "aux", "length", ")", ";", "out", "flush", "(", ")", ";", "/", "/", "change", "file", "length", "(", "if", "required", ")", "long", "length", "=", "math", "max", "(", "max", "length", "known", ",", "out", "length", ")", ";", "if", "(", "length", "!", "=", "out", "target", "length", "(", ")", ")", "{", "out", "target", "set", "length", "(", "length", ")", ";", "}", "close", "(", ")", ";", "return", "length", ";", "}" ]
[ "returns", "the", "rm", "delegation", "token", "data", "from", "the", "{", "@", "link", "data", "input", "stream", "}", "as", "a", "{", "@", "link", "r", "m", "delegation", "token", "identifier", "data", "}", "it", "can", "handle", "both", "the", "current", "and", "old", "(", "non", "-", "protobuf", ")", "formats" ]
[ "public", "static", "r", "m", "delegation", "token", "identifier", "data", "read", "r", "m", "delegation", "token", "identifier", "data", "(", "data", "input", "stream", "fs", "in", ")", "throws", "i", "o", "exception", "{", "r", "m", "delegation", "token", "identifier", "data", "identifier", "data", "=", "new", "r", "m", "delegation", "token", "identifier", "data", "(", ")", ";", "try", "{", "identifier", "data", "read", "fields", "(", "fs", "in", ")", ";", "}", "catch", "(", "invalid", "protocol", "buffer", "exception", "e", ")", "{", "log", "warn", "(", "\"", "recovering", "old", "formatted", "token", "\"", ")", ";", "fs", "in", "reset", "(", ")", ";", "y", "a", "r", "n", "delegation", "token", "identifier", "identifier", "=", "new", "r", "m", "delegation", "token", "identifier", "(", ")", ";", "identifier", "read", "fields", "in", "old", "format", "(", "fs", "in", ")", ";", "identifier", "data", "set", "identifier", "(", "identifier", ")", ";", "identifier", "data", "set", "renew", "date", "(", "fs", "in", "read", "long", "(", ")", ")", ";", "}", "return", "identifier", "data", ";", "}" ]
[ "return", "the", "window", "containing", "the", "values", "associated", "with", "this", "key" ]
[ "public", "window", "window", "(", ")", "{", "return", "window", ";", "}" ]
[ "finds", "the", "type", "parameter", "for", "the", "given", "class", "which", "is", "assignable", "to", "the", "bound", "class" ]
[ "public", "static", "<", "t", ">", "class", "<", "t", ">", "get", "type", "parameter", "(", "class", "<", "?", ">", "klass", ",", "class", "<", "?", "super", "t", ">", "bound", ")", "{", "type", "t", "=", "require", "non", "null", "(", "klass", ")", ";", "while", "(", "t", "instanceof", "class", "<", "?", ">", ")", "{", "t", "=", "(", "(", "class", "<", "?", ">", ")", "t", ")", "get", "generic", "superclass", "(", ")", ";", "}", "/", "*", "this", "is", "not", "guaranteed", "to", "work", "for", "all", "cases", "with", "convoluted", "piping", "*", "of", "type", "parameters", ":", "but", "it", "can", "at", "least", "resolve", "straight", "-", "forward", "*", "extension", "with", "single", "type", "parameter", "(", "as", "per", "[", "issue", "-", "89", "]", ")", "*", "and", "when", "it", "fails", "to", "do", "that", ",", "will", "indicate", "with", "specific", "exception", "*", "/", "if", "(", "t", "instanceof", "parameterized", "type", ")", "{", "/", "/", "should", "typically", "have", "one", "of", "type", "parameters", "(", "first", "one", ")", "that", "matches", ":", "for", "(", "type", "param", ":", "(", "(", "parameterized", "type", ")", "t", ")", "get", "actual", "type", "arguments", "(", ")", ")", "{", "if", "(", "param", "instanceof", "class", "<", "?", ">", ")", "{", "final", "class", "<", "t", ">", "cls", "=", "determine", "class", "(", "bound", ",", "param", ")", ";", "if", "(", "cls", "!", "=", "null", ")", "{", "return", "cls", ";", "}", "}", "else", "if", "(", "param", "instanceof", "type", "variable", ")", "{", "for", "(", "type", "param", "bound", ":", "(", "(", "type", "variable", "<", "?", ">", ")", "param", ")", "get", "bounds", "(", ")", ")", "{", "if", "(", "param", "bound", "instanceof", "class", "<", "?", ">", ")", "{", "final", "class", "<", "t", ">", "cls", "=", "determine", "class", "(", "bound", ",", "param", "bound", ")", ";", "if", "(", "cls", "!", "=", "null", ")", "{", "return", "cls", ";", "}", "}", "}", "}", "else", "if", "(", "param", "instanceof", "parameterized", "type", ")", "{", "final", "type", "raw", "type", "=", "(", "(", "parameterized", "type", ")", "param", ")", "get", "raw", "type", "(", ")", ";", "if", "(", "raw", "type", "instanceof", "class", "<", "?", ">", ")", "{", "final", "class", "<", "t", ">", "cls", "=", "determine", "class", "(", "bound", ",", "raw", "type", ")", ";", "if", "(", "cls", "!", "=", "null", ")", "{", "return", "cls", ";", "}", "}", "}", "}", "}", "throw", "new", "illegal", "state", "exception", "(", "\"", "cannot", "figure", "out", "type", "parameterization", "for", "\"", "+", "klass", "get", "name", "(", ")", ")", ";", "}" ]
[ "returns", "the", "test", "status", "artifact" ]
[ "public", "artifact", "get", "test", "status", "artifact", "(", ")", "{", "/", "/", "these", "artifacts", "are", "used", "to", "keep", "track", "of", "the", "number", "of", "pending", "and", "completed", "tests", "return", "test", "action", "get", "cache", "status", "artifact", "(", ")", ";", "}" ]
[ "evaluates", "an", "expression", "of", "the", "form", "\"", "e", "1", "-", "e", "2", "-", "-", "e", "k", "\"", "by", "noting", "its", "equivalence", "to", "\"", "e", "1", "-", "(", "e", "2", "+", "+", "e", "k", ")", "\"", "and", "evaluating", "the", "subexpressions", "on", "the", "right", "-", "hand", "-", "side", "separately" ]
[ "private", "static", "<", "t", ">", "query", "task", "future", "<", "void", ">", "eval", "minus", "(", "final", "immutable", "list", "<", "query", "expression", ">", "operands", ",", "final", "query", "environment", "<", "t", ">", "env", ",", "final", "query", "expression", "context", "<", "t", ">", "context", ",", "final", "callback", "<", "t", ">", "callback", ")", "{", "query", "task", "future", "<", "thread", "safe", "mutable", "set", "<", "t", ">", ">", "lhs", "value", "future", "=", "query", "util", "eval", "all", "(", "env", ",", "context", ",", "operands", "get", "(", "0", ")", ")", ";", "function", "<", "thread", "safe", "mutable", "set", "<", "t", ">", ",", "query", "task", "future", "<", "void", ">", ">", "subtract", "async", "function", "=", "lhs", "value", "-", ">", "{", "final", "set", "<", "t", ">", "thread", "safe", "lhs", "value", "=", "lhs", "value", ";", "callback", "<", "t", ">", "subtraction", "callback", "=", "new", "callback", "<", "t", ">", "(", ")", "{", "@", "override", "public", "void", "process", "(", "iterable", "<", "t", ">", "partial", "result", ")", "{", "for", "(", "t", "target", ":", "partial", "result", ")", "{", "thread", "safe", "lhs", "value", "remove", "(", "target", ")", ";", "}", "}", "}", ";", "query", "task", "future", "<", "void", ">", "rhs", "evaluated", "future", "=", "eval", "plus", "(", "operands", "sub", "list", "(", "1", ",", "operands", "size", "(", ")", ")", ",", "env", ",", "context", ",", "subtraction", "callback", ")", ";", "return", "env", "when", "succeeds", "call", "(", "rhs", "evaluated", "future", ",", "new", "query", "task", "callable", "<", "void", ">", "(", ")", "{", "@", "override", "public", "void", "call", "(", ")", "throws", "query", "exception", ",", "interrupted", "exception", "{", "callback", "process", "(", "thread", "safe", "lhs", "value", ")", ";", "return", "null", ";", "}", "}", ")", ";", "}", ";", "return", "env", "transform", "async", "(", "lhs", "value", "future", ",", "subtract", "async", "function", ")", ";", "}" ]
[ "log", "delegation", "token", "to", "edit", "log" ]
[ "void", "log", "get", "delegation", "token", "(", "delegation", "token", "identifier", "id", ",", "long", "expiry", "time", ")", "{", "get", "delegation", "token", "op", "op", "=", "get", "delegation", "token", "op", "get", "instance", "(", "cache", "get", "(", ")", ")", "set", "delegation", "token", "identifier", "(", "id", ")", "set", "expiry", "time", "(", "expiry", "time", ")", ";", "log", "edit", "(", "op", ")", ";", "}" ]
[ "set", "the", "gl", "enum", "used", "in", "the", "call", "to", "{", "@", "link", "gl20", "#", "gl", "buffer", "data", "(", "int", ",", "int", ",", "java", "nio", "buffer", ",", "int", ")", "}", ",", "can", "only", "be", "called", "when", "the", "vbo", "is", "not", "bound" ]
[ "protected", "void", "set", "usage", "(", "int", "value", ")", "{", "if", "(", "is", "bound", ")", "throw", "new", "gdx", "runtime", "exception", "(", "\"", "cannot", "change", "usage", "while", "vbo", "is", "bound", "\"", ")", ";", "usage", "=", "value", ";", "}" ]
[ "get", "double", "minimum", ":", "67", "8", "maximum", ":", "123", "4" ]
[ "public", "double", "get", "double", "(", ")", "{", "return", "double", ";", "}" ]
[ "returns", "the", "index", "count", "for", "the", "file" ]
[ "int", "get", "index", "count", "(", ")", "{", "return", "index", "cnt", ";", "}" ]
[ "cumulative", "count", "of", "number", "of", "threads", "executed", "since", "the", "start", "of", "the", "application" ]
[ "public", "long", "get", "cumulative", "count", "threads", "executed", "(", ")", "{", "return", "cumulative", "counter", "stream", "get", "latest", "count", "(", "hystrix", "event", "type", "thread", "pool", "executed", ")", ";", "}" ]
[ "find", "the", "fields", "constant", "that", "matches", "field", "id", ",", "throwing", "an", "exception", "if", "it", "is", "not", "found" ]
[ "public", "static", "fields", "find", "by", "thrift", "id", "or", "throw", "(", "int", "field", "id", ")", "{", "fields", "fields", "=", "find", "by", "thrift", "id", "(", "field", "id", ")", ";", "if", "(", "fields", "=", "=", "null", ")", "throw", "new", "illegal", "argument", "exception", "(", "\"", "field", "\"", "+", "field", "id", "+", "\"", "doesn", "'", "t", "exist", "!", "\"", ")", ";", "return", "fields", ";", "}" ]
[ "create", "a", "new", "proxy", "object", "uses", "the", "given", "class", "loader", "(", "if", "necessary", "for", "proxy", "creation", ")", "{", "@", "code", "null", "}", "will", "simply", "be", "passed", "down", "and", "thus", "lead", "to", "the", "low", "-", "level", "proxy", "facility", "'", "s", "default", ",", "which", "is", "usually", "different", "from", "the", "default", "chosen", "by", "the", "aop", "proxy", "implementation", "'", "s", "{", "@", "link", "#", "get", "proxy", "(", ")", "}", "method" ]
[ "object", "get", "proxy", "(", "@", "nullable", "class", "loader", "class", "loader", ")", ";" ]
[ "returns", "an", "immutable", "array", "containing", "the", "given", "values", ",", "in", "order" ]
[ "public", "static", "immutable", "long", "array", "of", "(", "long", "e", "0", ",", "long", "e", "1", ")", "{", "return", "new", "immutable", "long", "array", "(", "new", "long", "[", "]", "{", "e", "0", ",", "e", "1", "}", ")", ";", "}" ]
[ "notifies", "that", "a", "node", "corresponding", "to", "{", "@", "code", "sky", "key", "}", "is", "about", "to", "complete", "the", "given", "{", "@", "code", "node", "state", "}", "always", "called", "symmetrically", "with", "{", "@", "link", "#", "state", "starting", "(", "sky", "key", ",", "node", "state", ")", "}", "}", "{", "@", "code", "elapsed", "time", "nanos", "}", "is", "either", "the", "elapsed", "time", "in", "the", "{", "@", "code", "node", "state", "}", "or", "-", "1", "if", "the", "timing", "was", "not", "recorded" ]
[ "void", "state", "ending", "(", "sky", "key", "sky", "key", ",", "node", "state", "node", "state", ",", "long", "elapsed", "time", "nanos", ")", ";" ]
[ "test", "with", "record", "length", "set", "to", "0" ]
[ "public", "void", "test", "zero", "record", "length", "(", ")", "throws", "i", "o", "exception", "{", "local", "fs", "delete", "(", "work", "dir", ",", "true", ")", ";", "path", "file", "=", "new", "path", "(", "work", "dir", ",", "new", "string", "(", "\"", "test", "format", "txt", "\"", ")", ")", ";", "create", "file", "(", "file", ",", "null", ",", "10", ",", "10", ")", ";", "/", "/", "set", "the", "fixed", "length", "record", "length", "config", "property", "job", "conf", "job", "=", "new", "job", "conf", "(", "default", "conf", ")", ";", "file", "input", "format", "set", "input", "paths", "(", "job", ",", "work", "dir", ")", ";", "fixed", "length", "input", "format", "format", "=", "new", "fixed", "length", "input", "format", "(", ")", ";", "format", "set", "record", "length", "(", "job", ",", "0", ")", ";", "format", "configure", "(", "job", ")", ";", "input", "split", "splits", "[", "]", "=", "format", "get", "splits", "(", "job", ",", "1", ")", ";", "boolean", "exception", "thrown", "=", "false", ";", "for", "(", "input", "split", "split", ":", "splits", ")", "{", "try", "{", "record", "reader", "<", "long", "writable", ",", "bytes", "writable", ">", "reader", "=", "format", "get", "record", "reader", "(", "split", ",", "job", ",", "void", "reporter", ")", ";", "}", "catch", "(", "i", "o", "exception", "ioe", ")", "{", "exception", "thrown", "=", "true", ";", "log", "info", "(", "\"", "exception", "message", ":", "\"", "+", "ioe", "get", "message", "(", ")", ")", ";", "}", "}", "assert", "true", "(", "\"", "exception", "for", "zero", "record", "length", ":", "\"", ",", "exception", "thrown", ")", ";", "}" ]
[ "removes", "from", "this", "array", "all", "of", "elements", "contained", "in", "the", "specified", "array" ]
[ "public", "boolean", "remove", "all", "(", "short", "array", "array", ")", "{", "int", "size", "=", "this", "size", ";", "int", "start", "size", "=", "size", ";", "short", "[", "]", "items", "=", "this", "items", ";", "for", "(", "int", "i", "=", "0", ",", "n", "=", "array", "size", ";", "i", "<", "n", ";", "i", "+", "+", ")", "{", "short", "item", "=", "array", "get", "(", "i", ")", ";", "for", "(", "int", "ii", "=", "0", ";", "ii", "<", "size", ";", "ii", "+", "+", ")", "{", "if", "(", "item", "=", "=", "items", "[", "ii", "]", ")", "{", "remove", "index", "(", "ii", ")", ";", "size", "-", "-", ";", "break", ";", "}", "}", "}", "return", "size", "!", "=", "start", "size", ";", "}" ]
[ "returns", "a", "new", "array", "based", "int", "buffer", "with", "the", "specified", "capacity" ]
[ "public", "static", "int", "buffer", "new", "int", "buffer", "(", "int", "capacity", ")", "{", "return", "new", "read", "write", "int", "array", "buffer", "(", "capacity", ")", ";", "}" ]
[ "returns", "the", "size", "of", "the", "optional", "header", "data" ]
[ "public", "int", "get", "size", "of", "optional", "header", "(", ")", "{", "return", "size", "of", "optional", "header", ";", "}" ]
[ "transforms", "the", "specified", "world", "coordinate", "to", "screen", "coordinates" ]
[ "public", "vector", "2", "project", "(", "vector", "2", "world", "coords", ")", "{", "tmp", "set", "(", "world", "coords", "x", ",", "world", "coords", "y", ",", "1", ")", ";", "camera", "project", "(", "tmp", ",", "screen", "x", ",", "screen", "y", ",", "screen", "width", ",", "screen", "height", ")", ";", "world", "coords", "set", "(", "tmp", "x", ",", "tmp", "y", ")", ";", "return", "world", "coords", ";", "}" ]
[ "test", "the", "property", "'", "id", "'" ]
[ "public", "void", "id", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "id", "}" ]
[ "nb", ":", "this", "compares", "parents", "using", "reference", "equality", "instead", "of", "logical", "equality", "this", "is", "a", "performance", "optimization", "to", "avoid", "possibly", "expensive", "recursive", "equality", "expansions", "and", "suitable", "for", "comparisons", "needed", "by", "interning", "deserialized", "values", "if", "full", "logical", "equality", "is", "desired", ",", "it", "'", "s", "possible", "to", "either", "enable", "full", "interning", "(", "at", "a", "modest", "cpu", "cost", ")", "or", "change", "the", "parent", "comparison", "to", "use", "deep", "equality", "this", "same", "comment", "applies", "to", "{", "@", "link", "single", "variables", "#", "equals", "}" ]
[ "public", "boolean", "equals", "(", "object", "other", ")", "{", "if", "(", "!", "(", "other", "instanceof", "map", "variables", ")", ")", "{", "return", "false", ";", "}", "if", "(", "this", "=", "=", "other", ")", "{", "return", "true", ";", "}", "map", "variables", "that", "=", "(", "map", "variables", ")", "other", ";", "if", "(", "this", "parent", "!", "=", "that", "parent", ")", "{", "return", "false", ";", "}", "return", "objects", "equals", "(", "this", "key", "to", "index", ",", "that", "key", "to", "index", ")", "&", "&", "objects", "equals", "(", "this", "values", ",", "that", "values", ")", ";", "}" ]
[ "method", "called", "when", "a", "change", "is", "made", "to", "the", "domain", "object" ]
[ "public", "void", "domain", "object", "changed", "(", "domain", "object", "changed", "event", "ev", ")", ";" ]
[ "returns", "a", "copy", "of", "the", "input", "character", "sequence", "in", "which", "all", "{", "@", "linkplain", "#", "is", "lower", "case", "(", "char", ")", "lowercase", "ascii", "characters", "}", "have", "been", "converted", "to", "uppercase", "all", "other", "characters", "are", "copied", "without", "modification" ]
[ "public", "static", "string", "to", "upper", "case", "(", "char", "sequence", "chars", ")", "{", "if", "(", "chars", "instanceof", "string", ")", "{", "return", "to", "upper", "case", "(", "(", "string", ")", "chars", ")", ";", "}", "char", "[", "]", "new", "chars", "=", "new", "char", "[", "chars", "length", "(", ")", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "new", "chars", "length", ";", "i", "+", "+", ")", "{", "new", "chars", "[", "i", "]", "=", "to", "upper", "case", "(", "chars", "char", "at", "(", "i", ")", ")", ";", "}", "return", "string", "value", "of", "(", "new", "chars", ")", ";", "}" ]
[ "log", "an", "exception", "(", "throwable", ")", "at", "the", "warn", "level", "with", "an", "accompanying", "message" ]
[ "public", "void", "warn", "(", "string", "msg", ",", "throwable", "t", ")", "{", "logger", "log", "(", "fqcn", ",", "level", "warn", ",", "msg", ",", "t", ")", ";", "}" ]
[ "return", "true", "if", "this", "mixed", "properties", "and", "additional", "properties", "class", "object", "is", "equal", "to", "o" ]
[ "public", "boolean", "equals", "(", "object", "o", ")", "{", "if", "(", "this", "=", "=", "o", ")", "{", "return", "true", ";", "}", "if", "(", "o", "=", "=", "null", "|", "|", "get", "class", "(", ")", "!", "=", "o", "get", "class", "(", ")", ")", "{", "return", "false", ";", "}", "mixed", "properties", "and", "additional", "properties", "class", "mixed", "properties", "and", "additional", "properties", "class", "=", "(", "mixed", "properties", "and", "additional", "properties", "class", ")", "o", ";", "return", "objects", "equals", "(", "this", "uuid", ",", "mixed", "properties", "and", "additional", "properties", "class", "uuid", ")", "&", "&", "objects", "equals", "(", "this", "date", "time", ",", "mixed", "properties", "and", "additional", "properties", "class", "date", "time", ")", "&", "&", "objects", "equals", "(", "this", "map", ",", "mixed", "properties", "and", "additional", "properties", "class", "map", ")", ";", "}" ]
[ "assert", "the", "retained", "size", "in", "bytes", "of", "{" ]
[ "private", "static", "void", "assert", "builder", "size", "(", "group", "by", "hash", "group", "by", "hash", ",", "list", "<", "type", ">", "types", ",", "list", "<", "integer", ">", "page", "positions", ",", "list", "<", "integer", ">", "row", "counts", ",", "long", "actual", "size", "in", "bytes", ")", "{", "object", "big", "array", "<", "object", ">", "page", "references", "=", "new", "object", "big", "array", "<", ">", "(", ")", ";", "page", "references", "ensure", "capacity", "(", "page", "positions", "size", "(", ")", ")", ";", "long", "page", "references", "size", "in", "bytes", "=", "page", "references", "size", "of", "(", ")", ";", "object", "big", "array", "<", "object", ">", "grouped", "rows", "=", "new", "object", "big", "array", "<", ">", "(", ")", ";", "grouped", "rows", "ensure", "capacity", "(", "row", "counts", "size", "(", ")", ")", ";", "long", "grouped", "rows", "size", "in", "bytes", "=", "grouped", "rows", "size", "of", "(", ")", ";", "int", "empty", "slots", "=", "4", ";", "long", "empty", "page", "reference", "slots", "size", "in", "bytes", "=", "int", "fifo", "queue", "size", "+", "size", "of", "(", "new", "int", "[", "empty", "slots", "]", ")", ";", "/", "/", "build", "fake", "pages", "to", "get", "the", "real", "retained", "sizes", "row", "pages", "builder", "row", "pages", "builder", "=", "row", "pages", "builder", "(", "types", ")", ";", "for", "(", "int", "page", "position", ":", "page", "positions", ")", "{", "if", "(", "page", "position", ">", "0", ")", "{", "row", "pages", "builder", "add", "sequence", "page", "(", "page", "position", ",", "new", "int", "[", "types", "size", "(", ")", "]", ")", ";", "}", "}", "long", "referenced", "pages", "size", "in", "bytes", "=", "0", ";", "for", "(", "page", "page", ":", "row", "pages", "builder", "build", "(", ")", ")", "{", "/", "/", "each", "page", "reference", "is", "with", "two", "arrays", "and", "a", "page", "referenced", "pages", "size", "in", "bytes", "+", "=", "page", "reference", "instance", "size", "+", "page", "get", "retained", "size", "in", "bytes", "(", ")", "+", "size", "of", "(", "new", "object", "[", "page", "get", "position", "count", "(", ")", "]", ")", ";", "}", "long", "row", "heaps", "size", "in", "bytes", "=", "0", ";", "for", "(", "int", "count", ":", "row", "counts", ")", "{", "if", "(", "count", ">", "0", ")", "{", "row", "heaps", "size", "in", "bytes", "+", "=", "new", "test", "row", "heap", "(", "count", ")", "get", "estimated", "size", "in", "bytes", "(", ")", ";", "}", "}", "long", "expected", "size", "in", "bytes", "=", "instance", "size", "+", "group", "by", "hash", "get", "estimated", "size", "(", ")", "+", "referenced", "pages", "size", "in", "bytes", "+", "row", "heaps", "size", "in", "bytes", "+", "page", "references", "size", "in", "bytes", "+", "grouped", "rows", "size", "in", "bytes", "+", "empty", "page", "reference", "slots", "size", "in", "bytes", ";", "assert", "equals", "(", "actual", "size", "in", "bytes", ",", "expected", "size", "in", "bytes", ")", ";", "}" ]