Datasets:
Anonymous2023
/
KGSum

Dataset card Data Studio Files Community
docstring_tokens
list
code_tokens
list
[ "create", "the", "path", "to", "a", "service", "record", "for", "a", "component" ]
[ "public", "static", "string", "component", "path", "(", "string", "user", ",", "string", "service", "class", ",", "string", "service", "name", ",", "string", "component", "name", ")", "{", "return", "join", "(", "component", "list", "path", "(", "user", ",", "service", "class", ",", "service", "name", ")", ",", "component", "name", ")", ";", "}" ]
[ "returns", "true", "if", "field", "corresponding", "to", "field", "i", "d", "is", "set", "(", "has", "been", "assigned", "a", "value", ")", "and", "false", "otherwise" ]
[ "public", "boolean", "is", "set", "(", "fields", "field", ")", "{", "if", "(", "field", "=", "=", "null", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", ")", ";", "}", "switch", "(", "field", ")", "{", "case", "success", ":", "return", "is", "set", "success", "(", ")", ";", "}", "throw", "new", "illegal", "state", "exception", "(", ")", ";", "}" ]
[ "returns", "true", "if", "the", "initial", "protections", "include", "execute" ]
[ "public", "boolean", "is", "execute", "(", ")", "{", "return", "(", "initprot", "&", "segment", "constants", "protection", "x", ")", "!", "=", "0", ";", "}" ]
[ "returns", "a", "summary", "of", "the", "function", "'", "s", "expected", "signatures" ]
[ "list", "<", "signature", ">", "get", "expected", "signatures", "(", "function", "definition", "definition", ")", ";" ]
[ "writes", "the", "specified", "string", "to", "the", "output", "stream", "while", "injecting", "coloring", "sequences", "when", "appropriate", "mode", "keyword", "is", "found", "and", "flushes", "list", "of", "supported", "mode", "keywords", "is", "defined", "by", "the", "enum", "{", "@", "link", "mode", "}", "see", "class", "documentation", "for", "details" ]
[ "public", "void", "print", "(", "string", "str", ")", "{", "for", "(", "string", "part", ":", "pattern", "split", "(", "str", ")", ")", "{", "int", "index", "=", "part", "index", "of", "(", "mode", "suffix", ")", ";", "/", "/", "mode", "name", "will", "contain", "at", "least", "one", "character", ",", "so", "suffix", "index", "/", "/", "must", "be", "at", "least", "1", "if", "it", "isn", "'", "t", "then", "there", "is", "no", "match", "if", "(", "index", ">", "1", ")", "{", "for", "(", "mode", "mode", ":", "modes", ")", "{", "if", "(", "index", "=", "=", "mode", "name", "(", ")", "length", "(", ")", "&", "&", "part", "starts", "with", "(", "mode", "name", "(", ")", ")", ")", "{", "setup", "terminal", "(", "mode", ")", ";", "part", "=", "part", "substring", "(", "index", "+", "mode", "suffix", "length", "(", ")", ")", ";", "break", ";", "}", "}", "}", "writer", "print", "(", "part", ")", ";", "writer", "flush", "(", ")", ";", "}", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "int", "get", "int", "(", "int", "column", "index", ")", "throws", "s", "q", "l", "exception", "{", "return", "+", "+", "counter", ";", "}" ]
[ "get", "capital", "camel" ]
[ "public", "string", "get", "capital", "camel", "(", ")", "{", "return", "capital", "camel", ";", "}" ]
[ "set", "the", "span", "of", "font", "'", "s", "size" ]
[ "public", "span", "utils", "set", "font", "size", "(", "@", "int", "range", "(", "from", "=", "0", ")", "final", "int", "size", ")", "{", "return", "set", "font", "size", "(", "size", ",", "false", ")", ";", "}" ]
[ "test", "the", "property", "'", "namespace", "integer", "'" ]
[ "public", "void", "namespace", "integer", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "namespace", "integer", "}" ]
[ "gets", "the", "opcode", "value" ]
[ "public", "int", "get", "opcode", "(", ")", "{", "return", "opcode", ";", "}" ]
[ "computes", "the", "intersection", "between", "the", "edge", "set", "and", "the", "given", "edge", "set", "for", "all", "matching", "pairs", ",", "only", "one", "edge", "will", "be", "in", "the", "resulting", "data", "set" ]
[ "private", "data", "set", "<", "edge", "<", "k", ",", "ev", ">", ">", "get", "distinct", "edge", "intersection", "(", "data", "set", "<", "edge", "<", "k", ",", "ev", ">", ">", "edges", ")", "{", "return", "this", "get", "edges", "(", ")", "join", "(", "edges", ")", "where", "(", "0", ",", "1", ",", "2", ")", "equal", "to", "(", "0", ",", "1", ",", "2", ")", "with", "(", "new", "join", "function", "<", "edge", "<", "k", ",", "ev", ">", ",", "edge", "<", "k", ",", "ev", ">", ",", "edge", "<", "k", ",", "ev", ">", ">", "(", ")", "{", "@", "override", "public", "edge", "<", "k", ",", "ev", ">", "join", "(", "edge", "<", "k", ",", "ev", ">", "first", ",", "edge", "<", "k", ",", "ev", ">", "second", ")", "throws", "exception", "{", "return", "first", ";", "}", "}", ")", "with", "forwarded", "fields", "first", "(", "\"", "*", "\"", ")", "name", "(", "\"", "intersect", "edges", "\"", ")", "distinct", "(", ")", "name", "(", "\"", "edges", "\"", ")", ";", "}" ]
[ "looks", "for", "pascal", "strings", "given", "a", "sequence", "of", "bytes", "that", "represent", "a", "sequence", "of", "ascii", "chars" ]
[ "public", "static", "sequence", "find", "pascal", "sequence", "(", "mem", "buffer", "buf", ",", "sequence", "sequence", ",", "int", "alignment", ")", "{", "data", "type", "string", "data", "type", "=", "sequence", "get", "string", "data", "type", "(", ")", ";", "if", "(", "(", "string", "data", "type", "instanceof", "pascal", "unicode", "data", "type", ")", "|", "|", "(", "string", "data", "type", "instanceof", "unicode", "data", "type", ")", ")", "{", "return", "find", "unicode", "pascal", "(", "buf", ",", "sequence", ")", ";", "}", "if", "(", "(", "string", "data", "type", "instanceof", "pascal", "string", "data", "type", ")", "|", "|", "(", "string", "data", "type", "instanceof", "pascal", "string", "2", "5", "5", "data", "type", ")", "|", "|", "(", "string", "data", "type", "instanceof", "string", "data", "type", ")", ")", "{", "return", "find", "ascii", "pascal", "(", "buf", ",", "sequence", ",", "alignment", ")", ";", "}", "return", "null", ";", "}" ]
[ "get", "number", "of", "destination", "references", "flowing", "out", "of", "this", "subroutine", "(", "block", ")", "all", "calls", "from", "this", "block", ",", "and", "all", "external", "flow", "type", "block", "references", "from", "this", "block", "are", "counted" ]
[ "public", "int", "get", "num", "destinations", "(", "code", "block", "block", ",", "task", "monitor", "monitor", ")", "throws", "cancelled", "exception", "{", "if", "(", "!", "(", "block", "get", "model", "(", ")", "instanceof", "partition", "code", "sub", "model", ")", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", ")", ";", "}", "return", "subroutine", "dest", "reference", "iterator", "get", "num", "destinations", "(", "block", ",", "monitor", ")", ";", "}" ]
[ "implements", "{", "@", "link", "options", "parser", "#", "canonicalize", "}" ]
[ "list", "<", "string", ">", "as", "canonicalized", "list", "(", ")", "{", "return", "as", "canonicalized", "list", "of", "parsed", "options", "(", ")", "stream", "(", ")", "map", "(", "parsed", "option", "description", ":", ":", "get", "deprecated", "canonical", "form", ")", "collect", "(", "immutable", "list", "to", "immutable", "list", "(", ")", ")", ";", "}" ]
[ "exposed", "remote", "api" ]
[ "public", "api", "get", "api", "(", ")", "{", "return", "new", "api", "(", "this", ")", ";", "}" ]
[ "used", "for", "testing", "and", "diagnostics", ":", "list", "the", "constructor", "line", "numbers", "used", "to", "resolve", "this", "encoding", "this", "includes", "braces", "to", "describe", "the", "tree", "structure" ]
[ "public", "string", "dump", "constructor", "tree", "(", ")", "{", "return", "root", "state", "dump", "constructor", "tree", "(", ")", ";", "}" ]
[ "sets", "the", "<", "code", ">", "direct", "map", "<", "code", ">", "property" ]
[ "public", "void", "set", "direct", "map", "(", "map", "<", "string", ",", "boolean", ">", "direct", "map", ")", "{", "this", "direct", "map", "=", "direct", "map", ";", "}" ]
[ "returns", "a", "^", "p", "mod", "m" ]
[ "private", "long", "pow", "mod", "(", "long", "a", ",", "long", "p", ",", "long", "m", ")", "{", "long", "res", "=", "1", ";", "for", "(", ";", "p", "!", "=", "0", ";", "p", ">", ">", "=", "1", ")", "{", "if", "(", "(", "p", "&", "1", ")", "!", "=", "0", ")", "{", "res", "=", "mul", "mod", "(", "res", ",", "a", ",", "m", ")", ";", "}", "a", "=", "square", "mod", "(", "a", ",", "m", ")", ";", "}", "return", "res", ";", "}" ]
[ "determines", "whether", "or", "not", "the", "dual", "listing", "is", "currently", "being", "shown", "to", "the", "user" ]
[ "public", "boolean", "is", "dual", "listing", "showing", "(", ")", "{", "listing", "code", "comparison", "panel", "dual", "listing", "panel", "=", "function", "comparison", "panel", "get", "dual", "listing", "panel", "(", ")", ";", "if", "(", "dual", "listing", "panel", "=", "=", "null", ")", "{", "return", "false", ";", "}", "return", "dual", "listing", "panel", "is", "showing", "(", ")", ";", "}" ]
[ "color", "in", "rgb", "format" ]
[ "public", "string", "get", "connection", "color", "(", ")", "{", "return", "connection", "color", ";", "}" ]
[ "converts", "the", "provided", "string", "list", "to", "a", "string", "array" ]
[ "public", "static", "string", "[", "]", "convert", "strings", "(", "list", "<", "string", ">", "strings", ")", "{", "string", "[", "]", "ret", "=", "new", "string", "[", "strings", "size", "(", ")", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "ret", "length", ";", "i", "+", "+", ")", "{", "ret", "[", "i", "]", "=", "strings", "get", "(", "i", ")", ";", "}", "return", "ret", ";", "}" ]
[ "model", "tests", "for", "additional", "properties", "object" ]
[ "public", "void", "test", "additional", "properties", "object", "(", ")", "{", "/", "/", "todo", ":", "test", "additional", "properties", "object", "}" ]
[ "used", "for", "rendering", "html" ]
[ "string", "get", "display", "name", "(", ")", ";" ]
[ "get", "small", "camel" ]
[ "public", "string", "get", "small", "camel", "(", ")", "{", "return", "small", "camel", ";", "}" ]
[ "close", "all", "the", "open", "file", "handles" ]
[ "public", "synchronized", "void", "close", "(", ")", "throws", "i", "o", "exception", "{", "if", "(", "log", "stream", "!", "=", "null", ")", "{", "log", "stream", "close", "(", ")", ";", "}", "for", "(", "file", "output", "stream", "log", ":", "streams", "to", "flush", ")", "{", "log", "close", "(", ")", ";", "}", "}" ]
[ "calculates", "(", "this", "quaternion", ")", "^", "alpha", "where", "alpha", "is", "a", "real", "number", "and", "stores", "the", "result", "in", "this", "quaternion", "see", "http", ":", "en", "wikipedia", "orgwiki", "quaternion", "#", "exponential", "2c", "logarithm", "2c", "and", "power" ]
[ "public", "quaternion", "exp", "(", "float", "alpha", ")", "{", "/", "/", "calculate", "|", "q", "|", "^", "alpha", "float", "norm", "=", "len", "(", ")", ";", "float", "norm", "exp", "=", "(", "float", ")", "math", "pow", "(", "norm", ",", "alpha", ")", ";", "/", "/", "calculate", "theta", "float", "theta", "=", "(", "float", ")", "math", "acos", "(", "w", "/", "norm", ")", ";", "/", "/", "calculate", "coefficient", "of", "basis", "elements", "float", "coeff", "=", "0", ";", "if", "(", "math", "abs", "(", "theta", ")", "<", "0", "001", ")", "/", "/", "if", "theta", "is", "small", "enough", ",", "use", "the", "limit", "of", "sin", "(", "alpha", "*", "theta", ")", "/", "sin", "(", "theta", ")", "instead", "of", "actual", "/", "/", "value", "coeff", "=", "norm", "exp", "*", "alpha", "/", "norm", ";", "else", "coeff", "=", "(", "float", ")", "(", "norm", "exp", "*", "math", "sin", "(", "alpha", "*", "theta", ")", "/", "(", "norm", "*", "math", "sin", "(", "theta", ")", ")", ")", ";", "/", "/", "write", "results", "w", "=", "(", "float", ")", "(", "norm", "exp", "*", "math", "cos", "(", "alpha", "*", "theta", ")", ")", ";", "x", "*", "=", "coeff", ";", "y", "*", "=", "coeff", ";", "z", "*", "=", "coeff", ";", "/", "/", "fix", "any", "possible", "discrepancies", "nor", "(", ")", ";", "return", "this", ";", "}" ]
[ "the", "virtual", "ip", "addresses", "associated", "with", "the", "service", "could", "be", "cidr", "prefix", "for", "http", "traffic", ",", "generated", "route", "configurations", "will", "include", "http", "route", "domains", "for", "both", "the", "`", "addresses", "`", "and", "`", "hosts", "`", "field", "values", "and", "the", "destination", "will", "be", "identified", "based", "on", "the", "http", "host", "authority", "header", "if", "one", "or", "more", "ip", "addresses", "are", "specified", ",", "the", "incoming", "traffic", "will", "be", "identified", "as", "belonging", "to", "this", "service", "if", "the", "destination", "ip", "matches", "the", "i", "p", "c", "i", "d", "rs", "specified", "in", "the", "addresses", "field", "if", "the", "addresses", "field", "is", "empty", ",", "traffic", "will", "be", "identified", "solely", "based", "on", "the", "destination", "port", "in", "such", "scenarios", ",", "the", "port", "on", "which", "the", "service", "is", "being", "accessed", "must", "not", "be", "shared", "by", "any", "other", "service", "in", "the", "mesh", "in", "other", "words", ",", "the", "sidecar", "will", "behave", "as", "a", "simple", "tcp", "proxy", ",", "forwarding", "incoming", "traffic", "on", "a", "specified", "port", "to", "the", "specified", "destination", "endpoint", "i", "phost", "unix", "domain", "socket", "addresses", "are", "not", "supported", "in", "this", "field", "<", "code", ">", "repeated", "string", "addresses", "=", "2", ";", "<", "code", ">" ]
[ "public", "builder", "add", "addresses", "(", "java", "lang", "string", "value", ")", "{", "if", "(", "value", "=", "=", "null", ")", "{", "throw", "new", "null", "pointer", "exception", "(", ")", ";", "}", "ensure", "addresses", "is", "mutable", "(", ")", ";", "addresses", "add", "(", "value", ")", ";", "on", "changed", "(", ")", ";", "return", "this", ";", "}" ]
[ "submits", "a", "request", "for", "execution", "and", "returns", "a", "data", "source", "representing", "the", "pending", "decoded", "image", "(", "s", ")", "the", "returned", "data", "source", "must", "be", "closed", "once", "the", "client", "has", "finished", "with", "it" ]
[ "public", "data", "source", "<", "closeable", "reference", "<", "closeable", "image", ">", ">", "fetch", "decoded", "image", "(", "image", "request", "image", "request", ",", "object", "caller", "context", ",", "image", "request", "request", "level", "lowest", "permitted", "request", "level", "on", "submit", ",", "@", "nullable", "request", "listener", "request", "listener", ",", "@", "nullable", "string", "ui", "component", "id", ")", "{", "try", "{", "producer", "<", "closeable", "reference", "<", "closeable", "image", ">", ">", "producer", "sequence", "=", "m", "producer", "sequence", "factory", "get", "decoded", "image", "producer", "sequence", "(", "image", "request", ")", ";", "return", "submit", "fetch", "request", "(", "producer", "sequence", ",", "image", "request", ",", "lowest", "permitted", "request", "level", "on", "submit", ",", "caller", "context", ",", "request", "listener", ",", "ui", "component", "id", ")", ";", "}", "catch", "(", "exception", "exception", ")", "{", "return", "data", "sources", "immediate", "failed", "data", "source", "(", "exception", ")", ";", "}", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "void", "update", "array", "(", "string", "column", "label", ",", "array", "x", ")", "throws", "s", "q", "l", "exception", "{", "}" ]
[ "return", "an", "address", "set", "that", "contains", "all", "addresses", "that", "make", "up", "the", "code", "units", "containing", "the", "indicated", "address", "in", "the", "latest", ",", "my", ",", "and", "original", "programs" ]
[ "protected", "address", "set", "view", "get", "code", "unit", "address", "set", "(", "address", "addr", ")", "{", "return", "get", "code", "unit", "address", "set", "(", "new", "address", "set", "(", "addr", ",", "addr", ")", ")", ";", "}" ]
[ "performs", "a", "deep", "comparison", "of", "two", "<", "code", ">", "object", "<", "code", ">", "arrays", "this", "also", "will", "be", "called", "for", "the", "top", "level", "of", "multi", "-", "dimensional", ",", "ragged", ",", "and", "multi", "-", "typed", "arrays" ]
[ "public", "equals", "builder", "append", "(", "object", "[", "]", "lhs", ",", "object", "[", "]", "rhs", ")", "{", "if", "(", "!", "is", "equals", ")", "{", "return", "this", ";", "}", "if", "(", "lhs", "=", "=", "rhs", ")", "{", "return", "this", ";", "}", "if", "(", "lhs", "=", "=", "null", "|", "|", "rhs", "=", "=", "null", ")", "{", "this", "set", "equals", "(", "false", ")", ";", "return", "this", ";", "}", "if", "(", "lhs", "length", "!", "=", "rhs", "length", ")", "{", "this", "set", "equals", "(", "false", ")", ";", "return", "this", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "lhs", "length", "&", "&", "is", "equals", ";", "+", "+", "i", ")", "{", "append", "(", "lhs", "[", "i", "]", ",", "rhs", "[", "i", "]", ")", ";", "}", "return", "this", ";", "}" ]
[ "build", "lock", "key" ]
[ "protected", "string", "build", "lock", "key", "(", "table", "records", "rows", "including", "p", "k", ")", "{", "if", "(", "rows", "including", "p", "k", "size", "(", ")", "=", "=", "0", ")", "{", "return", "null", ";", "}", "string", "builder", "sb", "=", "new", "string", "builder", "(", ")", ";", "sb", "append", "(", "rows", "including", "p", "k", "get", "table", "meta", "(", ")", "get", "table", "name", "(", ")", ")", ";", "sb", "append", "(", "\"", ":", "\"", ")", ";", "int", "filed", "sequence", "=", "0", ";", "list", "<", "map", "<", "string", ",", "field", ">", ">", "pks", "rows", "=", "rows", "including", "p", "k", "pk", "rows", "(", ")", ";", "for", "(", "map", "<", "string", ",", "field", ">", "row", "map", ":", "pks", "rows", ")", "{", "int", "pk", "split", "index", "=", "0", ";", "for", "(", "string", "pk", "name", ":", "get", "table", "meta", "(", ")", "get", "primary", "key", "only", "name", "(", ")", ")", "{", "if", "(", "pk", "split", "index", ">", "0", ")", "{", "sb", "append", "(", "\"", "\"", ")", ";", "}", "sb", "append", "(", "row", "map", "get", "(", "pk", "name", ")", "get", "value", "(", ")", ")", ";", "pk", "split", "index", "+", "+", ";", "}", "filed", "sequence", "+", "+", ";", "if", "(", "filed", "sequence", "<", "pks", "rows", "size", "(", ")", ")", "{", "sb", "append", "(", "\"", ",", "\"", ")", ";", "}", "}", "return", "sb", "to", "string", "(", ")", ";", "}" ]
[ "get", "a", "{", "@", "link", "erasure", "coding", "policy", "}", "by", "policy", "id", ",", "including", "system", "policy", "and", "user", "defined", "policy" ]
[ "public", "erasure", "coding", "policy", "get", "by", "i", "d", "(", "byte", "id", ")", "{", "final", "erasure", "coding", "policy", "info", "ecpi", "=", "get", "policy", "info", "by", "i", "d", "(", "id", ")", ";", "if", "(", "ecpi", "=", "=", "null", ")", "{", "return", "null", ";", "}", "return", "ecpi", "get", "policy", "(", ")", ";", "}" ]
[ "return", "the", "current", "transaction" ]
[ "public", "record", "get", "txn", "(", ")", "{", "return", "record", ";", "}" ]
[ "bootstrap", "standby", "when", "the", "existing", "nn", "is", "active" ]
[ "public", "void", "test", "bootstrap", "standby", "with", "active", "n", "n", "(", ")", "throws", "exception", "{", "/", "/", "make", "the", "first", "nn", "in", "active", "state", "cluster", "transition", "to", "active", "(", "0", ")", ";", "bootstrap", "standbys", "(", ")", ";", "}" ]
[ "return", "textual", "representation", "of", "the", "counter", "values" ]
[ "public", "synchronized", "string", "to", "string", "(", ")", "{", "string", "builder", "sb", "=", "new", "string", "builder", "(", "\"", "counters", ":", "\"", "+", "count", "counters", "(", ")", ")", ";", "for", "(", "g", "group", ":", "this", ")", "{", "sb", "append", "(", "\"", "\\", "n", "\\", "t", "\"", ")", "append", "(", "group", "get", "display", "name", "(", ")", ")", ";", "for", "(", "counter", "counter", ":", "group", ")", "{", "sb", "append", "(", "\"", "\\", "n", "\\", "t", "\\", "t", "\"", ")", "append", "(", "counter", "get", "display", "name", "(", ")", ")", "append", "(", "\"", "=", "\"", ")", "append", "(", "counter", "get", "value", "(", ")", ")", ";", "}", "}", "return", "sb", "to", "string", "(", ")", ";", "}" ]
[ "test", "that", "program", "merge", "can", "determine", "the", "byte", "differences", "between", "program", "1", "and", "program", "2" ]
[ "public", "void", "test", "apply", "byte", "differences", "(", ")", "throws", "exception", "{", "program", "builder", "1", "create", "memory", "(", "\"", "d", "1", "\"", ",", "\"", "0x", "1", "0", "0", "\"", ",", "0x", "1", "0", "0", ",", "null", ",", "(", "byte", ")", "0x", "a", "c", ")", ";", "program", "builder", "1", "create", "memory", "(", "\"", "d", "2", "\"", ",", "\"", "0x", "2", "0", "0", "\"", ",", "0x", "1", "0", "0", ")", ";", "program", "builder", "2", "create", "memory", "(", "\"", "d", "1", "\"", ",", "\"", "0x", "1", "0", "0", "\"", ",", "0x", "1", "0", "0", ",", "null", ",", "(", "byte", ")", "0x", "a", "f", ")", ";", "program", "builder", "2", "create", "memory", "(", "\"", "d", "4", "\"", ",", "\"", "0x", "4", "0", "0", "\"", ",", "0x", "1", "0", "0", ")", ";", "/", "/", "p", "1", "has", "0x", "1", "0", "0", "to", "0x", "1ff", "with", "byte", "values", "of", "0x", "c", "f", ",", "but", "in", "p", "2", "of", "0x", "a", "f", "/", "/", "p", "1", "has", "changed", "byte", "at", "0x", "1", "0", "0", "2b", "4", "5", "from", "0x", "8b", "to", "0xee", "/", "/", "p", "2", "has", "changed", "byte", "at", "0x", "1", "0", "0", "2b", "4", "9", "from", "0x", "5", "7", "to", "0xee", "program", "builder", "1", "set", "bytes", "(", "\"", "0x", "1", "0", "0", "2b", "4", "5", "\"", ",", "\"", "ee", "\"", ")", ";", "program", "builder", "1", "set", "bytes", "(", "\"", "0x", "1", "0", "0", "2b", "4", "9", "\"", ",", "\"", "ee", "\"", ")", ";", "program", "builder", "2", "set", "bytes", "(", "\"", "0x", "1", "0", "0", "2b", "4", "5", "\"", ",", "\"", "8b", "\"", ")", ";", "program", "builder", "2", "set", "bytes", "(", "\"", "0x", "1", "0", "0", "2b", "4", "9", "\"", ",", "\"", "57", "\"", ")", ";", "program", "merge", "=", "new", "program", "merge", "manager", "(", "p", "1", ",", "p", "2", ",", "task", "monitor", "adapter", "dummy", "monitor", ")", ";", "program", "merge", "set", "diff", "filter", "(", "new", "program", "diff", "filter", "(", "program", "diff", "filter", "byte", "diffs", ")", ")", ";", "program", "merge", "set", "merge", "filter", "(", "new", "program", "merge", "filter", "(", "program", "merge", "filter", "bytes", ",", "program", "merge", "filter", "replace", ")", ")", ";", "address", "set", "as", "=", "new", "address", "set", "(", ")", ";", "as", "add", "range", "(", "addr", "(", "0x", "1", "0", "0", ")", ",", "addr", "(", "0x", "1ff", ")", ")", ";", "as", "add", "range", "(", "addr", "(", "0x", "0", "1", "0", "0", "2b", "4", "5", ")", ",", "addr", "(", "0x", "0", "1", "0", "0", "2b", "4", "5", ")", ")", ";", "as", "add", "range", "(", "addr", "(", "0x", "0", "1", "0", "0", "2b", "4", "9", ")", ",", "addr", "(", "0x", "0", "1", "0", "0", "2b", "4", "9", ")", ")", ";", "/", "/", "add", "the", "bytes", "for", "the", "blocks", "that", "are", "in", "program", "1", "and", "not", "in", "program", "2", "as", "add", "range", "(", "addr", "(", "0x", "0", "0", "0", "0", "0", "2", "0", "0", ")", ",", "addr", "(", "0x", "0", "0", "0", "0", "0", "2ff", ")", ")", ";", "/", "/", "add", "the", "blocks", "that", "are", "in", "program", "2", "and", "not", "program", "1", "that", "are", "compatible", "as", "add", "range", "(", "addr", "(", "0x", "0", "0", "0", "0", "0", "4", "0", "0", ")", ",", "addr", "(", "0x", "0", "0", "0", "0", "0", "4ff", ")", ")", ";", "assert", "equals", "(", "as", ",", "program", "merge", "get", "filtered", "differences", "(", ")", ")", ";", "program", "merge", "merge", "(", "as", ",", "task", "monitor", "adapter", "dummy", "monitor", ")", ";", "address", "set", "un", "mergable", "byte", "addresses", "=", "new", "address", "set", "(", ")", ";", "/", "/", "add", "the", "bytes", "for", "the", "blocks", "that", "are", "in", "program", "1", "and", "not", "in", "program", "2", "un", "mergable", "byte", "addresses", "add", "range", "(", "addr", "(", "0x", "0", "0", "0", "0", "0", "2", "0", "0", ")", ",", "addr", "(", "0x", "0", "0", "0", "0", "0", "2ff", ")", ")", ";", "/", "/", "add", "the", "blocks", "that", "are", "in", "program", "2", "and", "not", "program", "1", "that", "are", "compatible", "un", "mergable", "byte", "addresses", "add", "range", "(", "addr", "(", "0x", "0", "0", "0", "0", "0", "4", "0", "0", ")", ",", "addr", "(", "0x", "0", "0", "0", "0", "0", "4ff", ")", ")", ";", "assert", "equals", "(", "un", "mergable", "byte", "addresses", ",", "program", "merge", "get", "filtered", "differences", "(", ")", ")", ";", "}" ]
[ "convenience", "method", "to", "create", "a", "model", "with", "a", "single", "node", "containing", "a", "cone", "shape", "the", "resources", "the", "material", "might", "contain", "are", "not", "managed", ",", "use", "{", "@", "link", "model", "#", "manage", "disposable", "(", "disposable", ")", "}", "to", "add", "those", "to", "the", "model" ]
[ "public", "model", "create", "cone", "(", "float", "width", ",", "float", "height", ",", "float", "depth", ",", "int", "divisions", ",", "int", "primitive", "type", ",", "final", "material", "material", ",", "final", "long", "attributes", ")", "{", "return", "create", "cone", "(", "width", ",", "height", ",", "depth", ",", "divisions", ",", "primitive", "type", ",", "material", ",", "attributes", ",", "0", ",", "360", ")", ";", "}" ]
[ "get", "the", "raw", "data", "of", "the", "attribute" ]
[ "public", "byte", "array", "get", "data", "(", ")", "{", "return", "data", ";", "}" ]
[ "return", "the", "http", "method", "of", "the", "request", "as", "a", "string", "value" ]
[ "string", "get", "method", "value", "(", ")", ";" ]
[ "verify", "that", "a", "component", "tree", "contains", "a", "component", "that", "matches", "the", "provided", "condition", "at", "any", "level", "in", "its", "tree", "note", "that", "asserting", "on", "indirect", "children", "breaks", "encapsulation", "and", "can", "lead", "to", "change", "detector", "tests", "[", "0", "]", "prefer", "{", "@", "link", "sub", "component", "extractor", "#", "sub", "component", "with", "(", "component", "context", ",", "condition", ")", "}", "over", "this", "whenever", "possible", "<", "h", "2", ">", "example", "use", "<", "h", "2", ">", "suppose", "you", "have", "a", "<", "code", ">", "my", "wrapper", "component", "spec", "<", "code", ">", "that", "creates", "a", "{", "@", "link", "com", "facebook", "litho", "widget", "card", "}", "which", "contains", "a", "{", "@", "link", "com", "facebook", "litho", "widget", "text", "}", "for", "a", "<", "code", ">", "text", "<", "code", ">", "prop", "that", "your", "component", "accepts", "you", "want", "to", "ensure", "that", "the", "text", "truncation", "logic", "correctly", "applies", "to", "the", "text", "that", "sits", "inside", "the", "card", "using", "{", "@", "link", "sub", "component", "extractor", "#", "sub", "component", "with", "(", "component", "context", ",", "condition", ")", "}", "won", "'", "t", "work", "here", "as", "it", "will", "only", "be", "able", "to", "make", "assertions", "on", "the", "{", "@", "link", "com", "facebook", "litho", "widget", "card", "}", "but", "not", "the", "{", "@", "link", "com", "facebook", "litho", "widget", "text", "}", "sitting", "inside", "<", "code", ">", "m", "component", "=", "my", "wrapper", "component", "create", "(", "c", ")", "text", "(", "\"", "i", "'", "m", "mr", "meeseeks", "!", "look", "at", "me", "!", "\"", ")", "build", "(", ")", ";", "assert", "that", "(", "c", ",", "m", "component", ")", "has", "(", "deep", "sub", "component", "with", "(", "c", ",", "text", "equals", "(", "\"", "i", "'", "m", "mr", "meeseeks", "!", "\"", ")", ")", ")", "does", "not", "have", "(", "deep", "sub", "component", "with", "(", "c", ",", "text", "(", "contains", "string", "(", "\"", "wubba", "lubba", "dub", "dub", "\"", ")", ")", ")", ")", ";", "<", "code", ">", "for", "more", "applicable", "combinators", ",", "see", "below", ":" ]
[ "public", "static", "condition", "<", "?", "super", "component", ">", "deep", "sub", "component", "with", "(", "final", "component", "context", "c", ",", "final", "condition", "<", "inspectable", "component", ">", "inner", ")", "{", "return", "new", "condition", "<", "component", ">", "(", "new", "text", "description", "(", "\"", "deep", "subcomponent", "with", "<", "%", "s", ">", "\"", ",", "inner", ")", ")", "{", "@", "override", "public", "boolean", "matches", "(", "component", "value", ")", "{", "for", "(", "inspectable", "component", "component", ":", "sub", "components", "deeply", "(", "c", ")", "extract", "(", "value", ")", ")", "{", "if", "(", "inner", "matches", "(", "component", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}", "}", ";", "}" ]
[ "mark", "all", "current", "and", "future", "threads", "paused", "will", "take", "effect", "asynchronously" ]
[ "void", "pause", "all", "threads", "(", ")", "{", "debugger", "state", "=", "debugger", "state", "all", "threads", "paused", ";", "}" ]
[ "remove", "loading", "more", "scroll", "listener" ]
[ "public", "void", "disable", "loadmore", "(", ")", "{", "m", "is", "load", "more", "widget", "enabled", "=", "false", ";", "if", "(", "m", "adapter", "!", "=", "null", "&", "&", "m", "load", "more", "view", "!", "=", "null", ")", "{", "m", "adapter", "enable", "load", "more", "(", "false", ")", ";", "}", "}" ]
[ "get", "the", "name", "of", "the", "{", "@", "code", "request", "context", "}", "attribute", "for", "this", "view", ",", "if", "any" ]
[ "public", "string", "get", "request", "context", "attribute", "(", ")", "{", "return", "this", "request", "context", "attribute", ";", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "string", "system", "id", "(", ")", "{", "return", "system", "id", ";", "}" ]
[ "similar", "to", "{", "@", "link", "#", "get", "variable", "local", "(", "string", ")", "}", ",", "but", "for", "transient", "variables", "only", "see", "{", "@", "link", "#", "set", "transient", "variable", "(", "string", ",", "object", ")", "}", "for", "the", "rules", "on", "'", "transient", "'", "variables" ]
[ "map", "<", "string", ",", "object", ">", "get", "transient", "variables", "local", "(", ")", ";" ]
[ "change", "the", "sort", "order", "at", "the", "given", "index", "to", "descending", "sort" ]
[ "public", "void", "set", "descending", "order", "(", "int", "index", ")", "{", "this", "comparators", "get", "(", "index", ")", "set", "ascending", "(", "false", ")", ";", "}" ]
[ "returns", "the", "string", "representation", "of", "the", "specified", "reference", "'", "s", "\"", "to", "\"", "symbol" ]
[ "public", "static", "string", "get", "user", "to", "symbol", "string", "(", "program", "program", ",", "reference", "ref", ")", "{", "if", "(", "ref", "is", "external", "reference", "(", ")", ")", "{", "external", "location", "ext", "loc", "=", "(", "(", "external", "reference", ")", "ref", ")", "get", "external", "location", "(", ")", ";", "return", "ext", "loc", "get", "library", "name", "(", ")", "+", "\"", ":", ":", "\"", "+", "ext", "loc", "get", "label", "(", ")", ";", "}", "long", "id", "=", "ref", "get", "symbol", "i", "d", "(", ")", ";", "symbol", "s", "=", "(", "id", ">", "=", "0", ")", "?", "program", "get", "symbol", "table", "(", ")", "get", "symbol", "(", "id", ")", ":", "null", ";", "return", "(", "s", "!", "=", "null", ")", "?", "s", "get", "name", "(", ")", ":", "\"", "\"", ";", "}" ]
[ "this", "is", "called", "when", "all", "the", "declared", "dependencies", "exist", "it", "may", "request", "new", "dependencies" ]
[ "sky", "value", "compute", "(", "map", "<", "sky", "key", ",", "sky", "value", ">", "deps", ",", "sky", "function", "environment", "env", ")", "throws", "interrupted", "exception", ";" ]
[ "add", "a", "single", "character", "it", "will", "be", "shown", "in", "a", "quoted", "text", "region" ]
[ "public", "void", "add", "code", "point", "char", "(", "int", "code", "point", ")", "{", "ensure", "text", "mode", "(", ")", ";", "if", "(", "code", "point", "=", "=", "quote", "char", ")", "{", "sb", "append", "(", "\"", "\\", "\\", "\"", ")", ";", "}", "sb", "append", "code", "point", "(", "code", "point", ")", ";", "}" ]
[ "returns", "the", "count", "of", "{", "@", "code", "node", "}", "'", "s", "{", "@", "link", "#", "in", "edges", "(", "object", ")", "incoming", "edges", "}", "in", "a", "directed", "network", "in", "an", "undirected", "network", ",", "returns", "the", "{", "@", "link", "#", "degree", "(", "object", ")", "}", "if", "the", "count", "is", "greater", "than", "{", "@", "code", "integer", "max", "value", "}", ",", "returns", "{", "@", "code", "integer", "max", "value", "}" ]
[ "int", "in", "degree", "(", "n", "node", ")", ";" ]
[ "append", "a", "keyvalue", "pair", "to", "the", "map", "the", "key", "must", "be", "greater", "or", "equal", "to", "the", "previous", "key", "added", "to", "the", "map" ]
[ "public", "synchronized", "void", "append", "(", "writable", "comparable", "key", ",", "writable", "val", ")", "throws", "i", "o", "exception", "{", "check", "key", "(", "key", ")", ";", "long", "pos", "=", "data", "get", "length", "(", ")", ";", "/", "/", "only", "write", "an", "index", "if", "we", "'", "ve", "changed", "positions", "in", "a", "block", "compressed", "/", "/", "file", ",", "this", "means", "we", "write", "an", "entry", "at", "the", "start", "of", "each", "block", "if", "(", "size", ">", "=", "last", "index", "key", "count", "+", "index", "interval", "&", "&", "pos", ">", "last", "index", "pos", ")", "{", "position", "set", "(", "pos", ")", ";", "/", "/", "point", "to", "current", "eof", "index", "append", "(", "key", ",", "position", ")", ";", "last", "index", "pos", "=", "pos", ";", "last", "index", "key", "count", "=", "size", ";", "}", "data", "append", "(", "key", ",", "val", ")", ";", "/", "/", "append", "key", "/", "value", "to", "data", "size", "+", "+", ";", "}" ]
[ "get", "backing", "byte", "array", "analogous", "to", "{", "@", "link", "byte", "buffer", "#", "array", "(", ")", "}" ]
[ "byte", "[", "]", "array", "(", ")", ";" ]
[ "create", "a", "servlet", "application", "context", "to", "be", "provided", "to", "the", "{", "@", "code", "dispatcher", "servlet", "}", "the", "returned", "context", "is", "delegated", "to", "spring", "'", "s", "{", "@", "link", "dispatcher", "servlet", "#", "dispatcher", "servlet", "(", "web", "application", "context", ")", "}", "as", "such", ",", "it", "typically", "contains", "controllers", ",", "view", "resolvers", ",", "locale", "resolvers", ",", "and", "other", "web", "-", "related", "beans" ]
[ "protected", "abstract", "web", "application", "context", "create", "servlet", "application", "context", "(", ")", ";" ]
[ "converts", "the", "given", "{", "@", "link", "table", "}", "into", "a", "{", "@", "link", "data", "set", "}", "of", "a", "specified", "type", "the", "fields", "of", "the", "{", "@", "link", "table", "}", "are", "mapped", "to", "{", "@", "link", "data", "set", "}", "fields", "as", "follows", ":", "{", "@", "link", "org", "apache", "flink", "types", "row", "}", "and", "{", "@", "link", "org", "apache", "flink", "api", "java", "tuple", "tuple", "}", "types", ":", "fields", "are", "mapped", "by", "position", ",", "field", "types", "must", "match", "pojo", "{", "@", "link", "data", "set", "}", "types", ":", "fields", "are", "mapped", "by", "field", "name", ",", "field", "types", "must", "match" ]
[ "<", "t", ">", "data", "set", "<", "t", ">", "to", "data", "set", "(", "table", "table", ",", "class", "<", "t", ">", "clazz", ")", ";" ]
[ "modify", "the", "job", "conf", "to", "set", "the", "task", "output", "filter" ]
[ "public", "static", "void", "set", "task", "output", "filter", "(", "job", "conf", "job", ",", "task", "status", "filter", "new", "value", ")", "{", "job", "set", "(", "\"", "jobclient", "output", "filter", "\"", ",", "new", "value", "to", "string", "(", ")", ")", ";", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "void", "set", "g", "l", "3", "0", "(", "gl30", "gl", "3", "0", ")", "{", "this", "gl", "3", "0", "=", "gl", "3", "0", ";", "if", "(", "gl", "3", "0", "!", "=", "null", ")", "{", "this", "gl", "2", "0", "=", "gl", "3", "0", ";", "gdx", "gl", "=", "gl", "2", "0", ";", "gdx", "gl", "2", "0", "=", "gl", "2", "0", ";", "gdx", "gl", "3", "0", "=", "gl", "3", "0", ";", "}", "}" ]
[ "get", "the", "register", "at", "the", "location" ]
[ "private", "register", "get", "register", "(", "address", "addr", ",", "int", "op", "index", ",", "int", "sub", "op", "index", ")", "{", "if", "(", "addr", "=", "=", "null", ")", "{", "return", "null", ";", "}", "instruction", "instr", "=", "current", "program", "get", "listing", "(", ")", "get", "instruction", "containing", "(", "addr", ")", ";", "if", "(", "instr", "=", "=", "null", ")", "{", "return", "null", ";", "}", "list", "<", "object", ">", "def", "op", "rep", "=", "instr", "get", "default", "operand", "representation", "list", "(", "op", "index", ")", ";", "if", "(", "sub", "op", "index", ">", "=", "0", "&", "&", "sub", "op", "index", "<", "def", "op", "rep", "size", "(", ")", ")", "{", "object", "obj", "=", "def", "op", "rep", "get", "(", "sub", "op", "index", ")", ";", "if", "(", "obj", "instanceof", "register", ")", "{", "return", "(", "register", ")", "obj", ";", "}", "}", "return", "instr", "get", "register", "(", "op", "index", ")", ";", "}" ]
[ "test", "that", "a", "d", "f", "s", "client", "waits", "for", "random", "time", "before", "retry", "on", "busy", "blocks" ]
[ "public", "void", "test", "d", "f", "s", "client", "retries", "on", "busy", "blocks", "(", ")", "throws", "i", "o", "exception", "{", "system", "out", "println", "(", "\"", "testing", "d", "f", "s", "client", "random", "waiting", "on", "busy", "blocks", "\"", ")", ";", "/", "/", "/", "/", "test", "settings", ":", "/", "/", "/", "/", "xcievers", "file", "len", "#", "clients", "time", "window", "#", "retries", "/", "/", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "=", "/", "/", "test", "1", ":", "2", "6", "mb", "50", "300", "ms", "3", "/", "/", "test", "2", ":", "2", "6", "mb", "50", "300", "ms", "50", "/", "/", "test", "3", ":", "2", "6", "mb", "50", "1000", "ms", "3", "/", "/", "test", "4", ":", "2", "6", "mb", "50", "1000", "ms", "50", "/", "/", "/", "/", "minimum", "xcievers", "is", "2", "since", "1", "thread", "is", "reserved", "for", "registry", "/", "/", "test", "1", "&", "3", "may", "fail", "since", "#", "retries", "is", "low", "/", "/", "test", "2", "&", "4", "should", "never", "fail", "since", "(", "#", "threads", ")", "/", "(", "xcievers", "-", "1", ")", "is", "the", "upper", "/", "/", "bound", "for", "guarantee", "to", "not", "throw", "block", "missing", "exception", "/", "/", "int", "xcievers", "=", "2", ";", "int", "file", "len", "=", "6", "*", "1024", "*", "1024", ";", "int", "threads", "=", "50", ";", "int", "retries", "=", "3", ";", "int", "time", "win", "=", "300", ";", "/", "/", "/", "/", "test", "1", ":", "might", "fail", "/", "/", "long", "timestamp", "=", "time", "now", "(", ")", ";", "boolean", "pass", "=", "busy", "test", "(", "xcievers", ",", "threads", ",", "file", "len", ",", "time", "win", ",", "retries", ")", ";", "long", "timestamp", "2", "=", "time", "now", "(", ")", ";", "if", "(", "pass", ")", "{", "log", "info", "(", "\"", "test", "1", "succeeded", "!", "time", "spent", ":", "\"", "+", "(", "timestamp", "2", "-", "timestamp", ")", "/", "1000", "0", "+", "\"", "sec", "\"", ")", ";", "}", "else", "{", "log", "warn", "(", "\"", "test", "1", "failed", ",", "but", "relax", "time", "spent", ":", "\"", "+", "(", "timestamp", "2", "-", "timestamp", ")", "/", "1000", "0", "+", "\"", "sec", "\"", ")", ";", "}", "/", "/", "/", "/", "test", "2", ":", "should", "never", "fail", "/", "/", "retries", "=", "50", ";", "timestamp", "=", "time", "now", "(", ")", ";", "pass", "=", "busy", "test", "(", "xcievers", ",", "threads", ",", "file", "len", ",", "time", "win", ",", "retries", ")", ";", "timestamp", "2", "=", "time", "now", "(", ")", ";", "assert", "true", "(", "\"", "something", "wrong", "!", "test", "2", "got", "exception", "with", "maxmum", "retries", "!", "\"", ",", "pass", ")", ";", "log", "info", "(", "\"", "test", "2", "succeeded", "!", "time", "spent", ":", "\"", "+", "(", "timestamp", "2", "-", "timestamp", ")", "/", "1000", "0", "+", "\"", "sec", "\"", ")", ";", "/", "/", "/", "/", "test", "3", ":", "might", "fail", "/", "/", "retries", "=", "3", ";", "time", "win", "=", "1000", ";", "timestamp", "=", "time", "now", "(", ")", ";", "pass", "=", "busy", "test", "(", "xcievers", ",", "threads", ",", "file", "len", ",", "time", "win", ",", "retries", ")", ";", "timestamp", "2", "=", "time", "now", "(", ")", ";", "if", "(", "pass", ")", "{", "log", "info", "(", "\"", "test", "3", "succeeded", "!", "time", "spent", ":", "\"", "+", "(", "timestamp", "2", "-", "timestamp", ")", "/", "1000", "0", "+", "\"", "sec", "\"", ")", ";", "}", "else", "{", "log", "warn", "(", "\"", "test", "3", "failed", ",", "but", "relax", "time", "spent", ":", "\"", "+", "(", "timestamp", "2", "-", "timestamp", ")", "/", "1000", "0", "+", "\"", "sec", "\"", ")", ";", "}", "/", "/", "/", "/", "test", "4", ":", "should", "never", "fail", "/", "/", "retries", "=", "50", ";", "time", "win", "=", "1000", ";", "timestamp", "=", "time", "now", "(", ")", ";", "pass", "=", "busy", "test", "(", "xcievers", ",", "threads", ",", "file", "len", ",", "time", "win", ",", "retries", ")", ";", "timestamp", "2", "=", "time", "now", "(", ")", ";", "assert", "true", "(", "\"", "something", "wrong", "!", "test", "4", "got", "exception", "with", "maxmum", "retries", "!", "\"", ",", "pass", ")", ";", "log", "info", "(", "\"", "test", "4", "succeeded", "!", "time", "spent", ":", "\"", "+", "(", "timestamp", "2", "-", "timestamp", ")", "/", "1000", "0", "+", "\"", "sec", "\"", ")", ";", "}" ]
[ "shortcut", "to", "{", "@", "link", "key", "pair", "#", "get", "private", "(", ")", "}" ]
[ "protected", "priv", "get", "private", "key", "(", ")", "{", "key", "pair", "key", "pair", "=", "get", "key", "pair", "(", ")", ";", "return", "key", "pair", "=", "=", "null", "?", "null", ":", "(", "priv", ")", "key", "pair", "get", "private", "(", ")", ";", "}" ]
[ "confirm", "that", "running", "on", "a", "new", "thread", "scheduler", "uses", "the", "same", "thread", "for", "the", "entire", "stream" ]
[ "public", "void", "observe", "on", "with", "new", "thread", "scheduler", "(", ")", "{", "final", "atomic", "integer", "count", "=", "new", "atomic", "integer", "(", ")", ";", "final", "int", "multiple", "=", "99", ";", "flowable", "range", "(", "1", ",", "100000", ")", "map", "(", "new", "function", "<", "integer", ",", "integer", ">", "(", ")", "{", "@", "override", "public", "integer", "apply", "(", "integer", "t", "1", ")", "{", "return", "t", "1", "*", "multiple", ";", "}", "}", ")", "observe", "on", "(", "schedulers", "new", "thread", "(", ")", ")", "blocking", "for", "each", "(", "new", "consumer", "<", "integer", ">", "(", ")", "{", "@", "override", "public", "void", "accept", "(", "integer", "t", "1", ")", "{", "assert", "equals", "(", "count", "increment", "and", "get", "(", ")", "*", "multiple", ",", "t", "1", "int", "value", "(", ")", ")", ";", "/", "/", "fixme", "to", "blocking", "methods", "run", "on", "the", "current", "thread", "string", "name", "=", "thread", "current", "thread", "(", ")", "get", "name", "(", ")", ";", "assert", "false", "(", "\"", "wrong", "thread", "name", ":", "\"", "+", "name", ",", "name", "starts", "with", "(", "\"", "rx", "\"", ")", ")", ";", "}", "}", ")", ";", "}" ]
[ "start", "plugin", "boot", "service" ]
[ "void", "start", "(", "plugin", "configuration", "plugin", "config", ")", ";" ]
[ "removes", "all", "assigned", "values", "of", "this", "attribute" ]
[ "public", "void", "clear", "(", ")", "{", "values", "remove", "all", "(", ")", ";", "}" ]
[ "this", "is", "how", "the", "i", "ds", "were", "formed", "in", "v", "5", "4" ]
[ "public", "static", "final", "string", "v", "5", "4", "document", "id", "(", "string", "job", "id", ",", "int", "doc", "num", ")", "{", "return", "v", "5", "4", "document", "prefix", "(", "job", "id", ")", "+", "doc", "num", ";", "}" ]
[ "the", "preferred", "file", "name", "to", "use", "when", "loading", "the", "default", "behavior", "of", "this", "method", "is", "to", "return", "the", "(", "cleaned", "up", ")", "name", "of", "the", "given", "{", "@", "link", "byte", "provider", "}", "note", ":", "this", "method", "may", "get", "called", "frequently", ",", "so", "only", "parse", "the", "given", "{", "@", "link", "byte", "provider", "}", "if", "absolutely", "necessary" ]
[ "public", "default", "string", "get", "preferred", "file", "name", "(", "byte", "provider", "provider", ")", "{", "return", "provider", "get", "name", "(", ")", "replace", "all", "(", "\"", "[", "\\", "\\", "\\", "\\", ":", "|", "]", "+", "\"", ",", "\"", "/", "\"", ")", ";", "}" ]
[ "return", "whether", "the", "script", "requires", "a", "config", "interface", "to", "be", "generated", "for", "it", "this", "is", "typically", "the", "case", "for", "scripts", "that", "do", "not", "determine", "java", "signatures", "themselves", ",", "with", "no", "appropriate", "config", "interface", "specified", "in", "{", "@", "code", "get", "script", "interfaces", "(", ")", "}" ]
[ "boolean", "requires", "config", "interface", "(", ")", ";" ]
[ "returns", "the", "immutable", "list", "of", "include", "directories", "to", "be", "added", "with", "\"", "-", "iquote", "\"", "(", "possibly", "empty", "but", "never", "null", ")", "this", "includes", "the", "include", "dirs", "from", "the", "transitive", "deps", "closure", "of", "the", "target", "this", "list", "does", "not", "contain", "duplicates", "all", "fragments", "are", "either", "absolute", "or", "relative", "to", "the", "exec", "root", "(", "see", "{", "@", "link", "com", "google", "devtools", "build", "lib", "analysis", "blaze", "directories", "#", "get", "exec", "root", "(", "string", ")", "}", ")" ]
[ "public", "immutable", "list", "<", "path", "fragment", ">", "get", "quote", "include", "dirs", "(", ")", "{", "return", "command", "line", "cc", "compilation", "context", "quote", "include", "dirs", ";", "}" ]
[ "set", "the", "num", "files", "-", "1", "by", "default" ]
[ "public", "old", "csv", "num", "files", "(", "int", "num", "files", ")", "{", "this", "num", "files", "=", "optional", "of", "(", "num", "files", ")", ";", "return", "this", ";", "}" ]
[ "returns", "a", "new", "{", "@", "link", "com", "bumptech", "glide", "load", "data", "data", "rewinder", "}", "wrapping", "the", "given", "data" ]
[ "data", "rewinder", "<", "t", ">", "build", "(", "@", "non", "null", "t", "data", ")", ";" ]
[ "{", "@", "inherit", "doc", "}", "the", "default", "implementation", "returns", "the", "result", "of", "calling", "{", "@", "link", "#", "visit", "children", "}", "on", "{", "@", "code", "ctx", "}" ]
[ "@", "override", "public", "t", "visit", "show", "schemas", "(", "sql", "base", "parser", "show", "schemas", "context", "ctx", ")", "{", "return", "visit", "children", "(", "ctx", ")", ";", "}" ]
[ "get", "class", "name" ]
[ "public", "string", "get", "class", "name", "(", ")", "{", "return", "class", "name", ";", "}" ]
[ "returns", "a", "{", "@", "link", "writeable", "reader", "}", "that", "can", "be", "used", "to", "de", "-", "serialize", "the", "instance" ]
[ "protected", "abstract", "writeable", "reader", "<", "t", ">", "instance", "reader", "(", ")", ";" ]
[ "get", "namespace", "number" ]
[ "public", "big", "decimal", "get", "namespace", "number", "(", ")", "{", "return", "namespace", "number", ";", "}" ]
[ "test", "the", "property", "'", "tags", "'" ]
[ "public", "void", "tags", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "tags", "}" ]
[ "get", "the", "int", "value", "associated", "with", "an", "index" ]
[ "public", "int", "get", "int", "(", "int", "index", ")", "throws", "j", "s", "o", "n", "exception", "{", "object", "o", "=", "get", "(", "index", ")", ";", "return", "o", "instanceof", "number", "?", "(", "(", "number", ")", "o", ")", "int", "value", "(", ")", ":", "(", "int", ")", "get", "double", "(", "index", ")", ";", "}" ]
[ "return", "time", "duration", "in", "the", "given", "time", "unit", "valid", "units", "are", "encoded", "in", "properties", "as", "suffixes", ":", "nanoseconds", "(", "ns", ")", ",", "microseconds", "(", "us", ")", ",", "milliseconds", "(", "ms", ")", ",", "seconds", "(", "s", ")", ",", "minutes", "(", "m", ")", ",", "hours", "(", "h", ")", ",", "and", "days", "(", "d", ")", "if", "no", "unit", "is", "provided", ",", "the", "default", "unit", "is", "applied" ]
[ "public", "long", "get", "time", "duration", "(", "string", "name", ",", "long", "default", "value", ",", "time", "unit", "default", "unit", ",", "time", "unit", "return", "unit", ")", "{", "string", "v", "str", "=", "get", "(", "name", ")", ";", "if", "(", "null", "=", "=", "v", "str", ")", "{", "return", "return", "unit", "convert", "(", "default", "value", ",", "default", "unit", ")", ";", "}", "else", "{", "return", "get", "time", "duration", "helper", "(", "name", ",", "v", "str", ",", "default", "unit", ",", "return", "unit", ")", ";", "}", "}" ]
[ "gets", "the", "matching", "address", "from", "the", "other", "listing", "for", "the", "specified", "address", "from", "one", "of", "the", "two", "listings", "whose", "differences", "this", "class", "determines" ]
[ "public", "address", "get", "matching", "address", "(", "address", "address", ",", "boolean", "is", "listing", "1", ")", "{", "if", "(", "correlation", "=", "=", "null", ")", "{", "return", "null", ";", "}", "if", "(", "is", "listing", "1", ")", "{", "return", "correlation", "get", "address", "in", "second", "(", "address", ")", ";", "}", "return", "correlation", "get", "address", "in", "first", "(", "address", ")", ";", "}" ]
[ "gets", "one", "or", "more", "machine", "learning", "job", "configuration", "info", "for", "additional", "info", "see", "<", "a", "href", "=", "\"", "https", ":", "www", "elastic", "coguideenelasticsearchreferencecurrentml", "-", "get", "-", "job", "html", "\"", ">", "ml", "get", "job", "documentation" ]
[ "public", "get", "job", "response", "get", "job", "(", "get", "job", "request", "request", ",", "request", "options", "options", ")", "throws", "i", "o", "exception", "{", "return", "rest", "high", "level", "client", "perform", "request", "and", "parse", "entity", "(", "request", ",", "m", "l", "request", "converters", ":", ":", "get", "job", ",", "options", ",", "get", "job", "response", ":", ":", "from", "x", "content", ",", "collections", "empty", "set", "(", ")", ")", ";", "}" ]
[ "create", "user", "this", "can", "only", "be", "done", "by", "the", "logged", "in", "user" ]
[ "public", "void", "create", "user", "test", "(", "test", "context", "test", "context", ")", "{", "async", "async", "=", "test", "context", "async", "(", ")", ";", "user", "body", "=", "null", ";", "api", "create", "user", "(", "body", ",", "result", "-", ">", "{", "/", "/", "todo", ":", "test", "validations", "async", "complete", "(", ")", ";", "}", ")", ";", "}" ]
[ "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", "\"", ")", ";", "}" ]
[ "exit", "a", "parse", "tree", "produced", "by", "{", "@", "link", "eql", "base", "parser", "#", "pipe", "}" ]
[ "void", "exit", "pipe", "(", "eql", "base", "parser", "pipe", "context", "ctx", ")", ";" ]
[ "{", "@", "code", "true", "}", "if", "the", "{", "@", "linkplain", "writeable", "}", "is", "being", "stored", "in", "serialized", "form", ",", "{", "@", "code", "false", "}", "otherwise" ]
[ "abstract", "boolean", "is", "serialized", "(", ")", ";" ]
[ "test", "the", "property", "'", "map", "of", "enum", "string", "'" ]
[ "public", "void", "map", "of", "enum", "string", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "map", "of", "enum", "string", "}" ]
[ "sets", "whether", "or", "not", "to", "create", "bookmarks", "for", "problems", "encountered", "while", "trying", "to", "create", "an", "new", "structure", "or", "information", "associated", "with", "it" ]
[ "public", "void", "set", "create", "bookmarks", "(", "boolean", "create", "bookmarks", ")", "{", "this", "create", "bookmarks", "=", "create", "bookmarks", ";", "}" ]
[ "apply", "transformation", "on", "a", "given", "class", "byte", "definition", "the", "method", "will", "always", "return", "a", "non", "-", "null", "byte", "array", "(", "if", "no", "transformation", "has", "taken", "place", "the", "array", "content", "will", "be", "identical", "to", "the", "original", "one", ")" ]
[ "public", "byte", "[", "]", "transform", "if", "necessary", "(", "string", "class", "name", ",", "string", "internal", "name", ",", "byte", "[", "]", "bytes", ",", "@", "nullable", "protection", "domain", "pd", ")", "{", "byte", "[", "]", "result", "=", "bytes", ";", "for", "(", "class", "file", "transformer", "cft", ":", "this", "transformers", ")", "{", "try", "{", "byte", "[", "]", "transformed", "=", "cft", "transform", "(", "this", "class", "loader", ",", "internal", "name", ",", "null", ",", "pd", ",", "result", ")", ";", "if", "(", "transformed", "!", "=", "null", ")", "{", "result", "=", "transformed", ";", "}", "}", "catch", "(", "illegal", "class", "format", "exception", "ex", ")", "{", "throw", "new", "illegal", "state", "exception", "(", "\"", "class", "file", "transformation", "failed", "\"", ",", "ex", ")", ";", "}", "}", "return", "result", ";", "}" ]
[ "converts", "a", "short", "to", "a", "long" ]
[ "public", "static", "long", "short", "to", "long", "(", "short", "s", ")", "{", "return", "int", "to", "long", "(", "s", "&", "short", "mask", ")", ";", "}" ]
[ "{", "@", "inherit", "doc", "}", "this", "method", "returns", "a", "{", "@", "link", "sorted", "map", "}", ",", "instead", "of", "the", "{", "@", "code", "map", "}", "specified", "in", "the", "{", "@", "link", "table", "}", "interface" ]
[ "sorted", "map", "<", "r", ",", "map", "<", "c", ",", "v", ">", ">", "row", "map", "(", ")", ";" ]
[ "gets", "instance", "of", "the", "resolver", "as", "a", "singleton" ]
[ "public", "static", "spring", "expression", "language", "value", "resolver", "get", "instance", "(", ")", "{", "if", "(", "instance", "=", "=", "null", ")", "{", "instance", "=", "new", "spring", "expression", "language", "value", "resolver", "(", ")", ";", "}", "return", "instance", ";", "}" ]
[ "returns", "a", "stream", "of", "all", "concrete", "setting", "instances", "for", "the", "given", "settings", "affix", "setting", "is", "only", "a", "specification", ",", "concrete", "settings", "depend", "on", "an", "actual", "set", "of", "setting", "keys" ]
[ "public", "stream", "<", "setting", "<", "t", ">", ">", "get", "all", "concrete", "settings", "(", "settings", "settings", ")", "{", "return", "match", "stream", "(", "settings", ")", "distinct", "(", ")", "map", "(", "this", ":", ":", "get", "concrete", "setting", ")", ";", "}" ]
[ "get", "name", "array" ]
[ "public", "list", "<", "integer", ">", "get", "name", "array", "(", ")", "{", "return", "name", "array", ";", "}" ]
[ "create", "and", "initialize", "a", "new", "filesystem", "this", "filesystem", "must", "be", "closed", "in", "test", "teardown" ]
[ "private", "s", "3", "a", "file", "system", "create", "f", "s", "(", "final", "uri", "uri", ",", "final", "configuration", "config", ")", "throws", "i", "o", "exception", "{", "s", "3", "a", "file", "system", "fs", "2", "=", "new", "s", "3", "a", "file", "system", "(", ")", ";", "fs", "2", "initialize", "(", "uri", ",", "config", ")", ";", "return", "fs", "2", ";", "}" ]
[ "request", "only", "a", "single", "value", "and", "don", "'", "t", "wait", "for", "another", "request", "just", "to", "emit", "an", "on", "complete" ]
[ "public", "void", "zip", "request", "1", "(", ")", "{", "flowable", "<", "integer", ">", "src", "=", "flowable", "just", "(", "1", ")", "subscribe", "on", "(", "schedulers", "computation", "(", ")", ")", ";", "test", "subscriber", "<", "integer", ">", "ts", "=", "new", "test", "subscriber", "<", ">", "(", "1l", ")", ";", "flowable", "zip", "(", "src", ",", "src", ",", "new", "bi", "function", "<", "integer", ",", "integer", ",", "integer", ">", "(", ")", "{", "@", "override", "public", "integer", "apply", "(", "integer", "t", "1", ",", "integer", "t", "2", ")", "{", "return", "t", "1", "+", "t", "2", "*", "10", ";", "}", "}", ")", "subscribe", "(", "ts", ")", ";", "ts", "await", "done", "(", "1", ",", "time", "unit", "seconds", ")", ";", "ts", "assert", "no", "errors", "(", ")", ";", "ts", "assert", "value", "(", "11", ")", ";", "}", "@", "suppress", "warnings", "(", "{", "\"", "unchecked", "\"", ",", "\"", "rawtypes", "\"", "}" ]
[ "releases", "the", "period" ]
[ "public", "void", "release", "period", "(", "media", "period", "media", "period", ")", "{", "media", "source", "holder", "holder", "=", "assertions", "check", "not", "null", "(", "media", "source", "by", "media", "period", "remove", "(", "media", "period", ")", ")", ";", "holder", "media", "source", "release", "period", "(", "media", "period", ")", ";", "holder", "active", "media", "period", "ids", "remove", "(", "(", "(", "masking", "media", "period", ")", "media", "period", ")", "id", ")", ";", "if", "(", "!", "media", "source", "by", "media", "period", "is", "empty", "(", ")", ")", "{", "disable", "unused", "media", "sources", "(", ")", ";", "}", "maybe", "release", "child", "source", "(", "holder", ")", ";", "}" ]
[ "issues", "requests", "containing", "data", "smaller", ",", "equal", ",", "and", "greater", "than", "test", "maxbuffer" ]
[ "private", "void", "test", "requests", "(", "client", "op", "client", "op", ")", "throws", "exception", "{", "client", "op", "execute", "(", "new", "byte", "[", "test", "maxbuffer", "-", "60", "]", ")", ";", "try", "{", "/", "/", "this", "should", "fail", "since", "the", "buffer", "size", ">", "the", "data", "size", "due", "to", "extra", "fields", "client", "op", "execute", "(", "new", "byte", "[", "test", "maxbuffer", "]", ")", ";", "fail", "(", "\"", "request", "exceeding", "jute", "maxbuffer", "succeeded", "!", "\"", ")", ";", "}", "catch", "(", "keeper", "exception", "connection", "loss", "exception", "e", ")", "{", "}", "try", "{", "client", "op", "execute", "(", "new", "byte", "[", "test", "maxbuffer", "+", "10", "]", ")", ";", "fail", "(", "\"", "request", "exceeding", "jute", "maxbuffer", "succeeded", "!", "\"", ")", ";", "}", "catch", "(", "keeper", "exception", "connection", "loss", "exception", "e", ")", "{", "}", "}" ]
[ "returns", "false", "if", "exhausted", "or", "if", "reset", "(", "k", ")", "has", "not", "been", "called" ]
[ "protected", "boolean", "has", "next", "(", ")", "{", "return", "!", "(", "pos", "<", "0", ")", ";", "}" ]
[ "this", "delegate", "creates", "a", "{", "@", "code", "java", "net", "url", "}", ",", "applying", "the", "given", "path", "relative", "to", "the", "path", "of", "the", "underlying", "url", "of", "this", "resource", "descriptor", "a", "leading", "slash", "will", "get", "dropped", ";", "a", "\"", "#", "\"", "symbol", "will", "get", "encoded" ]
[ "protected", "url", "create", "relative", "u", "r", "l", "(", "string", "relative", "path", ")", "throws", "malformed", "u", "r", "l", "exception", "{", "if", "(", "relative", "path", "starts", "with", "(", "\"", "/", "\"", ")", ")", "{", "relative", "path", "=", "relative", "path", "substring", "(", "1", ")", ";", "}", "/", "/", "#", "can", "appear", "in", "filenames", ",", "java", "net", "url", "should", "not", "treat", "it", "as", "a", "fragment", "relative", "path", "=", "string", "utils", "replace", "(", "relative", "path", ",", "\"", "#", "\"", ",", "\"", "%", "23", "\"", ")", ";", "/", "/", "use", "the", "url", "constructor", "for", "applying", "the", "relative", "path", "as", "a", "url", "spec", "return", "new", "url", "(", "this", "url", ",", "relative", "path", ")", ";", "}" ]
[ "assert", "that", "there", "are", "no", "threads", "running", "whose", "name", "matches", "the", "given", "regular", "expression" ]
[ "public", "static", "void", "assert", "no", "threads", "matching", "(", "string", "regex", ")", "{", "pattern", "pattern", "=", "pattern", "compile", "(", "regex", ")", ";", "if", "(", "any", "thread", "matching", "(", "pattern", ")", ")", "{", "assert", "fail", "(", "\"", "leaked", "thread", "matches", "\"", "+", "regex", ")", ";", "}", "}" ]
[ "test", "the", "property", "'", "prefix", "string", "'" ]
[ "public", "void", "prefix", "string", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "prefix", "string", "}" ]
[ "retrieve", "the", "last", "element", "of", "the", "given", "list", ",", "accessing", "the", "highest", "index" ]
[ "public", "static", "<", "t", ">", "t", "last", "element", "(", "@", "nullable", "list", "<", "t", ">", "list", ")", "{", "if", "(", "is", "empty", "(", "list", ")", ")", "{", "return", "null", ";", "}", "return", "list", "get", "(", "list", "size", "(", ")", "-", "1", ")", ";", "}" ]
[ "returns", "a", "new", "stub", "that", "uses", "the", "given", "call", "credentials" ]
[ "public", "final", "s", "with", "call", "credentials", "(", "call", "credentials", "credentials", ")", "{", "return", "build", "(", "channel", ",", "call", "options", "with", "call", "credentials", "(", "credentials", ")", ")", ";", "}" ]