Datasets:

Anonymous2023

/

KGSum

like 0

[ "create", "a", "composite", "filter", "based", "on", "this", "filter", "and", "the", "provided", "filter", "if", "this", "filter", "does", "not", "match", ",", "the", "next", "filter", "will", "not", "be", "applied" ]

[ "default", "method", "filter", "and", "(", "method", "filter", "next", ")", "{", "assert", "not", "null", "(", "next", ",", "\"", "next", "method", "filter", "must", "not", "be", "null", "\"", ")", ";", "return", "method", "-", ">", "matches", "(", "method", ")", "&", "&", "next", "matches", "(", "method", ")", ";", "}" ]

[ "the", "normal", "test", "case", "start", "with", "an", "imbalanced", "cluster", ",", "then", "balancer", "should", "balance", "succeed", "but", "not", "exit", ",", "then", "make", "the", "cluster", "imbalanced", "and", "wait", "for", "balancer", "to", "balance", "it", "again" ]

[ "public", "void", "test", "balancer", "service", "balance", "twice", "(", ")", "throws", "exception", "{", "configuration", "conf", "=", "new", "hdfs", "configuration", "(", ")", ";", "conf", "set", "time", "duration", "(", "d", "f", "s", "config", "keys", "dfs", "balancer", "service", "interval", "key", ",", "5", ",", "time", "unit", "seconds", ")", ";", "test", "balancer", "init", "conf", "(", "conf", ")", ";", "try", "{", "setup", "cluster", "(", "conf", ")", ";", "long", "total", "capacity", "=", "add", "one", "data", "node", "(", "conf", ")", ";", "/", "/", "make", "cluster", "imbalanced", "thread", "balancer", "thread", "=", "new", "balancer", "service", "(", "conf", ",", "new", "string", "[", "]", "{", "\"", "-", "as", "service", "\"", "}", ")", ";", "balancer", "thread", "start", "(", ")", ";", "test", "balancer", "wait", "for", "balancer", "(", "total", "used", "space", ",", "total", "capacity", ",", "client", ",", "cluster", ",", "balancer", "parameters", "default", ")", ";", "cluster", "trigger", "heartbeats", "(", ")", ";", "cluster", "trigger", "block", "reports", "(", ")", ";", "/", "/", "add", "another", "empty", "datanode", ",", "wait", "for", "cluster", "become", "balance", "again", "total", "capacity", "=", "add", "one", "data", "node", "(", "conf", ")", ";", "test", "balancer", "wait", "for", "balancer", "(", "total", "used", "space", ",", "total", "capacity", ",", "client", ",", "cluster", ",", "balancer", "parameters", "default", ")", ";", "balancer", "stop", "(", ")", ";", "balancer", "thread", "join", "(", ")", ";", "}", "finally", "{", "if", "(", "cluster", "!", "=", "null", ")", "{", "cluster", "shutdown", "(", ")", ";", "}", "}", "}" ]

[ "resolves", "the", "version", "based", "on", "operation", "type", "{", "@", "link", "#", "op", "type", "(", ")", "}" ]

[ "private", "long", "resolve", "version", "defaults", "(", ")", "{", "if", "(", "op", "type", "=", "=", "op", "type", "create", "&", "&", "version", "=", "=", "versions", "match", "any", ")", "{", "return", "versions", "match", "deleted", ";", "}", "else", "{", "return", "version", ";", "}", "}" ]

[ "execute", "the", "procedure", "until", "its", "stage", "is", "updated", "to", "the", "target", "stage" ]

[ "private", "static", "void", "execute", "procedure", "(", "dist", "cp", "procedure", "procedure", ",", "stage", "target", ",", "call", "call", ")", "throws", "i", "o", "exception", "{", "stage", "stage", "=", "stage", "pre", "check", ";", "procedure", "update", "stage", "(", "stage", ")", ";", "while", "(", "stage", "!", "=", "target", ")", "{", "try", "{", "call", "execute", "(", ")", ";", "}", "catch", "(", "retry", "exception", "e", ")", "{", "}", "finally", "{", "stage", "=", "procedure", "get", "stage", "(", ")", ";", "}", "}", "}" ]

[ "while", "satisfying", "filedirectory", ",", "trigger", "the", "cluster", "'", "s", "checkpoint", "to", "make", "sure", "satisfier", "persistence", "work", "as", "expected", "this", "test", "case", "runs", "as", "below", ":", "1", "use", "satisfy", "storage", "policy", "and", "add", "x", "attr", "to", "the", "file", "2", "do", "the", "checkpoint", "by", "secondary", "name", "node", "3", "restart", "the", "cluster", "immediately", "4", "make", "sure", "all", "the", "storage", "policies", "are", "satisfied" ]

[ "public", "void", "test", "with", "checkpoint", "(", ")", "throws", "exception", "{", "secondary", "name", "node", "secondary", "=", "null", ";", "try", "{", "cluster", "set", "up", "(", ")", ";", "fs", "set", "storage", "policy", "(", "test", "file", ",", "warm", ")", ";", "fs", "satisfy", "storage", "policy", "(", "test", "file", ")", ";", "/", "/", "start", "the", "checkpoint", "conf", "set", "(", "d", "f", "s", "config", "keys", "dfs", "namenode", "secondary", "http", "address", "key", ",", "\"", "0", "0", "0", "0", ":", "0", "\"", ")", ";", "secondary", "=", "new", "secondary", "name", "node", "(", "conf", ")", ";", "secondary", "do", "checkpoint", "(", ")", ";", "restart", "cluster", "(", ")", ";", "d", "f", "s", "test", "util", "wait", "expected", "storage", "type", "(", "test", "file", "name", ",", "storage", "type", "disk", ",", "1", ",", "timeout", ",", "fs", ")", ";", "d", "f", "s", "test", "util", "wait", "expected", "storage", "type", "(", "test", "file", "name", ",", "storage", "type", "archive", ",", "2", ",", "timeout", ",", "fs", ")", ";", "fs", "set", "storage", "policy", "(", "parent", "dir", ",", "cold", ")", ";", "fs", "satisfy", "storage", "policy", "(", "parent", "dir", ")", ";", "d", "f", "s", "test", "util", "wait", "expected", "storage", "type", "(", "parent", "file", "name", ",", "storage", "type", "archive", ",", "3", ",", "timeout", ",", "fs", ")", ";", "d", "f", "s", "test", "util", "wait", "expected", "storage", "type", "(", "child", "file", "name", ",", "storage", "type", "archive", ",", "3", ",", "timeout", ",", "fs", ")", ";", "}", "finally", "{", "if", "(", "secondary", "!", "=", "null", ")", "{", "secondary", "shutdown", "(", ")", ";", "}", "cluster", "shutdown", "(", ")", ";", "}", "}" ]

[ "the", "position", "in", "the", "file", "at", "which", "this", "symbol", "is", "defined", "for", "debug", "use", "<", "code", ">", "optional", "aapt", "pb", "source", "position", "source", "=", "2", ";", "<", "code", ">" ]

[ "public", "builder", "clear", "source", "(", ")", "{", "copy", "on", "write", "(", ")", ";", "instance", "clear", "source", "(", ")", ";", "return", "this", ";", "}" ]

[ "to", "test", "\\", "&", "quot", ";", "client", "\\", "&", "quot", ";", "model", "to", "test", "\\", "&", "quot", ";", "client", "\\", "&", "quot", ";", "model" ]

[ "public", "api", "response", "<", "client", ">", "test", "client", "model", "with", "http", "info", "(", "client", "body", ")", "throws", "api", "exception", "{", "object", "local", "var", "post", "body", "=", "body", ";", "/", "/", "verify", "the", "required", "parameter", "'", "body", "'", "is", "set", "if", "(", "body", "=", "=", "null", ")", "{", "throw", "new", "api", "exception", "(", "400", ",", "\"", "missing", "the", "required", "parameter", "'", "body", "'", "when", "calling", "test", "client", "model", "\"", ")", ";", "}", "/", "/", "create", "path", "and", "map", "variables", "string", "local", "var", "path", "=", "\"", "/", "fake", "\"", ";", "/", "/", "query", "params", "list", "<", "pair", ">", "local", "var", "query", "params", "=", "new", "array", "list", "<", "pair", ">", "(", ")", ";", "map", "<", "string", ",", "string", ">", "local", "var", "header", "params", "=", "new", "hash", "map", "<", "string", ",", "string", ">", "(", ")", ";", "map", "<", "string", ",", "string", ">", "local", "var", "cookie", "params", "=", "new", "hash", "map", "<", "string", ",", "string", ">", "(", ")", ";", "map", "<", "string", ",", "object", ">", "local", "var", "form", "params", "=", "new", "hash", "map", "<", "string", ",", "object", ">", "(", ")", ";", "final", "string", "[", "]", "local", "var", "accepts", "=", "{", "\"", "application", "/", "json", "\"", "}", ";", "final", "string", "local", "var", "accept", "=", "api", "client", "select", "header", "accept", "(", "local", "var", "accepts", ")", ";", "final", "string", "[", "]", "local", "var", "content", "types", "=", "{", "\"", "application", "/", "json", "\"", "}", ";", "final", "string", "local", "var", "content", "type", "=", "api", "client", "select", "header", "content", "type", "(", "local", "var", "content", "types", ")", ";", "string", "[", "]", "local", "var", "auth", "names", "=", "new", "string", "[", "]", "{", "}", ";", "generic", "type", "<", "client", ">", "local", "var", "return", "type", "=", "new", "generic", "type", "<", "client", ">", "(", ")", "{", "}", ";", "return", "api", "client", "invoke", "a", "p", "i", "(", "\"", "fake", "api", "test", "client", "model", "\"", ",", "local", "var", "path", ",", "\"", "patch", "\"", ",", "local", "var", "query", "params", ",", "local", "var", "post", "body", ",", "local", "var", "header", "params", ",", "local", "var", "cookie", "params", ",", "local", "var", "form", "params", ",", "local", "var", "accept", ",", "local", "var", "content", "type", ",", "local", "var", "auth", "names", ",", "local", "var", "return", "type", ",", "false", ")", ";", "}" ]

[ "model", "tests", "for", "tag" ]

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

[ "get", "nameservice", "id", "for", "the", "backup", "node", "based", "on", "backup", "node", "rpc", "address", "matching", "the", "local", "node", "address" ]

[ "public", "static", "string", "get", "backup", "name", "service", "id", "(", "configuration", "conf", ")", "{", "return", "get", "name", "service", "id", "(", "conf", ",", "dfs", "namenode", "backup", "address", "key", ")", ";", "}" ]

[ "adds", "a", "new", "member", "to", "the", "first", "available", "slot", "and", "updates", "slot", "assignments", "if", "the", "number", "of", "member", "is", "supported", "by", "the", "current", "pattern" ]

[ "public", "boolean", "add", "member", "(", "formation", "member", "member", ")", "{", "/", "/", "check", "if", "the", "pattern", "supports", "one", "more", "slot", "if", "(", "pattern", "supports", "slots", "(", "slot", "assignments", "size", "+", "1", ")", ")", "{", "/", "/", "add", "a", "new", "slot", "assignment", "slot", "assignments", "add", "(", "new", "slot", "assignment", "(", "member", ",", "slot", "assignments", "size", ")", ")", ";", "/", "/", "update", "the", "slot", "assignments", "and", "return", "success", "update", "slot", "assignments", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "after", "{", "@", "link", "abstract", "span", "}", "is", "finished", ",", "as", "be", "controller", "by", "\"", "skywalking", "-", "api", "\"", "module", ",", "notify", "the", "{", "@", "link", "trace", "segment", "}", "to", "archive", "it" ]

[ "public", "void", "archive", "(", "abstract", "tracing", "span", "finished", "span", ")", "{", "spans", "add", "(", "finished", "span", ")", ";", "}" ]

[ "applies", "a", "state", "handler", "to", "a", "component", "node", "from", "the", "cache" ]

