Datasets:
Anonymous2023
/
KGSum

Dataset card Data Studio Files Community
docstring_tokens
list
code_tokens
list
[ "get", "base", "location", "path", "of", "this", "table" ]
[ "path", "get", "location", "path", "(", ")", ";" ]
[ "model", "tests", "for", "nullable", "shape" ]
[ "public", "void", "test", "nullable", "shape", "(", ")", "{", "/", "/", "todo", ":", "test", "nullable", "shape", "}" ]
[ "sets", "the", "key", "for", "this", "section", "this", "is", "only", "used", "for", "testing", "as", "the", "key", "will", "be", "set", "from", "the", "{", "@", "link", "builder", "}" ]
[ "public", "void", "set", "key", "(", "string", "key", ")", "{", "m", "key", "=", "key", ";", "}" ]
[ "returns", "the", "class", "object", "representing", "the", "class", "or", "interface", "that", "declares", "the", "constructor" ]
[ "public", "class", "get", "declaring", "class", "(", ")", "{", "return", "constructor", "get", "declaring", "class", "(", ")", ";", "}" ]
[ "factory", "method", "to", "retrieve", "the", "default", "setter", "groovy", "has", "a", "bug", "(", "groovy", "-", "6286", ")", "which", "does", "not", "allow", "method", "names", "and", "inner", "classes", "to", "have", "the", "same", "name", "this", "method", "fixes", "issue", "#", "967", "and", "allows", "groovy", "consumers", "to", "choose", "this", "method", "and", "not", "trigger", "the", "bug" ]
[ "public", "static", "setter", "default", "setter", "(", ")", "{", "return", "setter", "(", ")", ";", "}" ]
[ "gets", "real", "submission", "state" ]
[ "protected", "action", "state", "get", "real", "submission", "state", "(", "final", "flow", "flow", ")", "{", "return", "get", "state", "(", "flow", ",", "cas", "webflow", "constants", "state", "id", "real", "submit", ",", "action", "state", "class", ")", ";", "}" ]
[ "lower", "scores", "sort", "first", ";", "if", "scores", "are", "equal", ",", "then", "later", "(", "zzz", ")", "terms", "sort", "first" ]
[ "public", "int", "compare", "to", "(", "candidate", "other", ")", "{", "if", "(", "score", "=", "=", "other", "score", ")", "{", "/", "/", "later", "(", "zzz", ")", "terms", "sort", "before", "earlier", "(", "aaa", ")", "terms", ":", "return", "other", "term", "compare", "to", "(", "term", ")", ";", "}", "else", "{", "return", "double", "compare", "(", "score", ",", "other", "score", ")", ";", "}", "}" ]
[ "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", "\"", ")", ";", "}" ]
[ "gauges", "may", "go", "up", "and", "down", ",", "in", "zoo", "keeper", "they", "are", "a", "way", "to", "export", "internal", "values", "with", "a", "callback" ]
[ "public", "void", "register", "gauge", "(", "string", "name", ",", "gauge", "gauge", ")", "{", "objects", "require", "non", "null", "(", "name", ")", ";", "gauges", "compute", "(", "name", ",", "(", "id", ",", "prev", ")", "-", ">", "new", "prometheus", "gauge", "wrapper", "(", "id", ",", "gauge", ",", "prev", "!", "=", "null", "?", "prev", "inner", ":", "null", ")", ")", ";", "}" ]
[ "asserts", "that", "marking", "this", "step", "a", "final", "step", "throws", "{", "@", "link", "illegal", "state", "exception", "}" ]
[ "protected", "void", "assert", "final", "step", "throws", "illegal", "state", "exception", "(", "closing", "future", "<", "?", ">", "closing", "future", ")", "{", "try", "{", "closing", "future", "finish", "to", "future", "(", ")", ";", "fail", "(", ")", ";", "}", "catch", "(", "illegal", "state", "exception", "expected", ")", "{", "}", "try", "{", "closing", "future", "finish", "to", "value", "and", "closer", "(", "new", "no", "op", "value", "and", "closer", "consumer", "<", ">", "(", ")", ",", "executor", ")", ";", "fail", "(", ")", ";", "}", "catch", "(", "illegal", "state", "exception", "expected", ")", "{", "}", "}" ]
[ "async", "invocation", "timeout", "will", "be", "handled", "even", "if", "<", "code", ">", "future", "get", "(", ")", "<", "code", ">", "is", "not", "called" ]
[ "public", "<", "t", ">", "completable", "future", "<", "t", ">", "async", "call", "(", "callable", "<", "t", ">", "callable", ")", "{", "try", "{", "try", "{", "set", "attachment", "(", "async", "key", ",", "boolean", "true", "to", "string", "(", ")", ")", ";", "final", "t", "o", "=", "callable", "call", "(", ")", ";", "/", "/", "local", "invoke", "will", "return", "directly", "if", "(", "o", "!", "=", "null", ")", "{", "if", "(", "o", "instanceof", "completable", "future", ")", "{", "return", "(", "completable", "future", "<", "t", ">", ")", "o", ";", "}", "return", "completable", "future", "completed", "future", "(", "o", ")", ";", "}", "else", "{", "/", "/", "the", "service", "has", "a", "normal", "sync", "method", "signature", ",", "should", "get", "future", "from", "rpc", "context", "}", "}", "catch", "(", "exception", "e", ")", "{", "throw", "new", "rpc", "exception", "(", "e", ")", ";", "}", "finally", "{", "remove", "attachment", "(", "async", "key", ")", ";", "}", "}", "catch", "(", "final", "rpc", "exception", "e", ")", "{", "completable", "future", "<", "t", ">", "exception", "future", "=", "new", "completable", "future", "<", ">", "(", ")", ";", "exception", "future", "complete", "exceptionally", "(", "e", ")", ";", "return", "exception", "future", ";", "}", "return", "(", "(", "completable", "future", "<", "t", ">", ")", "get", "context", "(", ")", "get", "future", "(", ")", ")", ";", "}" ]
[ "returns", "a", "map", "with", "the", "contents", "of", "this", "{", "@", "code", "fluent", "iterable", "}", "as", "its", "{", "@", "code", "values", "}", ",", "indexed", "by", "keys", "derived", "from", "those", "values", "in", "other", "words", ",", "each", "input", "value", "produces", "an", "entry", "in", "the", "map", "whose", "key", "is", "the", "result", "of", "applying", "{", "@", "code", "key", "function", "}", "to", "that", "value", "these", "entries", "appear", "in", "the", "same", "order", "as", "they", "appeared", "in", "this", "fluent", "iterable", "example", "usage", ":", "{", "@", "code", "color", "red", "=", "new", "color", "(", "\"", "red", "\"", ",", "255", ",", "0", ",", "0", ")", ";", "fluent", "iterable", "<", "color", ">", "all", "colors", "=", "fluent", "iterable", "from", "(", "immutable", "set", "of", "(", "red", ",", "green", ",", "blue", ")", ")", ";", "map", "<", "string", ",", "color", ">", "color", "for", "name", "=", "all", "colors", "unique", "index", "(", "to", "string", "function", "(", ")", ")", ";", "assert", "that", "(", "color", "for", "name", ")", "contains", "entry", "(", "\"", "red", "\"", ",", "red", ")", ";", "}", "if", "your", "index", "may", "associate", "multiple", "values", "with", "each", "key", ",", "use", "{", "@", "link", "#", "index", "(", "function", ")", "index", "}", "<", "b", ">", "{", "@", "code", "stream", "}", "equivalent", ":", "<", "b", ">", "use", "{", "@", "code", "stream", "collect", "(", "immutable", "map", "to", "immutable", "map", "(", "key", "function", ",", "v", "-", ">", "v", ")", ")", "}", "{", "@", "code", "immutable", "map", "copy", "of", "(", "stream", "collect", "(", "collectors", "to", "map", "(", "key", "function", ",", "v", "-", ">", "v", ")", ")", ")", "}", ",", "but", "be", "aware", "that", "this", "may", "not", "preserve", "the", "order", "of", "entries" ]
[ "public", "final", "<", "k", ">", "immutable", "map", "<", "k", ",", "e", ">", "unique", "index", "(", "function", "<", "?", "super", "e", ",", "k", ">", "key", "function", ")", "{", "return", "maps", "unique", "index", "(", "get", "delegate", "(", ")", ",", "key", "function", ")", ";", "}" ]
[ "returns", "the", "pending", "repository", "generation", "{", "@", "link", "repository", "data", "}", "for", "this", "generation", "and", "all", "generations", "down", "to", "the", "safe", "generation", "{", "@", "link", "#", "generation", "}", "may", "exist", "in", "the", "repository", "and", "should", "not", "be", "reused", "for", "writing", "new", "{", "@", "link", "repository", "data", "}", "to", "the", "repository", "see", "package", "level", "documentation", "for", "the", "blob", "store", "based", "repositories", "{", "@", "link", "org", "elasticsearch", "repositories", "blobstore", "}", "for", "details", "on", "how", "this", "value", "is", "used", "during", "snapshots" ]
[ "public", "long", "pending", "generation", "(", ")", "{", "return", "pending", "generation", ";", "}" ]
[ "reads", "up", "to", "<", "code", ">", "len", "<", "code", ">", "bytes", "of", "data", "from", "this", "input", "stream", "into", "an", "array", "of", "bytes", "this", "method", "blocks", "until", "some", "input", "is", "available", "if", "the", "first", "argument", "is", "<", "code", ">", "null", ",", "<", "code", ">", "up", "to", "<", "code", ">", "len", "<", "code", ">", "bytes", "are", "read", "and", "discarded" ]
[ "public", "int", "read", "(", "byte", "[", "]", "b", ",", "int", "off", ",", "int", "len", ")", "throws", "i", "o", "exception", "{", "if", "(", "len", "=", "=", "0", ")", "{", "return", "0", ";", "}", "if", "(", "!", "use", "wrap", ")", "{", "return", "in", "stream", "read", "(", "b", ",", "off", ",", "len", ")", ";", "}", "if", "(", "ostart", ">", "=", "ofinish", ")", "{", "/", "/", "we", "loop", "for", "new", "data", "as", "we", "are", "blocking", "int", "i", "=", "0", ";", "while", "(", "i", "=", "=", "0", ")", "i", "=", "read", "more", "data", "(", ")", ";", "if", "(", "i", "=", "=", "-", "1", ")", "return", "-", "1", ";", "}", "if", "(", "len", "<", "=", "0", ")", "{", "return", "0", ";", "}", "int", "available", "=", "ofinish", "-", "ostart", ";", "if", "(", "len", "<", "available", ")", "available", "=", "len", ";", "if", "(", "b", "!", "=", "null", ")", "{", "system", "arraycopy", "(", "obuffer", ",", "ostart", ",", "b", ",", "off", ",", "available", ")", ";", "}", "ostart", "=", "ostart", "+", "available", ";", "return", "available", ";", "}" ]
[ "get", "the", "token", "kind", "returns", "{", "@", "link", "#", "token", "kind", "}", "always", "if", "a", "subclass", "does", "not", "want", "its", "renewcancel", "process", "to", "be", "managed", "by", "{", "@", "link", "abfs", "delegation", "token", "manager", "}", ",", "this", "must", "be", "overridden" ]
[ "public", "text", "get", "kind", "(", ")", "{", "return", "token", "kind", ";", "}" ]
[ "exports", "a", "version", "of", "our", "tool", "without", "any", "config", "settings", "this", "is", "useful", "for", "making", "a", "new", "'", "default", "'", "tool", "to", "be", "shared", "with", "others", ",", "which", "will", "not", "contain", "any", "user", "settings" ]
[ "public", "void", "export", "default", "tool", "(", ")", "{", "tool", "template", "template", "=", "tool", "get", "tool", "template", "(", "false", ")", ";", "export", "tool", "(", "template", ")", ";", "}" ]
[ "gets", "the", "number", "of", "address", "ranges", "that", "the", "two", "programs", "memories", "are", "broken", "into", "for", "comparing", "the", "programs" ]
[ "public", "int", "get", "num", "ranges", "(", ")", "{", "return", "ranges", "length", ";", "}" ]
[ "set", "a", "human", "-", "readable", "description", "of", "this", "bean", "definition" ]
[ "public", "void", "set", "description", "(", "@", "nullable", "string", "description", ")", "{", "this", "description", "=", "description", ";", "}" ]
[ "stops", "the", "spark", "server", "and", "clears", "all", "routes" ]
[ "public", "static", "void", "stop", "(", ")", "{", "get", "instance", "(", ")", "stop", "(", ")", ";", "}" ]
[ "replace", "the", "references", "where", "possible" ]
[ "private", "void", "replace", "references", "(", "final", "address", "set", "view", "address", "set", ",", "final", "int", "chosen", "conflict", "option", ",", "final", "task", "monitor", "monitor", ")", "throws", "cancelled", "exception", "{", "if", "(", "(", "chosen", "conflict", "option", "&", "keep", "original", ")", "!", "=", "0", ")", "{", "listing", "merge", "mgr", "merge", "original", "replace", "references", "(", "address", "set", ",", "monitor", ")", ";", "}", "else", "if", "(", "(", "chosen", "conflict", "option", "&", "keep", "latest", ")", "!", "=", "0", ")", "{", "listing", "merge", "mgr", "merge", "latest", "replace", "references", "(", "address", "set", ",", "monitor", ")", ";", "}", "else", "if", "(", "(", "chosen", "conflict", "option", "&", "keep", "my", ")", "!", "=", "0", ")", "{", "listing", "merge", "mgr", "merge", "my", "replace", "references", "(", "address", "set", ",", "monitor", ")", ";", "}", "}" ]
[ "returns", "acl", "binding", "that", "matched", "the", "delete", "filter", "if", "{", "@", "link", "#", "exception", "(", ")", "}", "is", "empty", ",", "the", "acl", "binding", "was", "successfully", "deleted" ]
[ "public", "acl", "binding", "acl", "binding", "(", ")", "{", "return", "acl", "binding", ";", "}" ]
[ "asserts", "that", "the", "provided", "json", "token", "is", "not", "null", ",", "i", "e", ",", "not", "at", "the", "end", "of", "the", "input" ]
[ "private", "static", "void", "assert", "not", "end", "of", "input", "(", "final", "json", "parser", "p", ",", "@", "nullable", "final", "json", "token", "json", "token", ")", "{", "check", "state", "(", "json", "token", "!", "=", "null", ",", "\"", "unexpected", "end", "of", "input", "at", "%", "s", "\"", ",", "p", "get", "current", "location", "(", ")", ")", ";", "}" ]
[ "sets", "the", "bulk", "flush", "interval", ",", "in", "milliseconds" ]
[ "public", "void", "set", "bulk", "flush", "interval", "(", "long", "interval", "millis", ")", "{", "preconditions", "check", "argument", "(", "interval", "millis", ">", "=", "0", ",", "\"", "interval", "(", "in", "milliseconds", ")", "between", "each", "flush", "must", "be", "larger", "than", "or", "equal", "to", "0", "\"", ")", ";", "this", "bulk", "requests", "config", "put", "(", "config", "key", "bulk", "flush", "interval", "ms", ",", "string", "value", "of", "(", "interval", "millis", ")", ")", ";", "}" ]
[ "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", "\"", ")", ";", "}" ]
[ "scenario", ":", "using", "your", "own", "java", "methods", "and", "calling", "them", "from", "the", "expression" ]
[ "public", "void", "test", "scenario", "registering", "java", "methods", "as", "functions", "and", "calling", "them", "(", ")", "throws", "security", "exception", ",", "no", "such", "method", "exception", "{", "try", "{", "/", "/", "create", "a", "parser", "spel", "expression", "parser", "parser", "=", "new", "spel", "expression", "parser", "(", ")", ";", "/", "/", "use", "the", "standard", "evaluation", "context", "standard", "evaluation", "context", "ctx", "=", "new", "standard", "evaluation", "context", "(", ")", ";", "ctx", "register", "function", "(", "\"", "repeat", "\"", ",", "expression", "language", "scenario", "tests", "class", "get", "declared", "method", "(", "\"", "repeat", "\"", ",", "string", "class", ")", ")", ";", "expression", "expr", "=", "parser", "parse", "raw", "(", "\"", "#", "repeat", "(", "'", "hello", "'", ")", "\"", ")", ";", "object", "value", "=", "expr", "get", "value", "(", "ctx", ")", ";", "assert", "that", "(", "value", ")", "is", "equal", "to", "(", "\"", "hellohello", "\"", ")", ";", "}", "catch", "(", "evaluation", "exception", "|", "parse", "exception", "ex", ")", "{", "throw", "new", "assertion", "error", "(", "ex", "get", "message", "(", ")", ",", "ex", ")", ";", "}", "}" ]
[ "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", "\"", ")", ";", "}" ]
[ "@", "serial", "data", "the", "number", "of", "distinct", "elements", ",", "the", "first", "element", ",", "its", "count", ",", "the", "second", "element", ",", "its", "count", ",", "and", "so", "on" ]
[ "private", "void", "write", "object", "(", "object", "output", "stream", "stream", ")", "throws", "i", "o", "exception", "{", "stream", "default", "write", "object", "(", ")", ";", "serialization", "write", "multiset", "(", "this", ",", "stream", ")", ";", "}" ]
[ "test", "that", "a", "structure", "can", "'", "t", "?", "?", "?" ]
[ "public", "void", "test", "cycling", "problem", "(", ")", "{", "structure", "new", "struct", "=", "create", "structure", "(", "\"", "test", "struct", "\"", ",", "80", ")", ";", "new", "struct", "set", "description", "(", "\"", "test", "replace", "with", "(", ")", "\"", ")", ";", "new", "struct", "add", "(", "new", "byte", "data", "type", "(", ")", ",", "\"", "field", "0", "\"", ",", "\"", "comment", "1", "\"", ")", ";", "new", "struct", "add", "(", "struct", ",", "\"", "field", "1", "\"", ",", "null", ")", ";", "new", "struct", "add", "(", "new", "word", "data", "type", "(", ")", ",", "null", ",", "\"", "comment", "2", "\"", ")", ";", "new", "struct", "add", "(", "new", "d", "word", "data", "type", "(", ")", ",", "\"", "field", "3", "\"", ",", "null", ")", ";", "try", "{", "struct", "add", "(", "new", "struct", ")", ";", "assert", "fail", "(", ")", ";", "}", "catch", "(", "illegal", "argument", "exception", "e", ")", "{", "}", "try", "{", "struct", "insert", "(", "0", ",", "new", "struct", ")", ";", "assert", "fail", "(", ")", ";", "}", "catch", "(", "illegal", "argument", "exception", "e", ")", "{", "}", "try", "{", "struct", "replace", "(", "0", ",", "new", "struct", ",", "new", "struct", "get", "length", "(", ")", ")", ";", "assert", "fail", "(", ")", ";", "}", "catch", "(", "illegal", "argument", "exception", "e", ")", "{", "}", "}" ]
[ "breadth", "-", "first", "search", "from", "the", "arguments" ]
[ "public", "<", "t", ">", "query", "task", "future", "<", "void", ">", "eval", "(", "final", "query", "environment", "<", "t", ">", "env", ",", "query", "expression", "context", "<", "t", ">", "context", ",", "final", "query", "expression", "expression", ",", "list", "<", "argument", ">", "args", ",", "final", "callback", "<", "t", ">", "callback", ")", "{", "query", "expression", "query", "expression", "=", "args", "get", "(", "0", ")", "get", "expression", "(", ")", ";", "final", "int", "depth", "bound", "=", "args", "size", "(", ")", ">", "1", "?", "args", "get", "(", "1", ")", "get", "integer", "(", ")", ":", "integer", "max", "value", ";", "if", "(", "env", "instanceof", "streamable", "query", "environment", ")", "{", "if", "(", "args", "size", "(", ")", "=", "=", "1", ")", "{", "return", "(", "(", "streamable", "query", "environment", "<", "t", ">", ")", "env", ")", "get", "deps", "unbounded", "parallel", "(", "query", "expression", ",", "context", ",", "callback", ",", "expression", ")", ";", "}", "return", "(", "(", "streamable", "query", "environment", "<", "t", ">", ")", "env", ")", "get", "deps", "bounded", "(", "query", "expression", ",", "context", ",", "callback", ",", "depth", "bound", ",", "expression", ")", ";", "}", "if", "(", "env", "instanceof", "query", "environment", "custom", "function", "query", "environment", ")", "{", "return", "env", "eval", "(", "query", "expression", ",", "context", ",", "partial", "result", "-", ">", "(", "(", "custom", "function", "query", "environment", "<", "t", ">", ")", "env", ")", "deps", "(", "partial", "result", ",", "depth", "bound", ",", "expression", ",", "callback", ")", ")", ";", "}", "final", "min", "depth", "uniquifier", "<", "t", ">", "min", "depth", "uniquifier", "=", "env", "create", "min", "depth", "uniquifier", "(", ")", ";", "return", "env", "eval", "(", "query", "expression", ",", "context", ",", "partial", "result", "-", ">", "{", "thread", "safe", "mutable", "set", "<", "t", ">", "current", "=", "env", "create", "thread", "safe", "mutable", "set", "(", ")", ";", "iterables", "add", "all", "(", "current", ",", "partial", "result", ")", ";", "try", "(", "silent", "closeable", "closeable", "=", "profiler", "instance", "(", ")", "profile", "(", "\"", "env", "build", "transitive", "closure", "\"", ")", ")", "{", "env", "build", "transitive", "closure", "(", "expression", ",", "current", ",", "depth", "bound", ")", ";", "}", "/", "/", "we", "need", "to", "iterate", "depth", "bound", "+", "1", "times", "for", "(", "int", "i", "=", "0", ";", "i", "<", "=", "depth", "bound", ";", "i", "+", "+", ")", "{", "/", "/", "filter", "already", "visited", "nodes", ":", "if", "we", "see", "a", "node", "in", "a", "later", "round", ",", "then", "we", "don", "'", "t", "need", "/", "/", "to", "visit", "it", "again", ",", "because", "the", "depth", "at", "which", "we", "see", "it", "at", "must", "be", "greater", "than", "or", "/", "/", "equal", "to", "the", "last", "visit", "immutable", "list", "<", "t", ">", "to", "process", "=", "min", "depth", "uniquifier", "unique", "at", "depth", "less", "than", "or", "equal", "to", "(", "current", ",", "i", ")", ";", "callback", "process", "(", "to", "process", ")", ";", "current", "=", "env", "create", "thread", "safe", "mutable", "set", "(", ")", ";", "try", "(", "silent", "closeable", "closeable", "=", "profiler", "instance", "(", ")", "profile", "(", "\"", "env", "get", "fwd", "deps", "\"", ")", ")", "{", "iterables", "add", "all", "(", "current", ",", "env", "get", "fwd", "deps", "(", "to", "process", ",", "context", ")", ")", ";", "}", "if", "(", "current", "is", "empty", "(", ")", ")", "{", "/", "/", "exit", "when", "there", "are", "no", "more", "nodes", "to", "visit", "break", ";", "}", "}", "}", ")", ";", "}" ]
[ "ensures", "a", "file", "can", "be", "renamed", "when", "there", "is", "no", "version", "metadata", "(", "e", "tag", ",", "version", "id", ")" ]
[ "public", "void", "test", "rename", "with", "no", "version", "metadata", "(", ")", "throws", "throwable", "{", "final", "path", "testpath", "=", "write", "file", "with", "no", "version", "metadata", "(", "\"", "renamenoversion", "dat", "\"", ")", ";", "final", "path", "dest", "=", "path", "(", "\"", "noversiondest", "dat", "\"", ")", ";", "fs", "rename", "(", "testpath", ",", "dest", ")", ";", "assert", "equals", "(", "\"", "contents", "of", "\"", "+", "dest", ",", "test", "data", ",", "read", "u", "t", "f", "8", "(", "fs", ",", "dest", ",", "-", "1", ")", ")", ";", "}" ]
[ "quick", "check", "whether", "the", "given", "{", "@", "link", "ray", "}", "and", "{", "@", "link", "bounding", "box", "}", "intersect" ]
[ "static", "public", "boolean", "intersect", "ray", "bounds", "fast", "(", "ray", "ray", ",", "vector", "3", "center", ",", "vector", "3", "dimensions", ")", "{", "final", "float", "div", "x", "=", "1f", "/", "ray", "direction", "x", ";", "final", "float", "div", "y", "=", "1f", "/", "ray", "direction", "y", ";", "final", "float", "div", "z", "=", "1f", "/", "ray", "direction", "z", ";", "float", "minx", "=", "(", "(", "center", "x", "-", "dimensions", "x", "*", "0", "5f", ")", "-", "ray", "origin", "x", ")", "*", "div", "x", ";", "float", "maxx", "=", "(", "(", "center", "x", "+", "dimensions", "x", "*", "0", "5f", ")", "-", "ray", "origin", "x", ")", "*", "div", "x", ";", "if", "(", "minx", ">", "maxx", ")", "{", "final", "float", "t", "=", "minx", ";", "minx", "=", "maxx", ";", "maxx", "=", "t", ";", "}", "float", "miny", "=", "(", "(", "center", "y", "-", "dimensions", "y", "*", "0", "5f", ")", "-", "ray", "origin", "y", ")", "*", "div", "y", ";", "float", "maxy", "=", "(", "(", "center", "y", "+", "dimensions", "y", "*", "0", "5f", ")", "-", "ray", "origin", "y", ")", "*", "div", "y", ";", "if", "(", "miny", ">", "maxy", ")", "{", "final", "float", "t", "=", "miny", ";", "miny", "=", "maxy", ";", "maxy", "=", "t", ";", "}", "float", "minz", "=", "(", "(", "center", "z", "-", "dimensions", "z", "*", "0", "5f", ")", "-", "ray", "origin", "z", ")", "*", "div", "z", ";", "float", "maxz", "=", "(", "(", "center", "z", "+", "dimensions", "z", "*", "0", "5f", ")", "-", "ray", "origin", "z", ")", "*", "div", "z", ";", "if", "(", "minz", ">", "maxz", ")", "{", "final", "float", "t", "=", "minz", ";", "minz", "=", "maxz", ";", "maxz", "=", "t", ";", "}", "float", "min", "=", "math", "max", "(", "math", "max", "(", "minx", ",", "miny", ")", ",", "minz", ")", ";", "float", "max", "=", "math", "min", "(", "math", "min", "(", "maxx", ",", "maxy", ")", ",", "maxz", ")", ";", "return", "max", ">", "=", "0", "&", "&", "max", ">", "=", "min", ";", "}" ]
[ "if", "the", "plugin", "has", "{", "@", "link", "#", "get", "update", "info", "(", ")", "an", "update", "}", ",", "returns", "the", "{", "@", "link", "hudson", "model", "update", "site", "plugin", "}", "object" ]
[ "public", "update", "site", "plugin", "get", "update", "info", "(", ")", "{", "update", "center", "uc", "=", "jenkins", "get", "(", ")", "get", "update", "center", "(", ")", ";", "update", "site", "plugin", "p", "=", "uc", "get", "plugin", "(", "get", "short", "name", "(", ")", ",", "get", "version", "number", "(", ")", ")", ";", "if", "(", "p", "!", "=", "null", "&", "&", "p", "is", "newer", "than", "(", "get", "version", "(", ")", ")", ")", "return", "p", ";", "return", "null", ";", "}" ]
[ "adds", "relationship", "where", "the", "current", "object", "is", "the", "primary", "key", "table", "in", "a", "relationship" ]
[ "public", "void", "add", "reference", "association", "(", "e", "r", "d", "association", "table", ",", "boolean", "reflect", ")", "{", "if", "(", "references", "=", "=", "null", ")", "{", "references", "=", "new", "array", "list", "<", ">", "(", ")", ";", "}", "references", "add", "(", "table", ")", ";", "if", "(", "reflect", ")", "{", "fire", "property", "change", "(", "input", ",", "null", ",", "table", ")", ";", "}", "}" ]
[ "transitions", "to", "the", "next", "state", "of", "this", "state", "machine", "handles", "the", "special", "case", "if", "the", "monitor", "has", "been", "cancelled", "by", "a", "call", "to", "sort", "(", ")", "or", "filter", "(", ")", "in", "either", "of", "these", "cases", ",", "the", "recover", "state", "would", "have", "been", "set", "and", "indicates", "that", "the", "monitor", "should", "be", "reset", "and", "the", "state", "machine", "should", "transition", "to", "the", "recover", "state", "instead", "of", "the", "next", "scheduled", "state", "if", "the", "monitor", "has", "been", "cancelled", ",", "and", "no", "recover", "state", "has", "been", "set", ",", "then", "the", "job", "was", "cancelled", "by", "the", "user", "and", "the", "job", "will", "end" ]
[ "private", "synchronized", "void", "goto", "next", "state", "(", ")", "{", "if", "(", "monitor", "is", "cancelled", "(", ")", ")", "{", "if", "(", "pending", "requested", "state", "!", "=", "null", ")", "{", "set", "state", "(", "pending", "requested", "state", ")", ";", "pending", "requested", "state", "=", "null", ";", "monitor", "clear", "canceled", "(", ")", ";", "}", "else", "{", "set", "state", "(", "done", ")", ";", "}", "}", "else", "{", "set", "state", "(", "get", "next", "state", "(", "current", "state", ")", ")", ";", "}", "}" ]
[ "set", "the", "interfaces", "to", "implement", "the", "<", "code", ">", "factory", "<", "code", ">", "interface", "will", "always", "be", "implemented", "regardless", "of", "what", "is", "specified", "here" ]
[ "public", "void", "set", "interfaces", "(", "class", "[", "]", "interfaces", ")", "{", "this", "interfaces", "=", "interfaces", ";", "}" ]
[ "assert", "the", "response", "status", "code", "is", "{", "@", "code", "http", "status", "forbidden", "}", "(", "403", ")" ]
[ "public", "result", "matcher", "is", "forbidden", "(", ")", "{", "return", "matcher", "(", "http", "status", "forbidden", ")", ";", "}" ]
[ "default", "number", "of", "columns", "in", "group", "default", ":", "1" ]
[ "colgroup", "$", "span", "(", "int", "cols", ")", ";", "/", "/", "$", "width", "omitted", "use", "css", "instead" ]
[ "test", "the", "property", "'", "name", "array", "'" ]
[ "public", "void", "name", "array", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "name", "array", "}" ]
[ "return", "whether", "application", "is", "foreground" ]
[ "public", "static", "boolean", "is", "app", "foreground", "(", ")", "{", "return", "utils", "bridge", "is", "app", "foreground", "(", ")", ";", "}" ]
[ "get", "service", "detail" ]
[ "public", "object", "node", "service", "detail", "(", "@", "request", "param", "(", "default", "value", "=", "constants", "default", "namespace", "id", ")", "string", "namespace", "id", ",", "string", "service", "name", ")", "throws", "nacos", "exception", "{", "service", "detailed", "service", "=", "service", "manager", "get", "service", "(", "namespace", "id", ",", "service", "name", ")", ";", "if", "(", "detailed", "service", "=", "=", "null", ")", "{", "throw", "new", "nacos", "exception", "(", "nacos", "exception", "not", "found", ",", "\"", "service", "\"", "+", "service", "name", "+", "\"", "is", "not", "found", "!", "\"", ")", ";", "}", "object", "node", "service", "object", "=", "jackson", "utils", "create", "empty", "json", "node", "(", ")", ";", "service", "object", "put", "(", "\"", "name", "\"", ",", "naming", "utils", "get", "service", "name", "(", "service", "name", ")", ")", ";", "service", "object", "put", "(", "\"", "protect", "threshold", "\"", ",", "detailed", "service", "get", "protect", "threshold", "(", ")", ")", ";", "service", "object", "put", "(", "\"", "group", "name", "\"", ",", "naming", "utils", "get", "group", "name", "(", "service", "name", ")", ")", ";", "service", "object", "replace", "(", "\"", "selector", "\"", ",", "jackson", "utils", "transfer", "to", "json", "node", "(", "detailed", "service", "get", "selector", "(", ")", ")", ")", ";", "service", "object", "replace", "(", "\"", "metadata", "\"", ",", "jackson", "utils", "transfer", "to", "json", "node", "(", "detailed", "service", "get", "metadata", "(", ")", ")", ")", ";", "object", "node", "detail", "view", "=", "jackson", "utils", "create", "empty", "json", "node", "(", ")", ";", "detail", "view", "replace", "(", "\"", "service", "\"", ",", "service", "object", ")", ";", "detail", "view", "replace", "(", "\"", "clusters", "\"", ",", "jackson", "utils", "transfer", "to", "json", "node", "(", "detailed", "service", "get", "cluster", "map", "(", ")", "values", "(", ")", ")", ")", ";", "return", "detail", "view", ";", "}" ]
[ "create", "a", "temp", "file", "for", "dumping", "the", "fsdir" ]
[ "private", "file", "get", "dump", "tree", "file", "(", "string", "dir", ",", "string", "suffix", ")", "{", "return", "new", "file", "(", "dir", ",", "string", "format", "(", "\"", "dump", "tree", "%", "s", "\"", ",", "suffix", ")", ")", ";", "}" ]
[ "starting", "a", "name", "with", "underscore", ",", "so", "that", "the", "user", "cannot", "access", "this", "function", "directly", "through", "a", "script", "it", "is", "only", "used", "within", "predefined", "painless", "functions" ]
[ "public", "version", "get", "index", "version", "(", ")", "{", "if", "(", "index", "version", "!", "=", "null", ")", "{", "return", "index", "version", ";", "}", "else", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "index", "version", "can", "not", "be", "looked", "up", "!", "\"", ")", ";", "}", "}" ]
[ "get", "any", "errors", "associated", "with", "building", "the", "given", "source", "file" ]
[ "public", "build", "error", "get", "errors", "(", "resource", "file", "source", "file", ")", "{", "return", "build", "errors", "get", "(", "source", "file", ")", ";", "}" ]
[ "current", "number", "of", "concurrent", "executions", "of", "{", "@", "link", "hystrix", "command", "#", "run", "(", ")", "}", ";" ]
[ "public", "int", "get", "current", "concurrent", "execution", "count", "(", ")", "{", "return", "concurrent", "execution", "count", "get", "(", ")", ";", "}" ]
[ "static", "helper", "method", "to", "easily", "display", "an", "two", "-", "option", "dialog", "the", "dialog", "will", "remain", "until", "the", "user", "presses", "the", "option", "1", ",", "option", "2", "or", "cancel", "button" ]
[ "public", "static", "int", "show", "option", "dialog", "(", "component", "parent", ",", "string", "title", ",", "string", "message", ",", "string", "option", "1", ",", "string", "option", "2", ")", "{", "return", "show", "option", "dialog", "(", "parent", ",", "title", ",", "message", ",", "option", "1", ",", "option", "2", ",", "plain", "message", ")", ";", "}" ]
[ "change", "to", "default", "conversion", "class", "and", "build", "a", "new", "{", "@", "link", "table", "schema", "}" ]
[ "public", "static", "table", "schema", "change", "default", "conversion", "class", "(", "table", "schema", "table", "schema", ")", "{", "data", "type", "[", "]", "old", "types", "=", "table", "schema", "get", "field", "data", "types", "(", ")", ";", "string", "[", "]", "field", "names", "=", "table", "schema", "get", "field", "names", "(", ")", ";", "table", "schema", "builder", "builder", "=", "table", "schema", "builder", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "table", "schema", "get", "field", "count", "(", ")", ";", "i", "+", "+", ")", "{", "data", "type", "field", "type", "=", "logical", "type", "data", "type", "converter", "from", "logical", "type", "to", "data", "type", "(", "logical", "type", "data", "type", "converter", "from", "data", "type", "to", "logical", "type", "(", "old", "types", "[", "i", "]", ")", ")", ";", "builder", "field", "(", "field", "names", "[", "i", "]", ",", "field", "type", ")", ";", "}", "return", "builder", "build", "(", ")", ";", "}" ]
[ "incorporate", "additional", "requirements", "into", "an", "existing", "requirements", "object" ]
[ "private", "static", "tester", "requirements", "incorporate", "requirements", "(", "tester", "requirements", "requirements", ",", "tester", "requirements", "more", "requirements", ",", "object", "source", ")", "throws", "conflicting", "requirements", "exception", "{", "set", "<", "feature", "<", "?", ">", ">", "present", "features", "=", "requirements", "get", "present", "features", "(", ")", ";", "set", "<", "feature", "<", "?", ">", ">", "absent", "features", "=", "requirements", "get", "absent", "features", "(", ")", ";", "set", "<", "feature", "<", "?", ">", ">", "more", "present", "features", "=", "more", "requirements", "get", "present", "features", "(", ")", ";", "set", "<", "feature", "<", "?", ">", ">", "more", "absent", "features", "=", "more", "requirements", "get", "absent", "features", "(", ")", ";", "check", "conflict", "(", "\"", "absent", "\"", ",", "absent", "features", ",", "\"", "present", "\"", ",", "more", "present", "features", ",", "source", ")", ";", "check", "conflict", "(", "\"", "present", "\"", ",", "present", "features", ",", "\"", "absent", "\"", ",", "more", "absent", "features", ",", "source", ")", ";", "present", "features", "add", "all", "(", "more", "present", "features", ")", ";", "absent", "features", "add", "all", "(", "more", "absent", "features", ")", ";", "return", "requirements", ";", "}" ]
[ "report", "the", "size", "of", "the", "new", "file" ]
[ "void", "report", "(", "long", "progress", ")", ";" ]
[ "returns", "the", "total", "number", "of", "frames", "of", "input", "audio", "that", "were", "skipped", "due", "to", "being", "classified", "as", "silence", "since", "the", "last", "call", "to", "{", "@", "link", "#", "flush", "(", ")", "}" ]
[ "public", "long", "get", "skipped", "frames", "(", ")", "{", "return", "skipped", "frames", ";", "}" ]
[ "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", "\"", ")", ";", "}" ]
[ "to", "string", "map" ]
[ "public", "static", "map", "<", "string", ",", "string", ">", "to", "string", "map", "(", "map", "<", "string", ",", "object", ">", "param", ")", "{", "map", "<", "string", ",", "string", ">", "covert", "map", "=", "new", "hash", "map", "<", ">", "(", ")", ";", "if", "(", "collection", "utils", "is", "not", "empty", "(", "param", ")", ")", "{", "param", "for", "each", "(", "(", "key", ",", "value", ")", "-", ">", "{", "if", "(", "value", "!", "=", "null", ")", "{", "covert", "map", "put", "(", "key", ",", "string", "utils", "to", "string", "(", "value", ")", ")", ";", "}", "}", ")", ";", "}", "return", "covert", "map", ";", "}" ]
[ "find", "the", "fields", "constant", "that", "matches", "name", ",", "or", "null", "if", "its", "not", "found" ]
[ "public", "static", "fields", "find", "by", "name", "(", "string", "name", ")", "{", "return", "by", "name", "get", "(", "name", ")", ";", "}" ]
[ "adds", "human", "readable", "version", "and", "creation", "date", "settings", "this", "method", "is", "used", "to", "display", "the", "settings", "in", "a", "human", "readable", "format", "in", "rest", "api" ]
[ "public", "static", "settings", "add", "human", "readable", "settings", "(", "settings", "settings", ")", "{", "settings", "builder", "builder", "=", "settings", "builder", "(", ")", "put", "(", "settings", ")", ";", "version", "version", "=", "setting", "index", "version", "created", "get", "(", "settings", ")", ";", "if", "(", "version", "!", "=", "version", "v", "empty", ")", "{", "builder", "put", "(", "setting", "version", "created", "string", ",", "version", "to", "string", "(", ")", ")", ";", "}", "version", "version", "upgraded", "=", "settings", "get", "as", "version", "(", "setting", "version", "upgraded", ",", "null", ")", ";", "if", "(", "version", "upgraded", "!", "=", "null", ")", "{", "builder", "put", "(", "setting", "version", "upgraded", "string", ",", "version", "upgraded", "to", "string", "(", ")", ")", ";", "}", "long", "creation", "date", "=", "settings", "get", "as", "long", "(", "setting", "creation", "date", ",", "null", ")", ";", "if", "(", "creation", "date", "!", "=", "null", ")", "{", "zoned", "date", "time", "creation", "date", "time", "=", "zoned", "date", "time", "of", "instant", "(", "instant", "of", "epoch", "milli", "(", "creation", "date", ")", ",", "zone", "offset", "utc", ")", ";", "builder", "put", "(", "setting", "creation", "date", "string", ",", "creation", "date", "time", "to", "string", "(", ")", ")", ";", "}", "return", "builder", "build", "(", ")", ";", "}" ]
[ "shutdown", "the", "state", "storage" ]
[ "public", "void", "service", "stop", "(", ")", "throws", "i", "o", "exception", "{", "close", "storage", "(", ")", ";", "}" ]
[ "evaluates", "the", "literal", "jelly", "script", "passed", "as", "a", "parameter", "as", "html", "and", "returns", "the", "page" ]
[ "protected", "html", "page", "evaluate", "as", "html", "(", "string", "jelly", "script", ")", "throws", "exception", "{", "jenkins", "rule", "web", "client", "wc", "=", "j", "create", "web", "client", "(", ")", ";", "web", "request", "req", "=", "new", "web", "request", "(", "wc", "create", "crumbed", "url", "(", "\"", "eval", "\"", ")", ",", "post", ")", ";", "req", "set", "encoding", "type", "(", "null", ")", ";", "req", "set", "request", "body", "(", "\"", "<", "j", ":", "jelly", "xmlns", ":", "j", "=", "'", "jelly", ":", "core", "'", "xmlns", ":", "st", "=", "'", "jelly", ":", "stapler", "'", "xmlns", ":", "l", "=", "'", "/", "lib", "/", "layout", "'", "xmlns", ":", "f", "=", "'", "/", "lib", "/", "form", "'", ">", "\"", "+", "jelly", "script", "+", "\"", "<", "/", "j", ":", "jelly", ">", "\"", ")", ";", "page", "page", "=", "wc", "get", "page", "(", "req", ")", ";", "return", "(", "html", "page", ")", "page", ";", "}" ]
[ "remove", "all", "entries", "from", "the", "hashtable" ]
[ "public", "void", "remove", "all", "(", ")", "{", "indexer", "clear", "(", ")", ";", "}" ]
[ "test", "the", "property", "'", "namespace", "boolean", "'" ]
[ "public", "void", "namespace", "boolean", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "namespace", "boolean", "}" ]
[ "remove", "registered", "service" ]
[ "protected", "void", "remove", "registered", "service", "(", "final", "registered", "service", "service", ")", "{", "this", "services", "remove", "(", "service", "get", "id", "(", ")", ")", ";", "}" ]
[ "configure", "client", "keys", "to", "use", "for", "authorization", "in", "an", "ssl", "session", "use", "null", "to", "reset", "to", "default" ]
[ "public", "api", "client", "set", "key", "managers", "(", "key", "manager", "[", "]", "managers", ")", "{", "this", "key", "managers", "=", "managers", ";", "apply", "ssl", "settings", "(", ")", ";", "return", "this", ";", "}" ]
[ "returns", "whether", "this", "map", "contains", "the", "specified", "value" ]
[ "public", "boolean", "contains", "value", "(", "object", "value", ")", "{", "if", "(", "value", "!", "=", "null", ")", "{", "for", "(", "int", "i", "=", "element", "data", "length", ";", "-", "-", "i", ">", "=", "0", ";", ")", "{", "entry", "<", "v", ">", "entry", "=", "element", "data", "[", "i", "]", ";", "while", "(", "entry", "!", "=", "null", ")", "{", "if", "(", "value", "equals", "(", "entry", "value", ")", ")", "{", "return", "true", ";", "}", "entry", "=", "entry", "next", ";", "}", "}", "}", "else", "{", "for", "(", "int", "i", "=", "element", "data", "length", ";", "-", "-", "i", ">", "=", "0", ";", ")", "{", "entry", "<", "v", ">", "entry", "=", "element", "data", "[", "i", "]", ";", "while", "(", "entry", "!", "=", "null", ")", "{", "if", "(", "entry", "value", "=", "=", "null", ")", "{", "return", "true", ";", "}", "entry", "=", "entry", "next", ";", "}", "}", "}", "return", "false", ";", "}" ]
[ "this", "method", "will", "always", "return", "after", "a", "maximum", "'", "timeout", "'", "waiting", ":", "1", "if", "value", "returns", "before", "timeout", ",", "return", "normally", "2", "if", "no", "value", "returns", "after", "timeout", ",", "throw", "timeout", "exception" ]
[ "public", "result", "get", "(", ")", "throws", "interrupted", "exception", ",", "execution", "exception", "{", "if", "(", "executor", "!", "=", "null", "&", "&", "executor", "instanceof", "threadless", "executor", ")", "{", "threadless", "executor", "threadless", "executor", "=", "(", "threadless", "executor", ")", "executor", ";", "threadless", "executor", "wait", "and", "drain", "(", ")", ";", "}", "return", "response", "future", "get", "(", ")", ";", "}" ]
[ "get", "the", "version", "of", "the", "router" ]
[ "string", "get", "version", "(", ")", ";" ]
[ "method", "to", "check", "to", "see", "if", "a", "connection", "is", "still", "usable" ]
[ "protected", "boolean", "ping", "connection", "(", "pooled", "connection", "conn", ")", "{", "boolean", "result", "=", "true", ";", "try", "{", "result", "=", "!", "conn", "get", "real", "connection", "(", ")", "is", "closed", "(", ")", ";", "}", "catch", "(", "s", "q", "l", "exception", "e", ")", "{", "if", "(", "log", "is", "debug", "enabled", "(", ")", ")", "{", "log", "debug", "(", "\"", "connection", "\"", "+", "conn", "get", "real", "hash", "code", "(", ")", "+", "\"", "is", "bad", ":", "\"", "+", "e", "get", "message", "(", ")", ")", ";", "}", "result", "=", "false", ";", "}", "if", "(", "result", "&", "&", "pool", "ping", "enabled", "&", "&", "pool", "ping", "connections", "not", "used", "for", ">", "=", "0", "&", "&", "conn", "get", "time", "elapsed", "since", "last", "use", "(", ")", ">", "pool", "ping", "connections", "not", "used", "for", ")", "{", "try", "{", "if", "(", "log", "is", "debug", "enabled", "(", ")", ")", "{", "log", "debug", "(", "\"", "testing", "connection", "\"", "+", "conn", "get", "real", "hash", "code", "(", ")", "+", "\"", "\"", ")", ";", "}", "connection", "real", "conn", "=", "conn", "get", "real", "connection", "(", ")", ";", "try", "(", "statement", "statement", "=", "real", "conn", "create", "statement", "(", ")", ")", "{", "statement", "execute", "query", "(", "pool", "ping", "query", ")", "close", "(", ")", ";", "}", "if", "(", "!", "real", "conn", "get", "auto", "commit", "(", ")", ")", "{", "real", "conn", "rollback", "(", ")", ";", "}", "result", "=", "true", ";", "if", "(", "log", "is", "debug", "enabled", "(", ")", ")", "{", "log", "debug", "(", "\"", "connection", "\"", "+", "conn", "get", "real", "hash", "code", "(", ")", "+", "\"", "is", "good", "!", "\"", ")", ";", "}", "}", "catch", "(", "exception", "e", ")", "{", "log", "warn", "(", "\"", "execution", "of", "ping", "query", "'", "\"", "+", "pool", "ping", "query", "+", "\"", "'", "failed", ":", "\"", "+", "e", "get", "message", "(", ")", ")", ";", "try", "{", "conn", "get", "real", "connection", "(", ")", "close", "(", ")", ";", "}", "catch", "(", "exception", "e", "2", ")", "{", "/", "/", "ignore", "}", "result", "=", "false", ";", "if", "(", "log", "is", "debug", "enabled", "(", ")", ")", "{", "log", "debug", "(", "\"", "connection", "\"", "+", "conn", "get", "real", "hash", "code", "(", ")", "+", "\"", "is", "bad", ":", "\"", "+", "e", "get", "message", "(", ")", ")", ";", "}", "}", "}", "return", "result", ";", "}" ]
[ "returns", "the", "{", "@", "link", "response", "}", "that", "caused", "this", "exception", "to", "be", "thrown" ]
[ "public", "response", "get", "response", "(", ")", "{", "return", "response", ";", "}" ]
[ "returns", "the", "index", "of", "the", "currently", "selected", "value", ";" ]
[ "public", "int", "get", "selected", "value", "index", "(", ")", "{", "return", "selected", ";", "}" ]
[ "visits", "the", "given", "type", "path", "info", "of", "any", "type", "of", "class", "member" ]
[ "public", "void", "visit", "type", "path", "info", "(", "clazz", "clazz", ",", "member", "member", ",", "type", "annotation", "type", "annotation", ",", "type", "path", "info", "type", "path", "info", ")", "{", "visit", "type", "path", "info", "(", "clazz", ",", "type", "annotation", ",", "type", "path", "info", ")", ";", "}" ]
[ "logs", "user", "into", "the", "system" ]
[ "public", "void", "login", "user", "(", "string", "username", ",", "string", "password", ",", "api", "client", "auth", "info", "auth", "info", ",", "handler", "<", "async", "result", "<", "string", ">", ">", "result", "handler", ")", "{", "delegate", "login", "user", "(", "username", ",", "password", ",", "auth", "info", ",", "result", "handler", ")", ";", "}" ]
[ "model", "tests", "for", "additional", "properties", "array" ]
[ "public", "void", "test", "additional", "properties", "array", "(", ")", "{", "/", "/", "todo", ":", "test", "additional", "properties", "array", "}" ]
[ "returns", "the", "list", "of", "functions", "in", "the", "panel", "this", "is", "only", "used", "for", "testing", "!" ]
[ "public", "list", "<", "function", ">", "get", "functions", "(", ")", "{", "return", "model", "get", "functions", "(", ")", ";", "}" ]
[ "reports", "the", "metrics", "captured", "by", "this", "class" ]
[ "private", "string", "report", "anomalies", "(", ")", "{", "string", "builder", "builder", "=", "new", "string", "builder", "(", ")", ";", "if", "(", "pdb", "anomalies", "size", "(", ")", ">", "0", ")", "{", "builder", "append", "(", "\"", "pdb", "anomalies", ":", "\"", ")", ";", "builder", "append", "(", "pdb", "anomalies", ")", ";", "builder", "append", "(", "\"", "\\", "n", "\"", ")", ";", "}", "return", "builder", "to", "string", "(", ")", ";", "}" ]
[ "push", "stream", "data", "which", "need", "to", "send", "to", "another", "oap", "server" ]
[ "public", "void", "push", "(", "string", "next", "worker", "name", ",", "stream", "data", "stream", "data", ")", "{", "remote", "message", "builder", "builder", "=", "remote", "message", "new", "builder", "(", ")", ";", "builder", "set", "next", "worker", "name", "(", "next", "worker", "name", ")", ";", "builder", "set", "remote", "data", "(", "stream", "data", "serialize", "(", ")", ")", ";", "this", "get", "data", "carrier", "(", ")", "produce", "(", "builder", "build", "(", ")", ")", ";", "}" ]
[ "decode", "the", "from", "one", "{", "@", "link", "byte", "buf", "}", "to", "an", "other", "this", "method", "will", "be", "called", "till", "either", "the", "input", "{", "@", "link", "byte", "buf", "}", "has", "nothing", "to", "read", "when", "return", "from", "this", "method", "or", "till", "nothing", "was", "read", "from", "the", "input", "{", "@", "link", "byte", "buf", "}" ]
[ "protected", "abstract", "void", "decode", "(", "channel", "handler", "context", "ctx", ",", "byte", "buf", "in", ",", "list", "<", "object", ">", "out", ")", "throws", "exception", ";" ]
[ "returns", "a", "collection", "of", "column", "constraints", "that", "will", "be", "used", "by", "the", "table", "column", "filtering", "feature", "to", "filter", "tables", "based", "on", "column", "values" ]
[ "public", "collection", "<", "column", "constraint", "<", "?", ">", ">", "get", "column", "constraints", "(", ")", ";" ]
[ "encode", "the", "current", "control", "message", "into", "a", "channel", "buffer" ]
[ "channel", "buffer", "buffer", "(", ")", "throws", "exception", "{", "channel", "buffer", "output", "stream", "bout", "=", "new", "channel", "buffer", "output", "stream", "(", "channel", "buffers", "direct", "buffer", "(", "encode", "length", "(", ")", ")", ")", ";", "write", "(", "bout", ")", ";", "bout", "close", "(", ")", ";", "return", "bout", "buffer", "(", ")", ";", "}" ]
[ "removes", "the", "specified", "listener", "from", "the", "front", "-", "end", "tool" ]
[ "public", "void", "remove", "project", "listener", "(", "project", "listener", "l", ")", ";" ]
[ "get", "authentication", "for", "the", "given", "name" ]
[ "public", "authentication", "get", "authentication", "(", "string", "auth", "name", ")", "{", "return", "authentications", "get", "(", "auth", "name", ")", ";", "}" ]
[ "gets", "a", "list", "of", "unprotected", "root", "actions", "these", "url", "prefixes", "should", "be", "exempted", "from", "access", "control", "checks", "by", "container", "-", "managed", "security", "ideally", "would", "be", "synchronized", "with", "{", "@", "link", "#", "get", "target", "}" ]
[ "public", "collection", "<", "string", ">", "get", "unprotected", "root", "actions", "(", ")", "{", "set", "<", "string", ">", "names", "=", "new", "tree", "set", "<", ">", "(", ")", ";", "names", "add", "(", "\"", "jnlp", "jars", "\"", ")", ";", "/", "/", "todo", "cleaner", "to", "refactor", "do", "jnlp", "jars", "into", "a", "ura", "(", "see", "also", "jenkins", "-", "44100", ")", "/", "/", "todo", "consider", "caching", "(", "expiring", "cache", "when", "actions", "changes", ")", "for", "(", "action", "a", ":", "get", "actions", "(", ")", ")", "{", "if", "(", "a", "instanceof", "unprotected", "root", "action", ")", "{", "string", "url", "=", "a", "get", "url", "name", "(", ")", ";", "if", "(", "url", "=", "=", "null", ")", "continue", ";", "names", "add", "(", "url", ")", ";", "}", "}", "return", "names", ";", "}" ]
[ "create", "a", "simple", "operator", "factory", "from", "existed", "stream", "operator" ]
[ "public", "static", "<", "out", ">", "simple", "operator", "factory", "<", "out", ">", "of", "(", "stream", "operator", "<", "out", ">", "operator", ")", "{", "if", "(", "operator", "=", "=", "null", ")", "{", "return", "null", ";", "}", "else", "if", "(", "operator", "instanceof", "stream", "source", "&", "&", "(", "(", "stream", "source", ")", "operator", ")", "get", "user", "function", "(", ")", "instanceof", "input", "format", "source", "function", ")", "{", "return", "new", "simple", "input", "format", "operator", "factory", "<", "out", ">", "(", "(", "stream", "source", ")", "operator", ")", ";", "}", "else", "if", "(", "operator", "instanceof", "stream", "sink", "&", "&", "(", "(", "stream", "sink", ")", "operator", ")", "get", "user", "function", "(", ")", "instanceof", "output", "format", "sink", "function", ")", "{", "return", "new", "simple", "output", "format", "operator", "factory", "<", ">", "(", "(", "stream", "sink", ")", "operator", ")", ";", "}", "else", "if", "(", "operator", "instanceof", "abstract", "udf", "stream", "operator", ")", "{", "return", "new", "simple", "udf", "stream", "operator", "factory", "<", "out", ">", "(", "(", "abstract", "udf", "stream", "operator", ")", "operator", ")", ";", "}", "else", "{", "return", "new", "simple", "operator", "factory", "<", ">", "(", "operator", ")", ";", "}", "}" ]
[ "destroys", "the", "<", "code", ">", "servlet", "context", "listener", "<", "code", ">", "which", "destroys", "the", "server" ]
[ "public", "void", "context", "destroyed", "(", "servlet", "context", "event", "event", ")", "{", "destroy", "(", ")", ";", "}" ]
[ "returns", "the", "location", "of", "a", "given", "static", "field" ]
[ "public", "static", "long", "object", "field", "offset", "(", "class", "<", "?", ">", "clazz", ",", "string", "field", "name", ")", "{", "try", "{", "return", "unsafe", "object", "field", "offset", "(", "clazz", "get", "declared", "field", "(", "field", "name", ")", ")", ";", "}", "catch", "(", "no", "such", "field", "exception", "|", "security", "exception", "e", ")", "{", "throw", "new", "error", "(", "e", ")", ";", "}", "}" ]
[ "tests", "that", "failing", "an", "allocation", "fails", "the", "pending", "slot", "request" ]
[ "public", "void", "test", "failing", "allocation", "fails", "pending", "slot", "requests", "(", ")", "throws", "exception", "{", "final", "completable", "future", "<", "allocation", "i", "d", ">", "allocation", "id", "future", "=", "new", "completable", "future", "<", ">", "(", ")", ";", "resource", "manager", "gateway", "set", "request", "slot", "consumer", "(", "slot", "request", "-", ">", "allocation", "id", "future", "complete", "(", "slot", "request", "get", "allocation", "id", "(", ")", ")", ")", ";", "try", "(", "slot", "pool", "impl", "slot", "pool", "=", "create", "and", "set", "up", "slot", "pool", "(", "resource", "manager", "gateway", ")", ")", "{", "final", "completable", "future", "<", "physical", "slot", ">", "slot", "future", "=", "request", "new", "allocated", "slot", "(", "slot", "pool", ",", "new", "slot", "request", "id", "(", ")", ")", ";", "final", "allocation", "i", "d", "allocation", "id", "=", "allocation", "id", "future", "get", "(", ")", ";", "assert", "that", "(", "slot", "future", "is", "done", "(", ")", ",", "is", "(", "false", ")", ")", ";", "final", "flink", "exception", "cause", "=", "new", "flink", "exception", "(", "\"", "fail", "pending", "slot", "request", "failure", "\"", ")", ";", "final", "optional", "<", "resource", "i", "d", ">", "response", "future", "=", "slot", "pool", "fail", "allocation", "(", "allocation", "id", ",", "cause", ")", ";", "assert", "that", "(", "response", "future", "is", "present", "(", ")", ",", "is", "(", "false", ")", ")", ";", "try", "{", "slot", "future", "get", "(", ")", ";", "fail", "(", "\"", "expected", "a", "slot", "allocation", "failure", "\"", ")", ";", "}", "catch", "(", "execution", "exception", "ee", ")", "{", "assert", "that", "(", "exception", "utils", "strip", "execution", "exception", "(", "ee", ")", ",", "equal", "to", "(", "cause", ")", ")", ";", "}", "}", "}" ]
[ "visits", "a", "elvis", "expression", "which", "is", "a", "shortcut", "for", "a", "null", "check", "on", "a", "conditional", "expression", "checks", ":", "type", "validation" ]
[ "public", "void", "visit", "elvis", "(", "e", "elvis", "user", "elvis", "node", ",", "semantic", "scope", "semantic", "scope", ")", "{", "if", "(", "semantic", "scope", "get", "condition", "(", "user", "elvis", "node", ",", "write", "class", ")", ")", "{", "throw", "user", "elvis", "node", "create", "error", "(", "new", "illegal", "argument", "exception", "(", "\"", "invalid", "assignment", ":", "cannot", "assign", "a", "value", "to", "elvis", "operation", "[", "?", ":", "]", "\"", ")", ")", ";", "}", "if", "(", "semantic", "scope", "get", "condition", "(", "user", "elvis", "node", ",", "read", "class", ")", "=", "=", "false", ")", "{", "throw", "user", "elvis", "node", "create", "error", "(", "new", "illegal", "argument", "exception", "(", "\"", "not", "a", "statement", ":", "result", "not", "used", "from", "elvis", "operation", "[", "?", ":", "]", "\"", ")", ")", ";", "}", "target", "type", "target", "type", "=", "semantic", "scope", "get", "decoration", "(", "user", "elvis", "node", ",", "target", "type", "class", ")", ";", "if", "(", "target", "type", "!", "=", "null", "&", "&", "target", "type", "get", "target", "type", "(", ")", "is", "primitive", "(", ")", ")", "{", "throw", "user", "elvis", "node", "create", "error", "(", "new", "illegal", "argument", "exception", "(", "\"", "elvis", "operator", "cannot", "return", "primitives", "\"", ")", ")", ";", "}", "a", "expression", "user", "left", "node", "=", "user", "elvis", "node", "get", "left", "node", "(", ")", ";", "semantic", "scope", "set", "condition", "(", "user", "left", "node", ",", "read", "class", ")", ";", "semantic", "scope", "copy", "decoration", "(", "user", "elvis", "node", ",", "user", "left", "node", ",", "target", "type", "class", ")", ";", "semantic", "scope", "replicate", "condition", "(", "user", "elvis", "node", ",", "user", "left", "node", ",", "explicit", "class", ")", ";", "semantic", "scope", "replicate", "condition", "(", "user", "elvis", "node", ",", "user", "left", "node", ",", "internal", "class", ")", ";", "checked", "visit", "(", "user", "left", "node", ",", "semantic", "scope", ")", ";", "class", "<", "?", ">", "left", "value", "type", "=", "semantic", "scope", "get", "decoration", "(", "user", "left", "node", ",", "value", "type", "class", ")", "get", "value", "type", "(", ")", ";", "a", "expression", "user", "right", "node", "=", "user", "elvis", "node", "get", "right", "node", "(", ")", ";", "semantic", "scope", "set", "condition", "(", "user", "right", "node", ",", "read", "class", ")", ";", "semantic", "scope", "copy", "decoration", "(", "user", "elvis", "node", ",", "user", "right", "node", ",", "target", "type", "class", ")", ";", "semantic", "scope", "replicate", "condition", "(", "user", "elvis", "node", ",", "user", "right", "node", ",", "explicit", "class", ")", ";", "semantic", "scope", "replicate", "condition", "(", "user", "elvis", "node", ",", "user", "right", "node", ",", "internal", "class", ")", ";", "checked", "visit", "(", "user", "right", "node", ",", "semantic", "scope", ")", ";", "class", "<", "?", ">", "right", "value", "type", "=", "semantic", "scope", "get", "decoration", "(", "user", "right", "node", ",", "value", "type", "class", ")", "get", "value", "type", "(", ")", ";", "if", "(", "user", "left", "node", "instanceof", "e", "null", ")", "{", "throw", "user", "elvis", "node", "create", "error", "(", "new", "illegal", "argument", "exception", "(", "\"", "extraneous", "elvis", "operator", "lhs", "is", "null", "\"", ")", ")", ";", "}", "if", "(", "user", "left", "node", "instanceof", "e", "boolean", "constant", "|", "|", "user", "left", "node", "instanceof", "e", "numeric", "|", "|", "user", "left", "node", "instanceof", "e", "decimal", "|", "|", "user", "left", "node", "instanceof", "e", "string", ")", "{", "throw", "user", "elvis", "node", "create", "error", "(", "new", "illegal", "argument", "exception", "(", "\"", "extraneous", "elvis", "operator", "lhs", "is", "a", "constant", "\"", ")", ")", ";", "}", "if", "(", "left", "value", "type", "is", "primitive", "(", ")", ")", "{", "throw", "user", "elvis", "node", "create", "error", "(", "new", "illegal", "argument", "exception", "(", "\"", "extraneous", "elvis", "operator", "lhs", "is", "a", "primitive", "\"", ")", ")", ";", "}", "if", "(", "user", "right", "node", "instanceof", "e", "null", ")", "{", "throw", "user", "elvis", "node", "create", "error", "(", "new", "illegal", "argument", "exception", "(", "\"", "extraneous", "elvis", "operator", "rhs", "is", "null", "\"", ")", ")", ";", "}", "class", "<", "?", ">", "value", "type", ";", "if", "(", "target", "type", "=", "=", "null", ")", "{", "class", "<", "?", ">", "promote", "=", "analyzer", "caster", "promote", "conditional", "(", "left", "value", "type", ",", "right", "value", "type", ")", ";", "semantic", "scope", "put", "decoration", "(", "user", "left", "node", ",", "new", "target", "type", "(", "promote", ")", ")", ";", "semantic", "scope", "put", "decoration", "(", "user", "right", "node", ",", "new", "target", "type", "(", "promote", ")", ")", ";", "value", "type", "=", "promote", ";", "}", "else", "{", "value", "type", "=", "target", "type", "get", "target", "type", "(", ")", ";", "}", "decorate", "with", "cast", "(", "user", "left", "node", ",", "semantic", "scope", ")", ";", "decorate", "with", "cast", "(", "user", "right", "node", ",", "semantic", "scope", ")", ";", "semantic", "scope", "put", "decoration", "(", "user", "elvis", "node", ",", "new", "value", "type", "(", "value", "type", ")", ")", ";", "}" ]
[ "verifies", "an", "integer", "is", "greater", "than", "zero" ]
[ "public", "static", "int", "gt", "0", "(", "int", "value", ",", "string", "name", ")", "{", "return", "(", "int", ")", "gt", "0", "(", "(", "long", ")", "value", ",", "name", ")", ";", "}" ]
[ "retrieves", "information", "about", "a", "group", "by", "its", "name", "this", "method", "is", "the", "group", "version", "of", "the", "{", "@", "link", "#", "load", "user", "by", "username", "2", "(", "string", ")", "}" ]
[ "public", "group", "details", "load", "group", "by", "groupname", "2", "(", "string", "groupname", ",", "boolean", "fetch", "members", ")", "throws", "username", "not", "found", "exception", "{", "if", "(", "util", "is", "overridden", "(", "abstract", "password", "based", "security", "realm", "class", ",", "get", "class", "(", ")", ",", "\"", "load", "group", "by", "groupname", "\"", ",", "string", "class", ")", ")", "{", "try", "{", "return", "load", "group", "by", "groupname", "(", "groupname", ")", ";", "}", "catch", "(", "org", "acegisecurity", "acegi", "security", "exception", "x", ")", "{", "throw", "x", "to", "spring", "(", ")", ";", "}", "catch", "(", "org", "springframework", "dao", "data", "access", "exception", "x", ")", "{", "throw", "x", "to", "spring", "(", ")", ";", "}", "}", "else", "{", "throw", "new", "abstract", "method", "error", "(", "\"", "implement", "load", "group", "by", "groupname", "2", "\"", ")", ";", "}", "}" ]
[ "insert", "a", "throttled", "wait", "if", "the", "throttle", "delay", "&", "gt", ";", "0" ]
[ "public", "void", "throttle", "(", ")", "throws", "interrupted", "i", "o", "exception", "{", "int", "throttle", "delay", "=", "get", "throttle", "delay", "(", ")", ";", "if", "(", "throttle", "delay", ">", "0", ")", "{", "try", "{", "thread", "sleep", "(", "throttle", "delay", ")", ";", "}", "catch", "(", "interrupted", "exception", "e", ")", "{", "/", "/", "convert", "to", "an", "ioe", "throw", "(", "interrupted", "i", "o", "exception", ")", "new", "interrupted", "i", "o", "exception", "(", "e", "to", "string", "(", ")", ")", "init", "cause", "(", "e", ")", ";", "}", "}", "}" ]
[ "removes", "all", "handlers", "and", "resets", "the", "default", "behavior" ]
[ "public", "static", "void", "reset", "(", ")", "{", "set", "init", "main", "thread", "scheduler", "handler", "(", "null", ")", ";", "set", "main", "thread", "scheduler", "handler", "(", "null", ")", ";", "}" ]
[ "put", "initial", "http", "request", "post", "parameters" ]
[ "public", "static", "void", "put", "initial", "http", "request", "post", "parameters", "(", "final", "request", "context", "context", ")", "{", "val", "request", "=", "get", "http", "servlet", "request", "from", "external", "webflow", "context", "(", "context", ")", ";", "context", "get", "flash", "scope", "(", ")", "put", "(", "\"", "http", "request", "initial", "post", "parameters", "\"", ",", "request", "get", "parameter", "map", "(", ")", ")", ";", "}" ]
[ "test", "the", "property", "'", "name", "'" ]
[ "public", "void", "name", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "name", "}" ]
[ "displays", "the", "default", "information", "in", "the", "merge", "tool" ]
[ "void", "show", "default", "component", "(", ")", "{", "provider", "show", "default", "component", "(", ")", ";", "}" ]
[ "sets", "the", "renderer", "time", "of", "the", "start", "of", "the", "period", ",", "in", "microseconds" ]
[ "public", "void", "set", "renderer", "offset", "(", "long", "renderer", "position", "offset", "us", ")", "{", "this", "renderer", "position", "offset", "us", "=", "renderer", "position", "offset", "us", ";", "}" ]
[ "adds", "the", "value", "to", "this", "graph" ]
[ "public", "synchronized", "void", "add", "value", "(", "t", "value", ")", "{", "get", "or", "create", "dependency", "node", "(", "value", ")", ";", "}" ]
[ "to", "be", "kept", "in", "sync", "with", "{", "@", "link", "file", "v", "f", "#", "compute", "relative", "path", "to", "root", "(", ")", "}" ]
[ "private", "string", "compute", "relative", "path", "to", "root", "(", ")", "{", "if", "(", "this", "root", "equals", "(", "this", "f", ")", ")", "{", "return", "\"", "\"", ";", "}", "linked", "list", "<", "string", ">", "relative", "path", "=", "new", "linked", "list", "<", ">", "(", ")", ";", "file", "path", "current", "=", "this", "f", ";", "while", "(", "current", "!", "=", "null", "&", "&", "!", "current", "equals", "(", "this", "root", ")", ")", "{", "relative", "path", "add", "first", "(", "current", "get", "name", "(", ")", ")", ";", "current", "=", "current", "get", "parent", "(", ")", ";", "}", "return", "join", "with", "forward", "slashes", "(", "relative", "path", ")", ";", "}" ]
[ "atomically", "sets", "the", "element", "at", "position", "{", "@", "code", "i", "}", "to", "the", "given", "updated", "value", "if", "the", "current", "value", "is", "<", "a", "href", "=", "\"", "#", "bit", "equals", "\"", ">", "bitwise", "equal", "to", "the", "expected", "value" ]
[ "public", "final", "boolean", "compare", "and", "set", "(", "int", "i", ",", "double", "expect", ",", "double", "update", ")", "{", "return", "longs", "compare", "and", "set", "(", "i", ",", "double", "to", "raw", "long", "bits", "(", "expect", ")", ",", "double", "to", "raw", "long", "bits", "(", "update", ")", ")", ";", "}" ]
[ "sets", "the", "padding", "on", "rounded", "drawable", "works", "only", "with", "{", "@", "code", "rounding", "method", "bitmap", "only", "}" ]
[ "public", "rounding", "params", "set", "padding", "(", "float", "padding", ")", "{", "preconditions", "check", "argument", "(", "padding", ">", "=", "0", ",", "\"", "the", "padding", "cannot", "be", "<", "0", "\"", ")", ";", "m", "padding", "=", "padding", ";", "return", "this", ";", "}" ]
[ "add", "a", "method", "to", "be", "supported", "by", "the", "service" ]
[ "public", "<", "req", "t", ",", "resp", "t", ">", "builder", "add", "method", "(", "server", "method", "definition", "<", "req", "t", ",", "resp", "t", ">", "def", ")", "{", "method", "descriptor", "<", "req", "t", ",", "resp", "t", ">", "method", "=", "def", "get", "method", "descriptor", "(", ")", ";", "check", "argument", "(", "service", "name", "equals", "(", "method", "get", "service", "name", "(", ")", ")", ",", "\"", "method", "name", "should", "be", "prefixed", "with", "service", "name", "and", "separated", "with", "'", "/", "'", "\"", "+", "\"", "expected", "service", "name", ":", "'", "%", "s", "'", "actual", "fully", "qualifed", "method", "name", ":", "'", "%", "s", "'", "\"", ",", "service", "name", ",", "method", "get", "full", "method", "name", "(", ")", ")", ";", "string", "name", "=", "method", "get", "full", "method", "name", "(", ")", ";", "check", "state", "(", "!", "methods", "contains", "key", "(", "name", ")", ",", "\"", "method", "by", "same", "name", "already", "registered", ":", "%", "s", "\"", ",", "name", ")", ";", "methods", "put", "(", "name", ",", "def", ")", ";", "return", "this", ";", "}" ]
[ "checks", "whether", "this", "connection", "is", "marked", "to", "break", "the", "pipeline" ]
[ "public", "boolean", "is", "breaking", "pipeline", "(", ")", "{", "return", "this", "break", "pipeline", ";", "}" ]
[ "implement", "accumulate", "multiply", "with", "old", "technique" ]
[ "public", "int", "accumulate", "mul", "(", "int", "nums", ")", "{", "logger", "info", "(", "\"", "source", "module", "{", "}", "\"", ",", "version", ")", ";", "var", "sum", "=", "1", ";", "for", "(", "final", "var", "num", ":", "nums", ")", "{", "sum", "*", "=", "num", ";", "}", "return", "sum", ";", "}" ]
[ "sets", "whether", "to", "pretend", "to", "be", "'", "root", "'", "inside", "the", "namespace" ]
[ "public", "command", "line", "builder", "set", "use", "fake", "root", "(", "boolean", "use", "fake", "root", ")", "{", "this", "use", "fake", "root", "=", "use", "fake", "root", ";", "return", "this", ";", "}" ]
[ "implementation", "of", "{", "@", "link", "collection", "#", "to", "array", "(", "object", "[", "]", ")", "}", "for", "collections", "backed", "by", "an", "object", "array", "the", "runtime", "type", "of", "the", "returned", "array", "is", "that", "of", "the", "specified", "array", "if", "the", "collection", "fits", "in", "the", "specified", "array", ",", "it", "is", "returned", "therein", "otherwise", ",", "a", "new", "array", "is", "allocated", "with", "the", "runtime", "type", "of", "the", "specified", "array", "and", "the", "size", "of", "the", "specified", "collection", "if", "the", "collection", "fits", "in", "the", "specified", "array", "with", "room", "to", "spare", "(", "i", "e", ",", "the", "array", "has", "more", "elements", "than", "the", "collection", ")", ",", "the", "element", "in", "the", "array", "immediately", "following", "the", "end", "of", "the", "collection", "is", "set", "to", "{", "@", "code", "null", "}", "this", "is", "useful", "in", "determining", "the", "length", "of", "the", "collection", "only", "if", "the", "caller", "knows", "that", "the", "collection", "does", "not", "contain", "any", "null", "elements" ]
[ "static", "<", "t", ">", "t", "[", "]", "to", "array", "impl", "(", "object", "[", "]", "src", ",", "int", "offset", ",", "int", "len", ",", "t", "[", "]", "dst", ")", "{", "check", "position", "indexes", "(", "offset", ",", "offset", "+", "len", ",", "src", "length", ")", ";", "if", "(", "dst", "length", "<", "len", ")", "{", "dst", "=", "new", "array", "(", "dst", ",", "len", ")", ";", "}", "else", "if", "(", "dst", "length", ">", "len", ")", "{", "dst", "[", "len", "]", "=", "null", ";", "}", "system", "arraycopy", "(", "src", ",", "offset", ",", "dst", ",", "0", ",", "len", ")", ";", "return", "dst", ";", "}" ]
[ "return", "g", "task", "group", "for", "this", "task" ]
[ "public", "g", "task", "group", "get", "group", "(", ")", "{", "return", "group", ";", "}" ]