Datasets:
Anonymous2023
/
KGSum

Dataset card Data Studio Files Community
docstring_tokens
list
code_tokens
list
[ "get", "userlogin", ":", "logs", "user", "into", "the", "system" ]
[ "default", "response", "entity", "<", "string", ">", "login", "user", "(", "@", "not", "null", "@", "api", "param", "(", "value", "=", "\"", "the", "user", "name", "for", "login", "\"", ",", "required", "=", "true", ")", "@", "valid", "@", "request", "param", "(", "value", "=", "\"", "username", "\"", ",", "required", "=", "true", ")", "string", "username", ",", "@", "not", "null", "@", "api", "param", "(", "value", "=", "\"", "the", "password", "for", "login", "in", "clear", "text", "\"", ",", "required", "=", "true", ")", "@", "valid", "@", "request", "param", "(", "value", "=", "\"", "password", "\"", ",", "required", "=", "true", ")", "string", "password", ")", "{", "return", "new", "response", "entity", "<", ">", "(", "http", "status", "not", "implemented", ")", ";", "}" ]
[ "set", "the", "default", "http", "status", "to", "use", "for", "redirects", "by", "default", "this", "is", "{", "@", "link", "http", "status", "#", "see", "other", "}" ]
[ "public", "void", "set", "redirect", "status", "(", "http", "status", "status", ")", "{", "assert", "not", "null", "(", "status", ",", "\"", "property", "'", "redirect", "status", "'", "is", "required", "\"", ")", ";", "assert", "is", "true", "(", "status", "is", "3xx", "redirection", "(", ")", ",", "\"", "not", "a", "redirect", "status", "code", "\"", ")", ";", "this", "redirect", "status", "=", "status", ";", "}" ]
[ "this", "method", "collects", "three", "types", "of", "instructions", ":", "1", ")", "adds", "a", "local", "variable", "assignment", "to", "the", "{", "@", "code", "local", "variables", "}", "map", "2", ")", "add", "move", "-", "result", "-", "pseudo", "to", "the", "{", "@", "code", "move", "result", "pseudo", "insns", "}", "list", "3", ")", "add", "invoke", "-", "range", "to", "the", "{", "@", "code", "invoke", "range", "insns", "}", "list" ]
[ "private", "void", "process", "insn", "(", "ssa", "insn", "insn", ")", "{", "register", "spec", "assignment", ";", "assignment", "=", "insn", "get", "local", "assignment", "(", ")", ";", "if", "(", "assignment", "!", "=", "null", ")", "{", "local", "item", "local", "=", "assignment", "get", "local", "item", "(", ")", ";", "array", "list", "<", "register", "spec", ">", "reg", "list", "=", "local", "variables", "get", "(", "local", ")", ";", "if", "(", "reg", "list", "=", "=", "null", ")", "{", "reg", "list", "=", "new", "array", "list", "<", "register", "spec", ">", "(", ")", ";", "local", "variables", "put", "(", "local", ",", "reg", "list", ")", ";", "}", "reg", "list", "add", "(", "assignment", ")", ";", "}", "if", "(", "insn", "instanceof", "normal", "ssa", "insn", ")", "{", "if", "(", "insn", "get", "opcode", "(", ")", "get", "opcode", "(", ")", "=", "=", "reg", "ops", "move", "result", "pseudo", ")", "{", "move", "result", "pseudo", "insns", "add", "(", "(", "normal", "ssa", "insn", ")", "insn", ")", ";", "}", "else", "if", "(", "optimizer", "get", "advice", "(", ")", "requires", "sources", "in", "order", "(", "insn", "get", "original", "rop", "insn", "(", ")", "get", "opcode", "(", ")", ",", "insn", "get", "sources", "(", ")", ")", ")", "{", "invoke", "range", "insns", "add", "(", "(", "normal", "ssa", "insn", ")", "insn", ")", ";", "}", "}", "else", "if", "(", "insn", "instanceof", "phi", "insn", ")", "{", "phi", "insns", "add", "(", "(", "phi", "insn", ")", "insn", ")", ";", "}", "}" ]
[ "{", "@", "inherit", "doc", "}", "always", "returns", "null", "for", "{", "@", "code", "phi", "insn", "}", "s" ]
[ "public", "rop", "get", "opcode", "(", ")", "{", "return", "null", ";", "}" ]
[ "do", "the", "actual", "work" ]
[ "protected", "abstract", "void", "perform", "(", "task", "listener", "listener", ")", "throws", "exception", ";" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "void", "update", "(", "long", "duration", ",", "time", "unit", "unit", ")", "{", "/", "/", "nop", "}" ]
[ "given", "a", "recipient", "will", "create", "a", "{", "@", "link", "group", "candidate", "}", "which", "may", "or", "may", "not", "have", "a", "profile", "key", "credential", "it", "will", "try", "to", "find", "missing", "profile", "key", "credentials", "from", "the", "server", "and", "persist", "locally" ]
[ "public", "@", "non", "null", "group", "candidate", "recipient", "id", "to", "candidate", "(", "@", "non", "null", "recipient", "id", "recipient", "id", ")", "throws", "i", "o", "exception", "{", "final", "recipient", "recipient", "=", "recipient", "resolved", "(", "recipient", "id", ")", ";", "uuid", "uuid", "=", "recipient", "get", "uuid", "(", ")", "or", "null", "(", ")", ";", "if", "(", "uuid", "=", "=", "null", ")", "{", "throw", "new", "assertion", "error", "(", "\"", "non", "uuid", "members", "should", "have", "need", "detected", "by", "now", "\"", ")", ";", "}", "optional", "<", "profile", "key", "credential", ">", "profile", "key", "credential", "=", "optional", "from", "nullable", "(", "recipient", "get", "profile", "key", "credential", "(", ")", ")", ";", "group", "candidate", "candidate", "=", "new", "group", "candidate", "(", "uuid", ",", "profile", "key", "credential", ")", ";", "if", "(", "!", "candidate", "has", "profile", "key", "credential", "(", ")", ")", "{", "profile", "key", "profile", "key", "=", "profile", "key", "util", "profile", "key", "or", "null", "(", "recipient", "get", "profile", "key", "(", ")", ")", ";", "if", "(", "profile", "key", "!", "=", "null", ")", "{", "log", "i", "(", "tag", ",", "string", "format", "(", "\"", "no", "profile", "key", "credential", "on", "recipient", "%", "s", ",", "fetching", "\"", ",", "recipient", "get", "id", "(", ")", ")", ")", ";", "optional", "<", "profile", "key", "credential", ">", "profile", "key", "credential", "optional", "=", "signal", "service", "account", "manager", "resolve", "profile", "key", "credential", "(", "uuid", ",", "profile", "key", ")", ";", "if", "(", "profile", "key", "credential", "optional", "is", "present", "(", ")", ")", "{", "boolean", "updated", "profile", "key", "=", "recipient", "database", "set", "profile", "key", "credential", "(", "recipient", "get", "id", "(", ")", ",", "profile", "key", ",", "profile", "key", "credential", "optional", "get", "(", ")", ")", ";", "if", "(", "!", "updated", "profile", "key", ")", "{", "log", "w", "(", "tag", ",", "string", "format", "(", "\"", "failed", "to", "update", "the", "profile", "key", "credential", "on", "recipient", "%", "s", "\"", ",", "recipient", "get", "id", "(", ")", ")", ")", ";", "}", "else", "{", "log", "i", "(", "tag", ",", "string", "format", "(", "\"", "got", "new", "profile", "key", "credential", "for", "recipient", "%", "s", "\"", ",", "recipient", "get", "id", "(", ")", ")", ")", ";", "candidate", "=", "candidate", "with", "profile", "key", "credential", "(", "profile", "key", "credential", "optional", "get", "(", ")", ")", ";", "}", "}", "}", "}", "return", "candidate", ";", "}" ]
[ "throws", "if", "a", "value", "<", "=", "0", "is", "set", "required" ]
[ "public", "test", "field", "prop", "text", "prop", "view", "model", "value", "(", "@", "string", "res", "int", "string", "res", ")", "{", "on", "mutation", "(", ")", ";", "assigned", "attributes", "epoxy", "generated", "model", "set", "(", "0", ")", ";", "value", "string", "attribute", "data", "set", "value", "(", "string", "res", ")", ";", "return", "this", ";", "}" ]
[ "block", "to", "the", "next", "millisecond", "until", "a", "new", "timestamp", "is", "obtained" ]
[ "private", "long", "wait", "until", "next", "time", "(", "long", "last", "timestamp", ")", "{", "long", "time", ";", "time", "=", "system", "current", "time", "millis", "(", ")", ";", "while", "(", "time", "<", "=", "last", "timestamp", ")", "{", ";", "time", "=", "system", "current", "time", "millis", "(", ")", ";", "}", "return", "time", ";", "}" ]
[ "this", "test", "uses", "a", "special", "(", "misbehaving", ")", "{", "@", "code", "merging", "window", "assigner", "}", "that", "produces", "cases", "where", "windows", "that", "don", "'", "t", "overlap", "with", "the", "newly", "added", "window", "are", "being", "merged", "we", "verify", "that", "the", "merging", "window", "set", "is", "nevertheless", "correct", "and", "contains", "all", "added", "windows" ]
[ "public", "void", "test", "non", "eager", "merging", "(", ")", "throws", "exception", "{", "@", "suppress", "warnings", "(", "\"", "unchecked", "\"", ")", "list", "state", "<", "tuple", "2", "<", "time", "window", ",", "time", "window", ">", ">", "mock", "state", "=", "mock", "(", "list", "state", "class", ")", ";", "merging", "window", "set", "<", "time", "window", ">", "window", "set", "=", "new", "merging", "window", "set", "<", ">", "(", "new", "non", "eagerly", "merging", "window", "assigner", "(", "3000", ")", ",", "mock", "state", ")", ";", "testing", "merge", "function", "merge", "function", "=", "new", "testing", "merge", "function", "(", ")", ";", "time", "window", "result", ";", "merge", "function", "reset", "(", ")", ";", "result", "=", "window", "set", "add", "window", "(", "new", "time", "window", "(", "0", ",", "2", ")", ",", "merge", "function", ")", ";", "assert", "not", "null", "(", "window", "set", "get", "state", "window", "(", "result", ")", ")", ";", "merge", "function", "reset", "(", ")", ";", "result", "=", "window", "set", "add", "window", "(", "new", "time", "window", "(", "2", ",", "5", ")", ",", "merge", "function", ")", ";", "assert", "not", "null", "(", "window", "set", "get", "state", "window", "(", "result", ")", ")", ";", "merge", "function", "reset", "(", ")", ";", "result", "=", "window", "set", "add", "window", "(", "new", "time", "window", "(", "1", ",", "2", ")", ",", "merge", "function", ")", ";", "assert", "not", "null", "(", "window", "set", "get", "state", "window", "(", "result", ")", ")", ";", "merge", "function", "reset", "(", ")", ";", "result", "=", "window", "set", "add", "window", "(", "new", "time", "window", "(", "10", ",", "12", ")", ",", "merge", "function", ")", ";", "assert", "not", "null", "(", "window", "set", "get", "state", "window", "(", "result", ")", ")", ";", "}" ]
[ "obtain", "the", "<", "code", ">", "de", "select", "type", "<", "code", ">", "by", "the", "literals", "given", "behind", "<", "code", ">", "de", "selects", "<", "code", ">", "in", "url", "<", "br", ">", "e", "g", ":", "de", "selects", "=", "\"", "resource", "requests", "\"" ]
[ "public", "static", "de", "select", "type", "obtain", "type", "(", "string", "literals", ")", "{", "for", "(", "de", "select", "type", "type", ":", "values", "(", ")", ")", "{", "if", "(", "type", "literals", "equals", "ignore", "case", "(", "literals", ")", ")", "{", "return", "type", ";", "}", "}", "return", "null", ";", "}" ]
[ "accept", "the", "source", "type", "and", "target", "type", "or", "not" ]
[ "default", "boolean", "accept", "(", "class", "<", "?", ">", "source", "type", ",", "class", "<", "?", ">", "target", "type", ")", "{", "return", "is", "assignable", "from", "(", "source", "type", ",", "get", "source", "type", "(", ")", ")", "&", "&", "is", "assignable", "from", "(", "target", "type", ",", "get", "target", "type", "(", ")", ")", ";", "}" ]
[ "advanced", "configuration", "option", "the", "number", "of", "days", "for", "which", "job", "results", "are", "retained", "updates", "the", "{", "@", "link", "job", "#", "results", "retention", "days", "}", "setting" ]
[ "public", "builder", "set", "results", "retention", "days", "(", "long", "results", "retention", "days", ")", "{", "this", "results", "retention", "days", "=", "results", "retention", "days", ";", "return", "this", ";", "}" ]
[ "fields", "that", "have", "to", "be", "ignored", "when", "shuffling", "as", "part", "of", "test", "from", "x", "content" ]
[ "protected", "string", "[", "]", "get", "shuffle", "fields", "exceptions", "(", ")", "{", "return", "strings", "empty", "array", ";", "}" ]
[ "display", "the", "\"", "save", "tool", "configuration", "as", "\"", "dialog", ";", "blocks", "until", "user", "hits", "the", "\"", "cancel", "\"", "button" ]
[ "public", "void", "show", "(", "string", "name", ",", "string", "new", "default", "name", ")", "{", "this", "default", "name", "=", "new", "default", "name", ";", "did", "cancel", "=", "false", ";", "icon", "list", "model", "remove", "all", "elements", "(", ")", ";", "load", "icons", "(", ")", ";", "tool", "template", "[", "]", "template", "=", "tool", "chest", "get", "tool", "templates", "(", ")", ";", "for", "(", "tool", "template", "element", ":", "template", ")", "{", "tool", "icon", "u", "r", "l", "icon", "url", "=", "(", "(", "ghidra", "tool", "template", ")", "element", ")", "get", "icon", "u", "r", "l", "(", ")", ";", "update", "map", "(", "icon", "url", ")", ";", "}", "name", "field", "set", "text", "(", "new", "default", "name", ")", ";", "set", "focus", "component", "(", "name", "field", ")", ";", "name", "field", "select", "all", "(", ")", ";", "tool", "icon", "u", "r", "l", "icon", "url", "=", "tool", "get", "icon", "u", "r", "l", "(", ")", ";", "icon", "icon", "=", "icon", "url", "get", "icon", "(", ")", ";", "string", "icon", "name", "=", "null", ";", "if", "(", "icon", "!", "=", "null", ")", "{", "string", "location", "=", "icon", "url", "get", "location", "(", ")", ";", "file", "file", "=", "new", "file", "(", "location", ")", ";", "if", "(", "file", "exists", "(", ")", ")", "{", "icon", "name", "=", "location", ";", "}", "else", "{", "icon", "name", "=", "resource", "manager", "get", "icon", "name", "(", "icon", ")", ";", "}", "icon", "field", "set", "text", "(", "icon", "name", ")", ";", "update", "map", "(", "icon", "url", ")", ";", "}", "load", "icons", "(", ")", ";", "if", "(", "icon", "name", "!", "=", "null", ")", "{", "icon", "list", "set", "selected", "value", "(", "icon", "url", ",", "true", ")", ";", "}", "tool", "show", "dialog", "(", "this", ")", ";", "}" ]
[ "add", "a", "archive", "that", "has", "been", "localized", "to", "the", "conf", "used", "by", "internal", "distributed", "cache", "code" ]
[ "public", "static", "void", "add", "local", "archives", "(", "configuration", "conf", ",", "string", "str", ")", "{", "string", "archives", "=", "conf", "get", "(", "cache", "localarchives", ")", ";", "conf", "set", "(", "cache", "localarchives", ",", "archives", "=", "=", "null", "?", "str", ":", "archives", "+", "\"", ",", "\"", "+", "str", ")", ";", "}" ]
[ "set", "the", "number", "of", "units", "in", "a", "group", "this", "format", "does", "not", "support", "groups" ]
[ "public", "void", "set", "group", "size", "(", "int", "group", "size", ")", "{", "throw", "new", "unsupported", "operation", "exception", "(", "\"", "groups", "are", "not", "supported", "\"", ")", ";", "}" ]
[ "format", "url", "template", "using", "default", "server", "variables" ]
[ "public", "string", "url", "(", ")", "{", "return", "url", "(", "null", ")", ";", "}" ]
[ "postmultiplies", "this", "matrix", "with", "the", "provided", "matrix", "and", "stores", "the", "result", "in", "this", "matrix", "for", "example", ":", "a", "mul", "(", "b", ")", "results", "in", "a", ":", "=", "ab" ]
[ "public", "matrix", "3", "mul", "(", "matrix", "3", "m", ")", "{", "float", "[", "]", "val", "=", "this", "val", ";", "float", "v", "0", "0", "=", "val", "[", "m00", "]", "*", "m", "val", "[", "m00", "]", "+", "val", "[", "m01", "]", "*", "m", "val", "[", "m10", "]", "+", "val", "[", "m02", "]", "*", "m", "val", "[", "m20", "]", ";", "float", "v", "0", "1", "=", "val", "[", "m00", "]", "*", "m", "val", "[", "m01", "]", "+", "val", "[", "m01", "]", "*", "m", "val", "[", "m11", "]", "+", "val", "[", "m02", "]", "*", "m", "val", "[", "m21", "]", ";", "float", "v", "0", "2", "=", "val", "[", "m00", "]", "*", "m", "val", "[", "m02", "]", "+", "val", "[", "m01", "]", "*", "m", "val", "[", "m12", "]", "+", "val", "[", "m02", "]", "*", "m", "val", "[", "m22", "]", ";", "float", "v", "1", "0", "=", "val", "[", "m10", "]", "*", "m", "val", "[", "m00", "]", "+", "val", "[", "m11", "]", "*", "m", "val", "[", "m10", "]", "+", "val", "[", "m12", "]", "*", "m", "val", "[", "m20", "]", ";", "float", "v", "1", "1", "=", "val", "[", "m10", "]", "*", "m", "val", "[", "m01", "]", "+", "val", "[", "m11", "]", "*", "m", "val", "[", "m11", "]", "+", "val", "[", "m12", "]", "*", "m", "val", "[", "m21", "]", ";", "float", "v", "1", "2", "=", "val", "[", "m10", "]", "*", "m", "val", "[", "m02", "]", "+", "val", "[", "m11", "]", "*", "m", "val", "[", "m12", "]", "+", "val", "[", "m12", "]", "*", "m", "val", "[", "m22", "]", ";", "float", "v", "2", "0", "=", "val", "[", "m20", "]", "*", "m", "val", "[", "m00", "]", "+", "val", "[", "m21", "]", "*", "m", "val", "[", "m10", "]", "+", "val", "[", "m22", "]", "*", "m", "val", "[", "m20", "]", ";", "float", "v", "2", "1", "=", "val", "[", "m20", "]", "*", "m", "val", "[", "m01", "]", "+", "val", "[", "m21", "]", "*", "m", "val", "[", "m11", "]", "+", "val", "[", "m22", "]", "*", "m", "val", "[", "m21", "]", ";", "float", "v", "2", "2", "=", "val", "[", "m20", "]", "*", "m", "val", "[", "m02", "]", "+", "val", "[", "m21", "]", "*", "m", "val", "[", "m12", "]", "+", "val", "[", "m22", "]", "*", "m", "val", "[", "m22", "]", ";", "val", "[", "m00", "]", "=", "v", "0", "0", ";", "val", "[", "m10", "]", "=", "v", "1", "0", ";", "val", "[", "m20", "]", "=", "v", "2", "0", ";", "val", "[", "m01", "]", "=", "v", "0", "1", ";", "val", "[", "m11", "]", "=", "v", "1", "1", ";", "val", "[", "m21", "]", "=", "v", "2", "1", ";", "val", "[", "m02", "]", "=", "v", "0", "2", ";", "val", "[", "m12", "]", "=", "v", "1", "2", ";", "val", "[", "m22", "]", "=", "v", "2", "2", ";", "return", "this", ";", "}" ]
[ "get", "enum", "number" ]
[ "public", "enum", "number", "enum", "get", "enum", "number", "(", ")", "{", "return", "enum", "number", ";", "}" ]
[ "runs", "a", "new", "plugin", "instance" ]
[ "public", "static", "void", "run", "plugin", "(", "plugin", "new", "plugin", "instance", ")", "{", "if", "(", "plugin", "instance", "=", "=", "null", "|", "|", "plugin", "instance", "is", "finished", "(", ")", ")", "{", "plugin", "instance", "=", "new", "plugin", "instance", ";", "plugin", "instance", "start", "(", ")", ";", "/", "/", "start", "the", "thread", "}", "else", "if", "(", "!", "plugin", "instance", "is", "finished", "(", ")", ")", "{", "bytecode", "viewer", "show", "message", "(", "\"", "there", "is", "currently", "another", "plugin", "running", "right", "now", ",", "please", "wait", "for", "that", "to", "finish", "executing", "\"", ")", ";", "}", "}" ]
[ "sets", "the", "indices", "the", "count", "will", "be", "executed", "on" ]
[ "public", "count", "request", "indices", "(", "string", "indices", ")", "{", "objects", "require", "non", "null", "(", "indices", ",", "\"", "indices", "must", "not", "be", "null", "\"", ")", ";", "for", "(", "string", "index", ":", "indices", ")", "{", "objects", "require", "non", "null", "(", "index", ",", "\"", "index", "must", "not", "be", "null", "\"", ")", ";", "}", "this", "indices", "=", "indices", ";", "return", "this", ";", "}" ]
[ "return", "{", "@", "code", "o", "}", "as", "an", "instance", "of", "the", "element", "type", "{", "@", "code", "t", "}", "if", "{", "@", "code", "o", "}", "is", "non", "-", "null", "but", "known", "to", "not", "be", "an", "instance", "of", "{", "@", "code", "t", "}", ",", "this", "method", "returns", "{", "@", "code", "null", "}", "the", "base", "implementation", "does", "not", "perform", "any", "type", "checks", ";", "override", "this", "method", "to", "provide", "strong", "type", "checks", "for", "the", "{", "@", "link", "#", "contains", "}", "and", "{", "@", "link", "#", "remove", "}", "methods", "to", "ensure", "the", "arguments", "to", "the", "{", "@", "link", "equality", "comparator", "}", "for", "the", "set", "always", "have", "the", "expected", "types" ]
[ "protected", "t", "as", "element", "type", "(", "object", "o", ")", "{", "return", "(", "t", ")", "o", ";", "}" ]
[ "sets", "the", "position", "on", "the", "x", "axis" ]
[ "public", "void", "set", "x", "(", "float", "x", ")", "{", "this", "position", "x", "=", "x", ";", "updated", "=", "false", ";", "}" ]
[ "returns", "a", "short", "-", "hand", "representation", "of", "the", "contents", "such", "as", "{", "@", "code", "\"", "[", "1", "100", "]", "\"", "}" ]
[ "public", "string", "to", "string", "(", ")", "{", "return", "range", "(", ")", "to", "string", "(", ")", ";", "}" ]
[ "returns", "whether", "this", "predicate", "can", "be", "used", "while", "simplifying", "other", "or", "operands" ]
[ "default", "boolean", "allowed", "in", "or", "(", "rel", "opt", "predicate", "list", "predicates", ")", "{", "return", "true", ";", "}" ]
[ "get", "name", "with", "parameters" ]
[ "public", "string", "get", "plain", "node", "name", "(", "boolean", "use", "simple", "name", ",", "boolean", "show", "defaults", ")", "{", "d", "b", "s", "object", "object", "=", "get", "object", "(", ")", ";", "if", "(", "object", "=", "=", "null", ")", "{", "return", "show", "defaults", "?", "d", "b", "constants", "null", "value", "label", ":", "null", ";", "}", "string", "object", "name", ";", "if", "(", "!", "use", "simple", "name", "&", "&", "object", "instanceof", "d", "b", "p", "overloaded", "object", ")", "{", "object", "name", "=", "(", "(", "d", "b", "p", "overloaded", "object", ")", "object", ")", "get", "overloaded", "name", "(", ")", ";", "}", "else", "{", "object", "name", "=", "object", "get", "name", "(", ")", ";", "}", "if", "(", "show", "defaults", "&", "&", "common", "utils", "is", "empty", "(", "object", "name", ")", ")", "{", "object", "name", "=", "object", "to", "string", "(", ")", ";", "if", "(", "common", "utils", "is", "empty", "(", "object", "name", ")", ")", "{", "object", "name", "=", "object", "get", "class", "(", ")", "get", "name", "(", ")", "+", "\"", "@", "\"", "+", "object", "hash", "code", "(", ")", ";", "/", "/", "$", "non", "-", "nls", "-", "1", "$", "}", "}", "/", "*", "if", "(", "object", "instanceof", "d", "b", "p", "unique", "object", ")", "{", "string", "unique", "name", "=", "(", "(", "d", "b", "p", "unique", "object", ")", "object", ")", "get", "unique", "name", "(", ")", ";", "if", "(", "!", "unique", "name", "equals", "(", "object", "name", ")", ")", "{", "if", "(", "unique", "name", "starts", "with", "(", "object", "name", ")", ")", "{", "unique", "name", "=", "unique", "name", "substring", "(", "object", "name", "length", "(", ")", ")", ";", "}", "object", "name", "+", "=", "\"", "(", "\"", "+", "unique", "name", "+", "\"", ")", "\"", ";", "}", "}", "*", "/", "return", "object", "name", ";", "}" ]
[ "create", "a", "local", "map", "output", "index", "file", "name" ]
[ "public", "path", "get", "output", "index", "file", "for", "write", "(", "long", "size", ")", "throws", "i", "o", "exception", "{", "return", "l", "dir", "alloc", "get", "local", "path", "for", "write", "(", "m", "r", "job", "config", "output", "+", "path", "separator", "+", "map", "output", "filename", "string", "+", "map", "output", "index", "suffix", "string", ",", "size", ",", "get", "conf", "(", ")", ")", ";", "}" ]
[ "create", "action", "objects", "to", "be", "contributed", "to", "the", "owner", "{", "@", "link", "fingerprint", "}", "by", "default", ",", "creates", "no", "actions", "{", "@", "link", "fingerprint", "}", "calls", "this", "method", "for", "every", "{", "@", "link", "fingerprint", "facet", "}", "that", "it", "owns", "when", "the", "rendering", "is", "requested" ]
[ "public", "void", "create", "actions", "(", "list", "<", "action", ">", "result", ")", "{", "/", "/", "create", "no", "actions", "by", "default", "}" ]
[ "convert", "the", "given", "object", "to", "string", "with", "each", "line", "indented", "by", "4", "spaces", "(", "except", "the", "first", "line", ")" ]
[ "private", "string", "to", "indented", "string", "(", "object", "o", ")", "{", "if", "(", "o", "=", "=", "null", ")", "{", "return", "\"", "null", "\"", ";", "}", "return", "o", "to", "string", "(", ")", "replace", "(", "\"", "\\", "n", "\"", ",", "\"", "\\", "n", "\"", ")", ";", "}" ]
[ "flag", "to", "indicate", "received", "any" ]
[ "public", "void", "reset", "n", "m", "heartbeat", "receive", "flag", "(", ")", "{", "synchronized", "(", "resource", "tracker", "for", "labels", "class", ")", "{", "received", "n", "m", "heartbeat", "=", "false", ";", "}", "}" ]
[ "returns", "a", "suitable", "string", "for", "the", "user", "-", "friendly", "representation", "of", "the", "label", "works", "even", "if", "the", "argument", "is", "null" ]
[ "public", "static", "string", "print", "(", "@", "nullable", "label", "label", ")", "{", "return", "label", "=", "=", "null", "?", "\"", "(", "unknown", ")", "\"", ":", "label", "to", "string", "(", ")", ";", "}" ]
[ "set", "target", "method", "name" ]
[ "public", "void", "set", "method", "name", "(", "string", "method", "name", ")", "{", "set", "(", "method", "name", ",", "method", "name", ")", ";", "}" ]
[ "convert", "a", "list", "of", "jdbc", "types", ",", "as", "defined", "in", "{", "@", "code", "java", "sql", "types", "}", ",", "to", "a", "list", "of", "sql", "parameter", "objects", "as", "used", "in", "this", "package" ]
[ "public", "static", "list", "<", "sql", "parameter", ">", "sql", "types", "to", "anonymous", "parameter", "list", "(", "@", "nullable", "int", "types", ")", "{", "if", "(", "types", "=", "=", "null", ")", "{", "return", "new", "array", "list", "<", ">", "(", ")", ";", "}", "list", "<", "sql", "parameter", ">", "result", "=", "new", "array", "list", "<", ">", "(", "types", "length", ")", ";", "for", "(", "int", "type", ":", "types", ")", "{", "result", "add", "(", "new", "sql", "parameter", "(", "type", ")", ")", ";", "}", "return", "result", ";", "}" ]
[ "support", "removal", "operations", "when", "filtering", "a", "filtered", "multimap", "since", "a", "filtered", "multimap", "has", "iterators", "that", "don", "'", "t", "support", "remove", ",", "passing", "one", "to", "the", "filtered", "entry", "multimap", "constructor", "would", "lead", "to", "a", "multimap", "whose", "removal", "operations", "would", "fail", "this", "method", "combines", "the", "predicates", "to", "avoid", "that", "problem" ]
[ "private", "static", "<", "k", ",", "v", ">", "set", "multimap", "<", "k", ",", "v", ">", "filter", "filtered", "(", "filtered", "set", "multimap", "<", "k", ",", "v", ">", "multimap", ",", "predicate", "<", "?", "super", "entry", "<", "k", ",", "v", ">", ">", "entry", "predicate", ")", "{", "predicate", "<", "entry", "<", "k", ",", "v", ">", ">", "predicate", "=", "predicates", "<", "entry", "<", "k", ",", "v", ">", ">", "and", "(", "multimap", "entry", "predicate", "(", ")", ",", "entry", "predicate", ")", ";", "return", "new", "filtered", "entry", "set", "multimap", "<", ">", "(", "multimap", "unfiltered", "(", ")", ",", "predicate", ")", ";", "}" ]
[ "ensure", "that", "the", "service", "is", "found", "and", "enabled", "in", "the", "service", "registry" ]
[ "private", "static", "void", "verify", "registered", "service", "properties", "(", "final", "registered", "service", "registered", "service", ",", "final", "service", "service", ")", "{", "if", "(", "registered", "service", "=", "=", "null", ")", "{", "val", "msg", "=", "string", "format", "(", "\"", "service", "[", "%", "s", "]", "is", "not", "found", "in", "service", "registry", "\"", ",", "service", "get", "id", "(", ")", ")", ";", "logger", "warn", "(", "msg", ")", ";", "throw", "new", "unauthorized", "service", "exception", "(", "unauthorized", "service", "exception", "code", "unauthz", "service", ",", "msg", ")", ";", "}", "if", "(", "!", "registered", "service", "get", "access", "strategy", "(", ")", "is", "service", "access", "allowed", "(", ")", ")", "{", "val", "msg", "=", "string", "format", "(", "\"", "service", "management", ":", "unauthorized", "service", "access", "\"", "+", "\"", "service", "[", "%", "s", "]", "is", "not", "enabled", "in", "the", "cas", "service", "registry", "\"", ",", "service", "get", "id", "(", ")", ")", ";", "logger", "warn", "(", "msg", ")", ";", "throw", "new", "unauthorized", "service", "exception", "(", "unauthorized", "service", "exception", "code", "unauthz", "service", ",", "msg", ")", ";", "}", "}" ]
[ "guess", "content", "-", "type", "header", "from", "the", "given", "file", "(", "defaults", "to", "\"", "applicationoctet", "-", "stream", "\"", ")" ]
[ "public", "string", "guess", "content", "type", "from", "file", "(", "file", "file", ")", "{", "string", "content", "type", "=", "u", "r", "l", "connection", "guess", "content", "type", "from", "name", "(", "file", "get", "name", "(", ")", ")", ";", "if", "(", "content", "type", "=", "=", "null", ")", "{", "return", "\"", "application", "/", "octet", "-", "stream", "\"", ";", "}", "else", "{", "return", "content", "type", ";", "}", "}" ]
[ "returns", "the", "error", "stream" ]
[ "public", "string", "to", "string", "(", ")", "{", "return", "sbe", "to", "string", "(", ")", ";", "}" ]
[ "get", "date", "time" ]
[ "public", "offset", "date", "time", "get", "date", "time", "(", ")", "{", "return", "date", "time", ";", "}" ]
[ "wraps", "a", "{", "@", "link", "input", "stream", "}", ",", "limiting", "the", "number", "of", "bytes", "which", "can", "be", "read" ]
[ "public", "static", "input", "stream", "limit", "(", "input", "stream", "in", ",", "long", "limit", ")", "{", "return", "new", "limited", "input", "stream", "(", "in", ",", "limit", ")", ";", "}" ]
[ "called", "when", "this", "task", "is", "the", "task", "that", "is", "currently", "being", "processed", "and", "it", "is", "unloaded" ]
[ "public", "void", "unload", "(", ")", "{", "if", "(", "loader", "instanceof", "asynchronous", "asset", "loader", ")", "(", "(", "asynchronous", "asset", "loader", ")", "loader", ")", "unload", "async", "(", "manager", ",", "asset", "desc", "file", "name", ",", "resolve", "(", "loader", ",", "asset", "desc", ")", ",", "asset", "desc", "params", ")", ";", "}" ]
[ "handle", "data", "node", ",", "according", "to", "probe", "result", "when", "probe", "type", "is", "check", "dead", ",", "remove", "the", "datanode", "from", "dead", "node", "detector", "#", "dead", "nodes", "if", "probe", "success" ]
[ "private", "void", "probe", "call", "back", "(", "probe", "probe", ",", "boolean", "success", ")", "{", "log", "debug", "(", "\"", "probe", "datanode", ":", "{", "}", "result", ":", "{", "}", ",", "type", ":", "{", "}", "\"", ",", "probe", "get", "datanode", "info", "(", ")", ",", "success", ",", "probe", "get", "type", "(", ")", ")", ";", "probe", "in", "prog", "remove", "(", "probe", "get", "datanode", "info", "(", ")", "get", "datanode", "uuid", "(", ")", ")", ";", "if", "(", "success", ")", "{", "if", "(", "probe", "get", "type", "(", ")", "=", "=", "probe", "type", "check", "dead", ")", "{", "log", "info", "(", "\"", "remove", "the", "node", "out", "from", "dead", "node", "list", ":", "{", "}", "\"", ",", "probe", "get", "datanode", "info", "(", ")", ")", ";", "remove", "dead", "node", "(", "probe", "get", "datanode", "info", "(", ")", ")", ";", "}", "else", "if", "(", "probe", "get", "type", "(", ")", "=", "=", "probe", "type", "check", "suspect", ")", "{", "log", "debug", "(", "\"", "remove", "the", "node", "out", "from", "suspect", "node", "list", ":", "{", "}", "\"", ",", "probe", "get", "datanode", "info", "(", ")", ")", ";", "remove", "node", "from", "dead", "node", "detector", "(", "probe", "get", "datanode", "info", "(", ")", ")", ";", "}", "}", "else", "{", "if", "(", "probe", "get", "type", "(", ")", "=", "=", "probe", "type", "check", "suspect", ")", "{", "log", "warn", "(", "\"", "probe", "failed", ",", "add", "suspect", "node", "to", "dead", "node", "list", ":", "{", "}", "\"", ",", "probe", "get", "datanode", "info", "(", ")", ")", ";", "add", "to", "dead", "(", "probe", "get", "datanode", "info", "(", ")", ")", ";", "}", "}", "}" ]
[ "restrict", "the", "motion", "of", "the", "dragged", "child", "view", "along", "the", "horizontal", "axis", "the", "default", "implementation", "does", "not", "allow", "horizontal", "motion", ";", "the", "extending", "class", "must", "override", "this", "method", "and", "provide", "the", "desired", "clamping" ]
[ "public", "int", "clamp", "view", "position", "horizontal", "(", "view", "child", ",", "int", "left", ",", "int", "dx", ")", "{", "return", "0", ";", "}" ]
[ "creates", "a", "{", "@", "link", "private", "key", "}", "from", "the", "contents", "of", "{", "@", "code", "b", "reader", "}", "that", "contains", "an", "dsa", "private", "key", "encoded", "in", "open", "s", "s", "l", "traditional", "format" ]
[ "private", "static", "private", "key", "parse", "open", "ssl", "dsa", "(", "buffered", "reader", "b", "reader", ",", "supplier", "<", "char", "[", "]", ">", "password", "supplier", ")", "throws", "i", "o", "exception", ",", "general", "security", "exception", "{", "string", "builder", "sb", "=", "new", "string", "builder", "(", ")", ";", "string", "line", "=", "b", "reader", "read", "line", "(", ")", ";", "map", "<", "string", ",", "string", ">", "pem", "headers", "=", "new", "hash", "map", "<", ">", "(", ")", ";", "while", "(", "line", "!", "=", "null", ")", "{", "if", "(", "openssl", "dsa", "footer", "equals", "(", "line", "trim", "(", ")", ")", ")", "{", "/", "/", "unencrypted", "break", ";", "}", "/", "/", "parse", "pem", "headers", "according", "to", "https", ":", "/", "/", "www", "ietf", "org", "/", "rfc", "/", "rfc", "1", "4", "2", "1", "txt", "if", "(", "line", "contains", "(", "\"", ":", "\"", ")", ")", "{", "string", "[", "]", "header", "=", "line", "split", "(", "\"", ":", "\"", ")", ";", "pem", "headers", "put", "(", "header", "[", "0", "]", "trim", "(", ")", ",", "header", "[", "1", "]", "trim", "(", ")", ")", ";", "}", "else", "{", "sb", "append", "(", "line", "trim", "(", ")", ")", ";", "}", "line", "=", "b", "reader", "read", "line", "(", ")", ";", "}", "if", "(", "null", "=", "=", "line", "|", "|", "openssl", "dsa", "footer", "equals", "(", "line", "trim", "(", ")", ")", "=", "=", "false", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "malformed", "pem", "file", ",", "pem", "footer", "is", "invalid", "or", "missing", "\"", ")", ";", "}", "byte", "[", "]", "key", "bytes", "=", "possibly", "decrypt", "p", "k", "c", "s", "1", "key", "(", "pem", "headers", ",", "sb", "to", "string", "(", ")", ",", "password", "supplier", ")", ";", "d", "s", "a", "private", "key", "spec", "spec", "=", "parse", "dsa", "der", "(", "key", "bytes", ")", ";", "key", "factory", "key", "factory", "=", "key", "factory", "get", "instance", "(", "\"", "dsa", "\"", ")", ";", "return", "key", "factory", "generate", "private", "(", "spec", ")", ";", "}" ]
[ "this", "is", "used", "when", "the", "license", "expires" ]
[ "public", "void", "stop", "all", "datafeeds", "on", "this", "node", "(", "string", "reason", ")", "{", "int", "num", "datafeeds", "=", "running", "datafeeds", "on", "this", "node", "size", "(", ")", ";", "if", "(", "num", "datafeeds", "!", "=", "0", ")", "{", "logger", "info", "(", "\"", "closing", "[", "{", "}", "]", "datafeeds", ",", "because", "[", "{", "}", "]", "\"", ",", "num", "datafeeds", ",", "reason", ")", ";", "for", "(", "holder", "holder", ":", "running", "datafeeds", "on", "this", "node", "values", "(", ")", ")", "{", "holder", "stop", "(", "reason", ",", "time", "value", "time", "value", "seconds", "(", "20", ")", ",", "null", ")", ";", "}", "}", "}" ]
[ "returns", "true", "if", "this", "dep", "group", "consists", "of", "the", "error", "transience", "value", "and", "the", "error", "transience", "value", "is", "newer", "than", "the", "entry", ",", "meaning", "that", "the", "entry", "must", "be", "re", "-", "evaluated" ]
[ "private", "boolean", "invalidated", "by", "error", "transience", "(", "collection", "<", "sky", "key", ">", "dep", "group", ",", "node", "entry", "entry", ")", "throws", "interrupted", "exception", "{", "return", "dep", "group", "size", "(", ")", "=", "=", "1", "&", "&", "dep", "group", "contains", "(", "error", "transience", "value", "key", ")", "&", "&", "!", "graph", "get", "(", "null", ",", "reason", "other", ",", "error", "transience", "value", "key", ")", "get", "version", "(", ")", "at", "most", "(", "entry", "get", "version", "(", ")", ")", ";", "}" ]
[ "validate", "repository", "name" ]
[ "private", "void", "validate", "rep", "name", "(", "string", "[", "]", "args", ",", "int", "i", ",", "file", "root", "dir", "file", ")", "{", "if", "(", "args", "length", "<", "(", "i", "+", "1", ")", ")", "{", "display", "usage", "(", "\"", "invalid", "usage", "!", "\"", ")", ";", "system", "exit", "(", "-", "1", ")", ";", "}", "string", "rep", "name", "=", "args", "[", "i", "]", ";", "file", "f", "=", "new", "file", "(", "root", "dir", "file", ",", "naming", "utilities", "mangle", "(", "rep", "name", ")", ")", ";", "if", "(", "!", "f", "is", "directory", "(", ")", ")", "{", "msg", "error", "(", "user", "admin", "class", ",", "\"", "repository", "not", "found", ":", "\"", "+", "rep", "name", ")", ";", "system", "exit", "(", "-", "1", ")", ";", "}", "}" ]
[ "valid", "characters", "for", "consumer", "group", "instance", "id", "are", "the", "ascii", "alphanumerics", ",", "'", "'", ",", "'", "'", ",", "and", "'", "-", "'" ]
[ "static", "boolean", "contains", "valid", "pattern", "(", "string", "topic", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "topic", "length", "(", ")", ";", "+", "+", "i", ")", "{", "char", "c", "=", "topic", "char", "at", "(", "i", ")", ";", "boolean", "valid", "char", "=", "(", "c", ">", "=", "'", "a", "'", "&", "&", "c", "<", "=", "'", "z", "'", ")", "|", "|", "(", "c", ">", "=", "'", "0", "'", "&", "&", "c", "<", "=", "'", "9", "'", ")", "|", "|", "(", "c", ">", "=", "'", "a", "'", "&", "&", "c", "<", "=", "'", "z", "'", ")", "|", "|", "c", "=", "=", "'", "'", "|", "|", "c", "=", "=", "'", "'", "|", "|", "c", "=", "=", "'", "-", "'", ";", "if", "(", "!", "valid", "char", ")", "return", "false", ";", "}", "return", "true", ";", "}" ]
[ "test", "to", "verify", "cache", "behavior", "-", "-", "assert", "that", "put", "overwrites", "value", "if", "present" ]
[ "public", "void", "test", "cache", "put", "(", ")", "throws", "throwable", "{", "caching", "authorizer", "<", "string", ",", "integer", ">", "cache", "=", "new", "caching", "authorizer", "<", ">", "(", "dummy", "ttl", "value", ",", "\"", "test", "\"", ")", ";", "cache", "init", "(", "create", "configuration", "(", ")", ")", ";", "cache", "put", "(", "\"", "test", "\"", ",", "1", ")", ";", "cache", "put", "(", "\"", "test", "\"", ",", "3", ")", ";", "int", "result", "=", "cache", "get", "(", "\"", "test", "\"", ")", ";", "assert", "equals", "(", "\"", "cache", "returned", "unexpected", "result", "\"", ",", "3", ",", "result", ")", ";", "}" ]
[ "set", "the", "prefixes", "that", "identify", "single", "-", "line", "comments", "within", "the", "sql", "scripts", "defaults", "to", "{", "@", "code", "[", "\"", "-", "-", "\"", "]", "}" ]
[ "public", "void", "set", "comment", "prefixes", "(", "string", "comment", "prefixes", ")", "{", "assert", "not", "empty", "(", "comment", "prefixes", ",", "\"", "'", "comment", "prefixes", "'", "must", "not", "be", "null", "or", "empty", "\"", ")", ";", "assert", "no", "null", "elements", "(", "comment", "prefixes", ",", "\"", "'", "comment", "prefixes", "'", "must", "not", "contain", "null", "elements", "\"", ")", ";", "this", "comment", "prefixes", "=", "comment", "prefixes", ";", "}" ]
[ "calculates", "the", "password", "on", "the", "client", "side", "for", "the", "general", "-", "purpose", "handshake", "the", "password", "consists", "of", "the", "block", "access", "token", "'", "s", "password" ]
[ "private", "char", "[", "]", "build", "client", "password", "(", "token", "<", "block", "token", "identifier", ">", "block", "token", ")", "{", "return", "new", "string", "(", "base", "6", "4", "encode", "base", "6", "4", "(", "block", "token", "get", "password", "(", ")", ",", "false", ")", ",", "charsets", "utf", "8", ")", "to", "char", "array", "(", ")", ";", "}" ]
[ "returns", "the", "id", "of", "the", "async", "search" ]
[ "public", "string", "get", "id", "(", ")", "{", "return", "id", ";", "}" ]
[ "test", "{", "@", "link", "d", "f", "s", "striped", "input", "stream", "#", "get", "block", "at", "(", "long", ")", "}" ]
[ "public", "void", "test", "refresh", "block", "(", ")", "throws", "exception", "{", "final", "int", "num", "blocks", "=", "4", ";", "d", "f", "s", "test", "util", "create", "striped", "file", "(", "cluster", ",", "file", "path", ",", "null", ",", "num", "blocks", ",", "stripes", "per", "block", ",", "false", ",", "ec", "policy", ")", ";", "located", "blocks", "lbs", "=", "fs", "get", "client", "(", ")", "namenode", "get", "block", "locations", "(", "file", "path", "to", "string", "(", ")", ",", "0", ",", "block", "group", "size", "*", "num", "blocks", ")", ";", "final", "d", "f", "s", "striped", "input", "stream", "in", "=", "new", "d", "f", "s", "striped", "input", "stream", "(", "fs", "get", "client", "(", ")", ",", "file", "path", "to", "string", "(", ")", ",", "false", ",", "ec", "policy", ",", "null", ")", ";", "list", "<", "located", "block", ">", "lb", "list", "=", "lbs", "get", "located", "blocks", "(", ")", ";", "for", "(", "located", "block", "a", "lb", "list", ":", "lb", "list", ")", "{", "located", "striped", "block", "lsb", "=", "(", "located", "striped", "block", ")", "a", "lb", "list", ";", "located", "block", "[", "]", "blks", "=", "striped", "block", "util", "parse", "striped", "block", "group", "(", "lsb", ",", "cell", "size", ",", "data", "blocks", ",", "parity", "blocks", ")", ";", "for", "(", "int", "j", "=", "0", ";", "j", "<", "data", "blocks", ";", "j", "+", "+", ")", "{", "located", "block", "refreshed", "=", "in", "refresh", "located", "block", "(", "blks", "[", "j", "]", ")", ";", "assert", "equals", "(", "blks", "[", "j", "]", "get", "block", "(", ")", ",", "refreshed", "get", "block", "(", ")", ")", ";", "assert", "equals", "(", "blks", "[", "j", "]", "get", "start", "offset", "(", ")", ",", "refreshed", "get", "start", "offset", "(", ")", ")", ";", "assert", "array", "equals", "(", "blks", "[", "j", "]", "get", "locations", "(", ")", ",", "refreshed", "get", "locations", "(", ")", ")", ";", "}", "}", "}" ]
[ "returns", "a", "block", "that", "has", "an", "appended", "null", "at", "the", "end", ",", "no", "matter", "if", "the", "original", "block", "has", "null", "or", "not", "the", "original", "block", "won", "'", "t", "be", "modified" ]
[ "block", "append", "null", "(", ")", ";" ]
[ "base", "type", "defs", "with", "a", "non", "-", "standard", "name", "should", "resolve", "to", "a", "typedef", "that", "points", "to", "the", "ghidra", "basetype", "instance" ]
[ "public", "void", "test", "non", "standard", "base", "type", "name", "(", ")", "throws", "cancelled", "exception", ",", "i", "o", "exception", ",", "d", "w", "a", "r", "f", "exception", "{", "debug", "info", "entry", "base", "d", "i", "e", "=", "add", "base", "type", "(", "\"", "blah", "\"", ",", "4", ",", "d", "w", "a", "r", "f", "encoding", "dw", "ate", "signed", ",", "cu", ")", ";", "import", "all", "data", "types", "(", ")", ";", "type", "def", "dt", "=", "(", "type", "def", ")", "dwarf", "d", "t", "m", "get", "data", "type", "(", "base", "d", "i", "e", "get", "offset", "(", ")", ",", "null", ")", ";", "data", "type", "base", "type", "d", "t", "=", "dt", "get", "base", "data", "type", "(", ")", ";", "assert", "true", "(", "base", "type", "d", "t", "instanceof", "abstract", "integer", "data", "type", ")", ";", "assert", "true", "(", "(", "(", "abstract", "integer", "data", "type", ")", "base", "type", "d", "t", ")", "is", "signed", "(", ")", "=", "=", "true", ")", ";", "}" ]
[ "adds", "a", "route", "to", "the", "given", "handler", "function", "that", "handles", "all", "http", "{", "@", "code", "post", "}", "requests", "that", "match", "the", "given", "pattern" ]
[ "builder", "post", "(", "string", "pattern", ",", "handler", "function", "<", "server", "response", ">", "handler", "function", ")", ";" ]
[ "returns", "zero", "-", "based", "index", "of", "recently", "rendered", "frame", "in", "given", "loop", "or", "-", "1", "when", "drawable", "is", "recycled" ]
[ "public", "int", "get", "current", "frame", "index", "(", ")", "{", "return", "m", "native", "info", "handle", "get", "current", "frame", "index", "(", ")", ";", "}" ]
[ "writes", "the", "given", "character", "sequence", "to", "this", "sink" ]
[ "public", "void", "write", "(", "char", "sequence", "char", "sequence", ")", "throws", "i", "o", "exception", "{", "check", "not", "null", "(", "char", "sequence", ")", ";", "closer", "closer", "=", "closer", "create", "(", ")", ";", "try", "{", "writer", "out", "=", "closer", "register", "(", "open", "stream", "(", ")", ")", ";", "out", "append", "(", "char", "sequence", ")", ";", "out", "flush", "(", ")", ";", "/", "/", "https", ":", "/", "/", "code", "google", "com", "/", "p", "/", "guava", "-", "libraries", "/", "issues", "/", "detail", "?", "id", "=", "1330", "}", "catch", "(", "throwable", "e", ")", "{", "throw", "closer", "rethrow", "(", "e", ")", ";", "}", "finally", "{", "closer", "close", "(", ")", ";", "}", "}" ]
[ "converts", "a", "string", ",", "which", "should", "contain", "only", "ascii", "-", "representable", "characters", ",", "to", "a", "byte", "[", "]" ]
[ "static", "byte", "[", "]", "ascii", "(", "string", "string", ")", "{", "byte", "[", "]", "bytes", "=", "new", "byte", "[", "string", "length", "(", ")", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "string", "length", "(", ")", ";", "i", "+", "+", ")", "{", "bytes", "[", "i", "]", "=", "(", "byte", ")", "string", "char", "at", "(", "i", ")", ";", "}", "return", "bytes", ";", "}" ]
[ "the", "sink", ",", "acting", "as", "g", "r", "p", "c", "client", ",", "establishes", "a", "new", "resource", "stream", "with", "the", "source", "the", "sink", "sends", "request", "resources", "message", "to", "and", "receives", "resources", "messages", "from", "the", "source" ]
[ "public", "io", "grpc", "stub", "stream", "observer", "<", "com", "alibaba", "nacos", "istio", "model", "mcp", "request", "resources", ">", "establish", "resource", "stream", "(", "io", "grpc", "stub", "stream", "observer", "<", "com", "alibaba", "nacos", "istio", "model", "mcp", "resources", ">", "response", "observer", ")", "{", "return", "async", "bidi", "streaming", "call", "(", "get", "channel", "(", ")", "new", "call", "(", "get", "establish", "resource", "stream", "method", "(", ")", ",", "get", "call", "options", "(", ")", ")", ",", "response", "observer", ")", ";", "}" ]
[ "returns", "record", "associated", "with", "this", "match", "tag", "or", "null", "if", "the", "match", "tag", "has", "been", "deleted" ]
[ "d", "b", "record", "get", "record", "(", ")", "{", "return", "check", "is", "valid", "(", ")", "?", "record", ":", "null", ";", "}" ]
[ "typically", "name", "corresponds", "to", "annotation", "{", "@", "link", "metric", "#", "value", "(", ")", "}", "or", "the", "name", "of", "the", "class" ]
[ "string", "name", "(", ")", ";" ]
[ "returns", "true", "if", "this", "actor", "is", "a", "target", "actor", "for", "touch", "focus" ]
[ "public", "boolean", "is", "touch", "focus", "target", "(", ")", "{", "stage", "stage", "=", "get", "stage", "(", ")", ";", "if", "(", "stage", "=", "=", "null", ")", "return", "false", ";", "for", "(", "int", "i", "=", "0", ",", "n", "=", "stage", "touch", "focuses", "size", ";", "i", "<", "n", ";", "i", "+", "+", ")", "if", "(", "stage", "touch", "focuses", "get", "(", "i", ")", "target", "=", "=", "this", ")", "return", "true", ";", "return", "false", ";", "}" ]
[ "return", "true", "if", "this", "equilateral", "triangle", "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", ";", "}", "equilateral", "triangle", "equilateral", "triangle", "=", "(", "equilateral", "triangle", ")", "o", ";", "return", "objects", "equals", "(", "this", "shape", "type", ",", "equilateral", "triangle", "shape", "type", ")", "&", "&", "objects", "equals", "(", "this", "triangle", "type", ",", "equilateral", "triangle", "triangle", "type", ")", ";", "}" ]
[ "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", "custom", "package", "layout", "pattern", "view", "model", "on", "visibility", "changed", "(", "on", "model", "visibility", "changed", "listener", "<", "custom", "package", "layout", "pattern", "view", "model", ",", "custom", "package", "layout", "pattern", "view", ">", "listener", ")", "{", "on", "mutation", "(", ")", ";", "this", "on", "model", "visibility", "changed", "listener", "epoxy", "generated", "model", "=", "listener", ";", "return", "this", ";", "}" ]
[ "encode", "password", "string" ]
[ "protected", "string", "encode", "password", "(", "final", "string", "password", ")", "{", "return", "digest", "utils", "sha", "5", "1", "2", "(", "password", ")", ";", "}" ]
[ "register", "a", "listener", "that", "will", "be", "called", "when", "this", "model", "is", "unbound", "from", "a", "view", "the", "listener", "will", "contribute", "to", "this", "model", "'", "s", "hash", "code", "state", "per", "the", "{", "@", "link", "com", "airbnb", "epoxy", "epoxy", "attribute", "option", "#", "do", "not", "hash", "}", "rules", "you", "may", "clear", "the", "listener", "by", "setting", "a", "null", "value", ",", "or", "by", "calling", "{", "@", "link", "#", "reset", "(", ")", "}" ]
[ "public", "model", "for", "r", "processing", "test", "on", "unbind", "(", "on", "model", "unbound", "listener", "<", "model", "for", "r", "processing", "test", ",", "object", ">", "listener", ")", "{", "on", "mutation", "(", ")", ";", "this", "on", "model", "unbound", "listener", "epoxy", "generated", "model", "=", "listener", ";", "return", "this", ";", "}" ]
[ "get", "plugin", "descriptor" ]
[ "private", "static", "idea", "plugin", "descriptor", "get", "plugin", "(", ")", "{", "return", "plugin", "manager", "core", "get", "plugin", "(", "plugin", "id", "get", "id", "(", "plugin", "id", ")", ")", ";", "}" ]
[ "get", "anytype", "3" ]
[ "public", "object", "get", "anytype", "3", "(", ")", "{", "return", "anytype", "3", ";", "}" ]
[ "a", "sensible", "definition", "of", "{", "@", "link", "#", "retain", "all", "}", "in", "terms", "of", "the", "{", "@", "code", "retain", "all", "}", "method", "of", "{", "@", "link", "#", "element", "set", "}", "if", "you", "override", "{", "@", "link", "#", "element", "set", "}", ",", "you", "may", "wish", "to", "override", "{", "@", "link", "#", "retain", "all", "}", "to", "forward", "to", "this", "implementation" ]
[ "protected", "boolean", "standard", "retain", "all", "(", "collection", "<", "?", ">", "elements", "to", "retain", ")", "{", "return", "multisets", "retain", "all", "impl", "(", "this", ",", "elements", "to", "retain", ")", ";", "}" ]
[ "query", "the", "world", "for", "all", "fixtures", "that", "potentially", "overlap", "the", "provided", "aabb" ]
[ "public", "void", "query", "a", "a", "b", "b", "(", "query", "callback", "callback", ",", "float", "lower", "x", ",", "float", "lower", "y", ",", "float", "upper", "x", ",", "float", "upper", "y", ")", "{", "query", "callback", "=", "callback", ";", "jni", "query", "a", "a", "b", "b", "(", "addr", ",", "lower", "x", ",", "lower", "y", ",", "upper", "x", ",", "upper", "y", ")", ";", "}" ]
[ "removes", "the", "drag", "-", "and", "-", "drop", "hooks", "from", "the", "component", "and", "optionally", "from", "the", "all", "children", "you", "should", "call", "this", "if", "you", "add", "and", "remove", "components", "after", "you", "'", "ve", "set", "up", "the", "drag", "-", "and", "-", "drop", "this", "will", "recursively", "unregister", "all", "components", "contained", "within", "<", "var", ">", "c", "<", "var", ">", "if", "<", "var", ">", "c", "<", "var", ">", "is", "a", "{", "@", "link", "java", "awt", "container", "}" ]
[ "public", "static", "boolean", "remove", "(", "final", "java", "awt", "component", "c", ")", "{", "return", "remove", "(", "null", ",", "c", ",", "true", ")", ";", "}", "/", "/", "end", "remove" ]
[ "updates", "a", "pet", "in", "the", "store", "with", "form", "data" ]
[ "public", "void", "update", "pet", "with", "form", "test", "(", ")", "{", "long", "pet", "id", "=", "null", ";", "string", "name", "=", "null", ";", "string", "status", "=", "null", ";", "api", "update", "pet", "with", "form", "(", "pet", "id", ",", "name", ",", "status", ")", "block", "(", ")", ";", "/", "/", "todo", ":", "test", "validations", "}" ]
[ "copies", "the", "bytes", "to", "one", "program", "from", "another", "for", "the", "specified", "set", "of", "address", "ranges" ]
[ "public", "static", "void", "copy", "bytes", "in", "ranges", "(", "program", "to", "program", ",", "program", "from", "program", ",", "address", "set", "view", "addr", "set", ",", "task", "monitor", "monitor", ")", "throws", "memory", "access", "exception", ",", "cancelled", "exception", "{", "memory", "to", "mem", "=", "to", "program", "get", "memory", "(", ")", ";", "memory", "from", "mem", "=", "from", "program", "get", "memory", "(", ")", ";", "/", "/", "copy", "each", "range", "address", "range", "iterator", "iter", "=", "addr", "set", "get", "address", "ranges", "(", ")", ";", "while", "(", "iter", "has", "next", "(", ")", ")", "{", "monitor", "check", "canceled", "(", ")", ";", "address", "range", "range", "=", "iter", "next", "(", ")", ";", "copy", "byte", "range", "(", "to", "mem", ",", "from", "mem", ",", "range", ")", ";", "}", "}" ]
[ "convert", "the", "given", "object", "to", "string", "with", "each", "line", "indented", "by", "4", "spaces", "(", "except", "the", "first", "line", ")" ]
[ "private", "string", "to", "indented", "string", "(", "object", "o", ")", "{", "if", "(", "o", "=", "=", "null", ")", "{", "return", "\"", "null", "\"", ";", "}", "return", "o", "to", "string", "(", ")", "replace", "(", "\"", "\\", "n", "\"", ",", "\"", "\\", "n", "\"", ")", ";", "}" ]
[ "gets", "the", "cluster", "high", "available", "storage", "path", "from", "the", "provided", "configuration", "the", "format", "is", "{", "@", "code", "ha", "storage", "pathha", "cluster", "id", "}" ]
[ "public", "static", "path", "get", "cluster", "high", "available", "storage", "path", "(", "configuration", "configuration", ")", "{", "final", "string", "storage", "path", "=", "configuration", "get", "value", "(", "high", "availability", "options", "ha", "storage", "path", ")", ";", "if", "(", "is", "null", "or", "whitespace", "only", "(", "storage", "path", ")", ")", "{", "throw", "new", "illegal", "configuration", "exception", "(", "\"", "configuration", "is", "missing", "the", "mandatory", "parameter", ":", "\"", "+", "high", "availability", "options", "ha", "storage", "path", ")", ";", "}", "final", "path", "path", ";", "try", "{", "path", "=", "new", "path", "(", "storage", "path", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "throw", "new", "illegal", "configuration", "exception", "(", "\"", "invalid", "path", "for", "highly", "available", "storage", "(", "\"", "+", "high", "availability", "options", "ha", "storage", "path", "key", "(", ")", "+", "'", ")", "'", ",", "e", ")", ";", "}", "final", "string", "cluster", "id", "=", "configuration", "get", "value", "(", "high", "availability", "options", "ha", "cluster", "id", ")", ";", "final", "path", "cluster", "storage", "path", ";", "try", "{", "cluster", "storage", "path", "=", "new", "path", "(", "path", ",", "cluster", "id", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "throw", "new", "illegal", "configuration", "exception", "(", "string", "format", "(", "\"", "cannot", "create", "cluster", "high", "available", "storage", "path", "'", "%", "s", "/", "%", "s", "'", "this", "indicates", "that", "an", "invalid", "cluster", "id", "(", "%", "s", ")", "has", "been", "specified", "\"", ",", "storage", "path", ",", "cluster", "id", ",", "high", "availability", "options", "ha", "cluster", "id", "key", "(", ")", ")", ",", "e", ")", ";", "}", "return", "cluster", "storage", "path", ";", "}" ]
[ "helper", "method", "to", "set", "the", "credentials", "for", "the", "first", "o", "auth", "2", "authentication" ]
[ "public", "api", "client", "set", "oauth", "credentials", "(", "string", "client", "id", ",", "string", "client", "secret", ")", "{", "for", "(", "authentication", "auth", ":", "authentications", "values", "(", ")", ")", "{", "if", "(", "auth", "instanceof", "o", "auth", ")", "{", "(", "(", "o", "auth", ")", "auth", ")", "set", "credentials", "(", "client", "id", ",", "client", "secret", ",", "is", "debugging", "(", ")", ")", ";", "return", "this", ";", "}", "}", "throw", "new", "runtime", "exception", "(", "\"", "no", "o", "auth", "2", "authentication", "configured", "!", "\"", ")", ";", "}" ]
[ "test", "without", "nested", "directory", "and", "recursive", "file", "enumeration", "=", "true" ]
[ "public", "void", "test", "no", "nested", "directory", "true", "(", ")", "{", "try", "{", "string", "file", "path", "=", "test", "file", "utils", "create", "temp", "file", "(", "\"", "foo", "\"", ")", ";", "this", "format", "set", "file", "path", "(", "new", "path", "(", "file", "path", ")", ")", ";", "this", "config", "set", "boolean", "(", "\"", "recursive", "file", "enumeration", "\"", ",", "true", ")", ";", "format", "configure", "(", "this", "config", ")", ";", "file", "input", "split", "[", "]", "splits", "=", "format", "create", "input", "splits", "(", "1", ")", ";", "assert", "assert", "equals", "(", "1", ",", "splits", "length", ")", ";", "}", "catch", "(", "exception", "ex", ")", "{", "ex", "print", "stack", "trace", "(", ")", ";", "assert", "fail", "(", "ex", "get", "message", "(", ")", ")", ";", "}", "}" ]
[ "sets", "the", "maximum", "weight", "for", "the", "sliding", "window" ]
[ "public", "builder", "set", "sliding", "window", "max", "weight", "(", "int", "sliding", "window", "max", "weight", ")", "{", "this", "sliding", "window", "max", "weight", "=", "sliding", "window", "max", "weight", ";", "return", "this", ";", "}" ]
[ "notifies", "the", "process", "engine", "that", "a", "signal", "event", "of", "name", "'", "signal", "name", "'", "has", "been", "received", "this", "method", "delivers", "the", "signal", "to", "all", "executions", "waiting", "on", "the", "signal", "<", "p", ">", "note", ":", "the", "waiting", "executions", "are", "notified", "synchronously" ]
[ "void", "signal", "event", "received", "(", "string", "signal", "name", ")", ";" ]
[ "method", "that", "provides", "execution", "of", "the", "insert", "using", "the", "passed", "-", "in", "map", "of", "parameters", "and", "returning", "a", "generated", "key" ]
[ "protected", "number", "do", "execute", "and", "return", "key", "(", "map", "<", "string", ",", "?", ">", "args", ")", "{", "check", "compiled", "(", ")", ";", "list", "<", "object", ">", "values", "=", "match", "in", "parameter", "values", "with", "insert", "columns", "(", "args", ")", ";", "return", "execute", "insert", "and", "return", "key", "internal", "(", "values", ")", ";", "}" ]
[ "test", "a", "semaphore", "command", "execution", "that", "fails", "synchronously", "but", "has", "a", "fallback" ]
[ "public", "void", "test", "semaphore", "isolated", "observe", "sync", "failure", "with", "fallback", "(", ")", "{", "test", "observe", "failure", "with", "fallback", "(", "execution", "isolation", "strategy", "semaphore", ",", "false", ")", ";", "}" ]
[ "return", "the", "single", "{", "@", "link", "cache", "disk", "utils", "}", "instance", "cache", "size", ":", "unlimited", "cache", "count", ":", "unlimited" ]
[ "public", "static", "cache", "disk", "utils", "get", "instance", "(", "@", "non", "null", "final", "file", "cache", "dir", ")", "{", "return", "get", "instance", "(", "cache", "dir", ",", "default", "max", "size", ",", "default", "max", "count", ")", ";", "}" ]
[ "set", "the", "set", "of", "stopwords", "any", "word", "in", "this", "set", "is", "considered", "\"", "uninteresting", "\"", "and", "ignored", "even", "if", "your", "analyzer", "allows", "stopwords", ",", "you", "might", "want", "to", "tell", "the", "more", "like", "this", "code", "to", "ignore", "them", ",", "as", "for", "the", "purposes", "of", "document", "similarity", "it", "seems", "reasonable", "to", "assume", "that", "\"", "a", "stop", "word", "is", "never", "interesting", "\"" ]
[ "public", "void", "set", "stop", "words", "(", "set", "<", "?", ">", "stop", "words", ")", "{", "this", "stop", "words", "=", "stop", "words", ";", "}" ]
[ "closes", "all", "the", "resources", "allocated", "and", "used", "by", "this", "resolver" ]
[ "void", "close", "(", ")", ";" ]
[ "returns", "an", "{", "@", "link", "element", "order", "}", "that", "specifies", "the", "order", "of", "iteration", "for", "the", "elements", "of", "{", "@", "link", "#", "edges", "(", ")", "}", ",", "{", "@", "link", "#", "adjacent", "nodes", "(", "object", ")", "}", ",", "{", "@", "link", "#", "predecessors", "(", "object", ")", "}", ",", "{", "@", "link", "#", "successors", "(", "object", ")", "}", "and", "{", "@", "link", "#", "incident", "edges", "(", "object", ")", "}" ]
[ "element", "order", "<", "n", ">", "incident", "edge", "order", "(", ")", ";", "/", "/", "/", "/", "element", "-", "level", "accessors", "/", "/" ]
[ "{", "@", "link", "com", "alibaba", "csp", "sentinel", "command", "handler", "fetch", "active", "rule", "command", "handler", "}" ]
[ "public", "void", "test", "fetch", "active", "rule", "command", "invalid", "type", "(", ")", "{", "string", "http", "request", "str", "=", "\"", "get", "/", "get", "rules", "http", "/", "1", "1", "\"", "+", "crlf", "+", "\"", "host", ":", "localhost", ":", "8719", "\"", "+", "crlf", "+", "crlf", ";", "string", "expected", "body", "=", "\"", "invalid", "type", "\"", ";", "process", "failed", "(", "http", "request", "str", ",", "expected", "body", ")", ";", "}" ]
[ "same", "as", "{", "@", "link", "#", "create", "(", "string", ",", "fs", "permission", ",", "enum", "set", ",", "boolean", ",", "short", ",", "long", ",", "progressable", ",", "int", ",", "checksum", "opt", ")", "}", "with", "the", "addition", "of", "favored", "nodes", "that", "is", "a", "hint", "to", "where", "the", "namenode", "should", "place", "the", "file", "blocks", "the", "favored", "nodes", "hint", "is", "not", "persisted", "in", "hdfs", "hence", "it", "may", "be", "honored", "at", "the", "creation", "time", "only", "hdfs", "could", "move", "the", "blocks", "during", "balancing", "or", "replication", ",", "to", "move", "the", "blocks", "from", "favored", "nodes", "a", "value", "of", "null", "means", "no", "favored", "nodes", "for", "this", "create" ]
[ "public", "d", "f", "s", "output", "stream", "create", "(", "string", "src", ",", "fs", "permission", "permission", ",", "enum", "set", "<", "create", "flag", ">", "flag", ",", "boolean", "create", "parent", ",", "short", "replication", ",", "long", "block", "size", ",", "progressable", "progress", ",", "int", "buffersize", ",", "checksum", "opt", "checksum", "opt", ",", "inet", "socket", "address", "[", "]", "favored", "nodes", ")", "throws", "i", "o", "exception", "{", "return", "create", "(", "src", ",", "permission", ",", "flag", ",", "create", "parent", ",", "replication", ",", "block", "size", ",", "progress", ",", "buffersize", ",", "checksum", "opt", ",", "favored", "nodes", ",", "null", ")", ";", "}" ]
[ "atomically", "swaps", "in", "the", "common", "cancelled", "subscription", "instance", "and", "cancels", "the", "previous", "subscription", "if", "any" ]
[ "public", "static", "boolean", "cancel", "(", "atomic", "reference", "<", "subscription", ">", "field", ")", "{", "subscription", "current", "=", "field", "get", "(", ")", ";", "if", "(", "current", "!", "=", "cancelled", ")", "{", "current", "=", "field", "get", "and", "set", "(", "cancelled", ")", ";", "if", "(", "current", "!", "=", "cancelled", ")", "{", "if", "(", "current", "!", "=", "null", ")", "{", "current", "cancel", "(", ")", ";", "}", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]
[ "set", "the", "padding", "for", "content", "inside", "this", "ninepatch", "by", "default", "the", "padding", "is", "set", "to", "match", "the", "exterior", "of", "the", "ninepatch", ",", "so", "the", "content", "should", "fit", "exactly", "within", "the", "middle", "patch" ]
[ "public", "void", "set", "padding", "(", "float", "left", ",", "float", "right", ",", "float", "top", ",", "float", "bottom", ")", "{", "this", "pad", "left", "=", "left", ";", "this", "pad", "right", "=", "right", ";", "this", "pad", "top", "=", "top", ";", "this", "pad", "bottom", "=", "bottom", ";", "}" ]
[ "insert", "the", "p", "-", "code", "of", "instruction", "(", "s", ")", "in", "the", "delay", "slot", "at", "this", "point", "in", "the", "p", "-", "code", "generation", "for", "the", "current", "instruction" ]
[ "private", "void", "delay", "slot", "(", "op", "tpl", "op", ")", "throws", "unknown", "instruction", "exception", ",", "memory", "access", "exception", "{", "if", "(", "in", "delay", "slot", ")", "{", "throw", "new", "sleigh", "exception", "(", "\"", "delay", "slot", "recursion", "problem", "for", "instruction", "at", "\"", "+", "walker", "get", "addr", "(", ")", ")", ";", "}", "in", "delay", "slot", "=", "true", ";", "address", "baseaddr", "=", "parsercontext", "get", "addr", "(", ")", ";", "int", "falloffset", "=", "parsercontext", "get", "prototype", "(", ")", "get", "length", "(", ")", ";", "int", "delay", "slot", "byte", "cnt", "=", "parsercontext", "get", "prototype", "(", ")", "get", "delay", "slot", "byte", "count", "(", ")", ";", "parser", "walker", "oldwalker", "=", "walker", ";", "long", "olduniqueoffset", "=", "uniqueoffset", ";", "int", "bytecount", "=", "0", ";", "do", "{", "address", "addr", "=", "baseaddr", "add", "(", "falloffset", ")", ";", "set", "unique", "offset", "(", "addr", ")", ";", "try", "{", "parsercontext", "=", "(", "sleigh", "parser", "context", ")", "instcontext", "get", "parser", "context", "(", "addr", ")", ";", "}", "catch", "(", "unknown", "context", "exception", "e", ")", "{", "throw", "new", "unknown", "instruction", "exception", "(", "\"", "could", "not", "find", "cached", "delayslot", "parser", "context", "\"", ")", ";", "}", "int", "len", "=", "parsercontext", "get", "prototype", "(", ")", "get", "length", "(", ")", ";", "walker", "=", "new", "parser", "walker", "(", "parsercontext", ")", ";", "walker", "base", "state", "(", ")", ";", "build", "(", "walker", "get", "constructor", "(", ")", "get", "templ", "(", ")", ",", "-", "1", ")", ";", "falloffset", "+", "=", "len", ";", "bytecount", "+", "=", "len", ";", "}", "while", "(", "bytecount", "<", "delay", "slot", "byte", "cnt", ")", ";", "walker", "=", "oldwalker", ";", "/", "/", "restore", "the", "tree", "walk", "for", "the", "base", "instruction", "parsercontext", "=", "walker", "get", "parser", "context", "(", ")", ";", "uniqueoffset", "=", "olduniqueoffset", ";", "in", "delay", "slot", "=", "false", ";", "}" ]
[ "refresh", "mount", "table", "cache", "on", "connected", "router" ]
[ "private", "boolean", "refresh", "router", "cache", "(", ")", "throws", "i", "o", "exception", "{", "refresh", "mount", "table", "entries", "response", "response", "=", "client", "get", "mount", "table", "manager", "(", ")", "refresh", "mount", "table", "entries", "(", "refresh", "mount", "table", "entries", "request", "new", "instance", "(", ")", ")", ";", "return", "response", "get", "result", "(", ")", ";", "}" ]
[ "requires", ":", "{", "@", "link", "#", "action", "file", "system", "type", "(", ")", "}", "to", "be", "not", "{", "@", "code", "disabled", "}" ]
[ "file", "system", "create", "action", "file", "system", "(", "string", "relative", "output", "path", ",", "action", "input", "map", "input", "artifact", "data", ",", "iterable", "<", "artifact", ">", "output", "artifacts", ",", "boolean", "track", "failed", "remote", "reads", ")", "{", "return", "output", "service", "create", "action", "file", "system", "(", "executor", "engine", "get", "file", "system", "(", ")", ",", "executor", "engine", "get", "exec", "root", "(", ")", "as", "fragment", "(", ")", ",", "relative", "output", "path", ",", "source", "root", "supplier", "get", "(", ")", ",", "input", "artifact", "data", ",", "output", "artifacts", ",", "track", "failed", "remote", "reads", ")", ";", "}" ]
[ "called", "in", "case", "of", "multiple", "calls", "to", "complete" ]
[ "protected", "void", "on", "drop", "(", "r", "n", ")", "{", "/", "/", "default", "is", "no", "-", "op", "}" ]
[ "the", "timestamp", "of", "this", "record" ]
[ "public", "long", "timestamp", "(", ")", "{", "return", "timestamp", ";", "}" ]
[ "uploads", "an", "image" ]
[ "public", "single", "<", "model", "api", "response", ">", "rx", "upload", "file", "(", "long", "pet", "id", ",", "string", "additional", "metadata", ",", "async", "file", "file", ")", "{", "return", "single", "create", "(", "new", "io", "vertx", "rx", "java", "single", "on", "subscribe", "adapter", "<", ">", "(", "fut", "-", ">", "delegate", "upload", "file", "(", "pet", "id", ",", "additional", "metadata", ",", "file", ",", "fut", ")", ")", ")", ";", "}" ]
[ "create", "a", "new", "block", "reader", "specifically", "to", "satisfy", "a", "read", "this", "method", "also", "sends", "the", "op", "read", "block", "request" ]
[ "public", "static", "block", "reader", "new", "block", "reader", "(", "string", "file", ",", "extended", "block", "block", ",", "token", "<", "block", "token", "identifier", ">", "block", "token", ",", "long", "start", "offset", ",", "long", "len", ",", "boolean", "verify", "checksum", ",", "string", "client", "name", ",", "peer", "peer", ",", "datanode", "i", "d", "datanode", "i", "d", ",", "peer", "cache", "peer", "cache", ",", "caching", "strategy", "caching", "strategy", ",", "int", "network", "distance", ",", "configuration", "configuration", ")", "throws", "i", "o", "exception", "{", "/", "/", "in", "and", "out", "will", "be", "closed", "when", "sock", "is", "closed", "(", "by", "the", "caller", ")", "int", "buffer", "size", "=", "configuration", "get", "int", "(", "dfs", "client", "block", "reader", "remote", "buffer", "size", "key", ",", "dfs", "client", "block", "reader", "remote", "buffer", "size", "default", ")", ";", "final", "data", "output", "stream", "out", "=", "new", "data", "output", "stream", "(", "new", "buffered", "output", "stream", "(", "peer", "get", "output", "stream", "(", ")", ",", "buffer", "size", ")", ")", ";", "new", "sender", "(", "out", ")", "read", "block", "(", "block", ",", "block", "token", ",", "client", "name", ",", "start", "offset", ",", "len", ",", "verify", "checksum", ",", "caching", "strategy", ")", ";", "/", "/", "/", "/", "get", "bytes", "in", "block", "/", "/", "data", "input", "stream", "in", "=", "new", "data", "input", "stream", "(", "peer", "get", "input", "stream", "(", ")", ")", ";", "block", "op", "response", "proto", "status", "=", "block", "op", "response", "proto", "parse", "from", "(", "p", "b", "helper", "client", "vint", "prefixed", "(", "in", ")", ")", ";", "check", "success", "(", "status", ",", "peer", ",", "block", ",", "file", ")", ";", "read", "op", "checksum", "info", "proto", "checksum", "info", "=", "status", "get", "read", "op", "checksum", "info", "(", ")", ";", "data", "checksum", "checksum", "=", "data", "transfer", "proto", "util", "from", "proto", "(", "checksum", "info", "get", "checksum", "(", ")", ")", ";", "/", "/", "warning", "when", "we", "get", "checksum", "null", "?", "/", "/", "read", "the", "first", "chunk", "offset", "long", "first", "chunk", "offset", "=", "checksum", "info", "get", "chunk", "offset", "(", ")", ";", "if", "(", "first", "chunk", "offset", "<", "0", "|", "|", "first", "chunk", "offset", ">", "start", "offset", "|", "|", "first", "chunk", "offset", "<", "=", "(", "start", "offset", "-", "checksum", "get", "bytes", "per", "checksum", "(", ")", ")", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "block", "reader", ":", "error", "in", "first", "chunk", "offset", "(", "\"", "+", "first", "chunk", "offset", "+", "\"", ")", "start", "offset", "is", "\"", "+", "start", "offset", "+", "\"", "for", "file", "\"", "+", "file", ")", ";", "}", "return", "new", "block", "reader", "remote", "(", "file", ",", "block", "get", "block", "id", "(", ")", ",", "checksum", ",", "verify", "checksum", ",", "start", "offset", ",", "first", "chunk", "offset", ",", "len", ",", "peer", ",", "datanode", "i", "d", ",", "peer", "cache", ",", "network", "distance", ")", ";", "}" ]
[ "returns", "the", "label", "that", "represents", "{", "@", "code", "this", "|", "rhs", "}" ]
[ "public", "label", "or", "(", "label", "rhs", ")", "{", "return", "new", "label", "expression", "or", "(", "this", ",", "rhs", ")", ";", "}" ]
[ "test", "{", "@", "code", "enum", "set", "writable", "write", "(", "data", "output", "buffer", "out", ")", "}", "and", "iteration", "by", "test", "enum", "set", "through", "iterator", "(", ")" ]
[ "public", "void", "test", "enum", "set", "writable", "write", "read", "(", ")", "throws", "exception", "{", "enum", "set", "writable", "<", "test", "enum", "set", ">", "src", "set", "=", "new", "enum", "set", "writable", "<", "test", "enum", "set", ">", "(", "enum", "set", "of", "(", "test", "enum", "set", "append", ",", "test", "enum", "set", "create", ")", ",", "test", "enum", "set", "class", ")", ";", "data", "output", "buffer", "out", "=", "new", "data", "output", "buffer", "(", ")", ";", "src", "set", "write", "(", "out", ")", ";", "enum", "set", "writable", "<", "test", "enum", "set", ">", "dst", "set", "=", "new", "enum", "set", "writable", "<", "test", "enum", "set", ">", "(", ")", ";", "data", "input", "buffer", "in", "=", "new", "data", "input", "buffer", "(", ")", ";", "in", "reset", "(", "out", "get", "data", "(", ")", ",", "out", "get", "length", "(", ")", ")", ";", "dst", "set", "read", "fields", "(", "in", ")", ";", "enum", "set", "<", "test", "enum", "set", ">", "result", "=", "dst", "set", "get", "(", ")", ";", "iterator", "<", "test", "enum", "set", ">", "dst", "iter", "=", "result", "iterator", "(", ")", ";", "iterator", "<", "test", "enum", "set", ">", "src", "iter", "=", "src", "set", "iterator", "(", ")", ";", "while", "(", "dst", "iter", "has", "next", "(", ")", "&", "&", "src", "iter", "has", "next", "(", ")", ")", "{", "assert", "equals", "(", "\"", "test", "enum", "set", "writable", "write", "read", "error", "!", "!", "!", "\"", ",", "dst", "iter", "next", "(", ")", ",", "src", "iter", "next", "(", ")", ")", ";", "}", "}" ]
[ "test", "the", "case", "where", ",", "at", "the", "beginning", "of", "a", "segment", ",", "transactions", "have", "been", "written", "to", "one", "jn", "but", "not", "others" ]
[ "public", "void", "do", "test", "out", "of", "sync", "at", "beginning", "of", "segment", "(", "int", "node", "with", "one", "txn", ")", "throws", "exception", "{", "int", "node", "with", "empty", "segment", "=", "(", "node", "with", "one", "txn", "+", "1", ")", "%", "3", ";", "int", "node", "missing", "segment", "=", "(", "node", "with", "one", "txn", "+", "2", ")", "%", "3", ";", "write", "segment", "(", "cluster", ",", "qjm", ",", "1", ",", "3", ",", "true", ")", ";", "wait", "for", "all", "pending", "calls", "(", "qjm", "get", "logger", "set", "for", "tests", "(", ")", ")", ";", "cluster", "get", "journal", "node", "(", "node", "missing", "segment", ")", "stop", "and", "join", "(", "0", ")", ";", "/", "/", "open", "segment", "on", "2", "/", "3", "nodes", "edit", "log", "output", "stream", "stm", "=", "qjm", "start", "log", "segment", "(", "4", ",", "name", "node", "layout", "version", "current", "layout", "version", ")", ";", "try", "{", "wait", "for", "all", "pending", "calls", "(", "qjm", "get", "logger", "set", "for", "tests", "(", ")", ")", ";", "/", "/", "write", "transactions", "to", "only", "1", "/", "3", "nodes", "fail", "logger", "at", "txn", "(", "spies", "get", "(", "node", "with", "empty", "segment", ")", ",", "4", ")", ";", "try", "{", "write", "txns", "(", "stm", ",", "4", ",", "1", ")", ";", "fail", "(", "\"", "did", "not", "fail", "even", "though", "2", "/", "3", "failed", "\"", ")", ";", "}", "catch", "(", "quorum", "exception", "qe", ")", "{", "generic", "test", "utils", "assert", "exception", "contains", "(", "\"", "mock", "failure", "\"", ",", "qe", ")", ";", "}", "}", "finally", "{", "stm", "abort", "(", ")", ";", "}", "/", "/", "bring", "back", "the", "down", "jn", "cluster", "restart", "journal", "node", "(", "node", "missing", "segment", ")", ";", "/", "/", "make", "a", "new", "qjm", "at", "this", "point", ",", "the", "state", "is", "as", "follows", ":", "/", "/", "a", ":", "node", "with", "empty", "segment", ":", "1", "-", "3", "finalized", ",", "4", "inprogress", "(", "empty", ")", "/", "/", "b", ":", "node", "with", "one", "txn", ":", "1", "-", "3", "finalized", ",", "4", "inprogress", "(", "1", "txn", ")", "/", "/", "c", ":", "node", "missing", "segment", ":", "1", "-", "3", "finalized", "generic", "test", "utils", "assert", "glob", "equals", "(", "cluster", "get", "current", "dir", "(", "node", "with", "empty", "segment", ",", "jid", ")", ",", "\"", "edits", "*", "\"", ",", "n", "n", "storage", "get", "finalized", "edits", "file", "name", "(", "1", ",", "3", ")", ",", "n", "n", "storage", "get", "in", "progress", "edits", "file", "name", "(", "4", ")", ")", ";", "generic", "test", "utils", "assert", "glob", "equals", "(", "cluster", "get", "current", "dir", "(", "node", "with", "one", "txn", ",", "jid", ")", ",", "\"", "edits", "*", "\"", ",", "n", "n", "storage", "get", "finalized", "edits", "file", "name", "(", "1", ",", "3", ")", ",", "n", "n", "storage", "get", "in", "progress", "edits", "file", "name", "(", "4", ")", ")", ";", "generic", "test", "utils", "assert", "glob", "equals", "(", "cluster", "get", "current", "dir", "(", "node", "missing", "segment", ",", "jid", ")", ",", "\"", "edits", "*", "\"", ",", "n", "n", "storage", "get", "finalized", "edits", "file", "name", "(", "1", ",", "3", ")", ")", ";", "/", "/", "stop", "one", "of", "the", "nodes", "since", "we", "run", "this", "test", "three", "/", "/", "times", ",", "rotating", "the", "roles", "of", "the", "nodes", ",", "we", "'", "ll", "test", "/", "/", "all", "the", "permutations", "cluster", "get", "journal", "node", "(", "2", ")", "stop", "and", "join", "(", "0", ")", ";", "qjm", "=", "create", "spying", "q", "j", "m", "(", ")", ";", "qjm", "recover", "unfinalized", "segments", "(", ")", ";", "if", "(", "node", "with", "one", "txn", "=", "=", "0", "|", "|", "node", "with", "one", "txn", "=", "=", "1", ")", "{", "/", "/", "if", "the", "node", "that", "had", "the", "transaction", "committed", "was", "one", "of", "the", "nodes", "/", "/", "that", "responded", "during", "recovery", ",", "then", "we", "should", "have", "recovered", "txid", "/", "/", "4", "check", "recovery", "(", "cluster", ",", "4", ",", "4", ")", ";", "write", "segment", "(", "cluster", ",", "qjm", ",", "5", ",", "3", ",", "true", ")", ";", "}", "else", "{", "/", "/", "otherwise", ",", "we", "should", "have", "recovered", "only", "1", "-", "3", "and", "should", "be", "able", "to", "/", "/", "start", "a", "segment", "at", "4", "check", "recovery", "(", "cluster", ",", "1", ",", "3", ")", ";", "write", "segment", "(", "cluster", ",", "qjm", ",", "4", ",", "3", ",", "true", ")", ";", "}", "}" ]