[ "public", "static", "boolean", "load", "timeline", "snapshot", "(", "debug", "component", "node", ",", "string", "destination", ")", "{", "thread", "utils", "assert", "main", "thread", "(", ")", ";", "final", "component", "tree", "old", "tree", "=", "node", "get", "context", "(", ")", "get", "component", "tree", "(", ")", ";", "final", "tree", "revisions", "tree", "revisions", "=", "old", "tree", "get", "timeline", "(", ")", ";", "if", "(", "tree", "revisions", "!", "=", "null", ")", "{", "final", "tree", "revision", "selected", "=", "tree", "revisions", "find", "by", "key", "(", "destination", ")", ";", "if", "(", "selected", "!", "=", "null", ")", "{", "old", "tree", "reset", "state", "(", "selected", "revision", "number", ",", "selected", "root", ",", "selected", "props", ",", "selected", "handler", ")", ";", "}", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "default", "implementation", "that", "does", "nothing" ]

[ "public", "action", "get", "project", "action", "(", "project", "project", ")", "{", "return", "null", ";", "}" ]

[ "loads", "all", "indices", "states", "available", "on", "disk" ]

[ "list", "<", "index", "metadata", ">", "load", "indices", "states", "(", "predicate", "<", "string", ">", "exclude", "index", "path", "ids", "predicate", ")", "throws", "i", "o", "exception", "{", "list", "<", "index", "metadata", ">", "index", "metadata", "list", "=", "new", "array", "list", "<", ">", "(", ")", ";", "for", "(", "string", "index", "folder", "name", ":", "node", "env", "available", "index", "folders", "(", "exclude", "index", "path", "ids", "predicate", ")", ")", "{", "assert", "exclude", "index", "path", "ids", "predicate", "test", "(", "index", "folder", "name", ")", "=", "=", "false", ":", "\"", "unexpected", "folder", "\"", "+", "index", "folder", "name", "+", "\"", "which", "should", "have", "been", "excluded", "\"", ";", "index", "metadata", "index", "metadata", "=", "index", "metadata", "format", "load", "latest", "state", "(", "logger", ",", "named", "x", "content", "registry", ",", "node", "env", "resolve", "index", "folder", "(", "index", "folder", "name", ")", ")", ";", "if", "(", "index", "metadata", "!", "=", "null", ")", "{", "final", "string", "index", "path", "id", "=", "index", "metadata", "get", "index", "(", ")", "get", "u", "u", "i", "d", "(", ")", ";", "if", "(", "index", "folder", "name", "equals", "(", "index", "path", "id", ")", ")", "{", "index", "metadata", "list", "add", "(", "index", "metadata", ")", ";", "}", "else", "{", "throw", "new", "illegal", "state", "exception", "(", "\"", "[", "\"", "+", "index", "folder", "name", "+", "\"", "]", "invalid", "index", "folder", "name", ",", "rename", "to", "[", "\"", "+", "index", "path", "id", "+", "\"", "]", "\"", ")", ";", "}", "}", "else", "{", "logger", "debug", "(", "\"", "[", "{", "}", "]", "failed", "to", "find", "metadata", "for", "existing", "index", "location", "\"", ",", "index", "folder", "name", ")", ";", "}", "}", "return", "index", "metadata", "list", ";", "}" ]

[ "package", "private", "method", "to", "help", "unit", "test" ]

[ "void", "run", "once", "(", ")", "{", "try", "{", "/", "/", "the", "fetch", "task", "should", "run", "if", "the", "split", "assignment", "is", "not", "empty", "or", "there", "is", "a", "split", "/", "/", "change", "if", "(", "should", "run", "fetch", "task", "(", ")", ")", "{", "running", "task", "=", "fetch", "task", ";", "}", "else", "{", "running", "task", "=", "task", "queue", "take", "(", ")", ";", "}", "/", "/", "now", "the", "running", "task", "is", "not", "null", "if", "wake", "up", "(", ")", "is", "called", "after", "this", "point", ",", "/", "/", "task", "wake", "up", "(", ")", "will", "be", "called", "on", "the", "other", "hand", ",", "if", "the", "wake", "up", "(", ")", "call", "was", "make", "before", "/", "/", "this", "point", ",", "the", "wake", "up", "flag", "must", "have", "already", "been", "set", "the", "code", "hence", "checks", "the", "/", "/", "wake", "up", "/", "/", "flag", "first", "to", "avoid", "an", "unnecessary", "task", "run", "/", "/", "note", "that", "the", "running", "task", "may", "still", "encounter", "the", "case", "that", "the", "task", "is", "waken", "up", "/", "/", "before", "/", "/", "the", "it", "starts", "running", "log", "debug", "(", "\"", "prepare", "to", "run", "{", "}", "\"", ",", "running", "task", ")", ";", "if", "(", "!", "wake", "up", "get", "(", ")", "&", "&", "running", "task", "run", "(", ")", ")", "{", "log", "debug", "(", "\"", "finished", "running", "task", "{", "}", "\"", ",", "running", "task", ")", ";", "/", "/", "the", "task", "has", "finished", "running", "set", "it", "to", "null", "so", "it", "won", "'", "t", "be", "enqueued", "running", "task", "=", "null", ";", "check", "and", "set", "idle", "(", ")", ";", "}", "}", "catch", "(", "exception", "e", ")", "{", "throw", "new", "runtime", "exception", "(", "string", "format", "(", "\"", "split", "fetcher", "thread", "%", "d", "received", "unexpected", "exception", "while", "polling", "the", "records", "\"", ",", "id", ")", ",", "e", ")", ";", "}", "/", "/", "if", "the", "task", "is", "not", "null", "that", "means", "this", "task", "needs", "to", "be", "re", "-", "executed", "this", "only", "/", "/", "happens", "when", "the", "task", "is", "the", "fetching", "task", "or", "the", "task", "was", "interrupted", "maybe", "enqueue", "task", "(", "running", "task", ")", ";", "synchronized", "(", "wake", "up", ")", "{", "/", "/", "set", "the", "running", "task", "to", "null", "it", "is", "necessary", "for", "the", "shutdown", "method", "to", "avoid", "/", "/", "unnecessarily", "interrupt", "the", "running", "task", "running", "task", "=", "null", ";", "/", "/", "set", "the", "wake", "up", "flag", "to", "false", "wake", "up", "set", "(", "false", ")", ";", "log", "debug", "(", "\"", "cleaned", "wakeup", "flag", "\"", ")", ";", "}", "}" ]

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

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

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

[ "deployment", "query", "order", "by", "deployment", "name", "(", ")", ";" ]

[ "an", "optional", "parameter", "that", "focuses", "the", "exploration", "on", "documents", "that", "match", "the", "given", "query" ]

[ "public", "void", "guiding", "query", "(", "query", "builder", "query", "builder", ")", "{", "guiding", "query", "=", "query", "builder", ";", "}" ]

[ "checks", "whether", "the", "given", "filter", "is", "already", "registered", "in", "the", "chain" ]

[ "public", "static", "boolean", "has", "filter", "(", "filter", "filter", ")", "{", "jenkins", "j", "=", "jenkins", "get", "instance", "or", "null", "(", ")", ";", "plugin", "servlet", "filter", "container", "=", "null", ";", "if", "(", "j", "!", "=", "null", ")", "{", "container", "=", "get", "instance", "(", "j", "servlet", "context", ")", ";", "}", "if", "(", "j", "=", "=", "null", "|", "|", "container", "=", "=", "null", ")", "{", "return", "legacy", "contains", "(", "filter", ")", ";", "}", "else", "{", "return", "container", "list", "contains", "(", "filter", ")", ";", "}", "}" ]

[ "this", "tests", "the", "overload", "of", "the", "method", "that", "uses", "a", "map", "for", "query", "parameters", "instead", "of", "listing", "them", "out", "individually" ]

[ "public", "void", "test", "body", "with", "query", "params", "test", "query", "map", "(", ")", "{", "user", "user", "=", "null", ";", "fake", "api", "test", "body", "with", "query", "params", "query", "params", "query", "params", "=", "new", "fake", "api", "test", "body", "with", "query", "params", "query", "params", "(", ")", "query", "(", "null", ")", ";", "/", "/", "api", "test", "body", "with", "query", "params", "(", "user", ",", "query", "params", ")", ";", "/", "/", "todo", ":", "test", "validations", "}" ]

[ "skips", "checks", "for", "existing", "keys", ",", "doesn", "'", "t", "increment", "size" ]

[ "private", "void", "add", "resize", "(", "t", "key", ")", "{", "t", "[", "]", "key", "table", "=", "this", "key", "table", ";", "for", "(", "int", "i", "=", "place", "(", "key", ")", ";", ";", "i", "=", "(", "i", "+", "1", ")", "&", "mask", ")", "{", "if", "(", "key", "table", "[", "i", "]", "=", "=", "null", ")", "{", "key", "table", "[", "i", "]", "=", "key", ";", "return", ";", "}", "}", "}" ]

[ "gets", "server", "worker", "threads" ]

[ "public", "int", "get", "server", "worker", "threads", "(", ")", "{", "return", "server", "worker", "threads", ";", "}" ]

[ "this", "method", "is", "deprecated", "use", "set", "fills", "(", ")", "instead" ]

[ "public", "void", "set", "gradient", "colors", "(", "list", "<", "fill", ">", "gradient", "colors", ")", "{", "this", "m", "fills", "=", "gradient", "colors", ";", "}" ]

[ "verifies", "the", "display", "of", "references", "to", "functions" ]

[ "public", "void", "test", "view", "references", "to", "function", "(", ")", "{", "double", "click", "x", "ref", "(", "\"", "1001005", "\"", ",", "\"", "xref", "[", "1", "]", ":", "\"", ")", ";", "component", "provider", "comp", "=", "wait", "for", "component", "provider", "(", "table", "component", "provider", "class", ")", ";", "table", "component", "provider", "<", "?", ">", "table", "=", "(", "table", "component", "provider", "<", "?", ">", ")", "comp", ";", "assert", "equals", "(", "1", ",", "table", "get", "model", "(", ")", "get", "row", "count", "(", ")", ")", ";", "}" ]

[ "add", "a", "map", "of", "parameters", "to", "this", "parameter", "source" ]

[ "public", "map", "sql", "parameter", "source", "add", "values", "(", "@", "nullable", "map", "<", "string", ",", "?", ">", "values", ")", "{", "if", "(", "values", "!", "=", "null", ")", "{", "values", "for", "each", "(", "(", "key", ",", "value", ")", "-", ">", "{", "this", "values", "put", "(", "key", ",", "value", ")", ";", "if", "(", "value", "instanceof", "sql", "parameter", "value", ")", "{", "register", "sql", "type", "(", "key", ",", "(", "(", "sql", "parameter", "value", ")", "value", ")", "get", "sql", "type", "(", ")", ")", ";", "}", "}", ")", ";", "}", "return", "this", ";", "}" ]

[ "find", "by", "username" ]

[ "public", "list", "<", "couch", "db", "u", "2", "f", "device", "registration", ">", "find", "by", "username", "(", "final", "string", "username", ")", "{", "return", "query", "view", "(", "\"", "by", "username", "\"", ",", "username", ")", ";", "}" ]

[ "make", "calls", "to", "the", "b", "2", "b", "service", "dummy", "api" ]

[ "private", "static", "void", "make", "service", "calls", "(", "tenant", "tenant", ",", "calls", "count", "calls", "count", ")", "{", "var", "timer", "=", "new", "throttle", "timer", "impl", "(", "10", ",", "calls", "count", ")", ";", "var", "service", "=", "new", "b", "2", "b", "service", "(", "timer", ",", "calls", "count", ")", ";", "/", "/", "sleep", "is", "introduced", "to", "keep", "the", "output", "in", "check", "and", "easy", "to", "view", "and", "analyze", "the", "results", "int", "stream", "range", "(", "0", ",", "20", ")", "for", "each", "(", "i", "-", ">", "{", "service", "dummy", "customer", "api", "(", "tenant", ")", ";", "try", "{", "thread", "sleep", "(", "1", ")", ";", "}", "catch", "(", "interrupted", "exception", "e", ")", "{", "logger", "error", "(", "\"", "thread", "interrupted", ":", "{", "}", "\"", ",", "e", "get", "message", "(", ")", ")", ";", "}", "}", ")", ";", "}" ]

[ "reset", "the", "list", "of", "paths", "each", "time", "the", "dialog", "is", "shown" ]

[ "public", "void", "show", "(", "plugin", "tool", "tool", ")", "{", "set", "plugin", "paths", "list", "data", "(", "preferences", "get", "plugin", "paths", "(", ")", ")", ";", "set", "apply", "enabled", "(", "plugin", "paths", "changed", ")", ";", "set", "status", "message", "(", "empty", "status", ")", ";", "/", "/", "setting", "the", "path", "enables", "the", "apply", ",", "but", "we", "know", "we", "haven", "'", "t", "/", "/", "made", "any", "changes", "yet", ",", "so", "disable", "set", "apply", "enabled", "(", "false", ")", ";", "tool", "show", "dialog", "(", "this", ")", ";", "}" ]

