Datasets:
Anonymous2023
/
KGSum

Dataset card Data Studio Files Community
docstring_tokens
list
code_tokens
list
[ "request", "session", "credentials" ]
[ "public", "static", "marshalled", "credentials", "request", "session", "credentials", "(", "final", "configuration", "conf", ",", "final", "string", "bucket", ",", "final", "int", "duration", ")", "throws", "i", "o", "exception", "{", "assume", "session", "tests", "enabled", "(", "conf", ")", ";", "marshalled", "credentials", "sc", "=", "marshalled", "credential", "binding", "request", "session", "credentials", "(", "build", "aws", "credentials", "provider", "(", "conf", ")", ",", "s", "3", "a", "utils", "create", "aws", "conf", "(", "conf", ",", "bucket", ",", "aws", "service", "identifier", "sts", ")", ",", "conf", "get", "trimmed", "(", "assumed", "role", "sts", "endpoint", ",", "default", "assumed", "role", "sts", "endpoint", ")", ",", "conf", "get", "trimmed", "(", "assumed", "role", "sts", "endpoint", "region", ",", "assumed", "role", "sts", "endpoint", "region", "default", ")", ",", "duration", ",", "new", "invoker", "(", "new", "s", "3", "a", "retry", "policy", "(", "conf", ")", ",", "invoker", "log", "event", ")", ")", ";", "sc", "validate", "(", "\"", "requested", "session", "credentials", ":", "\"", ",", "marshalled", "credentials", "credential", "type", "required", "session", "only", ")", ";", "return", "sc", ";", "}" ]
[ "set", "the", "additional", "(", "undeclared", ")", "property", "with", "the", "specified", "name", "and", "value", "if", "the", "property", "does", "not", "already", "exist", ",", "create", "it", "otherwise", "replace", "it" ]
[ "public", "child", "schema", "put", "additional", "property", "(", "string", "key", ",", "object", "value", ")", "{", "if", "(", "this", "additional", "properties", "=", "=", "null", ")", "{", "this", "additional", "properties", "=", "new", "hash", "map", "<", "string", ",", "object", ">", "(", ")", ";", "}", "this", "additional", "properties", "put", "(", "key", ",", "value", ")", ";", "return", "this", ";", "}" ]
[ "sets", "max", "length", "of", "id", "generation" ]
[ "public", "void", "set", "max", "length", "(", "final", "int", "max", "length", ")", "{", "this", "random", "string", "generator", "=", "new", "base", "6", "4", "random", "string", "generator", "(", "max", "length", ")", ";", "this", "numeric", "generator", "=", "new", "default", "long", "numeric", "generator", "(", "1", ")", ";", "}" ]
[ "returns", "true", "if", "keeping", "the", "position", "on", "rotation", "is", "enabled", "and", "false", "if", "not" ]
[ "public", "boolean", "is", "keep", "position", "on", "rotation", "(", ")", "{", "return", "m", "keep", "position", "on", "rotation", ";", "}" ]
[ "return", "the", "hex", "string", "of", "hmac", "m", "d", "5", "encryption" ]
[ "public", "static", "string", "encrypt", "hmac", "m", "d", "5", "to", "string", "(", "final", "byte", "[", "]", "data", ",", "final", "byte", "[", "]", "key", ")", "{", "return", "utils", "bridge", "bytes", "2", "hex", "string", "(", "encrypt", "hmac", "m", "d", "5", "(", "data", ",", "key", ")", ")", ";", "}" ]
[ "creates", "a", "new", "{", "@", "link", "direct", "candidate", "generator", "builder", "}" ]
[ "private", "direct", "candidate", "generator", "builder", "candidate", "generator", "(", "string", "field", ")", "{", "return", "new", "direct", "candidate", "generator", "builder", "(", "field", ")", ";", "}" ]
[ "test", "{", "@", "code", "text", "bytes", "to", "code", "point", "(", "bytes", ")", "}", "with", "{", "@", "code", "buffer", "underflow", "exception", "}" ]
[ "public", "void", "test", "bytes", "to", "code", "point", "(", ")", "{", "try", "{", "byte", "buffer", "bytes", "=", "byte", "buffer", "wrap", "(", "new", "byte", "[", "]", "{", "-", "2", ",", "45", ",", "23", ",", "12", ",", "76", ",", "89", "}", ")", ";", "text", "bytes", "to", "code", "point", "(", "bytes", ")", ";", "assert", "true", "(", "\"", "test", "bytes", "to", "code", "point", "error", "!", "!", "!", "\"", ",", "bytes", "position", "(", ")", "=", "=", "6", ")", ";", "}", "catch", "(", "buffer", "underflow", "exception", "ex", ")", "{", "fail", "(", "\"", "test", "bytes", "to", "code", "point", "unexp", "exception", "\"", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "fail", "(", "\"", "test", "bytes", "to", "code", "point", "unexp", "exception", "\"", ")", ";", "}", "}" ]
[ "enhance", "a", "{", "@", "link", "bean", "@", "bean", "}", "method", "to", "check", "the", "supplied", "bean", "factory", "for", "the", "existence", "of", "this", "bean", "object" ]
[ "public", "object", "intercept", "(", "object", "enhanced", "config", "instance", ",", "method", "bean", "method", ",", "object", "[", "]", "bean", "method", "args", ",", "method", "proxy", "cglib", "method", "proxy", ")", "throws", "throwable", "{", "configurable", "bean", "factory", "bean", "factory", "=", "get", "bean", "factory", "(", "enhanced", "config", "instance", ")", ";", "string", "bean", "name", "=", "bean", "annotation", "helper", "determine", "bean", "name", "for", "(", "bean", "method", ")", ";", "/", "/", "determine", "whether", "this", "bean", "is", "a", "scoped", "-", "proxy", "if", "(", "bean", "annotation", "helper", "is", "scoped", "proxy", "(", "bean", "method", ")", ")", "{", "string", "scoped", "bean", "name", "=", "scoped", "proxy", "creator", "get", "target", "bean", "name", "(", "bean", "name", ")", ";", "if", "(", "bean", "factory", "is", "currently", "in", "creation", "(", "scoped", "bean", "name", ")", ")", "{", "bean", "name", "=", "scoped", "bean", "name", ";", "}", "}", "/", "/", "to", "handle", "the", "case", "of", "an", "inter", "-", "bean", "method", "reference", ",", "we", "must", "explicitly", "check", "the", "/", "/", "container", "for", "already", "cached", "instances", "/", "/", "first", ",", "check", "to", "see", "if", "the", "requested", "bean", "is", "a", "factory", "bean", "if", "so", ",", "create", "a", "subclass", "/", "/", "proxy", "that", "intercepts", "calls", "to", "get", "object", "(", ")", "and", "returns", "any", "cached", "bean", "instance", "/", "/", "this", "ensures", "that", "the", "semantics", "of", "calling", "a", "factory", "bean", "from", "within", "@", "bean", "methods", "/", "/", "is", "the", "same", "as", "that", "of", "referring", "to", "a", "factory", "bean", "within", "xml", "see", "spr", "-", "6602", "if", "(", "factory", "contains", "bean", "(", "bean", "factory", ",", "bean", "factory", "factory", "bean", "prefix", "+", "bean", "name", ")", "&", "&", "factory", "contains", "bean", "(", "bean", "factory", ",", "bean", "name", ")", ")", "{", "object", "factory", "bean", "=", "bean", "factory", "get", "bean", "(", "bean", "factory", "factory", "bean", "prefix", "+", "bean", "name", ")", ";", "if", "(", "factory", "bean", "instanceof", "scoped", "proxy", "factory", "bean", ")", "{", "/", "/", "scoped", "proxy", "factory", "beans", "are", "a", "special", "case", "and", "should", "not", "be", "further", "proxied", "}", "else", "{", "/", "/", "it", "is", "a", "candidate", "factory", "bean", "-", "go", "ahead", "with", "enhancement", "return", "enhance", "factory", "bean", "(", "factory", "bean", ",", "bean", "method", "get", "return", "type", "(", ")", ",", "bean", "factory", ",", "bean", "name", ")", ";", "}", "}", "if", "(", "is", "currently", "invoked", "factory", "method", "(", "bean", "method", ")", ")", "{", "/", "/", "the", "factory", "is", "calling", "the", "bean", "method", "in", "order", "to", "instantiate", "and", "register", "the", "bean", "/", "/", "(", "i", "e", "via", "a", "get", "bean", "(", ")", "call", ")", "-", ">", "invoke", "the", "super", "implementation", "of", "the", "method", "to", "actually", "/", "/", "create", "the", "bean", "instance", "if", "(", "logger", "is", "info", "enabled", "(", ")", "&", "&", "bean", "factory", "post", "processor", "class", "is", "assignable", "from", "(", "bean", "method", "get", "return", "type", "(", ")", ")", ")", "{", "logger", "info", "(", "string", "format", "(", "\"", "@", "bean", "method", "%", "s", "%", "s", "is", "non", "-", "static", "and", "returns", "an", "object", "\"", "+", "\"", "assignable", "to", "spring", "'", "s", "bean", "factory", "post", "processor", "interface", "this", "will", "\"", "+", "\"", "result", "in", "a", "failure", "to", "process", "annotations", "such", "as", "@", "autowired", ",", "\"", "+", "\"", "@", "resource", "and", "@", "post", "construct", "within", "the", "method", "'", "s", "declaring", "\"", "+", "\"", "@", "configuration", "class", "add", "the", "'", "static", "'", "modifier", "to", "this", "method", "to", "avoid", "\"", "+", "\"", "these", "container", "lifecycle", "issues", ";", "see", "@", "bean", "javadoc", "for", "complete", "details", "\"", ",", "bean", "method", "get", "declaring", "class", "(", ")", "get", "simple", "name", "(", ")", ",", "bean", "method", "get", "name", "(", ")", ")", ")", ";", "}", "return", "cglib", "method", "proxy", "invoke", "super", "(", "enhanced", "config", "instance", ",", "bean", "method", "args", ")", ";", "}", "return", "resolve", "bean", "reference", "(", "bean", "method", ",", "bean", "method", "args", ",", "bean", "factory", ",", "bean", "name", ")", ";", "}" ]
[ "shortcut", "to", "the", "unique", "return", "type", "equivalent", "to", ":", "{", "@", "code", "returning", "(", "return", "type", ")", "build", "(", ")", "return", "type", "(", ")", "}" ]
[ "public", "method", "parameter", "resolve", "return", "type", "(", "class", "<", "?", ">", "return", "type", ",", "class", "<", "?", ">", "generics", ")", "{", "return", "returning", "(", "return", "type", ",", "generics", ")", "build", "(", ")", "return", "type", "(", ")", ";", "}" ]
[ "setter", "factory", "method", "with", "required", "values", "all", "optional", "arguments", "can", "be", "set", "via", "the", "chained", "methods" ]
[ "public", "static", "setter", "with", "group", "key", "(", "hystrix", "command", "group", "key", "group", "key", ")", "{", "return", "new", "setter", "(", "group", "key", ")", ";", "}" ]
[ "does", "the", "given", "request", "qualify", "as", "\"", "not", "modified", "\"", "?" ]
[ "private", "boolean", "is", "request", "not", "modified", "(", "servlet", "web", "request", "web", "request", ")", "{", "return", "web", "request", "is", "not", "modified", "(", ")", ";", "}" ]
[ "recover", "the", "task", "output", "the", "retry", "-", "count", "for", "the", "job", "will", "be", "passed", "via", "the", "{", "@", "link", "m", "r", "constants", "#", "application", "attempt", "id", "}", "key", "in", "{", "@", "link", "task", "attempt", "context", "#", "get", "configuration", "(", ")", "}", "for", "the", "<", "code", ">", "output", "committer", "<", "code", ">", "this", "is", "called", "from", "the", "application", "master", "process", ",", "but", "it", "is", "called", "individually", "for", "each", "task", "if", "an", "exception", "is", "thrown", "the", "task", "will", "be", "attempted", "again" ]
[ "public", "void", "recover", "task", "(", "task", "attempt", "context", "task", "context", ")", "throws", "i", "o", "exception", "{", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "result", "set", "get", "generated", "keys", "(", ")", "throws", "s", "q", "l", "exception", "{", "check", "closed", "(", ")", ";", "return", "new", "stub", "result", "set", "(", ")", ";", "}" ]
[ "arranges", "the", "given", "node", "is", "the", "new", "head", "from", "now", "on" ]
[ "final", "void", "set", "first", "(", "node", "n", ")", "{", "if", "(", "eager", "truncate", ")", "{", "node", "m", "=", "new", "node", "(", "null", ",", "n", "index", ")", ";", "m", "lazy", "set", "(", "n", "get", "(", ")", ")", ";", "n", "=", "m", ";", "}", "set", "(", "n", ")", ";", "}" ]
[ "whether", "the", "\"", "remove", "only", "\"", "mode", "is", "on" ]
[ "public", "boolean", "is", "remove", "only", "(", ")", "{", "return", "this", "remove", "only", ";", "}" ]
[ "return", "whether", "to", "allow", "for", "a", "local", "jms", "transaction", "that", "is", "synchronized", "with", "a", "spring", "-", "managed", "transaction", "(", "where", "the", "main", "transaction", "might", "be", "a", "jdbc", "-", "based", "one", "for", "a", "specific", "data", "source", ",", "for", "example", ")", ",", "with", "the", "jms", "transaction", "committing", "right", "after", "the", "main", "transaction" ]
[ "boolean", "is", "synched", "local", "transaction", "allowed", "(", ")", ";" ]
[ "gets", "the", "current", "value", "at", "position", "{", "@", "code", "i", "}" ]
[ "public", "final", "double", "get", "(", "int", "i", ")", "{", "return", "long", "bits", "to", "double", "(", "longs", "get", "(", "i", ")", ")", ";", "}" ]
[ "test", "what", "happens", "when", "no", "refresh", "occurs" ]
[ "public", "void", "test", "with", "no", "refresh", "check", "(", ")", "throws", "exception", "{", "counting", "refreshable", "target", "source", "ts", "=", "new", "counting", "refreshable", "target", "source", "(", "true", ")", ";", "ts", "set", "refresh", "check", "delay", "(", "-", "1", ")", ";", "object", "a", "=", "ts", "get", "target", "(", ")", ";", "object", "b", "=", "ts", "get", "target", "(", ")", ";", "assert", "that", "(", "ts", "get", "call", "count", "(", ")", ")", "as", "(", "\"", "refresh", "target", "should", "only", "be", "called", "once", "\"", ")", "is", "equal", "to", "(", "1", ")", ";", "assert", "that", "(", "b", ")", "as", "(", "\"", "objects", "should", "be", "the", "same", "-", "refresh", "check", "delay", "not", "elapsed", "\"", ")", "is", "same", "as", "(", "a", ")", ";", "}" ]
[ "creates", "a", "new", "instance", "of", "the", "{", "@", "link", "web", "driver", "}", "implementation", "the", "instance", "must", "be", "killed", "by", "sending", "the", "\"", "quit", "\"", "command", "if", "the", "instance", "cannot", "be", "created", "because", "{", "@", "link", "#", "is", "available", "(", ")", "}", "is", "{", "@", "code", "false", "}", ",", "then", "{", "@", "link", "optional", "#", "empty", "(", ")", "}", "is", "returned", "otherwise", ",", "an", "attempt", "to", "start", "the", "session", "is", "made", "and", "the", "result", "returned" ]
[ "optional", "<", "web", "driver", ">", "create", "driver", "(", "capabilities", "capabilities", ")", "throws", "session", "not", "created", "exception", ";" ]
[ "returns", "true", "if", "a", "pe", "header", "exists" ]
[ "public", "boolean", "has", "pe", "header", "(", ")", "{", "if", "(", "e", "lfanew", ">", "=", "0", "&", "&", "e", "lfanew", "<", "=", "0x", "1", "0", "0", "0", "0", "0", "0", ")", "{", "try", "{", "n", "t", "header", "nt", "header", "=", "n", "t", "header", "create", "n", "t", "header", "(", "reader", ",", "e", "lfanew", ",", "section", "layout", "file", ",", "false", ",", "false", ")", ";", "if", "(", "nt", "header", "!", "=", "null", "&", "&", "nt", "header", "get", "optional", "header", "(", ")", "!", "=", "null", ")", "{", "return", "true", ";", "}", "}", "catch", "(", "invalid", "n", "t", "header", "exception", "|", "i", "o", "exception", "e", ")", "{", "/", "/", "fall", "through", "and", "return", "false", "}", "}", "return", "false", ";", "}" ]
[ "convert", "the", "username", "to", "that", "which", "can", "be", "used", "for", "registry", "entries", "lower", "cases", "it", ",", "strip", "the", "kerberos", "realm", "off", "a", "username", "if", "needed", ",", "and", "any", "\"", "\"", "hostname", "entries" ]
[ "public", "static", "string", "convert", "username", "(", "string", "username", ")", "{", "string", "converted", "=", "org", "apache", "hadoop", "util", "string", "utils", "to", "lower", "case", "(", "username", ")", ";", "int", "at", "symbol", "=", "converted", "index", "of", "(", "'", "@", "'", ")", ";", "if", "(", "at", "symbol", ">", "0", ")", "{", "converted", "=", "converted", "substring", "(", "0", ",", "at", "symbol", ")", ";", "}", "int", "slash", "symbol", "=", "converted", "index", "of", "(", "'", "/", "'", ")", ";", "if", "(", "slash", "symbol", ">", "0", ")", "{", "converted", "=", "converted", "substring", "(", "0", ",", "slash", "symbol", ")", ";", "}", "return", "converted", ";", "}" ]
[ "log", "writer", "methods", "are", "not", "supported" ]
[ "public", "print", "writer", "get", "log", "writer", "(", ")", "{", "throw", "new", "unsupported", "operation", "exception", "(", "\"", "get", "log", "writer", "\"", ")", ";", "}" ]
[ "return", "the", "scaled", "bitmap" ]
[ "public", "static", "bitmap", "scale", "(", "final", "bitmap", "src", ",", "final", "float", "scale", "width", ",", "final", "float", "scale", "height", ")", "{", "return", "scale", "(", "src", ",", "scale", "width", ",", "scale", "height", ",", "false", ")", ";", "}" ]
[ "returns", "statistics", "over", "a", "dataset", "containing", "the", "given", "values" ]
[ "public", "static", "stats", "of", "(", "iterable", "<", "?", "extends", "number", ">", "values", ")", "{", "stats", "accumulator", "accumulator", "=", "new", "stats", "accumulator", "(", ")", ";", "accumulator", "add", "all", "(", "values", ")", ";", "return", "accumulator", "snapshot", "(", ")", ";", "}" ]
[ "gets", "the", "task", "attempt", "status" ]
[ "public", "string", "get", "task", "status", "(", ")", "{", "return", "status", "to", "string", "(", ")", ";", "}" ]
[ "after", "each", "partition", "is", "parsed", ",", "we", "update", "the", "current", "metric", "totals", "with", "the", "total", "bytes", "and", "number", "of", "records", "parsed", "after", "all", "partitions", "have", "reported", ",", "we", "write", "the", "metric" ]
[ "public", "void", "record", "(", "topic", "partition", "partition", ",", "int", "bytes", ",", "int", "records", ")", "{", "this", "unrecorded", "partitions", "remove", "(", "partition", ")", ";", "this", "fetch", "metrics", "increment", "(", "bytes", ",", "records", ")", ";", "/", "/", "collect", "and", "aggregate", "per", "-", "topic", "metrics", "string", "topic", "=", "partition", "topic", "(", ")", ";", "fetch", "metrics", "topic", "fetch", "metric", "=", "this", "topic", "fetch", "metrics", "get", "(", "topic", ")", ";", "if", "(", "topic", "fetch", "metric", "=", "=", "null", ")", "{", "topic", "fetch", "metric", "=", "new", "fetch", "metrics", "(", ")", ";", "this", "topic", "fetch", "metrics", "put", "(", "topic", ",", "topic", "fetch", "metric", ")", ";", "}", "topic", "fetch", "metric", "increment", "(", "bytes", ",", "records", ")", ";", "if", "(", "this", "unrecorded", "partitions", "is", "empty", "(", ")", ")", "{", "/", "/", "once", "all", "expected", "partitions", "from", "the", "fetch", "have", "reported", "in", ",", "record", "the", "metrics", "this", "sensors", "bytes", "fetched", "record", "(", "this", "fetch", "metrics", "fetch", "bytes", ")", ";", "this", "sensors", "records", "fetched", "record", "(", "this", "fetch", "metrics", "fetch", "records", ")", ";", "/", "/", "also", "record", "per", "-", "topic", "metrics", "for", "(", "map", "entry", "<", "string", ",", "fetch", "metrics", ">", "entry", ":", "this", "topic", "fetch", "metrics", "entry", "set", "(", ")", ")", "{", "fetch", "metrics", "metric", "=", "entry", "get", "value", "(", ")", ";", "this", "sensors", "record", "topic", "fetch", "metrics", "(", "entry", "get", "key", "(", ")", ",", "metric", "fetch", "bytes", ",", "metric", "fetch", "records", ")", ";", "}", "}", "}" ]
[ "set", "this", "node", "'", "s", "level", "in", "the", "tree" ]
[ "public", "void", "set", "level", "(", "int", "level", ")", "{", "this", "level", "=", "level", ";", "}" ]
[ "returns", "all", "nodes", "in", "this", "graph", "adjacent", "to", "{", "@", "code", "node", "}", "which", "can", "be", "reached", "by", "traversing", "{", "@", "code", "node", "}", "'", "s", "outgoing", "edges", "in", "the", "direction", "(", "if", "any", ")", "of", "the", "edge", "in", "an", "undirected", "graph", ",", "this", "is", "equivalent", "to", "{", "@", "link", "#", "adjacent", "nodes", "(", "object", ")", "}", "this", "is", "not", "the", "same", "as", "\"", "all", "nodes", "reachable", "from", "{", "@", "code", "node", "}", "by", "following", "outgoing", "edges", "\"", "for", "that", "functionality", ",", "see", "{", "@", "link", "graphs", "#", "reachable", "nodes", "(", "graph", ",", "object", ")", "}" ]
[ "set", "<", "n", ">", "successors", "(", "n", "node", ")", ";" ]
[ "gets", "the", "net", "execution", "time", "of", "the", "job", ",", "i", "e", ",", "the", "execution", "time", "in", "the", "parallel", "system", ",", "without", "the", "pre", "-", "flight", "steps", "like", "the", "optimizer", "in", "a", "desired", "time", "unit" ]
[ "public", "long", "get", "net", "runtime", "(", "time", "unit", "desired", "unit", ")", "{", "return", "desired", "unit", "convert", "(", "get", "net", "runtime", "(", ")", ",", "time", "unit", "milliseconds", ")", ";", "}" ]
[ "refresh", "tokens", "are", "bound", "to", "be", "used", "only", "by", "the", "client", "that", "originally", "created", "them", "this", "check", "validates", "this", "condition", ",", "given", "the", "{", "@", "code", "authentication", "}", "of", "the", "client", "that", "attempted", "the", "refresh", "operation" ]
[ "private", "static", "optional", "<", "elasticsearch", "security", "exception", ">", "check", "client", "can", "refresh", "(", "refresh", "token", "status", "refresh", "token", ",", "authentication", "client", "authentication", ")", "{", "if", "(", "client", "authentication", "get", "user", "(", ")", "principal", "(", ")", "equals", "(", "refresh", "token", "get", "associated", "user", "(", ")", ")", "=", "=", "false", ")", "{", "logger", "warn", "(", "\"", "token", "was", "originally", "created", "by", "[", "{", "}", "]", "but", "[", "{", "}", "]", "attempted", "to", "refresh", "it", "\"", ",", "refresh", "token", "get", "associated", "user", "(", ")", ",", "client", "authentication", "get", "user", "(", ")", "principal", "(", ")", ")", ";", "return", "optional", "of", "(", "invalid", "grant", "exception", "(", "\"", "tokens", "must", "be", "refreshed", "by", "the", "creating", "client", "\"", ")", ")", ";", "}", "else", "if", "(", "client", "authentication", "get", "authenticated", "by", "(", ")", "get", "name", "(", ")", "equals", "(", "refresh", "token", "get", "associated", "realm", "(", ")", ")", "=", "=", "false", ")", "{", "logger", "warn", "(", "\"", "[", "{", "}", "]", "created", "the", "refresh", "token", "while", "authenticated", "by", "[", "{", "}", "]", "but", "is", "now", "authenticated", "by", "[", "{", "}", "]", "\"", ",", "refresh", "token", "get", "associated", "user", "(", ")", ",", "refresh", "token", "get", "associated", "realm", "(", ")", ",", "client", "authentication", "get", "authenticated", "by", "(", ")", "get", "name", "(", ")", ")", ";", "return", "optional", "of", "(", "invalid", "grant", "exception", "(", "\"", "tokens", "must", "be", "refreshed", "by", "the", "creating", "client", "\"", ")", ")", ";", "}", "else", "{", "return", "optional", "empty", "(", ")", ";", "}", "}" ]
[ "set", "a", "checked", "change", "listener", "that", "will", "provide", "the", "parent", "view", ",", "model", ",", "value", ",", "and", "adapter", "position", "of", "the", "checked", "view", "this", "will", "clear", "the", "normal", "compound", "button", "on", "checked", "change", "listener", "if", "one", "has", "been", "set" ]
[ "public", "model", "with", "checked", "change", "listener", "checked", "listener", "(", "final", "on", "model", "checked", "change", "listener", "<", "model", "with", "checked", "change", "listener", ",", "object", ">", "checked", "listener", ")", "{", "on", "mutation", "(", ")", ";", "if", "(", "checked", "listener", "=", "=", "null", ")", "{", "super", "checked", "listener", "=", "null", ";", "}", "else", "{", "super", "checked", "listener", "=", "new", "wrapped", "epoxy", "model", "checked", "change", "listener", "(", "checked", "listener", ")", ";", "}", "return", "this", ";", "}" ]
[ "adds", "the", "remaining", "values", "to", "the", "specified", "array" ]
[ "public", "int", "array", "to", "array", "(", "int", "array", "array", ")", "{", "while", "(", "has", "next", ")", "array", "add", "(", "next", "(", ")", ")", ";", "return", "array", ";", "}" ]
[ "to", "test", "special", "tags", "to", "test", "special", "tags", "and", "operation", "id", "starting", "with", "number" ]
[ "public", "void", "call", "1", "2", "3test", "special", "tags", "(", "client", "body", ",", "api", "client", "auth", "info", "auth", "info", ",", "handler", "<", "async", "result", "<", "client", ">", ">", "result", "handler", ")", "{", "delegate", "call", "1", "2", "3test", "special", "tags", "(", "body", ",", "auth", "info", ",", "result", "handler", ")", ";", "}" ]
[ "read", "the", "branch", "session", "list", "by", "xid" ]
[ "private", "list", "<", "branch", "transaction", "d", "o", ">", "read", "branch", "session", "by", "xid", "(", "jedis", "jedis", ",", "string", "xid", ")", "{", "list", "<", "branch", "transaction", "d", "o", ">", "branch", "transaction", "d", "os", "=", "new", "array", "list", "<", ">", "(", ")", ";", "string", "branch", "list", "key", "=", "build", "branch", "list", "key", "by", "xid", "(", "xid", ")", ";", "list", "<", "string", ">", "branch", "keys", "=", "jedis", "lrange", "(", "branch", "list", "key", ",", "0", ",", "-", "1", ")", ";", "pipeline", "pipeline", "=", "jedis", "pipelined", "(", ")", ";", "if", "(", "collection", "utils", "is", "not", "empty", "(", "branch", "keys", ")", ")", "{", "branch", "keys", "stream", "(", ")", "for", "each", "ordered", "(", "branch", "key", "-", ">", "pipeline", "hget", "all", "(", "branch", "key", ")", ")", ";", "list", "<", "object", ">", "branch", "infos", "=", "pipeline", "sync", "and", "return", "all", "(", ")", ";", "for", "(", "object", "branch", "info", ":", "branch", "infos", ")", "{", "if", "(", "branch", "info", "!", "=", "null", ")", "{", "map", "<", "string", ",", "string", ">", "branch", "info", "map", "=", "(", "map", "<", "string", ",", "string", ">", ")", "branch", "info", ";", "branch", "transaction", "d", "o", "branch", "transaction", "d", "o", "=", "(", "branch", "transaction", "d", "o", ")", "bean", "utils", "map", "to", "object", "(", "branch", "info", "map", ",", "branch", "transaction", "d", "o", "class", ")", ";", "branch", "transaction", "d", "os", "add", "(", "branch", "transaction", "d", "o", ")", ";", "}", "}", "}", "if", "(", "collection", "utils", "is", "not", "empty", "(", "branch", "transaction", "d", "os", ")", ")", "{", "branch", "transaction", "d", "os", "=", "branch", "transaction", "d", "os", "stream", "(", ")", "sorted", "(", "comparator", "comparing", "(", "branch", "transaction", "d", "o", ":", ":", "get", "gmt", "create", ")", ")", "collect", "(", "collectors", "to", "list", "(", ")", ")", ";", "}", "return", "branch", "transaction", "d", "os", ";", "}" ]
[ "the", "overridden", "method", "should", "handle", "appropriate", "properties", "and", "set", "value", "callbacks", "on", "their", "animations" ]
[ "<", "t", ">", "void", "add", "value", "callback", "(", "t", "property", ",", "@", "nullable", "lottie", "value", "callback", "<", "t", ">", "callback", ")", ";" ]
[ "call", "this", "if", "a", "mode", "was", "unsuccessful", "in", "sending" ]
[ "public", "void", "on", "unsuccessful", "request", "(", ")", "{", "data", "map", "clear", "(", ")", ";", "}" ]
[ "expands", "an", "expression", "into", "the", "set", "of", "matching", "names", "for", "example", ",", "given", "a", "set", "of", "names", "[", "\"", "foo", "-", "1", "\"", ",", "\"", "foo", "-", "2", "\"", ",", "\"", "bar", "-", "1", "\"", ",", "bar", "-", "2", "\"", "]", ",", "expressions", "resolve", "follows", ":", "\"", "foo", "-", "1", "\"", ":", "[", "\"", "foo", "-", "1", "\"", "]", "\"", "bar", "-", "1", "\"", ":", "[", "\"", "bar", "-", "1", "\"", "]", "\"", "foo", "-", "1", ",", "foo", "-", "2", "\"", ":", "[", "\"", "foo", "-", "1", "\"", ",", "\"", "foo", "-", "2", "\"", "]", "\"", "foo", "-", "\"", ":", "[", "\"", "foo", "-", "1", "\"", ",", "\"", "foo", "-", "2", "\"", "]", "\"", "-", "1", "\"", ":", "[", "\"", "bar", "-", "1", "\"", ",", "\"", "foo", "-", "1", "\"", "]", "\"", "\"", ":", "[", "\"", "bar", "-", "1", "\"", ",", "\"", "bar", "-", "2", "\"", ",", "\"", "foo", "-", "1", "\"", ",", "\"", "foo", "-", "2", "\"", "]", "\"", "all", "\"", ":", "[", "\"", "bar", "-", "1", "\"", ",", "\"", "bar", "-", "2", "\"", ",", "\"", "foo", "-", "1", "\"", ",", "\"", "foo", "-", "2", "\"", "]" ]
[ "public", "sorted", "set", "<", "string", ">", "expand", "(", "string", "expression", ",", "boolean", "allow", "no", "match", ")", "{", "sorted", "set", "<", "string", ">", "result", "=", "new", "tree", "set", "<", ">", "(", ")", ";", "if", "(", "strings", "is", "all", "or", "wildcard", "(", "expression", ")", ")", "{", "result", "add", "all", "(", "name", "set", "(", ")", ")", ";", "}", "else", "{", "string", "[", "]", "tokens", "=", "strings", "tokenize", "to", "string", "array", "(", "expression", ",", "\"", ",", "\"", ")", ";", "for", "(", "string", "token", ":", "tokens", ")", "{", "if", "(", "regex", "is", "simple", "match", "pattern", "(", "token", ")", ")", "{", "list", "<", "string", ">", "expanded", "=", "keys", "(", ")", "stream", "(", ")", "filter", "(", "key", "-", ">", "regex", "simple", "match", "(", "token", ",", "key", ")", ")", "map", "(", "this", ":", ":", "lookup", ")", "flat", "map", "(", "list", ":", ":", "stream", ")", "collect", "(", "collectors", "to", "list", "(", ")", ")", ";", "if", "(", "expanded", "is", "empty", "(", ")", "&", "&", "allow", "no", "match", "=", "=", "false", ")", "{", "throw", "not", "found", "exception", "supplier", "apply", "(", "token", ")", ";", "}", "result", "add", "all", "(", "expanded", ")", ";", "}", "else", "{", "list", "<", "string", ">", "matching", "names", "=", "lookup", "(", "token", ")", ";", "/", "/", "allow", "no", "match", "only", "applies", "to", "wildcard", "expressions", ",", "/", "/", "this", "isn", "'", "t", "so", "don", "'", "t", "check", "the", "allow", "no", "match", "here", "if", "(", "matching", "names", "is", "empty", "(", ")", ")", "{", "throw", "not", "found", "exception", "supplier", "apply", "(", "token", ")", ";", "}", "result", "add", "all", "(", "matching", "names", ")", ";", "}", "}", "}", "if", "(", "result", "is", "empty", "(", ")", "&", "&", "allow", "no", "match", "=", "=", "false", ")", "{", "throw", "not", "found", "exception", "supplier", "apply", "(", "expression", ")", ";", "}", "return", "result", ";", "}" ]
[ "create", "a", "new", "acl", "entry", "with", "scope", "and", "type", "(", "no", "name", "or", "permission", ")" ]
[ "public", "static", "acl", "entry", "acl", "entry", "(", "acl", "entry", "scope", "scope", ",", "acl", "entry", "type", "type", ")", "{", "return", "new", "acl", "entry", "builder", "(", ")", "set", "scope", "(", "scope", ")", "set", "type", "(", "type", ")", "build", "(", ")", ";", "}" ]
[ "consume", "a", "primitive", "long", "input" ]
[ "void", "accept", "(", "long", "t", ")", "throws", "throwable", ";" ]
[ "identifying", "certificate", "for", "this", "host", "{", "@", "code", "key", "cert", "chain", "}", "and", "{", "@", "code", "key", "}", "may", "be", "{", "@", "code", "null", "}", "for", "client", "contexts", ",", "which", "disables", "mutual", "authentication" ]
[ "public", "ssl", "context", "builder", "key", "manager", "(", "private", "key", "key", ",", "string", "key", "password", ",", "iterable", "<", "?", "extends", "x", "5", "0", "9", "certificate", ">", "key", "cert", "chain", ")", "{", "return", "key", "manager", "(", "key", ",", "key", "password", ",", "to", "array", "(", "key", "cert", "chain", ",", "empty", "x509", "certificates", ")", ")", ";", "}" ]
[ "test", "the", "property", "'", "attribute", "number", "'" ]
[ "public", "void", "attribute", "number", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "attribute", "number", "}" ]
[ "model", "tests", "for", "danish", "pig" ]
[ "public", "void", "test", "danish", "pig", "(", ")", "{", "/", "/", "todo", ":", "test", "danish", "pig", "}" ]
[ "parse", "import", "-", "package", "string", "from", "a", "bundle", "manifest" ]
[ "static", "list", "<", "bundle", "requirement", ">", "parse", "import", "package", "(", "string", "import", "package", "string", ")", "throws", "bundle", "exception", "{", "map", "<", "string", ",", "object", ">", "header", "map", "=", "new", "hash", "map", "<", ">", "(", ")", ";", "header", "map", "put", "(", "constants", "import", "package", ",", "import", "package", "string", ")", ";", "manifest", "parser", "manifest", "parser", "=", "new", "manifest", "parser", "(", "null", ",", "null", ",", "null", ",", "header", "map", ")", ";", "return", "manifest", "parser", "get", "requirements", "(", ")", ";", "}" ]
[ "returns", "the", "current", "number", "of", "ranges", "in", "the", "list" ]
[ "public", "int", "get", "num", "ranges", "(", ")", "{", "return", "ranges", "size", "(", ")", ";", "}" ]
[ "find", "by", "token" ]
[ "public", "list", "<", "couch", "db", "google", "authenticator", "token", ">", "find", "by", "token", "(", "final", "integer", "otp", ")", "{", "return", "query", "view", "(", "\"", "by", "token", "\"", ",", "otp", ")", ";", "}" ]
[ "returns", "the", "single", "edge", "that", "directly", "connects", "{", "@", "code", "node", "u", "}", "to", "{", "@", "code", "node", "v", "}", ",", "if", "one", "is", "present", ",", "or", "{", "@", "code", "optional", "empty", "(", ")", "}", "if", "no", "such", "edge", "exists", "in", "an", "undirected", "network", ",", "this", "is", "equal", "to", "{", "@", "code", "edge", "connecting", "(", "node", "v", ",", "node", "u", ")", "}" ]
[ "optional", "<", "e", ">", "edge", "connecting", "(", "n", "node", "u", ",", "n", "node", "v", ")", ";" ]
[ "\"", "touches", "\"", "the", "file", "or", "directory", "specified", "by", "the", "path", ",", "following", "symbolic", "links", "if", "it", "does", "not", "exist", ",", "it", "is", "created", "as", "an", "empty", "file", ";", "otherwise", ",", "the", "time", "of", "last", "access", "is", "updated", "to", "the", "current", "time" ]
[ "public", "static", "void", "touch", "file", "(", "path", "path", ")", "throws", "i", "o", "exception", "{", "if", "(", "path", "exists", "(", ")", ")", "{", "/", "/", "-", "1l", "means", "\"", "use", "the", "current", "time", "\"", ",", "and", "is", "ultimately", "implemented", "by", "/", "/", "utime", "(", "path", ",", "null", ")", ",", "thereby", "using", "the", "kernel", "'", "s", "clock", ",", "not", "the", "jvm", "'", "s", "/", "/", "(", "a", "previous", "implementation", "based", "on", "the", "jvm", "clock", "was", "found", "to", "be", "/", "/", "skewy", ")", "path", "set", "last", "modified", "time", "(", "-", "1l", ")", ";", "}", "else", "{", "create", "empty", "file", "(", "path", ")", ";", "}", "}" ]
[ "removes", "the", "mapping", "at", "the", "given", "index" ]
[ "public", "void", "remove", "at", "(", "int", "index", ")", "{", "system", "arraycopy", "(", "m", "keys", ",", "index", "+", "1", ",", "m", "keys", ",", "index", ",", "m", "size", "-", "(", "index", "+", "1", ")", ")", ";", "system", "arraycopy", "(", "m", "values", ",", "index", "+", "1", ",", "m", "values", ",", "index", ",", "m", "size", "-", "(", "index", "+", "1", ")", ")", ";", "-", "-", "m", "size", ";", "}" ]
[ "updates", "all", "the", "series", "from", "the", "current", "snapshot" ]
[ "protected", "void", "update", "counts", "(", "load", "statistics", "snapshot", "current", ")", "{", "defined", "executors", "update", "(", "current", "get", "defined", "executors", "(", ")", ")", ";", "online", "executors", "update", "(", "current", "get", "online", "executors", "(", ")", ")", ";", "connecting", "executors", "update", "(", "current", "get", "connecting", "executors", "(", ")", ")", ";", "busy", "executors", "update", "(", "current", "get", "busy", "executors", "(", ")", ")", ";", "idle", "executors", "update", "(", "current", "get", "idle", "executors", "(", ")", ")", ";", "available", "executors", "update", "(", "current", "get", "available", "executors", "(", ")", ")", ";", "queue", "length", "update", "(", "current", "get", "queue", "length", "(", ")", ")", ";", "}" ]
[ "multiplies", "the", "ray", "by", "the", "given", "matrix", "use", "this", "to", "transform", "a", "ray", "into", "another", "coordinate", "system" ]
[ "public", "ray", "mul", "(", "matrix", "4", "matrix", ")", "{", "tmp", "set", "(", "origin", ")", "add", "(", "direction", ")", ";", "tmp", "mul", "(", "matrix", ")", ";", "origin", "mul", "(", "matrix", ")", ";", "direction", "set", "(", "tmp", "sub", "(", "origin", ")", ")", "nor", "(", ")", ";", "return", "this", ";", "}" ]
[ "tests", "that", "any", "bulk", "failure", "in", "the", "listener", "callbacks", "is", "rethrown", "on", "an", "immediately", "following", "checkpoint" ]
[ "public", "void", "test", "bulk", "failure", "rethrown", "on", "checkpoint", "(", ")", "throws", "throwable", "{", "final", "dummy", "elasticsearch", "sink", "<", "string", ">", "sink", "=", "new", "dummy", "elasticsearch", "sink", "<", ">", "(", "new", "hash", "map", "<", "string", ",", "string", ">", "(", ")", ",", "new", "simple", "sink", "function", "<", "string", ">", "(", ")", ",", "new", "no", "op", "failure", "handler", "(", ")", ")", ";", "final", "one", "input", "stream", "operator", "test", "harness", "<", "string", ",", "object", ">", "test", "harness", "=", "new", "one", "input", "stream", "operator", "test", "harness", "<", ">", "(", "new", "stream", "sink", "<", ">", "(", "sink", ")", ")", ";", "test", "harness", "open", "(", ")", ";", "/", "/", "setup", "the", "next", "bulk", "request", ",", "and", "let", "the", "whole", "bulk", "request", "fail", "sink", "set", "fail", "next", "bulk", "request", "completely", "(", "new", "exception", "(", "\"", "artificial", "failure", "for", "bulk", "request", "\"", ")", ")", ";", "test", "harness", "process", "element", "(", "new", "stream", "record", "<", ">", "(", "\"", "msg", "\"", ")", ")", ";", "verify", "(", "sink", "get", "mock", "bulk", "processor", "(", ")", ",", "times", "(", "1", ")", ")", "add", "(", "any", "(", "index", "request", "class", ")", ")", ";", "/", "/", "manually", "execute", "the", "next", "bulk", "request", "sink", "manual", "bulk", "request", "with", "all", "pending", "requests", "(", ")", ";", "try", "{", "test", "harness", "snapshot", "(", "1l", ",", "1000l", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "/", "/", "the", "snapshot", "should", "have", "failed", "with", "the", "bulk", "request", "failure", "assert", "assert", "true", "(", "e", "get", "cause", "(", ")", "get", "cause", "(", ")", "get", "message", "(", ")", "contains", "(", "\"", "artificial", "failure", "for", "bulk", "request", "\"", ")", ")", ";", "/", "/", "test", "succeeded", "return", ";", "}", "assert", "fail", "(", ")", ";", "}" ]
[ "returns", "the", "{", "@", "link", "uri", "}", "associated", "with", "the", "last", "{", "@", "link", "#", "open", "(", "data", "spec", ")", "}", "call", "if", "redirection", "occurred", ",", "this", "is", "the", "redirected", "uri" ]
[ "public", "uri", "get", "last", "opened", "uri", "(", ")", "{", "return", "last", "opened", "uri", ";", "}" ]
[ "called", "when", "this", "entity", "instance", "is", "removed" ]
[ "void", "on", "removal", "(", "removal", "notification", "<", "key", ",", "bytes", "reference", ">", "notification", ")", ";" ]
[ "returns", "the", "logical", "and", "of", "this", "long", "value", "and", "the", "given", "specific", "long", "value" ]
[ "public", "long", "value", "and", "(", "specific", "long", "value", "other", ")", "{", "return", "this", ";", "}" ]
[ "gets", "the", "addresses", "in", "the", "first", "listing", "where", "matching", "code", "couldn", "'", "t", "be", "determined", "in", "the", "second", "listing" ]
[ "public", "address", "set", "view", "get", "listing", "1", "unmatched", "code", "(", ")", "{", "return", "new", "address", "set", "(", "unmatched", "code", "1", ")", ";", "}" ]
[ "model", "tests", "for", "additional", "properties", "array" ]
[ "public", "void", "test", "additional", "properties", "array", "(", ")", "{", "/", "/", "todo", ":", "test", "additional", "properties", "array", "}" ]
[ "return", "the", "maximum", "upload", "size", "allowed", ",", "or", "-", "1", "if", "the", "size", "limit", "isn", "'", "t", "known" ]
[ "public", "long", "get", "max", "upload", "size", "(", ")", "{", "return", "this", "max", "upload", "size", ";", "}" ]
[ "set", "the", "write", "checksum", "flag", "this", "is", "only", "applicable", "if", "the", "corresponding", "filesystem", "supports", "checksums", "by", "default", "doesn", "'", "t", "do", "anything" ]
[ "public", "void", "set", "write", "checksum", "(", "boolean", "write", "checksum", ")", "{", "/", "/", "doesn", "'", "t", "do", "anything", "}" ]
[ "build", "system", "credentials", "for", "apps", "proto", "objects" ]
[ "public", "static", "system", "credentials", "for", "apps", "proto", "new", "system", "credentials", "for", "apps", "proto", "(", "application", "id", "application", "id", ",", "byte", "buffer", "credentials", ")", "{", "system", "credentials", "for", "apps", "proto", "system", "credentials", "for", "apps", "proto", "=", "system", "credentials", "for", "apps", "proto", "new", "builder", "(", ")", "set", "app", "id", "(", "proto", "utils", "convert", "to", "proto", "format", "(", "application", "id", ")", ")", "set", "credentials", "for", "app", "(", "proto", "utils", "byte", "string", "interner", "intern", "(", "proto", "utils", "convert", "to", "proto", "format", "(", "credentials", "duplicate", "(", ")", ")", ")", ")", "build", "(", ")", ";", "return", "system", "credentials", "for", "apps", "proto", ";", "}" ]
[ "adds", "a", "replacement", "string", "for", "the", "given", "input", "character", "the", "specified", "character", "will", "be", "replaced", "by", "the", "given", "string", "whenever", "it", "occurs", "in", "the", "input", ",", "irrespective", "of", "whether", "it", "lies", "inside", "or", "outside", "the", "'", "safe", "'", "range" ]
[ "public", "builder", "add", "escape", "(", "char", "c", ",", "string", "replacement", ")", "{", "check", "not", "null", "(", "replacement", ")", ";", "/", "/", "this", "can", "replace", "an", "existing", "character", "(", "the", "builder", "is", "re", "-", "usable", ")", "replacement", "map", "put", "(", "c", ",", "replacement", ")", ";", "return", "this", ";", "}" ]
[ "returns", "data", "file", "chunk", "size", "this", "method", "should", "return", "null", "if", "no", "chunking", "is", "needed" ]
[ "protected", "byte", "size", "value", "chunk", "size", "(", ")", "{", "return", "null", ";", "}" ]
[ "set", "the", "list", "of", "components", "that", "depend", "on", "this", "plugin" ]
[ "public", "void", "set", "dependents", "(", "@", "non", "null", "set", "<", "string", ">", "dependents", ")", "{", "this", "dependents", "=", "dependents", ";", "}" ]
[ "abbreviate", "a", "string", "by", "putting", "'", "'", "in", "the", "middle", "of", "it", ",", "in", "an", "attempt", "to", "keep", "logs", "from", "getting", "too", "messy" ]
[ "static", "string", "abbreviate", "(", "string", "cmd", ",", "int", "len", ")", "{", "if", "(", "cmd", "length", "(", ")", ">", "len", "&", "&", "len", ">", "=", "5", ")", "{", "int", "first", "half", "=", "(", "len", "-", "3", ")", "/", "2", ";", "int", "rem", "=", "len", "-", "first", "half", "-", "3", ";", "return", "cmd", "substring", "(", "0", ",", "first", "half", ")", "+", "\"", "\"", "+", "cmd", "substring", "(", "cmd", "length", "(", ")", "-", "rem", ")", ";", "}", "else", "{", "return", "cmd", ";", "}", "}" ]
[ "sets", "the", "{", "@", "link", "bandwidth", "meter", "}", "that", "will", "be", "used", "by", "the", "player" ]
[ "public", "builder", "set", "bandwidth", "meter", "(", "bandwidth", "meter", "bandwidth", "meter", ")", "{", "assertions", "check", "state", "(", "!", "build", "called", ")", ";", "this", "bandwidth", "meter", "=", "bandwidth", "meter", ";", "return", "this", ";", "}" ]
[ "write", "the", "given", "stream", "of", "{", "@", "link", "data", "buffer", "data", "buffers", "}", "to", "the", "given", "{", "@", "code", "writable", "byte", "channel", "}", "does", "not", "close", "the", "channel", "when", "the", "flux", "is", "terminated", ",", "and", "does", "not", "{", "@", "linkplain", "#", "release", "(", "data", "buffer", ")", "release", "}", "the", "data", "buffers", "in", "the", "source", "if", "releasing", "is", "required", ",", "then", "subscribe", "to", "the", "returned", "{", "@", "code", "flux", "}", "with", "a", "{", "@", "link", "#", "release", "consumer", "(", ")", "}", "note", "that", "the", "writing", "process", "does", "not", "start", "until", "the", "returned", "{", "@", "code", "flux", "}", "is", "subscribed", "to" ]
[ "public", "static", "flux", "<", "data", "buffer", ">", "write", "(", "publisher", "<", "data", "buffer", ">", "source", ",", "writable", "byte", "channel", "channel", ")", "{", "assert", "not", "null", "(", "source", ",", "\"", "'", "source", "'", "must", "not", "be", "null", "\"", ")", ";", "assert", "not", "null", "(", "channel", ",", "\"", "'", "channel", "'", "must", "not", "be", "null", "\"", ")", ";", "flux", "<", "data", "buffer", ">", "flux", "=", "flux", "from", "(", "source", ")", ";", "return", "flux", "create", "(", "sink", "-", ">", "{", "writable", "byte", "channel", "subscriber", "subscriber", "=", "new", "writable", "byte", "channel", "subscriber", "(", "sink", ",", "channel", ")", ";", "sink", "on", "dispose", "(", "subscriber", ")", ";", "flux", "subscribe", "(", "subscriber", ")", ";", "}", ")", ";", "}" ]
[ "compare", "the", "buffers", "in", "serialized", "form" ]
[ "public", "int", "compare", "(", "byte", "[", "]", "b", "1", ",", "int", "s", "1", ",", "int", "l", "1", ",", "byte", "[", "]", "b", "2", ",", "int", "s", "2", ",", "int", "l", "2", ")", "{", "assert", "0", "=", "=", "l", "1", ";", "assert", "0", "=", "=", "l", "2", ";", "return", "0", ";", "}" ]
[ "maps", "the", "specified", "<", "code", ">", "key", "<", "code", ">", "to", "the", "specified", "<", "code", ">", "value", "<", "code", ">", "key", "can", "not", "be", "<", "code", ">", "null", "<", "code", ">", "if", "key", "is", "already", "mapped", "then", "the", "old", "value", "of", "the", "<", "code", ">", "key", "<", "code", ">", "is", "replaced", "by", "the", "specified", "<", "code", ">", "value", "<", "code", ">" ]
[ "public", "void", "set", "property", "(", "string", "key", ",", "string", "value", ")", "{", "if", "(", "null", "=", "=", "key", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "property", "key", "is", "null", "\"", ")", ";", "}", "string", "old", "value", "=", "properties", "put", "(", "key", ",", "value", ")", ";", "if", "(", "null", "!", "=", "old", "value", "&", "&", "!", "old", "value", "equals", "(", "value", ")", ")", "{", "log", "debug", "(", "\"", "key", "{", "}", "'", "s", "value", "{", "}", "is", "replaced", "with", "new", "value", "{", "}", "\"", ",", "key", ",", "old", "value", ",", "value", ")", ";", "}", "}" ]
[ "get", "my", "number" ]
[ "public", "big", "decimal", "get", "my", "number", "(", ")", "{", "return", "my", "number", ";", "}" ]
[ "removes", "this", "actor", "from", "its", "parent", ",", "if", "it", "has", "a", "parent" ]
[ "public", "boolean", "remove", "(", ")", "{", "if", "(", "parent", "!", "=", "null", ")", "return", "parent", "remove", "actor", "(", "this", ",", "true", ")", ";", "return", "false", ";", "}" ]
[ "set", "the", "value", "of", "the", "{", "@", "code", "if", "-", "modified", "-", "since", "}", "header", "the", "date", "should", "be", "specified", "as", "the", "number", "of", "milliseconds", "since", "january", "1", ",", "1970", "gmt" ]
[ "s", "if", "modified", "since", "(", "zoned", "date", "time", "if", "modified", "since", ")", ";" ]
[ "appends", "a", "{", "@", "link", "channel", "handler", "}", "at", "the", "last", "position", "of", "this", "pipeline" ]
[ "channel", "pipeline", "add", "last", "(", "string", "name", ",", "channel", "handler", "handler", ")", ";" ]
[ "read", "an", "optional", "{", "@", "link", "time", "value", "}", "from", "the", "stream", ",", "returning", "null", "if", "no", "time", "value", "was", "written" ]
[ "public", "@", "nullable", "time", "value", "read", "optional", "time", "value", "(", ")", "throws", "i", "o", "exception", "{", "if", "(", "read", "boolean", "(", ")", ")", "{", "return", "read", "time", "value", "(", ")", ";", "}", "else", "{", "return", "null", ";", "}", "}" ]
[ "fake", "notification", "'", "s", "id" ]
[ "public", "int", "deal", "notification", "id", "(", "int", "id", ",", "string", "package", "name", ",", "string", "tag", ",", "int", "user", "id", ")", "{", "return", "id", ";", "}" ]
[ "in", "this", "function", ",", "we", "get", "a", "bunch", "of", "streams", "from", "all", "of", "our", "journal", "manager", "objects", "then", "we", "add", "these", "to", "the", "collection", "one", "by", "one" ]
[ "public", "void", "select", "input", "streams", "(", "collection", "<", "edit", "log", "input", "stream", ">", "streams", ",", "long", "from", "tx", "id", ",", "boolean", "in", "progress", "ok", ",", "boolean", "only", "durable", "txns", ")", "{", "final", "priority", "queue", "<", "edit", "log", "input", "stream", ">", "all", "streams", "=", "new", "priority", "queue", "<", "edit", "log", "input", "stream", ">", "(", "64", ",", "edit", "log", "input", "stream", "comparator", ")", ";", "for", "(", "journal", "and", "stream", "jas", ":", "journals", ")", "{", "if", "(", "jas", "is", "disabled", "(", ")", ")", "{", "log", "info", "(", "\"", "skipping", "jas", "\"", "+", "jas", "+", "\"", "since", "it", "'", "s", "disabled", "\"", ")", ";", "continue", ";", "}", "try", "{", "jas", "get", "manager", "(", ")", "select", "input", "streams", "(", "all", "streams", ",", "from", "tx", "id", ",", "in", "progress", "ok", ",", "only", "durable", "txns", ")", ";", "}", "catch", "(", "i", "o", "exception", "ioe", ")", "{", "log", "warn", "(", "\"", "unable", "to", "determine", "input", "streams", "from", "\"", "+", "jas", "get", "manager", "(", ")", "+", "\"", "skipping", "\"", ",", "ioe", ")", ";", "}", "}", "chain", "and", "make", "redundant", "streams", "(", "streams", ",", "all", "streams", ",", "from", "tx", "id", ")", ";", "}" ]
[ "litho", "handles", "addingremoving", "views", "automatically", "using", "mountunmount", "calls", "manually", "adding", "removing", "views", "will", "mess", "up", "litho", "'", "s", "bookkeeping", "of", "added", "views", "and", "cause", "weird", "crashes", "down", "the", "line" ]
[ "public", "void", "remove", "view", "in", "layout", "(", "view", "view", ")", "{", "throw", "new", "unsupported", "operation", "exception", "(", "\"", "removing", "views", "manually", "within", "litho", "views", "is", "not", "supported", "\"", ")", ";", "}" ]
[ "add", "the", "given", "command", "to", "this", "command" ]
[ "public", "void", "add", "(", "command", "cmd", ")", "{", "cmds", "add", "(", "cmd", ")", ";", "}" ]
[ "gets", "the", "parent", "as", "has", "been", "specified", "in", "the", "constructor", "or", "via", "set", "parent" ]
[ "public", "class", "loader", "get", "configured", "parent", "(", ")", "{", "return", "parent", ";", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "record", "reader", "<", "long", "writable", ",", "t", ">", "get", "record", "reader", "(", "input", "split", "split", ",", "job", "conf", "job", ",", "reporter", "reporter", ")", "throws", "i", "o", "exception", "{", "/", "/", "wrap", "the", "dbrr", "in", "a", "shim", "class", "to", "deal", "with", "api", "differences", "return", "new", "d", "b", "record", "reader", "wrapper", "<", "t", ">", "(", "(", "org", "apache", "hadoop", "mapreduce", "lib", "db", "d", "b", "record", "reader", "<", "t", ">", ")", "create", "d", "b", "record", "reader", "(", "(", "org", "apache", "hadoop", "mapreduce", "lib", "db", "d", "b", "input", "format", "d", "b", "input", "split", ")", "split", ",", "job", ")", ")", ";", "}" ]
[ "return", "the", "hex", "string", "of", "hmac", "s", "h", "a", "2", "2", "4", "encryption" ]
[ "public", "static", "string", "encrypt", "hmac", "s", "h", "a", "2", "2", "4", "to", "string", "(", "final", "string", "data", ",", "final", "string", "key", ")", "{", "if", "(", "data", "=", "=", "null", "|", "|", "data", "length", "(", ")", "=", "=", "0", "|", "|", "key", "=", "=", "null", "|", "|", "key", "length", "(", ")", "=", "=", "0", ")", "return", "\"", "\"", ";", "return", "encrypt", "hmac", "s", "h", "a", "2", "2", "4", "to", "string", "(", "data", "get", "bytes", "(", ")", ",", "key", "get", "bytes", "(", ")", ")", ";", "}" ]
[ "enable", "or", "disable", "caching", "of", "ssl", "sessions" ]
[ "public", "abstract", "void", "set", "session", "cache", "enabled", "(", "boolean", "enabled", ")", ";" ]
[ "connects", "to", "the", "upstream", "{", "@", "code", "connectable", "flowable", "}", "if", "the", "number", "of", "subscribed", "subscriber", "reaches", "the", "specified", "count", "and", "disconnect", "after", "the", "specified", "timeout", "if", "all", "subscribers", "have", "unsubscribed", "<", "dl", ">", "<", "dt", ">", "<", "b", ">", "backpressure", ":", "<", "b", ">", "<", "dt", ">", "<", "dd", ">", "the", "operator", "itself", "doesn", "'", "t", "interfere", "with", "backpressure", "which", "is", "determined", "by", "the", "upstream", "{", "@", "code", "connectable", "flowable", "}", "'", "s", "backpressure", "behavior", "<", "dd", ">", "<", "dt", ">", "<", "b", ">", "scheduler", ":", "<", "b", ">", "<", "dt", ">", "<", "dd", ">", "this", "{", "@", "code", "ref", "count", "}", "overload", "operates", "on", "the", "{", "@", "code", "computation", "}", "{", "@", "link", "scheduler", "}", "<", "dd", ">", "<", "dl", ">", "history", ":", "2", "1", "14", "-", "experimental" ]
[ "public", "final", "flowable", "<", "t", ">", "ref", "count", "(", "int", "subscriber", "count", ",", "long", "timeout", ",", "@", "non", "null", "time", "unit", "unit", ")", "{", "return", "ref", "count", "(", "subscriber", "count", ",", "timeout", ",", "unit", ",", "schedulers", "computation", "(", ")", ")", ";", "}" ]
[ "return", "a", "merged", "root", "bean", "definition", ",", "traversing", "the", "parent", "bean", "definition", "if", "the", "specified", "bean", "corresponds", "to", "a", "child", "bean", "definition" ]
[ "protected", "root", "bean", "definition", "get", "merged", "local", "bean", "definition", "(", "string", "bean", "name", ")", "throws", "beans", "exception", "{", "/", "/", "quick", "check", "on", "the", "concurrent", "map", "first", ",", "with", "minimal", "locking", "root", "bean", "definition", "mbd", "=", "this", "merged", "bean", "definitions", "get", "(", "bean", "name", ")", ";", "if", "(", "mbd", "!", "=", "null", "&", "&", "!", "mbd", "stale", ")", "{", "return", "mbd", ";", "}", "return", "get", "merged", "bean", "definition", "(", "bean", "name", ",", "get", "bean", "definition", "(", "bean", "name", ")", ")", ";", "}" ]
[ "get", "number", "of", "active", "users", "i", "e", "users", "with", "applications", "which", "have", "pending", "resource", "requests" ]
[ "synchronized", "public", "int", "get", "num", "active", "users", "(", ")", "{", "return", "active", "users", ";", "}" ]
[ "tests", "that", "getting", "a", "next", "retry", "strategy", "below", "zero", "remaining", "retries", "fails" ]
[ "public", "void", "test", "retry", "failure", "(", ")", "throws", "throwable", "{", "new", "exponential", "backoff", "retry", "strategy", "(", "0", ",", "duration", "of", "millis", "(", "20l", ")", ",", "duration", "of", "millis", "(", "20l", ")", ")", "get", "next", "retry", "strategy", "(", ")", ";", "}" ]
[ "translates", "deprecated", "configurations", "into", "their", "non", "-", "deprecated", "equivalents" ]
[ "public", "static", "<", "t", ">", "map", "<", "string", ",", "t", ">", "translate", "deprecated", "configs", "(", "map", "<", "string", ",", "t", ">", "configs", ",", "map", "<", "string", ",", "list", "<", "string", ">", ">", "alias", "groups", ")", "{", "set", "<", "string", ">", "alias", "set", "=", "stream", "concat", "(", "alias", "groups", "key", "set", "(", ")", "stream", "(", ")", ",", "alias", "groups", "values", "(", ")", "stream", "(", ")", "flat", "map", "(", "collection", ":", ":", "stream", ")", ")", "collect", "(", "collectors", "to", "set", "(", ")", ")", ";", "/", "/", "pass", "through", "all", "configurations", "without", "aliases", "map", "<", "string", ",", "t", ">", "new", "configs", "=", "configs", "entry", "set", "(", ")", "stream", "(", ")", "filter", "(", "e", "-", ">", "!", "alias", "set", "contains", "(", "e", "get", "key", "(", ")", ")", ")", "/", "/", "filter", "out", "null", "values", "filter", "(", "e", "-", ">", "objects", "non", "null", "(", "e", "get", "value", "(", ")", ")", ")", "collect", "(", "collectors", "to", "map", "(", "map", "entry", ":", ":", "get", "key", ",", "map", "entry", ":", ":", "get", "value", ")", ")", ";", "alias", "groups", "for", "each", "(", "(", "target", ",", "aliases", ")", "-", ">", "{", "list", "<", "string", ">", "deprecated", "=", "aliases", "stream", "(", ")", "filter", "(", "configs", ":", ":", "contains", "key", ")", "collect", "(", "collectors", "to", "list", "(", ")", ")", ";", "if", "(", "deprecated", "is", "empty", "(", ")", ")", "{", "/", "/", "no", "deprecated", "key", "(", "s", ")", "found", "if", "(", "configs", "contains", "key", "(", "target", ")", ")", "{", "new", "configs", "put", "(", "target", ",", "configs", "get", "(", "target", ")", ")", ";", "}", "return", ";", "}", "string", "alias", "string", "=", "string", "join", "(", "\"", ",", "\"", ",", "deprecated", ")", ";", "if", "(", "configs", "contains", "key", "(", "target", ")", ")", "{", "/", "/", "ignore", "the", "deprecated", "key", "(", "s", ")", "because", "the", "actual", "key", "was", "set", "log", "error", "(", "target", "+", "\"", "was", "configured", ",", "as", "well", "as", "the", "deprecated", "alias", "(", "es", ")", "\"", "+", "alias", "string", "+", "\"", "using", "the", "value", "of", "\"", "+", "target", ")", ";", "new", "configs", "put", "(", "target", ",", "configs", "get", "(", "target", ")", ")", ";", "}", "else", "if", "(", "deprecated", "size", "(", ")", ">", "1", ")", "{", "log", "error", "(", "\"", "the", "configuration", "keys", "\"", "+", "alias", "string", "+", "\"", "are", "deprecated", "and", "may", "be", "\"", "+", "\"", "removed", "in", "the", "future", "additionally", ",", "this", "configuration", "is", "ambigous", "because", "\"", "+", "\"", "these", "configuration", "keys", "are", "all", "aliases", "for", "\"", "+", "target", "+", "\"", "please", "update", "\"", "+", "\"", "your", "configuration", "to", "have", "only", "\"", "+", "target", "+", "\"", "set", "\"", ")", ";", "new", "configs", "put", "(", "target", ",", "configs", "get", "(", "deprecated", "get", "(", "0", ")", ")", ")", ";", "}", "else", "{", "log", "warn", "(", "\"", "configuration", "key", "\"", "+", "deprecated", "get", "(", "0", ")", "+", "\"", "is", "deprecated", "and", "may", "be", "removed", "\"", "+", "\"", "in", "the", "future", "please", "update", "your", "configuration", "to", "use", "\"", "+", "target", "+", "\"", "instead", "\"", ")", ";", "new", "configs", "put", "(", "target", ",", "configs", "get", "(", "deprecated", "get", "(", "0", ")", ")", ")", ";", "}", "}", ")", ";", "return", "new", "configs", ";", "}" ]
[ "returns", "true", "if", "there", "is", "at", "least", "one", "warning", "header", "returned", "in", "the", "response" ]
[ "public", "boolean", "has", "warnings", "(", ")", "{", "header", "[", "]", "warnings", "=", "response", "get", "headers", "(", "\"", "warning", "\"", ")", ";", "return", "warnings", "!", "=", "null", "&", "&", "warnings", "length", ">", "0", ";", "}" ]
[ "returns", "the", "value", "of", "the", "header", "with", "the", "given", "name", "as", "a", "{", "@", "link", "string", "}", ",", "or", "null", "if", "the", "header", "is", "not", "set", "see", "{", "@", "link", "http", "response", "header", "}" ]
[ "string", "get", "header", "(", "string", "name", ")", ";" ]
[ "the", "value", "of", "the", "max", "locals", "item", "gives", "the", "number", "of", "local", "variables", "in", "the", "local", "variable", "array", "allocated", "upon", "invocation", "of", "this", "method", ",", "including", "the", "local", "variables", "used", "to", "pass", "parameters", "to", "the", "method", "on", "its", "invocation", "the", "greatest", "local", "variable", "index", "for", "a", "value", "of", "type", "long", "or", "double", "is", "max", "locals", "-", "2", "the", "greatest", "local", "variable", "index", "for", "a", "value", "of", "any", "other", "type", "is", "max", "locals", "-", "1" ]
[ "public", "int", "get", "max", "locals", "(", ")", "{", "return", "max", "locals", "&", "0xffff", ";", "}" ]
[ "copy", "the", "end", "of", "the", "array", "from", "a", "certain", "index", "back", "to", "make", "room", "for", "length", "many", "items", "and", "adds", "length", "to", "the", "size" ]
[ "private", "void", "copy", "back", "and", "grow", "(", "int", "from", "index", ",", "int", "length", ")", "{", "int", "new", "size", "=", "size", "+", "length", ";", "ensure", "capacity", "(", "new", "size", ")", ";", "system", "arraycopy", "(", "array", ",", "from", "index", ",", "array", ",", "from", "index", "+", "length", ",", "size", "-", "from", "index", ")", ";", "size", "=", "new", "size", ";", "}" ]
[ "converts", "all", "of", "the", "characters", "in", "this", "{", "@", "code", "binary", "string", "data", "}", "to", "lower", "case" ]
[ "public", "binary", "string", "data", "to", "lower", "case", "(", ")", "{", "if", "(", "java", "object", "!", "=", "null", ")", "{", "return", "java", "to", "lower", "case", "(", ")", ";", "}", "if", "(", "binary", "section", "size", "in", "bytes", "=", "=", "0", ")", "{", "return", "empty", "utf8", ";", "}", "int", "size", "=", "binary", "section", "segments", "[", "0", "]", "size", "(", ")", ";", "binary", "string", "data", "segment", "and", "offset", "segment", "and", "offset", "=", "start", "segment", "and", "offset", "(", "size", ")", ";", "byte", "[", "]", "bytes", "=", "new", "byte", "[", "binary", "section", "size", "in", "bytes", "]", ";", "bytes", "[", "0", "]", "=", "(", "byte", ")", "character", "to", "title", "case", "(", "segment", "and", "offset", "value", "(", ")", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "binary", "section", "size", "in", "bytes", ";", "i", "+", "+", ")", "{", "byte", "b", "=", "segment", "and", "offset", "value", "(", ")", ";", "if", "(", "num", "bytes", "for", "first", "byte", "(", "b", ")", "!", "=", "1", ")", "{", "/", "/", "fallback", "return", "java", "to", "lower", "case", "(", ")", ";", "}", "int", "lower", "=", "character", "to", "lower", "case", "(", "(", "int", ")", "b", ")", ";", "if", "(", "lower", ">", "127", ")", "{", "/", "/", "fallback", "return", "java", "to", "lower", "case", "(", ")", ";", "}", "bytes", "[", "i", "]", "=", "(", "byte", ")", "lower", ";", "segment", "and", "offset", "next", "byte", "(", "size", ")", ";", "}", "return", "from", "bytes", "(", "bytes", ")", ";", "}" ]
[ "verify", "saml", "authentication", "request" ]
[ "protected", "pair", "<", "saml", "registered", "service", ",", "saml", "registered", "service", "service", "provider", "metadata", "facade", ">", "verify", "saml", "authentication", "request", "(", "final", "pair", "<", "?", "extends", "signable", "s", "a", "m", "l", "object", ",", "message", "context", ">", "authentication", "context", ",", "final", "http", "servlet", "request", "request", ")", "throws", "exception", "{", "val", "authn", "request", "=", "(", "authn", "request", ")", "authentication", "context", "get", "key", "(", ")", ";", "val", "issuer", "=", "saml", "id", "p", "utils", "get", "issuer", "from", "saml", "object", "(", "authn", "request", ")", ";", "logger", "debug", "(", "\"", "located", "issuer", "[", "{", "}", "]", "from", "authentication", "request", "\"", ",", "issuer", ")", ";", "val", "registered", "service", "=", "verify", "saml", "registered", "service", "(", "issuer", ")", ";", "logger", "debug", "(", "\"", "fetching", "saml", "metadata", "adaptor", "for", "[", "{", "}", "]", "\"", ",", "issuer", ")", ";", "val", "adaptor", "=", "saml", "registered", "service", "service", "provider", "metadata", "facade", "get", "(", "saml", "profile", "handler", "configuration", "context", "get", "saml", "registered", "service", "caching", "metadata", "resolver", "(", ")", ",", "registered", "service", ",", "authn", "request", ")", ";", "if", "(", "adaptor", "is", "empty", "(", ")", ")", "{", "logger", "warn", "(", "\"", "no", "metadata", "could", "be", "found", "for", "[", "{", "}", "]", "\"", ",", "issuer", ")", ";", "throw", "new", "unauthorized", "service", "exception", "(", "unauthorized", "service", "exception", "code", "unauthz", "service", ",", "\"", "cannot", "find", "metadata", "linked", "to", "\"", "+", "issuer", ")", ";", "}", "val", "facade", "=", "adaptor", "get", "(", ")", ";", "verify", "authentication", "context", "signature", "(", "authentication", "context", ",", "request", ",", "authn", "request", ",", "facade", ")", ";", "saml", "utils", "log", "saml", "object", "(", "saml", "profile", "handler", "configuration", "context", "get", "open", "saml", "config", "bean", "(", ")", ",", "authn", "request", ")", ";", "return", "pair", "of", "(", "registered", "service", ",", "facade", ")", ";", "}" ]
[ "writes", "a", "sub", "array", "as", "a", "sequence", "of", "bytes" ]
[ "public", "void", "write", "(", "byte", "[", "]", "b", ",", "int", "offset", ",", "int", "length", ")", "throws", "i", "o", "exception", "{", "check", "open", "(", ")", ";", "random", "access", "file", "write", "(", "b", ",", "offset", ",", "length", ")", ";", "buffer", "=", "empty", ";", "buffer", "offset", "=", "0", ";", "lastbuffer", "=", "empty", ";", "lastbuffer", "offset", "=", "0", ";", "}" ]
[ "for", "a", "given", "key", "and", "depth", ",", "returns", "how", "much", "the", "depth", "should", "be", "incremented", "by", "when", "resolving", "a", "keypath", "to", "children", "this", "can", "be", "0", "or", "2", "when", "there", "is", "a", "globstar", "and", "the", "next", "key", "either", "matches", "or", "doesn", "'", "t", "match", "the", "current", "key" ]
[ "public", "int", "increment", "depth", "by", "(", "string", "key", ",", "int", "depth", ")", "{", "if", "(", "is", "container", "(", "key", ")", ")", "{", "/", "/", "if", "it", "'", "s", "a", "container", "then", "we", "added", "programatically", "and", "it", "isn", "'", "t", "a", "part", "of", "the", "keypath", "return", "0", ";", "}", "if", "(", "!", "keys", "get", "(", "depth", ")", "equals", "(", "\"", "*", "*", "\"", ")", ")", "{", "/", "/", "if", "it", "'", "s", "not", "a", "globstar", "then", "it", "is", "part", "of", "the", "keypath", "return", "1", ";", "}", "if", "(", "depth", "=", "=", "keys", "size", "(", ")", "-", "1", ")", "{", "/", "/", "the", "last", "key", "is", "a", "globstar", "return", "0", ";", "}", "if", "(", "keys", "get", "(", "depth", "+", "1", ")", "equals", "(", "key", ")", ")", "{", "/", "/", "we", "are", "a", "globstar", "and", "the", "next", "key", "is", "our", "current", "key", "so", "consume", "both", "return", "2", ";", "}", "return", "0", ";", "}" ]
[ "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", "\"", ")", ";", "}" ]
[ "allocates", "some", "unpooled", "memory", "and", "creates", "a", "new", "memory", "segment", "that", "represents", "that", "memory" ]
[ "public", "heap", "memory", "segment", "allocate", "unpooled", "segment", "(", "int", "size", ",", "object", "owner", ")", "{", "return", "new", "heap", "memory", "segment", "(", "new", "byte", "[", "size", "]", ",", "owner", ")", ";", "}" ]
[ "get", "the", "value", "of", "the", "'", "{", "@", "code", "disabled", "}", "'", "attribute" ]
[ "protected", "boolean", "is", "disabled", "(", ")", "{", "return", "this", "disabled", ";", "}" ]
[ "return", "the", "wrapped", "{", "@", "link", "stomp", "decoder", "}" ]
[ "public", "final", "stomp", "decoder", "get", "stomp", "decoder", "(", ")", "{", "return", "this", "stomp", "decoder", ";", "}" ]
[ "add", "branch", "w", "delay", "slot", "(", "consumes", "4", "-", "bytes", ")" ]
[ "public", "void", "add", "bytes", "branch", "with", "delay", "slot", "(", "string", "addr", ",", "string", "dest", "addr", ")", "throws", "memory", "access", "exception", "{", "address", "address", "=", "addr", "(", "addr", ")", ";", "address", "dest", "=", "addr", "(", "dest", "addr", ")", ";", "short", "rel", "dest", "=", "get", "byte", "relative", "offset", "(", "address", ",", "dest", ")", ";", "add", "instruction", "words", "(", "address", ",", "(", "short", ")", "(", "0xe", "0", "0", "0", "|", "(", "rel", "dest", "<", "<", "4", ")", "|", "0xf", ")", ")", ";", "/", "/", "brds", "rel", "add", "bytes", "fallthrough", "(", "address", "get", "offset", "(", ")", "+", "2", ")", ";", "}" ]
[ "an", "extension", "is", "known", "to", "be", "installed", "if", "it", "has", "a", "valid", "installation", "path", "and", "that", "path", "contains", "a", "module", "manifest", "file", "note", ":", "the", "module", "manifest", "file", "is", "a", "marker", "that", "indicates", "several", "things", ";", "one", "of", "which", "is", "the", "installation", "status", "of", "an", "extension", "when", "a", "user", "marks", "an", "extension", "to", "be", "uninstalled", "(", "by", "checking", "the", "appropriate", "checkbox", "in", "the", "{", "@", "link", "extension", "table", "model", "}", ")", ",", "the", "only", "thing", "that", "is", "done", "is", "to", "remove", "this", "manifest", "file", ",", "which", "tells", "the", "{", "@", "link", "extension", "table", "provider", "}", "to", "remove", "the", "entire", "extension", "directory", "on", "the", "next", "launch" ]
[ "public", "boolean", "is", "installed", "(", ")", "{", "if", "(", "install", "path", "=", "=", "null", "|", "|", "install", "path", "is", "empty", "(", ")", ")", "{", "return", "false", ";", "}", "/", "/", "if", "running", "out", "of", "a", "jar", "and", "the", "install", "path", "is", "valid", ",", "just", "return", "true", "the", "alternative", "/", "/", "would", "be", "to", "inspect", "the", "jar", "and", "verify", "that", "the", "install", "path", "is", "there", "and", "is", "valid", ",", "but", "that", "'", "s", "/", "/", "overkill", "if", "(", "application", "in", "single", "jar", "mode", "(", ")", ")", "{", "return", "true", ";", "}", "file", "mm", "=", "new", "file", "(", "install", "path", ",", "module", "utilities", "manifest", "file", "name", ")", ";", "return", "mm", "exists", "(", ")", ";", "}" ]
[ "return", "a", "single", "annotation", "on", "the", "underlying", "method", "traversing", "its", "super", "methods", "if", "no", "annotation", "can", "be", "found", "on", "the", "given", "method", "itself", "also", "supports", "merged", "composed", "annotations", "with", "attribute", "overrides", "as", "of", "spring", "framework", "4", "2", "2" ]
[ "public", "<", "a", "extends", "annotation", ">", "a", "get", "method", "annotation", "(", "class", "<", "a", ">", "annotation", "type", ")", "{", "return", "annotated", "element", "utils", "find", "merged", "annotation", "(", "this", "method", ",", "annotation", "type", ")", ";", "}" ]