[ "provide", "an", "{", "@", "link", "exchange", "function", "}", "pre", "-", "configured", "with", "{", "@", "link", "client", "http", "connector", "}", "and", "{", "@", "link", "exchange", "strategies", "}", "this", "is", "an", "alternative", "to", ",", "and", "effectively", "overrides", "{", "@", "link", "#", "client", "connector", "}", ",", "and", "{", "@", "link", "#", "exchange", "strategies", "(", "exchange", "strategies", ")", "}" ]

[ "builder", "exchange", "function", "(", "exchange", "function", "exchange", "function", ")", ";" ]

[ "get", "the", "thunk", "function", "corresponding", "to", "an", "external", "function", "such", "thunks", "should", "reside", "within", "the", "external", "block", "(", "note", ":", "this", "is", "specific", "to", "the", "elf", "import", ")" ]

[ "private", "address", "get", "external", "thunk", "address", "(", "string", "symbol", "name", ")", "throws", "not", "found", "exception", "{", "symbol", "external", "symbol", "=", "current", "program", "get", "symbol", "table", "(", ")", "get", "external", "symbol", "(", "symbol", "name", ")", ";", "if", "(", "external", "symbol", "!", "=", "null", "&", "&", "external", "symbol", "get", "symbol", "type", "(", ")", "=", "=", "symbol", "type", "function", ")", "{", "function", "f", "=", "(", "function", ")", "external", "symbol", "get", "object", "(", ")", ";", "address", "[", "]", "thunk", "addrs", "=", "f", "get", "function", "thunk", "addresses", "(", ")", ";", "if", "(", "thunk", "addrs", "length", "=", "=", "1", ")", "{", "return", "thunk", "addrs", "[", "0", "]", ";", "}", "}", "throw", "new", "not", "found", "exception", "(", "\"", "failed", "to", "locate", "label", ":", "\"", "+", "symbol", "name", ")", ";", "}" ]

[ "store", "the", "user", "parameter", "and", "free", "buffer", "index", "lists", "and", "write", "the", "file", "header" ]

[ "private", "void", "write", "header", "(", ")", "throws", "i", "o", "exception", "{", "if", "(", "read", "only", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "file", "is", "read", "-", "only", "\"", ")", ";", "}", "/", "/", "output", "free", "list", "int", "prev", "=", "-", "1", ";", "for", "(", "int", "index", ":", "free", "indexes", ")", "{", "put", "free", "block", "(", "index", ",", "prev", ")", ";", "prev", "=", "index", ";", "}", "seek", "block", "(", "0", ",", "0", ")", ";", "/", "/", "write", "header", "values", "raf", "write", "long", "(", "magic", "number", ")", ";", "raf", "write", "long", "(", "file", "id", ")", ";", "raf", "write", "int", "(", "header", "format", "version", ")", ";", "raf", "write", "int", "(", "block", "size", ")", ";", "raf", "write", "int", "(", "prev", ")", ";", "/", "/", "write", "user", "parameter", "count", "and", "values", "string", "[", "]", "parm", "names", "=", "get", "parameter", "names", "(", ")", ";", "raf", "write", "int", "(", "parm", "names", "length", ")", ";", "int", "cnt", "=", "ver1", "fixed", "header", "length", ";", "for", "(", "string", "parm", "name", ":", "parm", "names", ")", "{", "byte", "[", "]", "name", "bytes", "=", "parm", "name", "get", "bytes", "(", "string", "encoding", ")", ";", "cnt", "+", "=", "8", "+", "name", "bytes", "length", ";", "if", "(", "cnt", ">", "buffer", "size", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "buffer", "size", "too", "small", "\"", ")", ";", "}", "raf", "write", "int", "(", "name", "bytes", "length", ")", ";", "raf", "write", "(", "name", "bytes", ")", ";", "raf", "write", "int", "(", "get", "parameter", "(", "parm", "name", ")", ")", ";", "}", "}" ]

[ "deserializes", "the", "kafka", "record" ]

[ "t", "deserialize", "(", "consumer", "record", "<", "byte", "[", "]", ",", "byte", "[", "]", ">", "record", ")", "throws", "exception", ";" ]

[ "verify", "resolving", "path", "will", "return", "an", "iip", "that", "tracks", "if", "the", "original", "path", "was", "a", "raw", "path" ]

[ "public", "void", "test", "i", "nodes", "in", "path", "(", ")", "throws", "i", "o", "exception", "{", "f", "s", "directory", "fsd", "=", "cluster", "get", "namesystem", "(", ")", "get", "f", "s", "directory", "(", ")", ";", "final", "string", "path", "=", "\"", "/", "path", "\"", ";", "i", "nodes", "in", "path", "iip", "=", "fsd", "resolve", "path", "(", "null", ",", "path", ",", "dir", "op", "read", ")", ";", "assert", "false", "(", "iip", "is", "raw", "(", ")", ")", ";", "assert", "equals", "(", "path", ",", "iip", "get", "path", "(", ")", ")", ";", "iip", "=", "fsd", "resolve", "path", "(", "null", ",", "\"", "/", "reserved", "/", "raw", "\"", "+", "path", ",", "dir", "op", "read", ")", ";", "assert", "true", "(", "iip", "is", "raw", "(", ")", ")", ";", "assert", "equals", "(", "path", ",", "iip", "get", "path", "(", ")", ")", ";", "}" ]

[ "test", "serialization", "of", "outer", "boolean", "types" ]

[ "public", "void", "fake", "outer", "boolean", "serialize", "test", "(", ")", "throws", "api", "exception", "{", "boolean", "body", "=", "null", ";", "completable", "future", "<", "boolean", ">", "response", "=", "api", "fake", "outer", "boolean", "serialize", "(", "body", ")", ";", "/", "/", "todo", ":", "test", "validations", "}" ]

[ "for", "j", "unit", "testing", "only", ",", "set", "the", "option", "for", "resolving", "a", "conflict" ]

[ "void", "set", "conflict", "decision", "(", "int", "decision", ")", "{", "switch", "(", "decision", ")", "{", "case", "canceled", ":", "case", "ask", "user", ":", "case", "keep", "my", ":", "case", "keep", "latest", ":", "case", "keep", "original", ":", "conflict", "option", "=", "decision", ";", "break", ";", "default", ":", "throw", "new", "illegal", "argument", "exception", "(", ")", ";", "}", "}" ]

[ "returns", "true", "if", "automatic", "connection", "recovery", "is", "enabled", ",", "false", "otherwise" ]

[ "public", "boolean", "is", "automatic", "recovery", "(", ")", "{", "return", "automatic", "recovery", ";", "}" ]

[ "returns", "the", "proper", "utf", "-", "8", "representation", "of", "a", "string", "that", "was", "erroneously", "read", "using", "latin", "1" ]

[ "private", "static", "string", "convert", "latin", "1", "to", "utf", "8", "(", "string", "latin", "1", ")", "{", "return", "new", "string", "(", "latin", "1", "get", "bytes", "(", "standard", "charsets", "iso", "8859", "1", ")", ",", "standard", "charsets", "utf", "8", ")", ";", "}" ]

[ "this", "method", "will", "check", "for", "running", "transitions", "which", "do", "not", "exist", "after", "a", "layout", "change", "therefore", ",", "they", "need", "to", "be", "interrupted", "and", "\"", "finished", "\"" ]

[ "void", "finish", "undeclared", "transitions", "(", ")", "{", "for", "(", "animation", "state", "animation", "state", ":", "new", "array", "list", "<", ">", "(", "m", "animation", "states", "values", "(", ")", ")", ")", "{", "if", "(", "animation", "state", "should", "finish", "undeclared", "animation", ")", "{", "animation", "state", "should", "finish", "undeclared", "animation", "=", "false", ";", "for", "(", "property", "state", "property", "state", ":", "new", "array", "list", "<", ">", "(", "animation", "state", "property", "states", "values", "(", ")", ")", ")", "{", "final", "animation", "binding", "animation", "binding", "=", "property", "state", "animation", ";", "if", "(", "animation", "binding", "!", "=", "null", ")", "{", "animation", "binding", "stop", "(", ")", ";", "m", "animation", "binding", "listener", "finish", "animation", "(", "animation", "binding", ")", ";", "}", "}", "}", "}", "}" ]

[ "runs", "{", "@", "link", "#", "test", "method", "}", "on", "every", "instance", "method", "of", "the", "class", "of", "{", "@", "code", "instance", "}", "with", "at", "least", "{", "@", "code", "minimal", "visibility", "}", ",", "including", "those", "inherited", "from", "superclasses", "of", "the", "same", "package" ]

[ "public", "void", "test", "instance", "methods", "(", "object", "instance", ",", "visibility", "minimal", "visibility", ")", "{", "for", "(", "method", "method", ":", "get", "instance", "methods", "to", "test", "(", "instance", "get", "class", "(", ")", ",", "minimal", "visibility", ")", ")", "{", "test", "method", "(", "instance", ",", "method", ")", ";", "}", "}" ]

[ "get", "parameter", "types", "hints", "the", "right", "-", "hand", "side", "should", "be", "{", "@", "link", "sample", "family", "}" ]

[ "public", "class", "[", "]", "get", "parameter", "types", "(", ")", "{", "return", "new", "class", "[", "]", "{", "sample", "family", "class", "}", ";", "}" ]

[ "when", "the", "incremental", "mesh", "config", "request", "is", "the", "first", "in", "a", "stream", ",", "the", "initial", "resource", "versions", "must", "be", "populated", "otherwise", ",", "initial", "resource", "versions", "must", "be", "omitted", "the", "keys", "are", "the", "resources", "names", "of", "the", "mcp", "resources", "known", "to", "the", "mcp", "client", "the", "values", "in", "the", "map", "are", "the", "associated", "resource", "level", "version", "info", "<", "code", ">", "map", "&", "lt", ";", "string", ",", "string", "&", "gt", ";", "initial", "resource", "versions", "=", "3", ";", "<", "code", ">" ]

[ "public", "java", "lang", "string", "get", "initial", "resource", "versions", "or", "throw", "(", "java", "lang", "string", "key", ")", "{", "if", "(", "key", "=", "=", "null", ")", "{", "throw", "new", "java", "lang", "null", "pointer", "exception", "(", ")", ";", "}", "java", "util", "map", "<", "java", "lang", "string", ",", "java", "lang", "string", ">", "map", "=", "internal", "get", "initial", "resource", "versions", "(", ")", "get", "map", "(", ")", ";", "if", "(", "!", "map", "contains", "key", "(", "key", ")", ")", "{", "throw", "new", "java", "lang", "illegal", "argument", "exception", "(", ")", ";", "}", "return", "map", "get", "(", "key", ")", ";", "}" ]

[ "set", "the", "number", "of", "return", "bytes" ]

[ "public", "void", "set", "num", "return", "bytes", "(", "int", "return", "bytes", ")", "{", "this", "num", "return", "bytes", "=", "return", "bytes", ";", "}" ]

[ "validates", "the", "to", "string", "method", "for", "file", "status" ]

[ "private", "void", "validate", "to", "string", "(", "file", "status", "file", "status", ")", "throws", "i", "o", "exception", "{", "string", "builder", "expected", "=", "new", "string", "builder", "(", ")", ";", "expected", "append", "(", "\"", "file", "status", "{", "\"", ")", ";", "expected", "append", "(", "\"", "path", "=", "\"", ")", "append", "(", "file", "status", "get", "path", "(", ")", ")", "append", "(", "\"", ";", "\"", ")", ";", "expected", "append", "(", "\"", "is", "directory", "=", "\"", ")", "append", "(", "file", "status", "is", "directory", "(", ")", ")", "append", "(", "\"", ";", "\"", ")", ";", "if", "(", "!", "file", "status", "is", "directory", "(", ")", ")", "{", "expected", "append", "(", "\"", "length", "=", "\"", ")", "append", "(", "file", "status", "get", "len", "(", ")", ")", "append", "(", "\"", ";", "\"", ")", ";", "expected", "append", "(", "\"", "replication", "=", "\"", ")", "append", "(", "file", "status", "get", "replication", "(", ")", ")", "append", "(", "\"", ";", "\"", ")", ";", "expected", "append", "(", "\"", "blocksize", "=", "\"", ")", "append", "(", "file", "status", "get", "block", "size", "(", ")", ")", "append", "(", "\"", ";", "\"", ")", ";", "}", "expected", "append", "(", "\"", "modification", "time", "=", "\"", ")", "append", "(", "file", "status", "get", "modification", "time", "(", ")", ")", "append", "(", "\"", ";", "\"", ")", ";", "expected", "append", "(", "\"", "access", "time", "=", "\"", ")", "append", "(", "file", "status", "get", "access", "time", "(", ")", ")", "append", "(", "\"", ";", "\"", ")", ";", "expected", "append", "(", "\"", "owner", "=", "\"", ")", "append", "(", "file", "status", "get", "owner", "(", ")", ")", "append", "(", "\"", ";", "\"", ")", ";", "expected", "append", "(", "\"", "group", "=", "\"", ")", "append", "(", "file", "status", "get", "group", "(", ")", ")", "append", "(", "\"", ";", "\"", ")", ";", "expected", "append", "(", "\"", "permission", "=", "\"", ")", "append", "(", "file", "status", "get", "permission", "(", ")", ")", "append", "(", "\"", ";", "\"", ")", ";", "if", "(", "file", "status", "is", "symlink", "(", ")", ")", "{", "expected", "append", "(", "\"", "is", "symlink", "=", "\"", ")", "append", "(", "true", ")", "append", "(", "\"", ";", "\"", ")", ";", "expected", "append", "(", "\"", "symlink", "=", "\"", ")", "append", "(", "file", "status", "get", "symlink", "(", ")", ")", "append", "(", "\"", ";", "\"", ")", ";", "}", "else", "{", "expected", "append", "(", "\"", "is", "symlink", "=", "\"", ")", "append", "(", "false", ")", "append", "(", "\"", ";", "\"", ")", ";", "}", "expected", "append", "(", "\"", "has", "acl", "=", "\"", ")", "append", "(", "file", "status", "has", "acl", "(", ")", ")", "append", "(", "\"", ";", "\"", ")", ";", "expected", "append", "(", "\"", "is", "encrypted", "=", "\"", ")", "append", "(", "file", "status", "is", "encrypted", "(", ")", ")", "append", "(", "\"", ";", "\"", ")", ";", "expected", "append", "(", "\"", "is", "erasure", "coded", "=", "\"", ")", "append", "(", "file", "status", "is", "erasure", "coded", "(", ")", ")", "append", "(", "\"", "}", "\"", ")", ";", "assert", "equals", "(", "expected", "to", "string", "(", ")", ",", "file", "status", "to", "string", "(", ")", ")", ";", "}" ]

[ "creates", "closure", "in", "accordance", "with", "method", "return", "type" ]

[ "closure", "create", "closure", "(", "final", "meta", "holder", "meta", "holder", ",", "final", "method", "method", ",", "final", "object", "o", ",", "final", "object", "args", ")", ";" ]

[ "call", "this", "method", "to", "refresh", "the", "graph", "with", "a", "given", "matrix" ]

[ "public", "matrix", "refresh", "(", "matrix", "new", "matrix", ",", "view", "chart", ",", "boolean", "invalidate", ")", "{", "m", "matrix", "touch", "set", "(", "new", "matrix", ")", ";", "/", "/", "make", "sure", "scale", "and", "translation", "are", "within", "their", "bounds", "limit", "trans", "and", "scale", "(", "m", "matrix", "touch", ",", "m", "content", "rect", ")", ";", "if", "(", "invalidate", ")", "chart", "invalidate", "(", ")", ";", "new", "matrix", "set", "(", "m", "matrix", "touch", ")", ";", "return", "new", "matrix", ";", "}" ]

[ "get", "absolute", "maximum", "resource", "requirement", "for", "a", "queue" ]

[ "public", "resource", "get", "maximum", "resource", "requirement", "(", "string", "label", ",", "string", "queue", ",", "set", "<", "string", ">", "resource", "types", ")", "{", "return", "internal", "get", "labeled", "resource", "requirement", "for", "queue", "(", "queue", ",", "label", ",", "resource", "types", ",", "maximum", "capacity", ")", ";", "}" ]

[ "creates", "a", "new", "{", "@", "link", "list", "}", "which", "holds", "the", "{", "@", "link", "inet", "socket", "address", "}", "es" ]

[ "list", "<", "inet", "socket", "address", ">", "address", "list", "(", ")", "{", "list", "<", "inet", "socket", "address", ">", "address", "list", "=", "new", "array", "list", "<", "inet", "socket", "address", ">", "(", "name", "server", "count", ")", ";", "authoritative", "name", "server", "server", "=", "head", ";", "while", "(", "server", "!", "=", "null", ")", "{", "if", "(", "server", "address", "!", "=", "null", ")", "{", "address", "list", "add", "(", "server", "address", ")", ";", "}", "server", "=", "server", "next", ";", "}", "return", "address", "list", ";", "}" ]

[ "return", "whether", "to", "inhibit", "the", "delivery", "of", "messages", "published", "by", "its", "own", "connection" ]

[ "public", "boolean", "is", "pub", "sub", "no", "local", "(", ")", "{", "return", "this", "pub", "sub", "no", "local", ";", "}" ]

[ "method", "to", "select", "which", "known", "fid", "databases", "are", "currently", "active", "during", "search" ]

[ "private", "synchronized", "void", "choose", "active", "fid", "dbs", "(", ")", "{", "active", "fid", "configure", "dialog", "dialog", "=", "new", "active", "fid", "configure", "dialog", "(", "fid", "file", "manager", "get", "fid", "files", "(", ")", ")", ";", "tool", "show", "dialog", "(", "dialog", ")", ";", "}" ]

[ "returns", "the", "base", "-", "10", "logarithm", "of", "{", "@", "code", "x", "}", ",", "rounded", "according", "to", "the", "specified", "rounding", "mode" ]

[ "public", "static", "int", "log", "1", "0", "(", "big", "integer", "x", ",", "rounding", "mode", "mode", ")", "{", "check", "positive", "(", "\"", "x", "\"", ",", "x", ")", ";", "if", "(", "fits", "in", "long", "(", "x", ")", ")", "{", "return", "long", "math", "log", "1", "0", "(", "x", "long", "value", "(", ")", ",", "mode", ")", ";", "}", "int", "approx", "log", "1", "0", "=", "(", "int", ")", "(", "log", "2", "(", "x", ",", "floor", ")", "*", "ln", "2", "/", "ln", "10", ")", ";", "big", "integer", "approx", "pow", "=", "big", "integer", "ten", "pow", "(", "approx", "log", "1", "0", ")", ";", "int", "approx", "cmp", "=", "approx", "pow", "compare", "to", "(", "x", ")", ";", "/", "*", "*", "we", "adjust", "approx", "log", "1", "0", "and", "approx", "pow", "until", "they", "'", "re", "equal", "to", "floor", "(", "log", "1", "0", "(", "x", ")", ")", "and", "*", "10", "^", "floor", "(", "log", "1", "0", "(", "x", ")", ")", "*", "/", "if", "(", "approx", "cmp", ">", "0", ")", "{", "/", "*", "*", "the", "code", "is", "written", "so", "that", "even", "completely", "incorrect", "approximations", "will", "still", "yield", "the", "*", "correct", "answer", "eventually", ",", "but", "in", "practice", "this", "branch", "should", "almost", "never", "be", "entered", ",", "and", "*", "even", "then", "the", "loop", "should", "not", "run", "more", "than", "once", "*", "/", "do", "{", "approx", "log", "1", "0", "-", "-", ";", "approx", "pow", "=", "approx", "pow", "divide", "(", "big", "integer", "ten", ")", ";", "approx", "cmp", "=", "approx", "pow", "compare", "to", "(", "x", ")", ";", "}", "while", "(", "approx", "cmp", ">", "0", ")", ";", "}", "else", "{", "big", "integer", "next", "pow", "=", "big", "integer", "ten", "multiply", "(", "approx", "pow", ")", ";", "int", "next", "cmp", "=", "next", "pow", "compare", "to", "(", "x", ")", ";", "while", "(", "next", "cmp", "<", "=", "0", ")", "{", "approx", "log", "1", "0", "+", "+", ";", "approx", "pow", "=", "next", "pow", ";", "approx", "cmp", "=", "next", "cmp", ";", "next", "pow", "=", "big", "integer", "ten", "multiply", "(", "approx", "pow", ")", ";", "next", "cmp", "=", "next", "pow", "compare", "to", "(", "x", ")", ";", "}", "}", "int", "floor", "log", "=", "approx", "log", "1", "0", ";", "big", "integer", "floor", "pow", "=", "approx", "pow", ";", "int", "floor", "cmp", "=", "approx", "cmp", ";", "switch", "(", "mode", ")", "{", "case", "unnecessary", ":", "check", "rounding", "unnecessary", "(", "floor", "cmp", "=", "=", "0", ")", ";", "/", "/", "fall", "through", "case", "floor", ":", "case", "down", ":", "return", "floor", "log", ";", "case", "ceiling", ":", "case", "up", ":", "return", "floor", "pow", "equals", "(", "x", ")", "?", "floor", "log", ":", "floor", "log", "+", "1", ";", "case", "half", "down", ":", "case", "half", "up", ":", "case", "half", "even", ":", "/", "/", "since", "sqrt", "(", "10", ")", "is", "irrational", ",", "log", "1", "0", "(", "x", ")", "-", "floor", "log", "can", "never", "be", "exactly", "0", "5", "big", "integer", "x", "2", "=", "x", "pow", "(", "2", ")", ";", "big", "integer", "half", "power", "squared", "=", "floor", "pow", "pow", "(", "2", ")", "multiply", "(", "big", "integer", "ten", ")", ";", "return", "(", "x", "2", "compare", "to", "(", "half", "power", "squared", ")", "<", "=", "0", ")", "?", "floor", "log", ":", "floor", "log", "+", "1", ";", "default", ":", "throw", "new", "assertion", "error", "(", ")", ";", "}", "}" ]

[ "makes", "the", "built", "attribute", "mandatory" ]

[ "public", "builder", "<", "type", ">", "mandatory", "(", ")", "{", "return", "set", "property", "flag", "(", "property", "flag", "mandatory", ",", "\"", "mandatory", "\"", ")", ";", "}" ]

[ "processes", "each", "model", "'", "s", "property", "that", "relates", "to", "another", "model" ]

[ "public", "boolean", "process", "foreign", "key", "(", "codegen", "model", "model", ",", "codegen", "property", "property", ",", "map", "<", "string", ",", "object", ">", "relation", "definition", ")", "{", "string", "data", "type", "=", "property", "get", "data", "type", "(", ")", ";", "if", "(", "!", "property", "is", "array", "&", "&", "!", "is", "relation", "(", "data", "type", ")", ")", "return", "false", ";", "string", "model", "name", "=", "model", "get", "name", "(", ")", ";", "string", "try", "data", "type", "=", "property", "is", "array", "?", "property", "items", "data", "type", ":", "property", "data", "type", ";", "string", "try", "data", "format", "=", "property", "is", "array", "?", "property", "items", "data", "format", ":", "property", "data", "format", ";", "boolean", "is", "primitive", "=", "(", "try", "data", "type", "starts", "with", "(", "\"", "kotlin", "\"", ")", "|", "|", "try", "data", "type", "starts", "with", "(", "\"", "java", "\"", ")", ")", ";", "string", "prop", "name", "=", "is", "primitive", "?", "property", "get", "name", "(", ")", ":", "try", "data", "type", ";", "string", "pk", "name", "=", "to", "title", "case", "(", "to", "model", "name", "(", "model", "name", ")", ")", ";", "string", "pk", "col", "name", "=", "to", "column", "name", "(", "pk", "name", ")", ";", "string", "fk", "name", "=", "to", "title", "case", "(", "to", "model", "name", "(", "prop", "name", ")", ")", ";", "string", "fk", "col", "name", "=", "to", "column", "name", "(", "fk", "name", ")", ";", "string", "rel", "name", "=", "to", "model", "name", "(", "camelize", "(", "model", "name", ")", "+", "camelize", "(", "prop", "name", ")", ")", ";", "string", "rel", "tbl", "name", "=", "to", "table", "name", "(", "rel", "name", ")", ";", "final", "integer", "schema", "pk", "schema", "=", "new", "integer", "schema", "(", ")", "format", "(", "schema", "type", "util", "integer64", "format", ")", ";", "string", "pk", "data", "type", "=", "get", "schema", "type", "(", "pk", "schema", ")", ";", "string", "pk", "data", "format", "=", "pk", "schema", "get", "format", "(", ")", ";", "string", "pk", "col", "type", "=", "to", "column", "type", "(", "pk", "data", "type", ",", "pk", "data", "format", ")", ";", "string", "fk", "data", "type", "=", "is", "primitive", "?", "try", "data", "type", ":", "pk", "data", "type", ";", "string", "fk", "data", "format", "=", "is", "primitive", "?", "try", "data", "format", ":", "pk", "data", "format", ";", "string", "fk", "col", "type", "=", "to", "column", "type", "(", "fk", "data", "type", ",", "fk", "data", "format", ")", ";", "sql", "type", "args", "pk", "args", "=", "new", "sql", "type", "args", "(", ")", ";", "to", "column", "type", "args", "(", "pk", "data", "type", ",", "pk", "data", "format", ",", "null", ",", "null", ",", "pk", "args", ")", ";", "sql", "type", "args", "fk", "args", "=", "new", "sql", "type", "args", "(", ")", ";", "to", "column", "type", "args", "(", "fk", "data", "type", ",", "fk", "data", "format", ",", "null", ",", "null", ",", "fk", "args", ")", ";", "relation", "definition", "put", "(", "\"", "pk", "name", "\"", ",", "pk", "name", ")", ";", "relation", "definition", "put", "(", "\"", "pk", "col", "name", "\"", ",", "pk", "col", "name", ")", ";", "relation", "definition", "put", "(", "\"", "pk", "col", "type", "\"", ",", "pk", "col", "type", ")", ";", "relation", "definition", "put", "(", "\"", "pk", "col", "kotlin", "type", "\"", ",", "pk", "data", "type", ")", ";", "relation", "definition", "put", "(", "\"", "pk", "is", "numeric", "\"", ",", "pk", "args", "is", "numeric", ")", ";", "relation", "definition", "put", "(", "\"", "pk", "is", "integer", "\"", ",", "pk", "args", "is", "integer", ")", ";", "relation", "definition", "put", "(", "\"", "pk", "is", "string", "\"", ",", "pk", "args", "is", "string", ")", ";", "relation", "definition", "put", "(", "\"", "pk", "is", "primitive", "\"", ",", "pk", "args", "is", "primitive", ")", ";", "relation", "definition", "put", "(", "\"", "fk", "name", "\"", ",", "fk", "name", ")", ";", "relation", "definition", "put", "(", "\"", "fk", "col", "name", "\"", ",", "fk", "col", "name", ")", ";", "relation", "definition", "put", "(", "\"", "fk", "col", "type", "\"", ",", "fk", "col", "type", ")", ";", "relation", "definition", "put", "(", "\"", "fk", "col", "kotlin", "type", "\"", ",", "fk", "data", "type", ")", ";", "relation", "definition", "put", "(", "\"", "fk", "is", "numeric", "\"", ",", "fk", "args", "is", "numeric", ")", ";", "relation", "definition", "put", "(", "\"", "fk", "is", "integer", "\"", ",", "fk", "args", "is", "integer", ")", ";", "relation", "definition", "put", "(", "\"", "fk", "is", "string", "\"", ",", "fk", "args", "is", "string", ")", ";", "relation", "definition", "put", "(", "\"", "fk", "is", "primitive", "\"", ",", "fk", "args", "is", "primitive", ")", ";", "relation", "definition", "put", "(", "\"", "rel", "name", "\"", ",", "rel", "name", ")", ";", "relation", "definition", "put", "(", "\"", "rel", "tbl", "name", "\"", ",", "rel", "tbl", "name", ")", ";", "return", "true", ";", "}" ]

[ "builds", "the", "{", "@", "code", "router", "function", "}", "all", "created", "routes", "are", "{", "@", "linkplain", "router", "function", "#", "and", "(", "router", "function", ")", "composed", "}", "with", "one", "another", ",", "and", "filters", "(", "if", "any", ")", "are", "applied", "to", "the", "result" ]

[ "router", "function", "<", "server", "response", ">", "build", "(", ")", ";" ]

[ "generates", "a", "random", "chart", "data", "object", "with", "just", "one", "data", "set" ]

[ "private", "bar", "data", "generate", "data", "bar", "(", "int", "cnt", ")", "{", "array", "list", "<", "bar", "entry", ">", "entries", "=", "new", "array", "list", "<", ">", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "12", ";", "i", "+", "+", ")", "{", "entries", "add", "(", "new", "bar", "entry", "(", "i", ",", "(", "int", ")", "(", "math", "random", "(", ")", "*", "70", ")", "+", "30", ")", ")", ";", "}", "bar", "data", "set", "d", "=", "new", "bar", "data", "set", "(", "entries", ",", "\"", "new", "data", "set", "\"", "+", "cnt", ")", ";", "d", "set", "colors", "(", "color", "template", "vordiplom", "colors", ")", ";", "d", "set", "high", "light", "alpha", "(", "255", ")", ";", "bar", "data", "cd", "=", "new", "bar", "data", "(", "d", ")", ";", "cd", "set", "bar", "width", "(", "0", "9f", ")", ";", "return", "cd", ";", "}" ]

[ "only", "select", "tasks", "which", "have", "a", "local", "variable", "value", "greater", "than", "the", "passed", "value", "when", "they", "ended", "booleans", ",", "byte", "-", "arrays", "and", "{", "@", "link", "serializable", "}", "objects", "(", "which", "are", "not", "primitive", "type", "wrappers", ")", "are", "not", "supported" ]

[ "t", "task", "variable", "value", "greater", "than", "(", "string", "name", ",", "object", "value", ")", ";" ]

[ "sets", "up", "mocking", "support", "for", "genrules" ]

[ "public", "static", "void", "setup", "(", "mock", "tools", "config", "config", ")", "throws", "i", "o", "exception", "{", "config", "create", "(", "\"", "tools", "/", "genrule", "/", "build", "\"", ",", "\"", "exports", "files", "(", "[", "'", "genrule", "-", "setup", "sh", "'", "]", ")", "\"", ")", ";", "config", "create", "(", "\"", "tools", "/", "genrule", "/", "genrule", "-", "setup", "sh", "\"", ")", ";", "}" ]

[ "identify", "an", "user" ]

[ "private", "void", "identify", "(", ")", "{", "if", "(", "m", "t", "config", "get", "instance", "(", ")", "is", "disallow", "data", "collection", "(", ")", "|", "|", "is", "offline", ")", "{", "return", ";", "}", "try", "{", "@", "non", "nls", "final", "j", "s", "o", "n", "object", "props", "=", "new", "j", "s", "o", "n", "object", "(", ")", ";", "props", "put", "(", "\"", "ide", "\"", ",", "application", "names", "info", "get", "instance", "(", ")", "get", "full", "product", "name", "(", ")", ")", ";", "props", "put", "(", "\"", "i", "d", "e", "version", "\"", ",", "application", "info", "get", "instance", "(", ")", "get", "build", "(", ")", "get", "baseline", "version", "(", ")", ")", ";", "props", "put", "(", "\"", "version", "\"", ",", "m", "t", "config", "get", "instance", "(", ")", "get", "version", "(", ")", ")", ";", "final", "j", "s", "o", "n", "object", "update", "=", "message", "builder", "set", "(", "user", "id", ",", "props", ")", ";", "mixpanel", "send", "message", "(", "update", ")", ";", "}", "catch", "(", "final", "i", "o", "exception", "|", "j", "s", "o", "n", "exception", "e", ")", "{", "is", "offline", "=", "true", ";", "}", "}" ]

[ "test", "the", "owner", "(", "not", "admin", ")", "of", "directory", "can", "set", "the", "quota", "of", "it", "'", "s", "sub", "-", "directories" ]

[ "public", "void", "test", "owner", "can", "set", "sub", "dir", "quota", "(", ")", "throws", "exception", "{", "final", "string", "user", "name", "=", "\"", "user", "1", "\"", ";", "final", "string", "group", "name", "=", "\"", "hadoop", "\"", ";", "final", "string", "parent", "dir", "=", "\"", "/", "parent", "owner", "\"", ";", "final", "string", "sub", "dir", "=", "parent", "dir", "+", "\"", "/", "subdir", "\"", ";", "create", "dirss", "and", "set", "owner", "(", "parent", "dir", ",", "sub", "dir", ",", "user", "name", ",", "group", "name", ")", ";", "final", "d", "f", "s", "admin", "admin", "=", "new", "d", "f", "s", "admin", "(", "conf", ")", ";", "/", "/", "set", "quota", "with", "superuser", "string", "[", "]", "args", "=", "new", "string", "[", "]", "{", "\"", "-", "set", "quota", "\"", ",", "\"", "10", "\"", ",", "parent", "dir", "to", "string", "(", ")", "}", ";", "test", "quota", "run", "command", "(", "admin", ",", "args", ",", "false", ")", ";", "args", "=", "new", "string", "[", "]", "{", "\"", "-", "set", "space", "quota", "\"", ",", "\"", "128", "\"", ",", "parent", "dir", "to", "string", "(", ")", "}", ";", "test", "quota", "run", "command", "(", "admin", ",", "args", ",", "false", ")", ";", "user", "group", "information", "ugi", "=", "user", "group", "information", "create", "user", "for", "testing", "(", "user", "name", ",", "new", "string", "[", "]", "{", "group", "name", "}", ")", ";", "ugi", "do", "as", "(", "(", "privileged", "exception", "action", "<", "object", ">", ")", "(", ")", "-", ">", "{", "assert", "equals", "(", "\"", "not", "running", "as", "new", "user", "\"", ",", "user", "name", ",", "user", "group", "information", "get", "current", "user", "(", ")", "get", "short", "user", "name", "(", ")", ")", ";", "d", "f", "s", "admin", "user", "admin", "=", "new", "d", "f", "s", "admin", "(", "conf", ")", ";", "string", "[", "]", "args", "2", "=", "new", "string", "[", "]", "{", "\"", "-", "set", "quota", "\"", ",", "\"", "5", "\"", ",", "sub", "dir", "}", ";", "test", "quota", "run", "command", "(", "user", "admin", ",", "args", "2", ",", "false", ")", ";", "args", "2", "=", "new", "string", "[", "]", "{", "\"", "-", "set", "space", "quota", "\"", ",", "\"", "64", "\"", ",", "sub", "dir", "}", ";", "test", "quota", "run", "command", "(", "user", "admin", ",", "args", "2", ",", "false", ")", ";", "content", "summary", "c", "=", "dfs", "get", "content", "summary", "(", "new", "path", "(", "sub", "dir", ")", ")", ";", "assert", "equals", "(", "\"", "not", "same", "with", "setting", "quota", "\"", ",", "5", ",", "c", "get", "quota", "(", ")", ")", ";", "assert", "equals", "(", "\"", "not", "same", "with", "setting", "space", "quota", "\"", ",", "64", ",", "c", "get", "space", "quota", "(", ")", ")", ";", "args", "2", "=", "new", "string", "[", "]", "{", "\"", "-", "clr", "quota", "\"", ",", "sub", "dir", "}", ";", "test", "quota", "run", "command", "(", "user", "admin", ",", "args", "2", ",", "false", ")", ";", "args", "2", "=", "new", "string", "[", "]", "{", "\"", "-", "clr", "space", "quota", "\"", ",", "sub", "dir", "}", ";", "test", "quota", "run", "command", "(", "user", "admin", ",", "args", "2", ",", "false", ")", ";", "c", "=", "dfs", "get", "content", "summary", "(", "new", "path", "(", "sub", "dir", ")", ")", ";", "assert", "equals", "(", "\"", "not", "clean", "quota", "\"", ",", "-", "1", ",", "c", "get", "quota", "(", ")", ")", ";", "assert", "equals", "(", "\"", "not", "clean", "space", "quota", "\"", ",", "-", "1", ",", "c", "get", "space", "quota", "(", ")", ")", ";", "return", "null", ";", "}", ")", ";", "}" ]

[ "initializer", "method", "to", "avoid", "the", "publication", "of", "a", "self", "reference", "in", "the", "constructor" ]

[ "public", "void", "init", "(", "cluster", "service", "cluster", "service", ")", "{", "cluster", "service", "add", "local", "node", "master", "listener", "(", "this", ")", ";", "cluster", "service", "get", "cluster", "settings", "(", ")", "add", "settings", "update", "consumer", "(", "lifecycle", "settings", "slm", "retention", "schedule", "setting", ",", "this", ":", ":", "set", "update", "schedule", ")", ";", "}" ]

[ "set", "the", "duration", "without", "ongoing", "r", "p", "cs", "before", "going", "to", "idle", "mode", "in", "idle", "mode", "the", "channel", "shuts", "down", "all", "connections", ",", "the", "name", "resolver", "and", "the", "load", "balancer", "a", "new", "rpc", "would", "take", "the", "channel", "out", "of", "idle", "mode", "a", "channel", "starts", "in", "idle", "mode", "defaults", "to", "30", "minutes", "this", "is", "an", "advisory", "option", "do", "not", "rely", "on", "any", "specific", "behavior", "related", "to", "this", "option" ]

[ "public", "abstract", "t", "idle", "timeout", "(", "long", "value", ",", "time", "unit", "unit", ")", ";" ]

[ "gets", "the", "boolean", "value", "of", "the", "option", "with", "the", "given", "name", "from", "the", "given", "list", "of", "options" ]

[ "public", "static", "boolean", "get", "boolean", "option", "value", "(", "string", "option", "name", ",", "list", "<", "option", ">", "options", ",", "boolean", "default", "value", ")", "{", "if", "(", "options", "!", "=", "null", ")", "{", "for", "(", "option", "option", ":", "options", ")", "{", "if", "(", "option", "get", "name", "(", ")", "equals", "(", "option", "name", ")", ")", "{", "object", "val", "=", "option", "get", "value", "(", ")", ";", "if", "(", "val", "instanceof", "boolean", ")", "{", "return", "(", "boolean", ")", "option", "get", "value", "(", ")", ";", "}", "}", "}", "}", "return", "default", "value", ";", "}" ]

[ "{", "@", "link", "#", "handle", "(", ")", "}" ]

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

[ "delete", "purchase", "order", "by", "id", "for", "valid", "response", "try", "integer", "i", "ds", "with", "value", "&", "lt", ";", "1000", "anything", "above", "1000", "or", "nonintegers", "will", "generate", "api", "errors" ]

[ "public", "void", "delete", "order", "(", "string", "order", "id", ")", "throws", "api", "exception", "{", "delete", "order", "with", "http", "info", "(", "order", "id", ")", ";", "}" ]

[ "the", "comment", "associated", "with", "the", "&", "lt", ";", "public", "&", "gt", ";", "tag", "<", "code", ">", "optional", "string", "comment", "=", "3", ";", "<", "code", ">" ]

[ "private", "void", "clear", "comment", "(", ")", "{", "bit", "field", "0", "=", "(", "bit", "field", "0", "&", "~", "0x", "0", "0", "0", "0", "0", "0", "0", "4", ")", ";", "comment", "=", "get", "default", "instance", "(", ")", "get", "comment", "(", ")", ";", "}" ]

[ "get", "the", "current", "value", "of", "the", "gauge" ]

[ "double", "get", "value", "(", ")", ";" ]

[ "returns", "the", "operator", "table", "for", "this", "environment", "including", "a", "custom", "calcite", "configuration" ]

[ "private", "sql", "operator", "table", "get", "sql", "operator", "table", "(", "calcite", "config", "calcite", "config", ",", "function", "catalog", "function", "catalog", ")", "{", "sql", "operator", "table", "base", "operator", "table", "=", "sql", "operator", "tables", "chain", "(", "new", "basic", "operator", "table", "(", ")", ",", "new", "function", "catalog", "operator", "table", "(", "function", "catalog", ",", "type", "factory", ")", ")", ";", "return", "java", "scala", "conversion", "util", "to", "java", "(", "calcite", "config", "sql", "operator", "table", "(", ")", ")", "map", "(", "operator", "table", "-", ">", "{", "if", "(", "calcite", "config", "replaces", "sql", "operator", "table", "(", ")", ")", "{", "return", "operator", "table", ";", "}", "else", "{", "return", "sql", "operator", "tables", "chain", "(", "base", "operator", "table", ",", "operator", "table", ")", ";", "}", "}", ")", "or", "else", "(", "base", "operator", "table", ")", ";", "}" ]

[ "adds", "a", "settings", "consumer", "with", "a", "predicate", "that", "is", "only", "evaluated", "at", "update", "time", "note", ":", "only", "settings", "registered", "in", "{", "@", "link", "settings", "module", "}", "can", "be", "changed", "dynamically" ]

[ "public", "synchronized", "<", "t", ">", "void", "add", "settings", "update", "consumer", "(", "setting", "<", "t", ">", "setting", ",", "consumer", "<", "t", ">", "consumer", ",", "consumer", "<", "t", ">", "validator", ")", "{", "if", "(", "setting", "!", "=", "get", "(", "setting", "get", "key", "(", ")", ")", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "setting", "is", "not", "registered", "for", "key", "[", "\"", "+", "setting", "get", "key", "(", ")", "+", "\"", "]", "\"", ")", ";", "}", "add", "settings", "updater", "(", "setting", "new", "updater", "(", "consumer", ",", "logger", ",", "validator", ")", ")", ";", "}" ]

[ "tests", "safemode", "with", "view", "f", "s", "overload", "scheme", ",", "but", "-", "fs", "option", "with", "local", "fs" ]

[ "public", "void", "test", "safe", "mode", "should", "fail", "on", "local", "target", "f", "s", "(", ")", "throws", "exception", "{", "add", "mount", "links", "(", "default", "f", "s", "u", "r", "i", "get", "host", "(", ")", ",", "new", "string", "[", "]", "{", "local", "folder", "}", ",", "new", "string", "[", "]", "{", "local", "target", "dir", "to", "u", "r", "i", "(", ")", "to", "string", "(", ")", "}", ",", "conf", ")", ";", "final", "d", "f", "s", "admin", "dfs", "admin", "=", "new", "d", "f", "s", "admin", "(", "conf", ")", ";", "/", "/", "view", "f", "s", "oveload", "scheme", "uri", "with", "localfs", "mount", "point", "string", "uri", "=", "default", "f", "s", "u", "r", "i", "to", "string", "(", ")", "+", "local", "folder", ";", "redirect", "stream", "(", ")", ";", "int", "ret", "=", "tool", "runner", "run", "(", "dfs", "admin", ",", "new", "string", "[", "]", "{", "\"", "-", "fs", "\"", ",", "uri", ",", "\"", "-", "safemode", "\"", ",", "\"", "enter", "\"", "}", ")", ";", "assert", "equals", "(", "-", "1", ",", "ret", ")", ";", "assert", "err", "msg", "(", "\"", "safemode", ":", "file", "system", "file", ":", "/", "/", "/", "is", "not", "an", "hdfs", "file", "system", "\"", "+", "\"", "the", "fs", "class", "is", ":", "org", "apache", "hadoop", "fs", "local", "file", "system", "\"", ",", "0", ")", ";", "}" ]

[ "validates", "the", "fields", "on", "the", "page", "and", "updates", "the", "page", "'", "s", "status", "should", "be", "called", "every", "time", "a", "field", "on", "the", "page", "changes" ]

[ "private", "void", "validate", "(", ")", "{", "string", "message", "=", "null", ";", "if", "(", "ghidra", "project", "creator", "preferences", "get", "ghidra", "install", "dirs", "(", ")", "is", "empty", "(", ")", ")", "{", "message", "=", "\"", "no", "ghidra", "installations", "found", "click", "the", "+", "button", "to", "add", "one", "\"", ";", "}", "else", "if", "(", "ghidra", "install", "dir", "combo", "get", "text", "(", ")", "is", "empty", "(", ")", ")", "{", "message", "=", "\"", "ghidra", "installation", "must", "be", "specified", "\"", ";", "}", "else", "{", "try", "{", "file", "ghidra", "install", "dir", "=", "new", "file", "(", "ghidra", "install", "dir", "combo", "get", "text", "(", ")", ")", ";", "ghidra", "project", "creator", "preference", "page", "validate", "ghidra", "installation", "(", "ghidra", "install", "dir", ")", ";", "try", "{", "java", "config", "java", "config", "=", "new", "java", "config", "(", "ghidra", "install", "dir", ")", ";", "if", "(", "!", "java", "config", "is", "supported", "java", "home", "dir", "(", "java", "config", "get", "saved", "java", "home", "(", ")", ",", "java", "filter", "jdk", "only", ")", ")", "{", "message", "=", "\"", "a", "supported", "jdk", "is", "not", "associated", "with", "this", "ghidra", "\"", "+", "\"", "installation", "please", "run", "this", "ghidra", "and", "try", "again", "\"", ";", "}", "}", "catch", "(", "parse", "exception", "|", "i", "o", "exception", "e", ")", "{", "message", "=", "\"", "failed", "to", "determine", "ghidra", "'", "s", "jdk", "version", "\"", "+", "e", "get", "message", "(", ")", ";", "}", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "message", "=", "e", "get", "message", "(", ")", ";", "}", "}", "set", "error", "message", "(", "message", ")", ";", "set", "page", "complete", "(", "message", "=", "=", "null", ")", ";", "}" ]

[ "copy", "the", "contents", "of", "another", "instance", "into", "this", "instance" ]

[ "public", "void", "set", "(", "m", "d", "5", "hash", "that", ")", "{", "system", "arraycopy", "(", "that", "digest", ",", "0", ",", "this", "digest", ",", "0", ",", "md5", "len", ")", ";", "}" ]

[ "adds", "{", "@", "code", "node", "}", "if", "it", "is", "not", "already", "present", "<", "b", ">", "nodes", "must", "be", "unique", "<", "b", ">", ",", "just", "as", "{", "@", "code", "map", "}", "keys", "must", "be", "they", "must", "also", "be", "non", "-", "null" ]

[ "public", "builder", "<", "n", ">", "add", "node", "(", "n", "node", ")", "{", "mutable", "graph", "add", "node", "(", "node", ")", ";", "return", "this", ";", "}" ]

[ "adds", "a", "route", "to", "the", "given", "handler", "function", "that", "handles", "http", "{", "@", "code", "head", "}", "requests" ]

[ "builder", "head", "(", "handler", "function", "<", "server", "response", ">", "handler", "function", ")", ";" ]

[ "create", "a", "proxy", "for", "the", "specified", "protocol" ]

[ "public", "static", "<", "t", ">", "t", "create", "r", "m", "proxy", "(", "final", "configuration", "configuration", ",", "final", "class", "<", "t", ">", "protocol", ",", "user", "group", "information", "user", ",", "final", "token", "<", "?", "extends", "token", "identifier", ">", "token", ")", "throws", "i", "o", "exception", "{", "try", "{", "string", "rm", "cluster", "id", "=", "configuration", "get", "(", "yarn", "configuration", "rm", "cluster", "id", ",", "yarn", "configuration", "default", "rm", "cluster", "id", ")", ";", "log", "info", "(", "\"", "creating", "r", "m", "proxy", "to", "rm", "{", "}", "for", "protocol", "{", "}", "for", "user", "{", "}", "\"", ",", "rm", "cluster", "id", ",", "protocol", "get", "simple", "name", "(", ")", ",", "user", ")", ";", "if", "(", "token", "!", "=", "null", ")", "{", "/", "/", "preserve", "the", "token", "service", "sent", "by", "the", "rm", "when", "adding", "the", "token", "/", "/", "to", "ensure", "we", "replace", "the", "previous", "token", "setup", "by", "the", "rm", "/", "/", "afterwards", "we", "can", "update", "the", "service", "address", "for", "the", "rpc", "layer", "/", "/", "same", "as", "yarn", "server", "security", "utils", "update", "a", "m", "r", "m", "token", "(", ")", "user", "add", "token", "(", "token", ")", ";", "token", "set", "service", "(", "client", "r", "m", "proxy", "get", "a", "m", "r", "m", "token", "service", "(", "configuration", ")", ")", ";", "set", "auth", "mode", "in", "conf", "(", "configuration", ")", ";", "}", "final", "t", "proxy", "connection", "=", "user", "do", "as", "(", "new", "privileged", "exception", "action", "<", "t", ">", "(", ")", "{", "@", "override", "public", "t", "run", "(", ")", "throws", "exception", "{", "return", "client", "r", "m", "proxy", "create", "r", "m", "proxy", "(", "configuration", ",", "protocol", ")", ";", "}", "}", ")", ";", "return", "proxy", "connection", ";", "}", "catch", "(", "interrupted", "exception", "e", ")", "{", "throw", "new", "yarn", "runtime", "exception", "(", "e", ")", ";", "}", "}" ]

[ "wrap", "the", "provided", "aggregator", "so", "that", "it", "behaves", "(", "almost", ")", "as", "if", "it", "had", "been", "collected", "directly" ]

[ "public", "aggregator", "wrap", "(", "final", "aggregator", "in", ")", "{", "return", "new", "wrapped", "aggregator", "(", "in", ")", "{", "@", "override", "public", "internal", "aggregation", "[", "]", "build", "aggregations", "(", "long", "[", "]", "owning", "bucket", "ords", ")", "throws", "i", "o", "exception", "{", "if", "(", "selected", "buckets", "=", "=", "null", ")", "{", "throw", "new", "illegal", "state", "exception", "(", "\"", "collection", "has", "not", "been", "replayed", "yet", "\"", ")", ";", "}", "long", "[", "]", "rebased", "ords", "=", "new", "long", "[", "owning", "bucket", "ords", "length", "]", ";", "for", "(", "int", "ord", "idx", "=", "0", ";", "ord", "idx", "<", "owning", "bucket", "ords", "length", ";", "ord", "idx", "+", "+", ")", "{", "rebased", "ords", "[", "ord", "idx", "]", "=", "selected", "buckets", "find", "(", "owning", "bucket", "ords", "[", "ord", "idx", "]", ")", ";", "if", "(", "rebased", "ords", "[", "ord", "idx", "]", "=", "=", "-", "1", ")", "{", "throw", "new", "illegal", "state", "exception", "(", "\"", "cannot", "build", "for", "a", "bucket", "which", "has", "not", "been", "collected", "\"", ")", ";", "}", "}", "return", "in", "build", "aggregations", "(", "rebased", "ords", ")", ";", "}", "}", ";", "}" ]

[ "return", "the", "given", "field", "as", "a", "script", "field", "with", "the", "supplied", "script" ]

[ "public", "void", "add", "script", "field", "(", "string", "name", ",", "script", "script", ")", "{", "script", "fields", "put", "(", "name", ",", "script", ")", ";", "}" ]

[ "get", "the", "first", "fixture", "in", "this", "contact" ]

[ "public", "fixture", "get", "fixture", "a", "(", ")", "{", "return", "m", "fixture", "a", ";", "}" ]

[ "indicates", "that", "the", "pairing", "is", "from", "a", "high", "-", "trust", "source", "see", "{", "@", "link", "recipient", "#", "external", "high", "trust", "push", "(", "context", ",", "signal", "service", "address", ")", "}" ]

[ "public", "static", "@", "non", "null", "recipient", "id", "from", "high", "trust", "(", "@", "non", "null", "signal", "service", "address", "address", ")", "{", "return", "from", "(", "address", "get", "uuid", "(", ")", "or", "null", "(", ")", ",", "address", "get", "number", "(", ")", "or", "null", "(", ")", ",", "true", ")", ";", "}" ]

[ "check", "if", "any", "of", "the", "edges", "specified", "were", "initially", "touched", "in", "the", "currently", "active", "gesture", "if", "there", "is", "no", "currently", "active", "gesture", "this", "method", "will", "return", "false" ]

[ "public", "boolean", "is", "edge", "touched", "(", "int", "edges", ")", "{", "final", "int", "count", "=", "m", "initial", "edges", "touched", "length", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "count", ";", "i", "+", "+", ")", "{", "if", "(", "is", "edge", "touched", "(", "edges", ",", "i", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "startend", "tag", "nesting", "should", "be", "correct", "regardless", "of", "the", "order", "tags", "are", "added" ]

[ "public", "void", "adjacent", "(", ")", "{", "markup", "text", "text", "=", "new", "markup", "text", "(", "\"", "abcdef", "\"", ")", ";", "text", "add", "markup", "(", "0", ",", "3", ",", "\"", "$", "\"", ",", "\"", "$", "\"", ")", ";", "text", "add", "markup", "(", "3", ",", "6", ",", "\"", "#", "\"", ",", "\"", "#", "\"", ")", ";", "assert", "equals", "(", "\"", "$", "abc", "$", "#", "def", "#", "\"", ",", "text", "to", "string", "(", "false", ")", ")", ";", "text", "=", "new", "markup", "text", "(", "\"", "abcdef", "\"", ")", ";", "text", "add", "markup", "(", "3", ",", "6", ",", "\"", "#", "\"", ",", "\"", "#", "\"", ")", ";", "text", "add", "markup", "(", "0", ",", "3", ",", "\"", "$", "\"", ",", "\"", "$", "\"", ")", ";", "assert", "equals", "(", "\"", "$", "abc", "$", "#", "def", "#", "\"", ",", "text", "to", "string", "(", "false", ")", ")", ";", "}" ]

[ "returns", "true", "if", "the", "specified", "{", "@", "link", "fsrl", "}", "has", "a", "matched", "ghidra", "{", "@", "link", "domain", "file", "}", "in", "the", "current", "project" ]

[ "public", "static", "boolean", "is", "file", "imported", "into", "project", "(", "fsrl", "fsrl", ")", "{", "return", "is", "file", "open", "(", "fsrl", ")", "|", "|", "(", "get", "cached", "domain", "file", "for", "(", "fsrl", ")", "!", "=", "null", ")", ";", "}" ]

[ "returns", "the", "compiler", "version", "string", "(", "e", "g", "\"", "gcc", "-", "4", "1", "1", "\"", ")" ]

[ "public", "string", "get", "compiler", "(", ")", "{", "return", "compiler", ";", "}" ]

[ "gets", "resolved", "multifactor", "authentication", "providers" ]

[ "public", "static", "collection", "<", "string", ">", "get", "resolved", "multifactor", "authentication", "providers", "(", "final", "request", "context", "context", ")", "{", "return", "context", "get", "conversation", "scope", "(", ")", "get", "(", "\"", "resolved", "multifactor", "authentication", "providers", "\"", ",", "collection", "class", ")", ";", "}" ]

[ "equivalent", "to", "calling", "{", "@", "link", "#", "get", "(", "string", ")", "}", "and", "casting", "the", "result", "to", "a", "byte", "[", "]" ]

[ "public", "byte", "[", "]", "get", "bytes", "(", "string", "field", "name", ")", "{", "object", "bytes", "=", "get", "check", "type", "(", "field", "name", ",", "schema", "type", "bytes", ")", ";", "if", "(", "bytes", "instanceof", "byte", "buffer", ")", "return", "(", "(", "byte", "buffer", ")", "bytes", ")", "array", "(", ")", ";", "return", "(", "byte", "[", "]", ")", "bytes", ";", "}" ]

[ "simple", "implementation", "of", "function", "{", "@", "link", "#", "find", "(", "string", ")", "}" ]

[ "static", "finder", "contains", "(", "string", "word", ")", "{", "return", "txt", "-", ">", "stream", "of", "(", "txt", "split", "(", "\"", "\\", "n", "\"", ")", ")", "filter", "(", "line", "-", ">", "line", "to", "lower", "case", "(", ")", "contains", "(", "word", "to", "lower", "case", "(", ")", ")", ")", "collect", "(", "collectors", "to", "list", "(", ")", ")", ";", "}" ]

[ "get", "capital", "snake" ]

[ "public", "string", "get", "capital", "snake", "(", ")", "{", "return", "capital", "snake", ";", "}" ]

[ "clears", "and", "fills", "{", "@", "code", "m", "buckets", "}", "with", "buckets" ]

[ "private", "void", "fill", "buckets", "(", "sparse", "int", "array", "bucket", "sizes", ")", "{", "m", "buckets", "clear", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "bucket", "sizes", "size", "(", ")", ";", "+", "+", "i", ")", "{", "final", "int", "bucket", "size", "=", "bucket", "sizes", "key", "at", "(", "i", ")", ";", "final", "int", "max", "length", "=", "bucket", "sizes", "value", "at", "(", "i", ")", ";", "m", "buckets", "put", "(", "bucket", "size", ",", "new", "bucket", "<", "v", ">", "(", "get", "size", "in", "bytes", "(", "bucket", "size", ")", ",", "max", "length", ",", "0", ",", "m", "pool", "params", "fix", "buckets", "reinitialization", ")", ")", ";", "}", "}" ]

[ "sets", "the", "<", "code", ">", "photo", "urls", "<", "code", ">", "property" ]

[ "public", "void", "set", "photo", "urls", "(", "set", "<", "string", ">", "photo", "urls", ")", "{", "this", "photo", "urls", "=", "photo", "urls", ";", "}" ]

[ "inserts", "an", "a", "tag", "that", "surrounds", "the", "given", "position" ]

[ "public", "void", "add", "hyperlink", "(", "int", "start", "pos", ",", "int", "end", "pos", ",", "string", "url", ")", "{", "add", "markup", "(", "start", "pos", ",", "end", "pos", ",", "\"", "<", "a", "href", "=", "'", "\"", "+", "url", "+", "\"", "'", ">", "\"", ",", "\"", "<", "/", "a", ">", "\"", ")", ";", "}" ]

[ "is", "this", "panel", "currently", "comparing", "a", "data", "match", "?" ]

[ "private", "boolean", "is", "data", "compare", "(", ")", "{", "address", "left", "data", "address", "=", "get", "left", "data", "address", "(", ")", ";", "address", "right", "data", "address", "=", "get", "right", "data", "address", "(", ")", ";", "return", "(", "left", "data", "address", "!", "=", "null", "&", "&", "right", "data", "address", "!", "=", "null", ")", ";", "}" ]

[ "customize", "request", "specification" ]

[ "public", "test", "endpoint", "parameters", "oper", "req", "spec", "(", "consumer", "<", "request", "spec", "builder", ">", "req", "spec", "customizer", ")", "{", "req", "spec", "customizer", "accept", "(", "req", "spec", ")", ";", "return", "this", ";", "}" ]

[ "returns", "{", "@", "code", "true", "}", "if", "this", "multiset", "contains", "at", "least", "one", "occurrence", "of", "each", "element", "in", "the", "specified", "collection", "this", "method", "refines", "{", "@", "link", "collection", "#", "contains", "all", "}", "to", "further", "specify", "that", "it", "<", "b", ">", "may", "not", "<", "b", ">", "throw", "an", "exception", "in", "response", "to", "any", "of", "{", "@", "code", "elements", "}", "being", "null", "or", "of", "the", "wrong", "type", "<", "b", ">", "note", ":", "<", "b", ">", "this", "method", "does", "not", "take", "into", "account", "the", "occurrence", "count", "of", "an", "element", "in", "the", "two", "collections", ";", "it", "may", "still", "return", "{", "@", "code", "true", "}", "even", "if", "{", "@", "code", "elements", "}", "contains", "several", "occurrences", "of", "an", "element", "and", "this", "multiset", "contains", "only", "one", "this", "is", "no", "different", "than", "any", "other", "collection", "type", "like", "{", "@", "link", "list", "}", ",", "but", "it", "may", "be", "unexpected", "to", "the", "user", "of", "a", "multiset" ]

[ "boolean", "contains", "all", "(", "collection", "<", "?", ">", "elements", ")", ";" ]

[ "test", "a", "container", "run", "command", "update", "when", "using", "docker", "runtime", "and", "the", "device", "plugin", "it", "uses", "is", "like", "nvidia", "docker", "v", "1" ]

[ "public", "void", "test", "device", "resource", "docker", "runtime", "plugin", "1", "(", ")", "throws", "exception", "{", "node", "manager", "n", "m", "context", "context", "=", "mock", "(", "node", "manager", "n", "m", "context", "class", ")", ";", "n", "m", "state", "store", "service", "store", "service", "=", "mock", "(", "n", "m", "state", "store", "service", "class", ")", ";", "when", "(", "context", "get", "n", "m", "state", "store", "(", ")", ")", "then", "return", "(", "store", "service", ")", ";", "when", "(", "context", "get", "conf", "(", ")", ")", "then", "return", "(", "this", "conf", ")", ";", "do", "nothing", "(", ")", "when", "(", "store", "service", ")", "store", "assigned", "resources", "(", "is", "a", "(", "container", "class", ")", ",", "is", "a", "(", "string", "class", ")", ",", "is", "a", "(", "array", "list", "class", ")", ")", ";", "/", "/", "init", "scheduler", "manager", "device", "mapping", "manager", "dmm", "=", "new", "device", "mapping", "manager", "(", "context", ")", ";", "device", "mapping", "manager", "spy", "dmm", "=", "spy", "(", "dmm", ")", ";", "resource", "plugin", "manager", "rpm", "=", "mock", "(", "resource", "plugin", "manager", "class", ")", ";", "when", "(", "rpm", "get", "device", "mapping", "manager", "(", ")", ")", "then", "return", "(", "spy", "dmm", ")", ";", "/", "/", "init", "a", "plugin", "my", "plugin", "plugin", "=", "new", "my", "plugin", "(", ")", ";", "my", "plugin", "spy", "plugin", "=", "spy", "(", "plugin", ")", ";", "string", "resource", "name", "=", "my", "plugin", "resource", "name", ";", "/", "/", "init", "an", "adapter", "for", "the", "plugin", "device", "plugin", "adapter", "adapter", "=", "new", "device", "plugin", "adapter", "(", "resource", "name", ",", "spy", "plugin", ",", "spy", "dmm", ")", ";", "adapter", "initialize", "(", "context", ")", ";", "/", "/", "bootstrap", ",", "adding", "device", "adapter", "initialize", "(", "context", ")", ";", "adapter", "create", "resource", "handler", "(", "context", ",", "mock", "c", "groups", "handler", ",", "mock", "privileged", "executor", ")", ";", "adapter", "get", "device", "resource", "handler", "(", ")", "bootstrap", "(", "conf", ")", ";", "/", "/", "case", "1", "a", "container", "request", "docker", "runtime", "and", "1", "device", "container", "c", "1", "=", "mock", "container", "with", "device", "request", "(", "1", ",", "resource", "name", ",", "1", ",", "true", ")", ";", "/", "/", "generate", "spec", "based", "on", "v", "1", "spy", "plugin", "set", "device", "plugin", "version", "(", "\"", "v", "1", "\"", ")", ";", "/", "/", "pre", "start", "will", "do", "allocation", "adapter", "get", "device", "resource", "handler", "(", ")", "pre", "start", "(", "c", "1", ")", ";", "set", "<", "device", ">", "allocated", "device", "=", "spy", "dmm", "get", "allocated", "devices", "(", "resource", "name", ",", "c", "1", "get", "container", "id", "(", ")", ")", ";", "reset", "(", "spy", "dmm", ")", ";", "/", "/", "c", "1", "is", "requesting", "docker", "runtime", "/", "/", "it", "will", "create", "parent", "cgroup", "but", "no", "cgroups", "update", "operation", "needed", "/", "/", "check", "device", "cgroup", "create", "operation", "verify", "(", "mock", "c", "groups", "handler", ")", "create", "c", "group", "(", "c", "groups", "handler", "c", "group", "controller", "devices", ",", "c", "1", "get", "container", "id", "(", ")", "to", "string", "(", ")", ")", ";", "/", "/", "ensure", "no", "cgroups", "update", "operation", "verify", "(", "mock", "privileged", "executor", ",", "times", "(", "0", ")", ")", "execute", "privileged", "operation", "(", "any", "(", "privileged", "operation", "class", ")", ",", "any", "boolean", "(", ")", ")", ";", "docker", "command", "plugin", "dcp", "=", "adapter", "get", "docker", "command", "plugin", "instance", "(", ")", ";", "/", "/", "when", "docker", "linux", "container", "runtime", "invoke", "the", "docker", "command", "plugin", "instance", "/", "/", "first", "to", "create", "volume", "docker", "volume", "command", "dvc", "=", "dcp", "get", "create", "docker", "volume", "command", "(", "c", "1", ")", ";", "/", "/", "ensure", "that", "allocation", "is", "get", "once", "from", "device", "mapping", "manager", "verify", "(", "spy", "dmm", ")", "get", "allocated", "devices", "(", "resource", "name", ",", "c", "1", "get", "container", "id", "(", ")", ")", ";", "/", "/", "ensure", "that", "plugin", "'", "s", "on", "device", "allocated", "is", "invoked", "verify", "(", "spy", "plugin", ")", "on", "devices", "allocated", "(", "allocated", "device", ",", "yarn", "runtime", "type", "runtime", "default", ")", ";", "verify", "(", "spy", "plugin", ")", "on", "devices", "allocated", "(", "allocated", "device", ",", "yarn", "runtime", "type", "runtime", "docker", ")", ";", "assert", "assert", "equals", "(", "\"", "nvidia", "-", "docker", "\"", ",", "dvc", "get", "driver", "name", "(", ")", ")", ";", "assert", "assert", "equals", "(", "\"", "create", "\"", ",", "dvc", "get", "sub", "command", "(", ")", ")", ";", "assert", "assert", "equals", "(", "\"", "nvidia", "driver", "352", "68", "\"", ",", "dvc", "get", "volume", "name", "(", ")", ")", ";", "/", "/", "then", "the", "docker", "linux", "container", "runtime", "will", "update", "docker", "run", "command", "docker", "run", "command", "drc", "=", "new", "docker", "run", "command", "(", "c", "1", "get", "container", "id", "(", ")", "to", "string", "(", ")", ",", "\"", "user", "\"", ",", "\"", "image", "/", "tensorflow", "\"", ")", ";", "/", "/", "reset", "to", "avoid", "count", "times", "in", "above", "invocation", "reset", "(", "spy", "plugin", ")", ";", "reset", "(", "spy", "dmm", ")", ";", "/", "/", "second", ",", "update", "the", "run", "command", "dcp", "update", "docker", "run", "command", "(", "drc", ",", "c", "1", ")", ";", "/", "/", "the", "spec", "is", "already", "generated", "in", "get", "create", "docker", "volume", "command", "/", "/", "and", "there", "should", "be", "a", "cache", "hit", "for", "device", "runtime", "spec", "verify", "(", "spy", "plugin", ",", "times", "(", "0", ")", ")", "on", "devices", "allocated", "(", "allocated", "device", ",", "yarn", "runtime", "type", "runtime", "docker", ")", ";", "/", "/", "ensure", "that", "allocation", "is", "get", "from", "cache", "instead", "of", "device", "mapping", "/", "/", "manager", "verify", "(", "spy", "dmm", ",", "times", "(", "0", ")", ")", "get", "allocated", "devices", "(", "resource", "name", ",", "c", "1", "get", "container", "id", "(", ")", ")", ";", "string", "run", "str", "=", "drc", "to", "string", "(", ")", ";", "assert", "assert", "true", "(", "run", "str", "contains", "(", "\"", "nvidia", "driver", "352", "68", ":", "/", "usr", "/", "local", "/", "nvidia", ":", "ro", "\"", ")", ")", ";", "assert", "assert", "true", "(", "run", "str", "contains", "(", "\"", "/", "dev", "/", "hdw", "a", "0", ":", "/", "dev", "/", "hdw", "a", "0", "\"", ")", ")", ";", "/", "/", "third", ",", "cleanup", "in", "get", "cleanup", "docker", "volumes", "command", "dcp", "get", "cleanup", "docker", "volumes", "command", "(", "c", "1", ")", ";", "/", "/", "ensure", "device", "plugin", "'", "s", "on", "device", "released", "is", "invoked", "verify", "(", "spy", "plugin", ")", "on", "devices", "released", "(", "allocated", "device", ")", ";", "/", "/", "if", "we", "run", "the", "c", "1", "again", "no", "cache", "will", "be", "used", "for", "allocation", "and", "spec", "dcp", "get", "create", "docker", "volume", "command", "(", "c", "1", ")", ";", "verify", "(", "spy", "dmm", ")", "get", "allocated", "devices", "(", "resource", "name", ",", "c", "1", "get", "container", "id", "(", ")", ")", ";", "verify", "(", "spy", "plugin", ")", "on", "devices", "allocated", "(", "allocated", "device", ",", "yarn", "runtime", "type", "runtime", "docker", ")", ";", "}" ]

[ "reads", "and", "returns", "a", "float", "of", "length", "{", "@", "code", "byte", "length", "}", "from", "the", "{", "@", "link", "extractor", "input", "}" ]

[ "private", "double", "read", "float", "(", "extractor", "input", "input", ",", "int", "byte", "length", ")", "throws", "i", "o", "exception", "{", "long", "integer", "value", "=", "read", "integer", "(", "input", ",", "byte", "length", ")", ";", "double", "float", "value", ";", "if", "(", "byte", "length", "=", "=", "valid", "float32", "element", "size", "bytes", ")", "{", "float", "value", "=", "float", "int", "bits", "to", "float", "(", "(", "int", ")", "integer", "value", ")", ";", "}", "else", "{", "float", "value", "=", "double", "long", "bits", "to", "double", "(", "integer", "value", ")", ";", "}", "return", "float", "value", ";", "}" ]

[ "set", "the", "maximum", "number", "of", "particles" ]

[ "public", "void", "set", "particle", "max", "count", "(", "int", "count", ")", "{", "m", "particle", "system", "set", "particle", "max", "count", "(", "count", ")", ";", "}" ]

[ "sets", "the", "indices", "the", "search", "will", "be", "executed", "on" ]

[ "public", "search", "request", "builder", "set", "indices", "(", "string", "indices", ")", "{", "request", "indices", "(", "indices", ")", ";", "return", "this", ";", "}" ]

[ "enabledisable", "the", "joint", "motor" ]

[ "public", "void", "enable", "motor", "(", "boolean", "flag", ")", "{", "m", "body", "a", "set", "awake", "(", "true", ")", ";", "m", "body", "b", "set", "awake", "(", "true", ")", ";", "m", "enable", "motor", "=", "flag", ";", "}" ]

[ "return", "the", "blur", "bitmap", "fast", "zoom", "out", ",", "blur", ",", "zoom", "in" ]

[ "public", "static", "bitmap", "fast", "blur", "(", "final", "bitmap", "src", ",", "@", "float", "range", "(", "from", "=", "0", ",", "to", "=", "1", ",", "from", "inclusive", "=", "false", ")", "final", "float", "scale", ",", "@", "float", "range", "(", "from", "=", "0", ",", "to", "=", "25", ",", "from", "inclusive", "=", "false", ")", "final", "float", "radius", ")", "{", "return", "fast", "blur", "(", "src", ",", "scale", ",", "radius", ",", "false", ",", "false", ")", ";", "}" ]

[ "creates", "a", "result", "that", "the", "failure", "is", "not", "recoverable", "and", "no", "restarting", "should", "be", "conducted", "the", "result", "can", "be", "flagged", "to", "be", "from", "a", "global", "failure", "triggered", "by", "the", "scheduler", ",", "rather", "than", "from", "the", "failure", "of", "an", "individual", "task" ]

[ "public", "static", "failure", "handling", "result", "unrecoverable", "(", "throwable", "error", ",", "boolean", "global", "failure", ")", "{", "return", "new", "failure", "handling", "result", "(", "error", ",", "global", "failure", ")", ";", "}" ]

[ "this", "method", "is", "expected", "to", "merge", "the", "custom", "split", "info", "with", "split", "to", "recreate", "the", "custom", "file", "split", "it", "is", "expected", "to", "return", "optional", "empty", "(", ")", "if", "the", "custom", "split", "info", "does", "not", "match", "the", "split", "converter" ]

[ "optional", "<", "file", "split", ">", "recreate", "file", "split", "with", "custom", "info", "(", "file", "split", "split", ",", "map", "<", "string", ",", "string", ">", "custom", "split", "info", ")", "throws", "i", "o", "exception", ";" ]

[ "dequeue", "one", "element", "from", "head", "of", "the", "queue", ",", "will", "block", "if", "queue", "is", "empty" ]

[ "synchronized", "t", "dequeue", "(", ")", "throws", "interrupted", "exception", "{", "check", "consumer", "(", ")", ";", "while", "(", "0", "=", "=", "size", ")", "{", "wait", "(", ")", ";", "}", "return", "dequeue", "(", ")", ";", "}" ]