Datasets:
Anonymous2023
/
KGSum

Dataset card Data Studio Files Community
docstring_tokens
list
code_tokens
list
[ "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", "\"", ")", ";", "}" ]
[ "converts", "{", "@", "link", "join", "rel", "type", "}", "to", "{", "@", "link", "flink", "join", "type", "}" ]
[ "public", "static", "flink", "join", "type", "get", "flink", "join", "type", "(", "join", "rel", "type", "join", "rel", "type", ")", "{", "switch", "(", "join", "rel", "type", ")", "{", "case", "inner", ":", "return", "flink", "join", "type", "inner", ";", "case", "left", ":", "return", "flink", "join", "type", "left", ";", "case", "right", ":", "return", "flink", "join", "type", "right", ";", "case", "full", ":", "return", "flink", "join", "type", "full", ";", "case", "semi", ":", "return", "flink", "join", "type", "semi", ";", "case", "anti", ":", "return", "flink", "join", "type", "anti", ";", "default", ":", "throw", "new", "illegal", "argument", "exception", "(", "\"", "invalid", ":", "\"", "+", "join", "rel", "type", ")", ";", "}", "}" ]
[ "returns", "the", "value", "associated", "with", "{", "@", "code", "key", "}", "in", "this", "cache", ",", "first", "loading", "that", "value", "if", "necessary", "no", "observable", "state", "associated", "with", "this", "cache", "is", "modified", "until", "loading", "completes", "if", "another", "call", "to", "{", "@", "link", "#", "get", "}", "or", "{", "@", "link", "#", "get", "unchecked", "}", "is", "currently", "loading", "the", "value", "for", "{", "@", "code", "key", "}", ",", "simply", "waits", "for", "that", "thread", "to", "finish", "and", "returns", "its", "loaded", "value", "note", "that", "multiple", "threads", "can", "concurrently", "load", "values", "for", "distinct", "keys", "caches", "loaded", "by", "a", "{", "@", "link", "cache", "loader", "}", "will", "call", "{", "@", "link", "cache", "loader", "#", "load", "}", "to", "load", "new", "values", "into", "the", "cache", "newly", "loaded", "values", "are", "added", "to", "the", "cache", "using", "{", "@", "code", "cache", "as", "map", "(", ")", "put", "if", "absent", "}", "after", "loading", "has", "completed", ";", "if", "another", "value", "was", "associated", "with", "{", "@", "code", "key", "}", "while", "the", "new", "value", "was", "loading", "then", "a", "removal", "notification", "will", "be", "sent", "for", "the", "new", "value", "if", "the", "cache", "loader", "associated", "with", "this", "cache", "is", "known", "not", "to", "throw", "checked", "exceptions", ",", "then", "prefer", "{", "@", "link", "#", "get", "unchecked", "}", "over", "this", "method" ]
[ "v", "get", "(", "k", "key", ")", "throws", "execution", "exception", ";" ]
[ "utility", "function", "to", "add", "a", "new", "decoded", "data" ]
[ "protected", "void", "add", "http", "data", "(", "interface", "http", "data", "data", ")", "{", "if", "(", "data", "=", "=", "null", ")", "{", "return", ";", "}", "list", "<", "interface", "http", "data", ">", "datas", "=", "body", "map", "http", "data", "get", "(", "data", "get", "name", "(", ")", ")", ";", "if", "(", "datas", "=", "=", "null", ")", "{", "datas", "=", "new", "array", "list", "<", "interface", "http", "data", ">", "(", "1", ")", ";", "body", "map", "http", "data", "put", "(", "data", "get", "name", "(", ")", ",", "datas", ")", ";", "}", "datas", "add", "(", "data", ")", ";", "body", "list", "http", "data", "add", "(", "data", ")", ";", "}" ]
[ "return", "whether", "xml", "external", "entities", "are", "allowed" ]
[ "public", "boolean", "is", "process", "external", "entities", "(", ")", "{", "return", "this", "process", "external", "entities", ";", "}" ]
[ "the", "nonce", "provides", "a", "way", "for", "incremental", "mesh", "config", "requests", "to", "uniquely", "reference", "an", "incremental", "mesh", "config", "response", "the", "nonce", "is", "required", "<", "code", ">", "string", "nonce", "=", "4", ";", "<", "code", ">" ]
[ "public", "com", "google", "protobuf", "byte", "string", "get", "nonce", "bytes", "(", ")", "{", "java", "lang", "object", "ref", "=", "nonce", ";", "if", "(", "ref", "instanceof", "string", ")", "{", "com", "google", "protobuf", "byte", "string", "b", "=", "com", "google", "protobuf", "byte", "string", "copy", "from", "utf", "8", "(", "(", "java", "lang", "string", ")", "ref", ")", ";", "nonce", "=", "b", ";", "return", "b", ";", "}", "else", "{", "return", "(", "com", "google", "protobuf", "byte", "string", ")", "ref", ";", "}", "}" ]
[ "prepare", "the", "compressor", "to", "be", "used", "in", "a", "new", "stream", "with", "settings", "defined", "in", "the", "given", "configuration", "it", "will", "reset", "the", "compressor", "'", "s", "compression", "level", "and", "compression", "strategy" ]
[ "public", "void", "reinit", "(", "configuration", "conf", ")", "{", "if", "(", "conf", "=", "=", "null", ")", "{", "return", ";", "}", "level", "=", "z", "standard", "codec", "get", "compression", "level", "(", "conf", ")", ";", "reset", "(", ")", ";", "log", "debug", "(", "\"", "reinit", "compressor", "with", "new", "compression", "configuration", "\"", ")", ";", "}" ]
[ "set", "the", "list", "of", "preferred", "locales", ",", "in", "descending", "order", ",", "effectively", "replacing", "any", "existing", "locales" ]
[ "public", "void", "set", "preferred", "locales", "(", "list", "<", "locale", ">", "locales", ")", "{", "assert", "not", "empty", "(", "locales", ",", "\"", "locale", "list", "must", "not", "be", "empty", "\"", ")", ";", "this", "locales", "clear", "(", ")", ";", "this", "locales", "add", "all", "(", "locales", ")", ";", "update", "accept", "language", "header", "(", ")", ";", "}" ]
[ "sets", "the", "value", "of", "this", "dynamic", "the", "value", "could", "be", "an", "address", "or", "a", "number" ]
[ "public", "void", "set", "value", "(", "long", "value", ")", "{", "this", "d", "val", "=", "value", ";", "}" ]
[ "create", "a", "trash", "checkpoint" ]
[ "public", "void", "checkpoint", "(", ")", "throws", "i", "o", "exception", "{", "trash", "policy", "create", "checkpoint", "(", ")", ";", "}" ]
[ "the", "set", "of", "xml", "attributevalue", "pairs", "for", "this", "style", "<", "code", ">", "repeated", "aapt", "pb", "style", "entry", "entry", "=", "3", ";", "<", "code", ">" ]
[ "public", "com", "android", "aapt", "resources", "style", "entry", "get", "entry", "(", "int", "index", ")", "{", "return", "entry", "get", "(", "index", ")", ";", "}" ]
[ "return", "the", "time", "span", "by", "now", ",", "in", "unit", "the", "pattern", "is", "{", "@", "code", "yyyy", "-", "mm", "-", "dd", "hh", ":", "mm", ":", "ss", "}" ]
[ "public", "static", "long", "get", "time", "span", "by", "now", "(", "final", "string", "time", ",", "@", "time", "constants", "unit", "final", "int", "unit", ")", "{", "return", "get", "time", "span", "(", "time", ",", "get", "now", "string", "(", ")", ",", "get", "default", "format", "(", ")", ",", "unit", ")", ";", "}" ]
[ "like", "{", "@", "link", "#", "assert", "all", "semantic", "errors", "(", "string", ")", ",", "but", "a", "context", "is", "given" ]
[ "protected", "void", "assert", "all", "semantic", "errors", "(", "string", "assembly", ",", "string", "ctxstr", ")", "{", "run", "test", "(", "assembly", ",", "null", ",", "null", ",", "default", "addr", ",", "ctxstr", ",", "false", ",", "false", ",", "false", ",", "true", ")", ";", "}" ]
[ "removes", "a", "share", "buffer", "node", "from", "cache", "and", "state" ]
[ "void", "remove", "entry", "(", "node", "id", "node", "id", ")", "throws", "exception", "{", "this", "entry", "cache", "remove", "(", "node", "id", ")", ";", "this", "entries", "remove", "(", "node", "id", ")", ";", "}" ]
[ "update", "the", "widthheight", "spec", "this", "is", "useful", "if", "you", "are", "currently", "detached", "and", "are", "responding", "to", "a", "configuration", "change", "if", "you", "are", "currently", "attached", "then", "the", "host", "view", "is", "the", "source", "of", "truth", "for", "widthheight", ",", "so", "this", "call", "will", "be", "ignored" ]
[ "public", "void", "set", "size", "spec", "(", "int", "width", "spec", ",", "int", "height", "spec", ")", "{", "set", "size", "spec", "(", "width", "spec", ",", "height", "spec", ",", "null", ")", ";", "}" ]
[ "test", "for", "the", "deprecated", "apply", "(", "reducer", ",", "window", "function", ")" ]
[ "public", "void", "test", "apply", "with", "pre", "reducer", "and", "evictor", "(", ")", "throws", "exception", "{", "stream", "execution", "environment", "env", "=", "stream", "execution", "environment", "get", "execution", "environment", "(", ")", ";", "data", "stream", "<", "tuple", "2", "<", "string", ",", "integer", ">", ">", "source", "=", "env", "from", "elements", "(", "tuple", "2", "of", "(", "\"", "hello", "\"", ",", "1", ")", ",", "tuple", "2", "of", "(", "\"", "hello", "\"", ",", "2", ")", ")", ";", "dummy", "reducer", "reducer", "=", "new", "dummy", "reducer", "(", ")", ";", "data", "stream", "<", "tuple", "3", "<", "string", ",", "string", ",", "integer", ">", ">", "window", "=", "source", "key", "by", "(", "new", "tuple", "key", "selector", "(", ")", ")", "window", "(", "tumbling", "event", "time", "windows", "of", "(", "time", "of", "(", "1", ",", "time", "unit", "seconds", ")", ")", ")", "evictor", "(", "count", "evictor", "of", "(", "100", ")", ")", "apply", "(", "reducer", ",", "new", "window", "function", "<", "tuple", "2", "<", "string", ",", "integer", ">", ",", "tuple", "3", "<", "string", ",", "string", ",", "integer", ">", ",", "string", ",", "time", "window", ">", "(", ")", "{", "private", "static", "final", "long", "serial", "version", "u", "i", "d", "=", "1l", ";", "@", "override", "public", "void", "apply", "(", "string", "key", ",", "time", "window", "window", ",", "iterable", "<", "tuple", "2", "<", "string", ",", "integer", ">", ">", "values", ",", "collector", "<", "tuple", "3", "<", "string", ",", "string", ",", "integer", ">", ">", "out", ")", "throws", "exception", "{", "for", "(", "tuple", "2", "<", "string", ",", "integer", ">", "in", ":", "values", ")", "{", "out", "collect", "(", "new", "tuple", "3", "<", ">", "(", "in", "f", "0", ",", "in", "f", "0", ",", "in", "f", "1", ")", ")", ";", "}", "}", "}", ")", ";", "one", "input", "transformation", "<", "tuple", "2", "<", "string", ",", "integer", ">", ",", "tuple", "3", "<", "string", ",", "string", ",", "integer", ">", ">", "transform", "=", "(", "one", "input", "transformation", "<", "tuple", "2", "<", "string", ",", "integer", ">", ",", "tuple", "3", "<", "string", ",", "string", ",", "integer", ">", ">", ")", "window", "get", "transformation", "(", ")", ";", "one", "input", "stream", "operator", "<", "tuple", "2", "<", "string", ",", "integer", ">", ",", "tuple", "3", "<", "string", ",", "string", ",", "integer", ">", ">", "operator", "=", "transform", "get", "operator", "(", ")", ";", "assert", "assert", "true", "(", "operator", "instanceof", "window", "operator", ")", ";", "window", "operator", "<", "string", ",", "tuple", "2", "<", "string", ",", "integer", ">", ",", "?", ",", "?", ",", "?", ">", "win", "operator", "=", "(", "window", "operator", "<", "string", ",", "tuple", "2", "<", "string", ",", "integer", ">", ",", "?", ",", "?", ",", "?", ">", ")", "operator", ";", "assert", "assert", "true", "(", "win", "operator", "get", "trigger", "(", ")", "instanceof", "event", "time", "trigger", ")", ";", "assert", "assert", "true", "(", "win", "operator", "get", "window", "assigner", "(", ")", "instanceof", "tumbling", "event", "time", "windows", ")", ";", "assert", "assert", "true", "(", "win", "operator", "get", "state", "descriptor", "(", ")", "instanceof", "list", "state", "descriptor", ")", ";", "process", "element", "and", "ensure", "output", "(", "operator", ",", "win", "operator", "get", "key", "selector", "(", ")", ",", "basic", "type", "info", "string", "type", "info", ",", "new", "tuple", "2", "<", ">", "(", "\"", "hello", "\"", ",", "1", ")", ")", ";", "}" ]
[ "returns", "the", "next", "valid", "sequential", "call", "id", "by", "incrementing", "an", "atomic", "counter", "and", "masking", "off", "the", "sign", "bit", "valid", "call", "i", "ds", "are", "non", "-", "negative", "integers", "in", "the", "range", "[", "0", ",", "2", "^", "31", "-", "1", "]", "negative", "numbers", "are", "reserved", "for", "special", "purposes", "the", "values", "can", "overflow", "back", "to", "0", "and", "be", "reused", "note", "that", "prior", "versions", "of", "the", "client", "did", "not", "mask", "off", "the", "sign", "bit", ",", "so", "a", "server", "may", "still", "see", "a", "negative", "call", "id", "if", "it", "receives", "connections", "from", "an", "old", "client" ]
[ "public", "static", "int", "next", "call", "id", "(", ")", "{", "return", "call", "id", "counter", "get", "and", "increment", "(", ")", "&", "0x", "7", "f", "f", "f", "f", "f", "f", "f", ";", "}" ]
[ "creates", "new", "events", "for", "a", "a", "machine", "learning", "calendar", "asynchronously", ",", "notifies", "the", "listener", "on", "completion", "for", "additional", "info", "see", "<", "a", "href", "=", "\"", "https", ":", "www", "elastic", "coguideenelasticsearchreferencecurrentml", "-", "post", "-", "calendar", "-", "event", "html", "\"", ">", "add", "events", "to", "calendar", "api" ]
[ "public", "cancellable", "post", "calendar", "event", "async", "(", "post", "calendar", "event", "request", "request", ",", "request", "options", "options", ",", "action", "listener", "<", "post", "calendar", "event", "response", ">", "listener", ")", "{", "return", "rest", "high", "level", "client", "perform", "request", "async", "and", "parse", "entity", "(", "request", ",", "m", "l", "request", "converters", ":", ":", "post", "calendar", "events", ",", "options", ",", "post", "calendar", "event", "response", ":", ":", "from", "x", "content", ",", "listener", ",", "collections", "empty", "set", "(", ")", ")", ";", "}" ]
[ "invokes", "{", "@", "link", "video", "renderer", "event", "listener", "#", "on", "video", "disabled", "(", "decoder", "counters", ")", "}" ]
[ "public", "void", "disabled", "(", "decoder", "counters", "counters", ")", "{", "counters", "ensure", "updated", "(", ")", ";", "if", "(", "handler", "!", "=", "null", ")", "{", "handler", "post", "(", "(", ")", "-", ">", "{", "counters", "ensure", "updated", "(", ")", ";", "cast", "non", "null", "(", "listener", ")", "on", "video", "disabled", "(", "counters", ")", ";", "}", ")", ";", "}", "}" ]
[ "returns", "a", "collection", "view", "of", "all", "values", "associated", "with", "a", "key", "if", "no", "mappings", "in", "the", "multimap", "have", "the", "provided", "key", ",", "an", "empty", "collection", "is", "returned", "changes", "to", "the", "returned", "collection", "will", "update", "the", "underlying", "multimap", ",", "and", "vice", "versa", "because", "a", "{", "@", "code", "sorted", "set", "multimap", "}", "has", "unique", "sorted", "values", "for", "a", "given", "key", ",", "this", "method", "returns", "a", "{", "@", "link", "sorted", "set", "}", ",", "instead", "of", "the", "{", "@", "link", "collection", "}", "specified", "in", "the", "{", "@", "link", "multimap", "}", "interface" ]
[ "public", "sorted", "set", "<", "v", ">", "get", "(", "@", "nullable", "decl", "k", "key", ")", "{", "return", "(", "sorted", "set", "<", "v", ">", ")", "super", "get", "(", "key", ")", ";", "}" ]
[ "convenience", "method", "that", "retrieves", "the", "{", "@", "link", "#", "get", "output", "flash", "map", "\"", "output", "\"", "flash", "map", "}", ",", "updates", "it", "with", "the", "path", "and", "query", "params", "of", "the", "target", "url", ",", "and", "then", "saves", "it", "using", "the", "{", "@", "link", "#", "get", "flash", "map", "manager", "flash", "map", "manager", "}" ]
[ "public", "static", "void", "save", "output", "flash", "map", "(", "string", "location", ",", "http", "servlet", "request", "request", ",", "http", "servlet", "response", "response", ")", "{", "flash", "map", "flash", "map", "=", "get", "output", "flash", "map", "(", "request", ")", ";", "if", "(", "collection", "utils", "is", "empty", "(", "flash", "map", ")", ")", "{", "return", ";", "}", "uri", "components", "uri", "components", "=", "uri", "components", "builder", "from", "uri", "string", "(", "location", ")", "build", "(", ")", ";", "flash", "map", "set", "target", "request", "path", "(", "uri", "components", "get", "path", "(", ")", ")", ";", "flash", "map", "add", "target", "request", "params", "(", "uri", "components", "get", "query", "params", "(", ")", ")", ";", "flash", "map", "manager", "manager", "=", "get", "flash", "map", "manager", "(", "request", ")", ";", "assert", "state", "(", "manager", "!", "=", "null", ",", "\"", "no", "flash", "map", "manager", "is", "this", "a", "dispatcher", "servlet", "handled", "request", "?", "\"", ")", ";", "manager", "save", "output", "flash", "map", "(", "flash", "map", ",", "request", ",", "response", ")", ";", "}" ]
[ "updates", "the", "order", "of", "the", "actors", "in", "the", "tree", "for", "this", "node", "and", "all", "child", "nodes", "this", "is", "useful", "after", "changing", "the", "order", "of", "{", "@", "link", "#", "get", "children", "(", ")", "}" ]
[ "public", "void", "update", "children", "(", ")", "{", "if", "(", "!", "expanded", ")", "return", ";", "tree", "tree", "=", "get", "tree", "(", ")", ";", "if", "(", "tree", "=", "=", "null", ")", "return", ";", "object", "[", "]", "children", "=", "this", "children", "items", ";", "int", "n", "=", "this", "children", "size", ";", "int", "actor", "index", "=", "actor", "get", "z", "index", "(", ")", "+", "1", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "n", ";", "i", "+", "+", ")", "(", "(", "n", ")", "children", "[", "i", "]", ")", "remove", "from", "tree", "(", "tree", ",", "actor", "index", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "n", ";", "i", "+", "+", ")", "actor", "index", "+", "=", "(", "(", "n", ")", "children", "[", "i", "]", ")", "add", "to", "tree", "(", "tree", ",", "actor", "index", ")", ";", "}" ]
[ "increment", "the", "counter", "by", "{", "@", "code", "n", "}" ]
[ "public", "void", "inc", "(", "long", "n", ")", "{", "count", "add", "(", "n", ")", ";", "}" ]
[ "transition", "to", "the", "\"", "unattached", "\"", "state", "this", "means", "we", "have", "found", "an", "epoch", "greater", "than", "or", "equal", "to", "the", "current", "epoch", ",", "but", "wo", "do", "not", "yet", "know", "of", "the", "elected", "leader" ]
[ "public", "void", "transition", "to", "unattached", "(", "int", "epoch", ")", "throws", "i", "o", "exception", "{", "int", "current", "epoch", "=", "state", "epoch", "(", ")", ";", "if", "(", "epoch", "<", "=", "current", "epoch", ")", "{", "throw", "new", "illegal", "state", "exception", "(", "\"", "cannot", "transition", "to", "unattached", "with", "epoch", "=", "\"", "+", "epoch", "+", "\"", "from", "current", "state", "\"", "+", "state", ")", ";", "}", "final", "long", "election", "timeout", "ms", ";", "if", "(", "is", "observer", "(", ")", ")", "{", "election", "timeout", "ms", "=", "long", "max", "value", ";", "}", "else", "if", "(", "is", "candidate", "(", ")", ")", "{", "election", "timeout", "ms", "=", "candidate", "state", "or", "throw", "(", ")", "remaining", "election", "time", "ms", "(", "time", "milliseconds", "(", ")", ")", ";", "}", "else", "if", "(", "is", "voted", "(", ")", ")", "{", "election", "timeout", "ms", "=", "voted", "state", "or", "throw", "(", ")", "remaining", "election", "time", "ms", "(", "time", "milliseconds", "(", ")", ")", ";", "}", "else", "if", "(", "is", "unattached", "(", ")", ")", "{", "election", "timeout", "ms", "=", "unattached", "state", "or", "throw", "(", ")", "remaining", "election", "time", "ms", "(", "time", "milliseconds", "(", ")", ")", ";", "}", "else", "{", "election", "timeout", "ms", "=", "random", "election", "timeout", "ms", "(", ")", ";", "}", "transition", "to", "(", "new", "unattached", "state", "(", "time", ",", "epoch", ",", "voters", ",", "state", "high", "watermark", "(", ")", ",", "election", "timeout", "ms", ")", ")", ";", "}" ]
[ "get", "integer", "item" ]
[ "public", "integer", "get", "integer", "item", "(", ")", "{", "return", "integer", "item", ";", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "void", "set", "ref", "(", "int", "parameter", "index", ",", "ref", "x", ")", "throws", "s", "q", "l", "exception", "{", "}" ]
[ "customize", "the", "response", "for", "no", "handler", "found", "exception", "this", "method", "delegates", "to", "{", "@", "link", "#", "handle", "exception", "internal", "}" ]
[ "protected", "response", "entity", "<", "object", ">", "handle", "no", "handler", "found", "exception", "(", "no", "handler", "found", "exception", "ex", ",", "http", "headers", "headers", ",", "http", "status", "status", ",", "web", "request", "request", ")", "{", "return", "handle", "exception", "internal", "(", "ex", ",", "null", ",", "headers", ",", "status", ",", "request", ")", ";", "}" ]
[ "set", "the", "base", "name", "used", "for", "all", "components", "of", "the", "join", ",", "this", "may", "include", "any", "repartition", "topics", "created", "to", "complete", "the", "join" ]
[ "public", "joined", "<", "k", ",", "v", ",", "vo", ">", "with", "name", "(", "final", "string", "name", ")", "{", "return", "new", "joined", "<", ">", "(", "key", "serde", ",", "value", "serde", ",", "other", "value", "serde", ",", "name", ")", ";", "}" ]
[ "emulation", "callback", "immediately", "following", "execution", "of", "the", "last", "execute", "address", "one", "use", "of", "this", "callback", "is", "to", "modify", "the", "flowingfuture", "context", "state" ]
[ "public", "void", "post", "execute", "callback", "(", "emulate", "emulate", ",", "address", "last", "execute", "address", ",", "pcode", "op", "[", "]", "last", "execute", "pcode", ",", "int", "last", "pcode", "index", ",", "address", "current", "address", ")", "throws", "lowlevel", "error", "{", "/", "/", "no", "default", "implementation", "}" ]
[ "gets", "underlying", "{", "@", "code", "type", "}", "instance" ]
[ "public", "final", "type", "get", "type", "(", ")", "{", "return", "type", ";", "}" ]
[ "test", "load", "by", "class", "and", "class", "loader" ]
[ "public", "void", "test", "load", "by", "class", "and", "class", "loader", "(", ")", "{", "hello", "load", "=", "enhanced", "service", "loader", "load", "(", "hello", "class", ",", "hello", "class", "get", "class", "loader", "(", ")", ")", ";", "assertions", "assert", "equals", "(", "load", "say", "(", ")", ",", "\"", "olá", "\"", ")", ";", "}" ]
[ "adds", "the", "specified", "data", "type", "at", "the", "specified", "component", "index", "whether", "an", "insert", "or", "replace", "occurs", "depends", "on", "whether", "the", "indicated", "index", "is", "in", "a", "selection", "and", "whether", "in", "locked", "or", "unlocked", "mode" ]
[ "public", "data", "type", "component", "add", "(", "int", "row", "index", ",", "data", "type", "dt", ",", "int", "dt", "length", ")", "throws", "usr", "exception", "{", "data", "type", "component", "dtc", "=", "null", ";", "if", "(", "row", "index", "<", "get", "num", "components", "(", ")", ")", "{", "field", "range", "range", "=", "get", "selected", "range", "containing", "(", "row", "index", ")", ";", "if", "(", "(", "range", "=", "=", "null", ")", "|", "|", "(", "range", "get", "start", "(", ")", "get", "index", "(", ")", "int", "value", "(", ")", "=", "=", "range", "get", "end", "(", ")", "get", "index", "(", ")", "int", "value", "(", ")", "-", "1", ")", ")", "{", "dtc", "=", "replace", "(", "row", "index", ",", "dt", ",", "dt", "length", ")", ";", "}", "else", "{", "dtc", "=", "replace", "component", "range", "(", "range", "get", "start", "(", ")", "get", "index", "(", ")", "int", "value", "(", ")", ",", "range", "get", "end", "(", ")", "get", "index", "(", ")", "int", "value", "(", ")", "-", "1", ",", "dt", ",", "dt", "length", ")", ";", "}", "}", "else", "{", "dtc", "=", "insert", "(", "row", "index", ",", "dt", ",", "dt", "length", ")", ";", "}", "return", "dtc", ";", "}" ]
[ "compute", "the", "quota", "usage", "change", "for", "a", "truncate", "op" ]
[ "void", "compute", "quota", "delta", "for", "truncate", "(", "long", "new", "length", ",", "block", "storage", "policy", "bsps", ",", "quota", "counts", "delta", ")", "{", "final", "block", "info", "[", "]", "blocks", "=", "get", "blocks", "(", ")", ";", "if", "(", "blocks", "length", "=", "=", "0", ")", "{", "return", ";", "}", "long", "size", "=", "0", ";", "for", "(", "block", "info", "b", ":", "blocks", ")", "{", "size", "+", "=", "b", "get", "num", "bytes", "(", ")", ";", "}", "block", "info", "[", "]", "sblocks", "=", "null", ";", "file", "with", "snapshot", "feature", "sf", "=", "get", "file", "with", "snapshot", "feature", "(", ")", ";", "if", "(", "sf", "!", "=", "null", ")", "{", "file", "diff", "diff", "=", "sf", "get", "diffs", "(", ")", "get", "last", "(", ")", ";", "sblocks", "=", "diff", "!", "=", "null", "?", "diff", "get", "blocks", "(", ")", ":", "null", ";", "}", "for", "(", "int", "i", "=", "blocks", "length", "-", "1", ";", "i", ">", "=", "0", "&", "&", "size", ">", "new", "length", ";", "size", "-", "=", "blocks", "[", "i", "]", "get", "num", "bytes", "(", ")", ",", "-", "-", "i", ")", "{", "block", "info", "bi", "=", "blocks", "[", "i", "]", ";", "long", "truncated", "bytes", ";", "if", "(", "size", "-", "new", "length", "<", "bi", "get", "num", "bytes", "(", ")", ")", "{", "/", "/", "record", "a", "full", "block", "as", "the", "last", "block", "will", "be", "copied", "during", "/", "/", "recovery", "truncated", "bytes", "=", "bi", "get", "num", "bytes", "(", ")", "-", "get", "preferred", "block", "size", "(", ")", ";", "}", "else", "{", "truncated", "bytes", "=", "bi", "get", "num", "bytes", "(", ")", ";", "}", "/", "/", "the", "block", "exist", "in", "snapshot", ",", "adding", "back", "the", "truncated", "bytes", "in", "the", "/", "/", "existing", "files", "if", "(", "sblocks", "!", "=", "null", "&", "&", "i", "<", "sblocks", "length", "&", "&", "bi", "equals", "(", "sblocks", "[", "i", "]", ")", ")", "{", "truncated", "bytes", "-", "=", "bi", "get", "num", "bytes", "(", ")", ";", "}", "delta", "add", "storage", "space", "(", "-", "truncated", "bytes", "*", "bi", "get", "replication", "(", ")", ")", ";", "if", "(", "bsps", "!", "=", "null", ")", "{", "list", "<", "storage", "type", ">", "types", "=", "bsps", "choose", "storage", "types", "(", "bi", "get", "replication", "(", ")", ")", ";", "for", "(", "storage", "type", "t", ":", "types", ")", "{", "if", "(", "t", "support", "type", "quota", "(", ")", ")", "{", "delta", "add", "type", "space", "(", "t", ",", "-", "truncated", "bytes", ")", ";", "}", "}", "}", "}", "}" ]
[ "a", "sensible", "definition", "of", "{", "@", "link", "#", "poll", "last", "entry", "(", ")", "}", "in", "terms", "of", "{", "@", "code", "descending", "multiset", "(", ")", "entry", "set", "(", ")", "iterator", "(", ")", "}", "if", "you", "override", "{", "@", "link", "#", "descending", "multiset", "(", ")", "}", "or", "{", "@", "link", "#", "entry", "set", "(", ")", "}", ",", "you", "may", "wish", "to", "override", "{", "@", "link", "#", "poll", "last", "entry", "(", ")", "}", "to", "forward", "to", "this", "implementation" ]
[ "protected", "entry", "<", "e", ">", "standard", "poll", "last", "entry", "(", ")", "{", "iterator", "<", "entry", "<", "e", ">", ">", "entry", "iterator", "=", "descending", "multiset", "(", ")", "entry", "set", "(", ")", "iterator", "(", ")", ";", "if", "(", "!", "entry", "iterator", "has", "next", "(", ")", ")", "{", "return", "null", ";", "}", "entry", "<", "e", ">", "entry", "=", "entry", "iterator", "next", "(", ")", ";", "entry", "=", "multisets", "immutable", "entry", "(", "entry", "get", "element", "(", ")", ",", "entry", "get", "count", "(", ")", ")", ";", "entry", "iterator", "remove", "(", ")", ";", "return", "entry", ";", "}" ]
[ "test", "the", "property", "'", "small", "camel", "'" ]
[ "public", "void", "small", "camel", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "small", "camel", "}" ]
[ "return", "a", "logger", "to", "set", "on", "{", "@", "link", "invocable", "handler", "method", "}" ]
[ "protected", "log", "get", "handler", "method", "logger", "(", ")", "{", "return", "null", ";", "}" ]
[ "convert", "a", "value", "from", "its", "logical", "format", "(", "time", ")", "to", "it", "'", "s", "encoded", "format" ]
[ "public", "static", "int", "from", "logical", "(", "schema", "schema", ",", "java", "util", "date", "value", ")", "{", "if", "(", "!", "(", "logical", "name", "equals", "(", "schema", "name", "(", ")", ")", ")", ")", "throw", "new", "data", "exception", "(", "\"", "requested", "conversion", "of", "time", "object", "but", "the", "schema", "does", "not", "match", "\"", ")", ";", "calendar", "calendar", "=", "calendar", "get", "instance", "(", "utc", ")", ";", "calendar", "set", "time", "(", "value", ")", ";", "long", "unix", "millis", "=", "calendar", "get", "time", "in", "millis", "(", ")", ";", "if", "(", "unix", "millis", "<", "0", "|", "|", "unix", "millis", ">", "millis", "per", "day", ")", "{", "throw", "new", "data", "exception", "(", "\"", "kafka", "connect", "time", "type", "should", "not", "have", "any", "date", "fields", "set", "to", "non", "-", "zero", "values", "\"", ")", ";", "}", "return", "(", "int", ")", "unix", "millis", ";", "}" ]
[ "return", "the", "sim", "operator", "name" ]
[ "public", "static", "string", "get", "sim", "operator", "name", "(", ")", "{", "telephony", "manager", "tm", "=", "get", "telephony", "manager", "(", ")", ";", "return", "tm", "get", "sim", "operator", "name", "(", ")", ";", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "string", "insn", "arg", "string", "(", "dalv", "insn", "insn", ")", "{", "register", "spec", "list", "regs", "=", "insn", "get", "registers", "(", ")", ";", "return", "regs", "get", "(", "0", ")", "reg", "string", "(", ")", "+", "\"", ",", "\"", "+", "branch", "string", "(", "insn", ")", ";", "}" ]
[ "called", "for", "each", "file", "and", "directory", "that", "matches", "the", "criteria", "implied", "by", "{", "@", "link", "dir", "scanner", "}" ]
[ "public", "abstract", "void", "visit", "(", "file", "f", ",", "string", "relative", "path", ")", "throws", "i", "o", "exception", ";" ]
[ "gets", "the", "name", "node", "for", "the", "index", "may", "be", "null" ]
[ "public", "name", "node", "get", "name", "node", "(", "int", "nn", "index", ")", "{", "return", "get", "n", "n", "(", "nn", "index", ")", "name", "node", ";", "}" ]
[ "checks", "if", "byte", "array", "interpreted", "as", "sequence", "of", "bytes", "starts", "with", "pattern", "starting", "at", "position", "equal", "to", "offset" ]
[ "public", "static", "boolean", "starts", "with", "pattern", "(", "final", "byte", "[", "]", "byte", "array", ",", "final", "byte", "[", "]", "pattern", ")", "{", "return", "has", "pattern", "at", "(", "byte", "array", ",", "pattern", ",", "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", "\"", ")", ";", "}" ]
[ "returns", "time", "duration", "of", "allowed", "inactivity", "after", "which", "a", "part", "file", "will", "have", "to", "roll" ]
[ "public", "long", "get", "inactivity", "interval", "(", ")", "{", "return", "inactivity", "interval", ";", "}" ]
[ "returns", "the", "resource", "type", "name" ]
[ "public", "string", "get", "name", "(", ")", "{", "return", "name", ";", "}" ]
[ "sets", "server", "message", "sender" ]
[ "public", "void", "set", "server", "message", "sender", "(", "remoting", "server", "remoting", "server", ")", "{", "this", "remoting", "server", "=", "remoting", "server", ";", "}" ]
[ "returns", "the", "key", "used", "to", "lookup", "this", "system", "property" ]
[ "public", "string", "key", "(", ")", "{", "return", "key", ";", "}" ]
[ "get", "the", "count", "of", "bytes", "submitted" ]
[ "public", "long", "get", "bytes", "submitted", "(", ")", "{", "return", "bytes", "submitted", ";", "}" ]
[ "find", "the", "fields", "constant", "that", "matches", "name", ",", "or", "null", "if", "its", "not", "found" ]
[ "public", "static", "fields", "find", "by", "name", "(", "string", "name", ")", "{", "return", "by", "name", "get", "(", "name", ")", ";", "}" ]
[ "optimization", "to", "avoid", "autoboxing" ]
[ "public", "int", "get", "start", "value", "int", "(", ")", "{", "if", "(", "start", "value", "int", "=", "=", "unset", "int", ")", "{", "start", "value", "int", "=", "(", "int", ")", "(", "integer", ")", "start", "value", ";", "}", "return", "start", "value", "int", ";", "}" ]
[ "register", "any", "commands", "to", "be", "used", "on", "the", "client", "side", ",", "e", "g", "sent", "from", "an", "in", "-", "game", "player" ]
[ "public", "void", "register", "client", "commands", "(", "command", "handler", "handler", ")", "{", "}" ]
[ "get", "length", "cm" ]
[ "public", "big", "decimal", "get", "length", "cm", "(", ")", "{", "return", "length", "cm", ";", "}" ]
[ "returns", "the", "item", "at", "the", "given", "index", "in", "the", "media", "queue" ]
[ "public", "media", "item", "get", "item", "(", "int", "position", ")", "{", "return", "media", "queue", "get", "(", "position", ")", ";", "}" ]
[ "get", "modified", "time", "for", "child", "if", "the", "child", "is", "present", "in", "mount", "table", "it", "will", "return", "the", "modified", "time", "if", "the", "child", "is", "not", "present", "but", "subdirs", "of", "this", "child", "are", "present", "then", "it", "will", "return", "latest", "modified", "subdir", "'", "s", "time", "as", "modified", "time", "of", "the", "requested", "child" ]
[ "private", "long", "get", "modified", "time", "(", "map", "<", "string", ",", "long", ">", "ret", ",", "string", "path", ",", "string", "child", ")", "{", "mount", "table", "resolver", "mount", "table", "=", "(", "mount", "table", "resolver", ")", "subcluster", "resolver", ";", "string", "src", "path", ";", "if", "(", "path", "equals", "(", "path", "separator", ")", ")", "{", "src", "path", "=", "path", "separator", "+", "child", ";", "}", "else", "{", "src", "path", "=", "path", "+", "path", "separator", "+", "child", ";", "}", "long", "mod", "time", "=", "0l", ";", "try", "{", "/", "/", "get", "mount", "table", "entry", "for", "the", "src", "path", "mount", "table", "entry", "=", "mount", "table", "get", "mount", "point", "(", "src", "path", ")", ";", "/", "/", "if", "src", "path", "is", "not", "in", "mount", "table", "but", "its", "subdirs", "are", "in", "mount", "/", "/", "table", "we", "will", "display", "latest", "modified", "subdir", "date", "/", "time", "if", "(", "entry", "=", "=", "null", ")", "{", "list", "<", "mount", "table", ">", "entries", "=", "mount", "table", "get", "mounts", "(", "src", "path", ")", ";", "for", "(", "mount", "table", "each", "entry", ":", "entries", ")", "{", "/", "/", "get", "the", "latest", "date", "if", "(", "ret", "get", "(", "child", ")", "=", "=", "null", "|", "|", "ret", "get", "(", "child", ")", "<", "each", "entry", "get", "date", "modified", "(", ")", ")", "{", "mod", "time", "=", "each", "entry", "get", "date", "modified", "(", ")", ";", "}", "}", "}", "else", "{", "mod", "time", "=", "entry", "get", "date", "modified", "(", ")", ";", "}", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "log", "error", "(", "\"", "cannot", "get", "mount", "point", "\"", ",", "e", ")", ";", "}", "return", "mod", "time", ";", "}" ]
[ "gets", "information", "about", "why", "a", "property", "was", "set", "typically", "this", "is", "the", "path", "to", "the", "resource", "objects", "(", "file", ",", "url", ",", "etc", ")", "the", "property", "came", "from", ",", "but", "it", "can", "also", "indicate", "that", "it", "was", "set", "programatically", ",", "or", "because", "of", "the", "command", "line" ]
[ "public", "synchronized", "string", "[", "]", "get", "property", "sources", "(", "string", "name", ")", "{", "if", "(", "properties", "=", "=", "null", ")", "{", "/", "/", "if", "properties", "is", "null", ",", "it", "means", "a", "resource", "was", "newly", "added", "/", "/", "but", "the", "props", "were", "cleared", "so", "as", "to", "load", "it", "upon", "future", "/", "/", "requests", "so", "lets", "force", "a", "load", "by", "asking", "a", "properties", "list", "get", "props", "(", ")", ";", "}", "/", "/", "return", "a", "null", "right", "away", "if", "our", "properties", "still", "/", "/", "haven", "'", "t", "loaded", "or", "the", "resource", "mapping", "isn", "'", "t", "defined", "if", "(", "properties", "=", "=", "null", "|", "|", "updating", "resource", "=", "=", "null", ")", "{", "return", "null", ";", "}", "else", "{", "string", "[", "]", "source", "=", "updating", "resource", "get", "(", "name", ")", ";", "if", "(", "source", "=", "=", "null", ")", "{", "return", "null", ";", "}", "else", "{", "return", "arrays", "copy", "of", "(", "source", ",", "source", "length", ")", ";", "}", "}", "}" ]
[ "<", "code", ">", "optional", "int", "3", "2", "blah", "=", "1", ";", "<", "code", ">" ]
[ "public", "boolean", "has", "blah", "(", ")", "{", "return", "(", "(", "bit", "field", "0", "&", "0x", "0", "0", "0", "0", "0", "0", "0", "1", ")", "=", "=", "0x", "0", "0", "0", "0", "0", "0", "0", "1", ")", ";", "}" ]
[ "returns", "test", "timeout", "of", "the", "given", "test", "target", "using", "explicitly", "specified", "timeout", "or", "default", "through", "to", "the", "size", "label", "'", "s", "associated", "default" ]
[ "public", "static", "test", "timeout", "get", "test", "timeout", "(", "rule", "test", "target", ")", "{", "string", "attr", "=", "nonconfigurable", "attribute", "mapper", "of", "(", "test", "target", ")", "get", "(", "\"", "timeout", "\"", ",", "type", "string", ")", ";", "if", "(", "!", "attr", "equals", "(", "attr", "to", "lower", "case", "(", ")", ")", ")", "{", "return", "null", ";", "/", "/", "attribute", "values", "must", "be", "lowercase", "}", "try", "{", "return", "test", "timeout", "value", "of", "(", "attr", "to", "upper", "case", "(", "locale", "english", ")", ")", ";", "}", "catch", "(", "illegal", "argument", "exception", "e", ")", "{", "return", "null", ";", "}", "}" ]
[ "runs", "{", "@", "link", "#", "test", "method", "}", "on", "every", "public", "static", "method", "of", "class", "{", "@", "code", "c", "}", ",", "including", "those", "\"", "inherited", "\"", "from", "superclasses", "of", "the", "same", "package" ]
[ "public", "void", "test", "all", "public", "static", "methods", "(", "class", "<", "?", ">", "c", ")", "{", "test", "static", "methods", "(", "c", ",", "visibility", "public", ")", ";", "}" ]
[ "return", "the", "bean", "name", "for", "this", "message", "channel" ]
[ "public", "string", "get", "bean", "name", "(", ")", "{", "return", "this", "bean", "name", ";", "}" ]
[ "returns", "the", "id", "of", "the", "{", "@", "link", "data", "stream", "}", "in", "the", "current", "{", "@", "link", "stream", "execution", "environment", "}" ]
[ "public", "int", "get", "id", "(", ")", "{", "return", "transformation", "get", "id", "(", ")", ";", "}" ]
[ "emit", "a", "message", "that", "can", "be", "logged", "or", "escalated", "by", "the", "logger", "implementation" ]
[ "public", "static", "void", "emit", "message", "(", "log", "level", "level", ",", "string", "category", "key", ",", "string", "message", ",", "int", "sampling", "frequency", ")", "{", "error", "reporter", "get", "instance", "(", ")", "report", "(", "map", "(", "level", ")", ",", "category", "key", ",", "message", ",", "sampling", "frequency", ")", ";", "}" ]
[ "initialize", "a", "codec", "and", "add", "it", "to", "the", "list" ]
[ "protected", "<", "t", ">", "void", "add", "codec", "(", "list", "<", "t", ">", "codecs", ",", "t", "codec", ")", "{", "init", "codec", "(", "codec", ")", ";", "codecs", "add", "(", "codec", ")", ";", "}" ]
[ "if", "the", "undo", "log", "content", "is", "big", "enough", "to", "be", "compress" ]
[ "protected", "boolean", "need", "compress", "(", "byte", "[", "]", "undo", "log", "content", ")", "{", "return", "rollback", "info", "compress", "enable", "&", "&", "undo", "log", "content", "length", ">", "rollback", "info", "compress", "threshold", ";", "}" ]
[ "deserializes", "this", "{", "@", "link", "dense", "integer", "array", "}" ]
[ "public", "void", "parse", "(", "pdb", "byte", "reader", "reader", ",", "task", "monitor", "monitor", ")", "throws", "pdb", "exception", ",", "cancelled", "exception", "{", "array", "clear", "(", ")", ";", "int", "array", "size", "=", "reader", "parse", "int", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "array", "size", ";", "i", "+", "+", ")", "{", "monitor", "check", "canceled", "(", ")", ";", "int", "val", "=", "reader", "parse", "int", "(", ")", ";", "array", "add", "(", "val", ")", ";", "}", "}" ]
[ "the", "timer", "is", "stop" ]
[ "boolean", "is", "stop", "(", ")", ";" ]
[ "detects", "a", "pdf417", "code", "in", "an", "image", "checks", "0", ",", "90", ",", "180", ",", "and", "270", "degree", "rotations" ]
[ "public", "static", "p", "d", "f", "4", "1", "7", "detector", "result", "detect", "(", "binary", "bitmap", "image", ",", "map", "<", "decode", "hint", "type", ",", "?", ">", "hints", ",", "boolean", "multiple", ")", "throws", "not", "found", "exception", "{", "/", "/", "todo", "detection", "improvement", ",", "try", "harder", "could", "try", "several", "different", "luminance", "thresholds", "/", "blackpoints", "or", "even", "/", "/", "different", "binarizers", "/", "/", "boolean", "try", "harder", "=", "hints", "!", "=", "null", "&", "&", "hints", "contains", "key", "(", "decode", "hint", "type", "try", "harder", ")", ";", "bit", "matrix", "bit", "matrix", "=", "image", "get", "black", "matrix", "(", ")", ";", "list", "<", "result", "point", "[", "]", ">", "barcode", "coordinates", "=", "detect", "(", "multiple", ",", "bit", "matrix", ")", ";", "/", "/", "try", "180", ",", "270", ",", "90", "degree", "rotations", ",", "in", "that", "order", "for", "(", "int", "rotate", "=", "0", ";", "barcode", "coordinates", "is", "empty", "(", ")", "&", "&", "rotate", "<", "3", ";", "rotate", "+", "+", ")", "{", "bit", "matrix", "=", "bit", "matrix", "clone", "(", ")", ";", "if", "(", "rotate", "!", "=", "1", ")", "{", "bit", "matrix", "rotate", "1", "8", "0", "(", ")", ";", "}", "else", "{", "bit", "matrix", "rotate", "9", "0", "(", ")", ";", "}", "barcode", "coordinates", "=", "detect", "(", "multiple", ",", "bit", "matrix", ")", ";", "}", "return", "new", "p", "d", "f", "4", "1", "7", "detector", "result", "(", "bit", "matrix", ",", "barcode", "coordinates", ")", ";", "}" ]
[ "returns", "the", "symlink", "definitions", "introduced", "by", "the", "fragments", "registered", "with", "this", "rule", "class", "provider", "this", "only", "includes", "definitions", "added", "by", "{", "@", "link", "#", "add", "symlink", "definition", "}", ",", "not", "the", "standard", "symlinks", "in", "{", "@", "link", "convenience", "symlinks", "#", "get", "standard", "link", "definitions", "}", "note", ":", "usages", "of", "custom", "symlink", "definitions", "should", "be", "rare", "currently", "it", "is", "only", "used", "to", "implement", "the", "py", "2", "-", "bin", "py", "3", "-", "bin", "symlinks" ]
[ "public", "immutable", "list", "<", "symlink", "definition", ">", "get", "symlink", "definitions", "(", ")", "{", "return", "symlink", "definitions", ";", "}" ]
[ "we", "don", "'", "t", "know", "which", "codesources", "belong", "to", "which", "plugin", ",", "so", "just", "remove", "the", "permission", "from", "key", "codebases", "like", "core", ",", "test", "-", "framework", ",", "etc", "this", "way", "tests", "fail", "if", "accesscontroller", "blocks", "are", "missing" ]
[ "static", "map", "<", "string", ",", "policy", ">", "get", "plugin", "permissions", "(", ")", "throws", "exception", "{", "list", "<", "url", ">", "plugin", "policies", "=", "collections", "list", "(", "bootstrap", "for", "testing", "class", "get", "class", "loader", "(", ")", "get", "resources", "(", "plugin", "info", "es", "plugin", "policy", ")", ")", ";", "if", "(", "plugin", "policies", "is", "empty", "(", ")", ")", "{", "return", "collections", "empty", "map", "(", ")", ";", "}", "/", "/", "compute", "classpath", "minus", "obvious", "places", ",", "all", "other", "jars", "will", "get", "the", "permission", "set", "<", "url", ">", "codebases", "=", "new", "hash", "set", "<", ">", "(", "parse", "class", "path", "with", "symlinks", "(", ")", ")", ";", "set", "<", "url", ">", "excluded", "=", "new", "hash", "set", "<", ">", "(", "arrays", "as", "list", "(", "/", "/", "es", "core", "bootstrap", "class", "get", "protection", "domain", "(", ")", "get", "code", "source", "(", ")", "get", "location", "(", ")", ",", "/", "/", "es", "test", "framework", "bootstrap", "for", "testing", "class", "get", "protection", "domain", "(", ")", "get", "code", "source", "(", ")", "get", "location", "(", ")", ",", "/", "/", "lucene", "test", "framework", "lucene", "test", "case", "class", "get", "protection", "domain", "(", ")", "get", "code", "source", "(", ")", "get", "location", "(", ")", ",", "/", "/", "randomized", "runner", "randomized", "runner", "class", "get", "protection", "domain", "(", ")", "get", "code", "source", "(", ")", "get", "location", "(", ")", ",", "/", "/", "junit", "library", "assert", "class", "get", "protection", "domain", "(", ")", "get", "code", "source", "(", ")", "get", "location", "(", ")", ")", ")", ";", "codebases", "remove", "all", "(", "excluded", ")", ";", "final", "map", "<", "string", ",", "url", ">", "codebases", "map", "=", "policy", "util", "get", "codebase", "jar", "map", "(", "codebases", ")", ";", "/", "/", "parse", "each", "policy", "file", ",", "with", "codebase", "substitution", "from", "the", "classpath", "final", "list", "<", "policy", ">", "policies", "=", "new", "array", "list", "<", ">", "(", "plugin", "policies", "size", "(", ")", ")", ";", "for", "(", "url", "policy", "file", ":", "plugin", "policies", ")", "{", "map", "<", "string", ",", "url", ">", "policy", "codebases", "=", "codebases", "map", ";", "/", "/", "if", "the", "codebases", "file", "is", "inside", "a", "jar", ",", "then", "we", "don", "'", "t", "need", "to", "load", "it", "since", "the", "jar", "will", "/", "/", "have", "already", "been", "read", "from", "the", "classpath", "if", "(", "policy", "file", "to", "string", "(", ")", "contains", "(", "\"", "jar", "!", "\"", ")", "=", "=", "false", ")", "{", "path", "policy", "path", "=", "path", "utils", "get", "(", "policy", "file", "to", "u", "r", "i", "(", ")", ")", ";", "path", "codebases", "path", "=", "policy", "path", "get", "parent", "(", ")", "resolve", "(", "\"", "plugin", "-", "security", "codebases", "\"", ")", ";", "if", "(", "files", "exists", "(", "codebases", "path", ")", ")", "{", "/", "/", "load", "codebase", "to", "class", "map", "used", "for", "tests", "policy", "codebases", "=", "new", "hash", "map", "<", ">", "(", "codebases", "map", ")", ";", "map", "<", "string", ",", "string", ">", "codebases", "props", "=", "parse", "properties", "file", "(", "codebases", "path", ")", ";", "for", "(", "var", "entry", ":", "codebases", "props", "entry", "set", "(", ")", ")", "{", "add", "class", "codebase", "(", "policy", "codebases", ",", "entry", "get", "key", "(", ")", ",", "entry", "get", "value", "(", ")", ")", ";", "}", "}", "}", "policies", "add", "(", "policy", "util", "read", "policy", "(", "policy", "file", ",", "policy", "codebases", ")", ")", ";", "}", "/", "/", "consult", "each", "policy", "file", "for", "those", "codebases", "map", "<", "string", ",", "policy", ">", "map", "=", "new", "hash", "map", "<", ">", "(", ")", ";", "for", "(", "url", "url", ":", "codebases", ")", "{", "map", "put", "(", "url", "get", "file", "(", ")", ",", "new", "policy", "(", ")", "{", "@", "override", "public", "boolean", "implies", "(", "protection", "domain", "domain", ",", "permission", "permission", ")", "{", "/", "/", "implements", "union", "for", "(", "policy", "p", ":", "policies", ")", "{", "if", "(", "p", "implies", "(", "domain", ",", "permission", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}", "}", ")", ";", "}", "return", "collections", "unmodifiable", "map", "(", "map", ")", ";", "}" ]
[ "redirects", "any", "http", "request", "of", "type", "put", "on", "'", "from", "path", "'", "to", "'", "to", "path", "'" ]
[ "public", "void", "put", "(", "string", "from", "path", ",", "string", "to", "path", ")", "{", "put", "(", "from", "path", ",", "to", "path", ",", "null", ")", ";", "}" ]
[ "stub", "image", "will", "be", "displayed", "in", "{", "@", "link", "com", "nostra", "1", "3", "universalimageloader", "core", "imageaware", "image", "aware", "image", "aware", "view", "}", "during", "image", "loading" ]
[ "public", "builder", "show", "stub", "image", "(", "int", "image", "res", ")", "{", "image", "res", "on", "loading", "=", "image", "res", ";", "return", "this", ";", "}" ]
[ "returns", "a", "{", "@", "link", "unicode", "escaper", "}", "equivalent", "to", "the", "given", "escaper", "instance", "if", "the", "escaper", "is", "already", "a", "unicode", "escaper", "then", "it", "is", "simply", "returned", ",", "otherwise", "it", "is", "wrapped", "in", "a", "unicode", "escaper", "when", "a", "{", "@", "link", "char", "escaper", "}", "escaper", "is", "wrapped", "by", "this", "method", "it", "acquires", "extra", "behavior", "with", "respect", "to", "the", "well", "-", "formedness", "of", "unicode", "character", "sequences", "and", "will", "throw", "{", "@", "link", "illegal", "argument", "exception", "}", "when", "given", "bad", "input" ]
[ "static", "unicode", "escaper", "as", "unicode", "escaper", "(", "escaper", "escaper", ")", "{", "check", "not", "null", "(", "escaper", ")", ";", "if", "(", "escaper", "instanceof", "unicode", "escaper", ")", "{", "return", "(", "unicode", "escaper", ")", "escaper", ";", "}", "else", "if", "(", "escaper", "instanceof", "char", "escaper", ")", "{", "return", "wrap", "(", "(", "char", "escaper", ")", "escaper", ")", ";", "}", "/", "/", "in", "practice", "this", "shouldn", "'", "t", "happen", "because", "it", "would", "be", "very", "odd", "not", "to", "/", "/", "extend", "either", "char", "escaper", "or", "unicode", "escaper", "for", "non", "trivial", "cases", "throw", "new", "illegal", "argument", "exception", "(", "\"", "cannot", "create", "a", "unicode", "escaper", "from", ":", "\"", "+", "escaper", "get", "class", "(", ")", "get", "name", "(", ")", ")", ";", "}" ]
[ "create", "a", "new", "acl", "entry", "with", "scope", ",", "type", ",", "name", "and", "permission" ]
[ "private", "static", "acl", "entry", "acl", "entry", "(", "acl", "entry", "scope", "scope", ",", "acl", "entry", "type", "type", ",", "string", "name", ",", "fs", "action", "permission", ")", "{", "return", "new", "acl", "entry", "builder", "(", ")", "set", "scope", "(", "scope", ")", "set", "type", "(", "type", ")", "set", "name", "(", "name", ")", "set", "permission", "(", "permission", ")", "build", "(", ")", ";", "}" ]
[ "return", "a", "{", "@", "code", "stomp", "headers", "}", "object", "that", "can", "only", "be", "read", ",", "not", "written", "to" ]
[ "public", "static", "stomp", "headers", "read", "only", "stomp", "headers", "(", "@", "nullable", "map", "<", "string", ",", "list", "<", "string", ">", ">", "headers", ")", "{", "return", "new", "stomp", "headers", "(", "(", "headers", "!", "=", "null", "?", "headers", ":", "collections", "empty", "map", "(", ")", ")", ",", "true", ")", ";", "}" ]
[ "set", "whether", "or", "not", "we", "want", "to", "ignore", "s", "q", "l", "warnings", "default", "is", "\"", "true", "\"", ",", "swallowing", "and", "logging", "all", "warnings", "switch", "this", "flag", "to", "\"", "false", "\"", "to", "make", "the", "jdbc", "template", "throw", "an", "s", "q", "l", "warning", "exception", "instead" ]
[ "public", "void", "set", "ignore", "warnings", "(", "boolean", "ignore", "warnings", ")", "{", "this", "ignore", "warnings", "=", "ignore", "warnings", ";", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "alts", "server", "builder", "add", "stream", "tracer", "factory", "(", "server", "stream", "tracer", "factory", "factory", ")", "{", "delegate", "add", "stream", "tracer", "factory", "(", "factory", ")", ";", "return", "this", ";", "}" ]
[ "update", "parameter", "ordinals", "and", "re", "-", "assign", "dynamic", "parameter", "storage", "note", ":", "load", "variables", "must", "have", "been", "called", "first" ]
[ "void", "update", "parameters", "and", "return", "(", ")", "{", "if", "(", "params", "=", "=", "null", ")", "{", "load", "variables", "(", ")", ";", "return", ";", "}", "if", "(", "has", "custom", "variable", "storage", "(", ")", ")", "{", "auto", "params", "=", "null", ";", "renumber", "parameter", "ordinals", "(", ")", ";", "return", ";", "}", "data", "type", "[", "]", "data", "types", "=", "new", "data", "type", "[", "params", "size", "(", ")", "+", "1", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "params", "size", "(", ")", ";", "i", "+", "+", ")", "{", "parameter", "d", "b", "param", "=", "params", "get", "(", "i", ")", ";", "param", "set", "dynamic", "storage", "(", "variable", "storage", "unassigned", "storage", ")", ";", "data", "types", "[", "i", "+", "1", "]", "=", "param", "get", "data", "type", "(", ")", ";", "}", "data", "types", "[", "0", "]", "=", "return", "param", "get", "formal", "data", "type", "(", ")", ";", "data", "type", "base", "type", "=", "data", "types", "[", "0", "]", ";", "if", "(", "base", "type", "instanceof", "type", "def", ")", "{", "base", "type", "=", "(", "(", "type", "def", ")", "base", "type", ")", "get", "base", "data", "type", "(", ")", ";", "}", "return", "param", "set", "dynamic", "storage", "(", "(", "base", "type", "instanceof", "void", "data", "type", ")", "?", "variable", "storage", "void", "storage", ":", "variable", "storage", "unassigned", "storage", ")", ";", "prototype", "model", "calling", "convention", "=", "get", "calling", "convention", "(", ")", ";", "if", "(", "calling", "convention", "=", "=", "null", ")", "{", "calling", "convention", "=", "get", "default", "calling", "convention", "(", ")", ";", "}", "if", "(", "calling", "convention", "=", "=", "null", ")", "{", "return", ";", "}", "variable", "storage", "[", "]", "variable", "storage", "=", "calling", "convention", "get", "storage", "locations", "(", "program", ",", "data", "types", ",", "true", ")", ";", "return", "param", "set", "dynamic", "storage", "(", "variable", "storage", "[", "0", "]", ")", ";", "int", "auto", "index", "=", "0", ";", "int", "param", "index", "=", "0", ";", "auto", "params", "=", "null", ";", "for", "(", "int", "i", "=", "1", ";", "i", "<", "variable", "storage", "length", ";", "i", "+", "+", ")", "{", "variable", "storage", "storage", "=", "variable", "storage", "[", "i", "]", ";", "if", "(", "storage", "is", "auto", "storage", "(", ")", ")", "{", "if", "(", "auto", "params", "=", "=", "null", ")", "{", "auto", "params", "=", "new", "array", "list", "<", ">", "(", ")", ";", "}", "data", "type", "dt", "=", "variable", "utilities", "get", "auto", "data", "type", "(", "this", ",", "return", "param", "get", "formal", "data", "type", "(", ")", ",", "storage", ")", ";", "try", "{", "auto", "params", "add", "(", "new", "auto", "parameter", "impl", "(", "dt", ",", "auto", "index", "+", "+", ",", "storage", ",", "this", ")", ")", ";", "}", "catch", "(", "invalid", "input", "exception", "e", ")", "{", "msg", "error", "(", "this", ",", "\"", "unexpected", "error", "during", "dynamic", "storage", "assignment", "for", "function", "at", "\"", "+", "get", "entry", "point", "(", ")", ",", "e", ")", ";", "break", ";", "}", "}", "else", "{", "parameter", "d", "b", "parameter", "d", "b", "=", "params", "get", "(", "param", "index", "+", "+", ")", ";", "parameter", "d", "b", "set", "dynamic", "storage", "(", "storage", ")", ";", "}", "}", "renumber", "parameter", "ordinals", "(", ")", ";", "}" ]
[ "the", "configuration", "for", "which", "the", "resource", "is", "defined", "<", "code", ">", "optional", "aapt", "pb", "config", "description", "config", "=", "2", ";", "<", "code", ">" ]
[ "private", "void", "clear", "config", "(", ")", "{", "config", "=", "null", ";", "bit", "field", "0", "=", "(", "bit", "field", "0", "&", "~", "0x", "0", "0", "0", "0", "0", "0", "0", "2", ")", ";", "}" ]
[ "all", "instances", "are", "the", "same" ]
[ "public", "boolean", "equals", "(", "object", "obj", ")", "{", "return", "(", "(", "obj", "!", "=", "null", ")", "&", "&", "obj", "get", "class", "(", ")", "equals", "(", "no", "client", "bind", "protocol", "socket", "factory", "class", ")", ")", ";", "}" ]
[ "returns", "true", "if", "the", "given", "value", "is", "contained", "in", "this", "string", "enum" ]
[ "public", "boolean", "contains", "(", "string", "value", ")", "{", "return", "(", "index", "of", "(", "value", ")", "!", "=", "-", "1", ")", ";", "}" ]
[ "true", "if", "this", "request", "is", "a", "multipart", "request" ]
[ "public", "boolean", "is", "multipart", "(", ")", "{", "return", "is", "multipart", ";", "}" ]
[ "deserializes", "the", "{", "@", "link", "pdb", "debug", "info", "}", "-", "based", "instance", "the", "pdb", "is", "updated", "with", "dbi", "age", "and", "target", "processor", "during", "deserialization", "of", "new", "dbi", "header" ]
[ "public", "long", "deserialize", "(", "boolean", "header", "only", ",", "task", "monitor", "monitor", ")", "throws", "i", "o", "exception", ",", "pdb", "exception", ",", "cancelled", "exception", "{", "if", "(", "header", "only", ")", "{", "pdb", "byte", "reader", "reader", "=", "pdb", "get", "reader", "for", "stream", "number", "(", "stream", "number", ",", "0", ",", "get", "header", "length", "(", ")", ",", "monitor", ")", ";", "deserialize", "header", "(", "reader", ")", ";", "}", "else", "{", "pdb", "byte", "reader", "reader", "=", "pdb", "get", "reader", "for", "stream", "number", "(", "stream", "number", ",", "monitor", ")", ";", "deserialize", "header", "(", "reader", ")", ";", "deserialize", "internal", "substreams", "(", "reader", ",", "monitor", ")", ";", "deserialize", "additional", "substreams", "(", "monitor", ")", ";", "}", "return", "version", "number", ";", "}" ]
[ "unmounts", "the", "given", "{", "@", "link", "mount", "item", "}", "with", "unique", "index" ]
[ "public", "void", "unmount", "(", "int", "index", ",", "mount", "item", "mount", "item", ")", "{", "final", "object", "content", "=", "mount", "item", "get", "content", "(", ")", ";", "if", "(", "content", "instanceof", "drawable", ")", "{", "ensure", "drawable", "mount", "items", "(", ")", ";", "unmount", "drawable", "(", "(", "drawable", ")", "content", ")", ";", "component", "host", "utils", "remove", "item", "(", "index", ",", "m", "drawable", "mount", "items", ",", "m", "scrap", "drawable", "mount", "items", ")", ";", "}", "else", "if", "(", "content", "instanceof", "view", ")", "{", "unmount", "view", "(", "(", "view", ")", "content", ")", ";", "ensure", "view", "mount", "items", "(", ")", ";", "component", "host", "utils", "remove", "item", "(", "index", ",", "m", "view", "mount", "items", ",", "m", "scrap", "view", "mount", "items", "array", ")", ";", "m", "is", "child", "drawing", "order", "dirty", "=", "true", ";", "maybe", "unregister", "touch", "expansion", "(", "index", ",", "mount", "item", ")", ";", "}", "ensure", "mount", "items", "(", ")", ";", "component", "host", "utils", "remove", "item", "(", "index", ",", "m", "mount", "items", ",", "m", "scrap", "mount", "items", "array", ")", ";", "release", "scrap", "data", "structures", "if", "needed", "(", ")", ";", "update", "accessibility", "state", "(", "get", "layout", "output", "(", "mount", "item", ")", ")", ";", "}" ]
[ "returns", "{", "@", "code", "true", "}", "if", "the", "given", "message", "should", "be", "handled", "if", "{", "@", "code", "false", "}", "it", "will", "be", "passed", "to", "the", "next", "{", "@", "link", "channel", "outbound", "handler", "}", "in", "the", "{", "@", "link", "channel", "pipeline", "}" ]
[ "public", "boolean", "accept", "outbound", "message", "(", "object", "msg", ")", "throws", "exception", "{", "return", "matcher", "match", "(", "msg", ")", ";", "}" ]
[ "exports", "a", "collection", "of", "monitoring", "documents", "using", "the", "configured", "exporters" ]
[ "public", "void", "export", "(", "final", "collection", "<", "monitoring", "doc", ">", "docs", ",", "final", "action", "listener", "<", "void", ">", "listener", ")", "throws", "export", "exception", "{", "if", "(", "this", "lifecycle", "state", "(", ")", "!", "=", "lifecycle", "state", "started", ")", "{", "listener", "on", "failure", "(", "new", "export", "exception", "(", "\"", "export", "service", "is", "not", "started", "\"", ")", ")", ";", "}", "else", "if", "(", "docs", "!", "=", "null", "&", "&", "docs", "size", "(", ")", ">", "0", ")", "{", "wrap", "export", "bulk", "(", "action", "listener", "wrap", "(", "bulk", "-", ">", "{", "if", "(", "bulk", "!", "=", "null", ")", "{", "do", "export", "(", "bulk", ",", "docs", ",", "listener", ")", ";", "}", "else", "{", "listener", "on", "response", "(", "null", ")", ";", "}", "}", ",", "listener", ":", ":", "on", "failure", ")", ")", ";", "}", "else", "{", "listener", "on", "response", "(", "null", ")", ";", "}", "}" ]
[ "construct", "a", "successful", "target", "completion", "event" ]
[ "public", "static", "target", "complete", "event", "successful", "build", "(", "configured", "target", "and", "data", "ct", ",", "completion", "context", "completion", "context", ",", "nested", "set", "<", "artifacts", "in", "output", "group", ">", "outputs", ")", "{", "return", "new", "target", "complete", "event", "(", "ct", ",", "null", ",", "completion", "context", ",", "outputs", ",", "false", ")", ";", "}" ]
[ "attempts", "to", "move", "source", "to", "target", "atomically", "and", "falls", "back", "to", "a", "non", "-", "atomic", "move", "if", "it", "fails" ]
[ "public", "static", "void", "atomic", "move", "with", "fallback", "(", "path", "source", ",", "path", "target", ")", "throws", "i", "o", "exception", "{", "try", "{", "files", "move", "(", "source", ",", "target", ",", "standard", "copy", "option", "atomic", "move", ")", ";", "}", "catch", "(", "i", "o", "exception", "outer", ")", "{", "try", "{", "files", "move", "(", "source", ",", "target", ",", "standard", "copy", "option", "replace", "existing", ")", ";", "log", "debug", "(", "\"", "non", "-", "atomic", "move", "of", "{", "}", "to", "{", "}", "succeeded", "after", "atomic", "move", "failed", "due", "to", "{", "}", "\"", ",", "source", ",", "target", ",", "outer", "get", "message", "(", ")", ")", ";", "}", "catch", "(", "i", "o", "exception", "inner", ")", "{", "inner", "add", "suppressed", "(", "outer", ")", ";", "throw", "inner", ";", "}", "}", "}" ]
[ "allocates", "a", "byte", "[", "]", "of", "the", "specified", "size", "for", "use", "as", "a", "temporary", "buffer", "and", "calls", "{", "@", "link", "#", "copy", "stream", "(", "input", "stream", ",", "output", "stream", ",", "byte", "[", "]", ")", "}" ]
[ "public", "static", "void", "copy", "stream", "(", "input", "stream", "input", ",", "output", "stream", "output", ",", "int", "buffer", "size", ")", "throws", "i", "o", "exception", "{", "copy", "stream", "(", "input", ",", "output", ",", "new", "byte", "[", "buffer", "size", "]", ")", ";", "}" ]
[ "creates", "a", "new", "build", "options", "instance", "for", "host" ]
[ "public", "build", "options", "create", "host", "options", "(", ")", "{", "builder", "builder", "=", "builder", "(", ")", ";", "for", "(", "fragment", "options", "options", ":", "fragment", "options", "map", "values", "(", ")", ")", "{", "builder", "add", "fragment", "options", "(", "options", "get", "host", "(", ")", ")", ";", "}", "return", "builder", "add", "starlark", "options", "(", "starlark", "options", "map", ")", "build", "(", ")", ";", "}" ]
[ "verifies", "that", "calling", "{", "@", "link", "metric", "group", "#", "add", "group", "(", "string", ",", "string", ")", "}", "on", "a", "{", "@", "link", "generic", "key", "metric", "group", "}", "goes", "through", "the", "generic", "code", "path" ]
[ "public", "void", "test", "user", "defined", "variable", "on", "key", "group", "(", ")", "{", "metric", "registry", "registry", "=", "no", "op", "metric", "registry", "instance", ";", "generic", "metric", "group", "root", "=", "new", "generic", "metric", "group", "(", "registry", ",", "new", "dummy", "abstract", "metric", "group", "(", "registry", ")", ",", "\"", "root", "\"", ")", ";", "string", "key", "1", "=", "\"", "key", "1", "\"", ";", "string", "value", "1", "=", "\"", "value", "1", "\"", ";", "root", "add", "group", "(", "key", "1", ",", "value", "1", ")", ";", "string", "key", "2", "=", "\"", "key", "2", "\"", ";", "string", "value", "2", "=", "\"", "value", "2", "\"", ";", "metric", "group", "group", "=", "root", "add", "group", "(", "key", "1", ")", "add", "group", "(", "key", "2", ",", "value", "2", ")", ";", "string", "variable", "value", "=", "group", "get", "all", "variables", "(", ")", "get", "(", "\"", "value", "2", "\"", ")", ";", "assert", "null", "(", "variable", "value", ")", ";", "string", "identifier", "=", "group", "get", "metric", "identifier", "(", "\"", "metric", "\"", ")", ";", "assert", "true", "(", "\"", "key", "1", "is", "missing", "from", "metric", "identifier", "\"", ",", "identifier", "contains", "(", "\"", "key", "1", "\"", ")", ")", ";", "assert", "true", "(", "\"", "key", "2", "is", "missing", "from", "metric", "identifier", "\"", ",", "identifier", "contains", "(", "\"", "key", "2", "\"", ")", ")", ";", "assert", "true", "(", "\"", "value", "2", "is", "missing", "from", "metric", "identifier", "\"", ",", "identifier", "contains", "(", "\"", "value", "2", "\"", ")", ")", ";", "string", "logical", "scope", "=", "(", "(", "abstract", "metric", "group", ")", "group", ")", "get", "logical", "scope", "(", "new", "dummy", "character", "filter", "(", ")", ")", ";", "assert", "true", "(", "\"", "key", "1", "is", "missing", "from", "logical", "scope", "\"", ",", "logical", "scope", "contains", "(", "key", "1", ")", ")", ";", "assert", "true", "(", "\"", "key", "2", "is", "missing", "from", "logical", "scope", "\"", ",", "logical", "scope", "contains", "(", "key", "2", ")", ")", ";", "assert", "true", "(", "\"", "value", "2", "is", "missing", "from", "logical", "scope", "\"", ",", "logical", "scope", "contains", "(", "value", "2", ")", ")", ";", "}" ]
[ "specify", "that", "the", "topic", "should", "be", "compacted" ]
[ "public", "new", "topic", "builder", "compacted", "(", ")", "{", "this", "configs", "put", "(", "cleanup", "policy", "config", ",", "cleanup", "policy", "compact", ")", ";", "return", "this", ";", "}" ]
[ "the", "client", "auth", "configuration" ]
[ "s", "s", "l", "client", "auth", "ssl", "client", "auth", "(", ")", "{", "return", "ssl", "client", "auth", ";", "}" ]
[ "sends", "a", "list", "of", "specified", "offsets", "to", "the", "consumer", "group", "coordinator", ",", "and", "also", "marks", "those", "offsets", "as", "part", "of", "the", "current", "transaction", "these", "offsets", "will", "be", "considered", "committed", "only", "if", "the", "transaction", "is", "committed", "successfully", "the", "committed", "offset", "should", "be", "the", "next", "message", "your", "application", "will", "consume", ",", "i", "e", "last", "processed", "message", "offset", "+", "1", "this", "method", "should", "be", "used", "when", "you", "need", "to", "batch", "consumed", "and", "produced", "messages", "together", ",", "typically", "in", "a", "consume", "-", "transform", "-", "produce", "pattern", "thus", ",", "the", "specified", "{", "@", "code", "consumer", "group", "id", "}", "should", "be", "the", "same", "as", "config", "parameter", "{", "@", "code", "group", "id", "}", "of", "the", "used", "{", "@", "link", "kafka", "consumer", "consumer", "}", "note", ",", "that", "the", "consumer", "should", "have", "{", "@", "code", "enable", "auto", "commit", "=", "false", "}", "and", "should", "also", "not", "commit", "offsets", "manually", "(", "via", "{", "@", "link", "kafka", "consumer", "#", "commit", "sync", "(", "map", ")", "sync", "}", "or", "{", "@", "link", "kafka", "consumer", "#", "commit", "async", "(", "map", ",", "offset", "commit", "callback", ")", "async", "}", "commits", ")" ]
[ "public", "void", "send", "offsets", "to", "transaction", "(", "map", "<", "topic", "partition", ",", "offset", "and", "metadata", ">", "offsets", ",", "string", "consumer", "group", "id", ")", "throws", "producer", "fenced", "exception", "{", "send", "offsets", "to", "transaction", "(", "offsets", ",", "new", "consumer", "group", "metadata", "(", "consumer", "group", "id", ")", ")", ";", "}" ]
[ "retrieves", "cause", "exception", "and", "wraps", "to", "{", "@", "link", "command", "action", "execution", "exception", "}" ]
[ "private", "void", "propagate", "cause", "(", "throwable", "throwable", ")", "throws", "command", "action", "execution", "exception", "{", "exception", "utils", "propagate", "cause", "(", "throwable", ")", ";", "}" ]
[ "returns", "the", "length", "of", "the", "stream" ]
[ "public", "int", "get", "length", "(", ")", "{", "return", "stream", "length", ";", "}" ]
[ "create", "a", "new", "shared", "file", "descriptor", "factory" ]
[ "public", "static", "shared", "file", "descriptor", "factory", "create", "(", "string", "prefix", ",", "string", "paths", "[", "]", ")", "throws", "i", "o", "exception", "{", "string", "loading", "failure", "reason", "=", "get", "loading", "failure", "reason", "(", ")", ";", "if", "(", "loading", "failure", "reason", "!", "=", "null", ")", "{", "throw", "new", "i", "o", "exception", "(", "loading", "failure", "reason", ")", ";", "}", "if", "(", "paths", "length", "=", "=", "0", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "no", "shared", "file", "descriptor", "factory", "paths", "were", "\"", "+", "\"", "configured", "\"", ")", ";", "}", "string", "builder", "errors", "=", "new", "string", "builder", "(", ")", ";", "string", "str", "prefix", "=", "\"", "\"", ";", "for", "(", "string", "path", ":", "paths", ")", "{", "try", "{", "file", "input", "stream", "fis", "=", "new", "file", "input", "stream", "(", "create", "descriptor", "0", "(", "prefix", "+", "\"", "test", "\"", ",", "path", ",", "1", ")", ")", ";", "fis", "close", "(", ")", ";", "delete", "stale", "temporary", "files", "0", "(", "prefix", ",", "path", ")", ";", "return", "new", "shared", "file", "descriptor", "factory", "(", "prefix", ",", "path", ")", ";", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "errors", "append", "(", "str", "prefix", ")", "append", "(", "\"", "error", "creating", "file", "descriptor", "in", "\"", ")", "append", "(", "path", ")", "append", "(", "\"", ":", "\"", ")", "append", "(", "e", "get", "message", "(", ")", ")", ";", "str", "prefix", "=", "\"", ",", "\"", ";", "}", "}", "throw", "new", "i", "o", "exception", "(", "errors", "to", "string", "(", ")", ")", ";", "}" ]
[ "tests", "that", "all", "views", "in", "the", "hierarchy", "under", "the", "root", ",", "for", "which", "the", "path", "is", "visible", ",", "do", "not", "have", "text", "that", "matches", "against", "the", "given", "regular", "expression" ]
[ "public", "view", "tree", "assert", "does", "not", "have", "visible", "text", "matching", "(", "final", "string", "pattern", ")", "{", "final", "immutable", "list", "<", "view", ">", "path", "=", "get", "path", "to", "visible", "matching", "text", "(", "pattern", ")", ";", "java", "6", "assertions", "assert", "that", "(", "path", ")", "overriding", "error", "message", "(", "\"", "found", "pattern", "\\", "\"", "%", "s", "\\", "\"", "in", "view", "hierarchy", "for", "path", ":", "%", "s", "\"", ",", "pattern", ",", "make", "string", "(", "path", ")", ")", "is", "null", "(", ")", ";", "return", "this", ";", "}" ]
[ "places", "the", "two", "given", "images", "side", "-", "by", "-", "side", "into", "a", "new", "image" ]
[ "public", "static", "image", "place", "images", "side", "by", "side", "(", "image", "left", ",", "image", "right", ")", "{", "int", "left", "height", "=", "left", "get", "height", "(", "null", ")", ";", "int", "left", "width", "=", "left", "get", "width", "(", "null", ")", ";", "int", "right", "height", "=", "right", "get", "height", "(", "null", ")", ";", "int", "right", "width", "=", "right", "get", "width", "(", "null", ")", ";", "int", "width", "=", "left", "width", "+", "right", "width", ";", "int", "height", "=", "math", "max", "(", "left", "height", ",", "right", "height", ")", ";", "buffered", "image", "new", "image", "=", "create", "empty", "image", "(", "width", ",", "height", ")", ";", "graphics", "g", "=", "new", "image", "get", "graphics", "(", ")", ";", "int", "y", "=", "0", ";", "if", "(", "left", "height", "<", "right", "height", ")", "{", "y", "=", "(", "right", "height", "-", "left", "height", ")", "/", "2", ";", "/", "/", "center", "smaller", "image", "}", "g", "draw", "image", "(", "left", ",", "0", ",", "y", ",", "null", ")", ";", "y", "=", "0", ";", "if", "(", "left", "height", ">", "right", "height", ")", "{", "y", "=", "(", "left", "height", "-", "right", "height", ")", "/", "2", ";", "}", "g", "draw", "image", "(", "right", ",", "left", "width", ",", "y", ",", "null", ")", ";", "g", "dispose", "(", ")", ";", "wait", "for", "image", "(", "null", ",", "new", "image", ")", ";", "return", "new", "image", ";", "}" ]
[ "，", ",", "，" ]
[ "public", "static", "<", "k", ",", "v", ">", "map", "<", "k", ",", "v", ">", "top", "n", "by", "value", "(", "map", "<", "k", ",", "v", ">", "map", ",", "final", "comparator", "<", "?", "super", "v", ">", "comparator", ",", "int", "n", ")", "{", "return", "top", "n", "by", "value", "internal", "(", "map", ",", "n", ",", "new", "entry", "value", "comparator", "<", "k", ",", "v", ">", "(", "comparator", ")", ")", ";", "}" ]
[ "this", "implementation", "compares", "the", "underlying", "bean", "definition" ]
[ "public", "boolean", "equals", "(", "@", "nullable", "object", "other", ")", "{", "return", "(", "this", "=", "=", "other", "|", "|", "(", "other", "instanceof", "bean", "definition", "resource", "&", "&", "(", "(", "bean", "definition", "resource", ")", "other", ")", "bean", "definition", "equals", "(", "this", "bean", "definition", ")", ")", ")", ";", "}" ]
[ "call", "this", "when", "the", "given", "nodes", "children", "have", "changed" ]
[ "void", "reload", "node", "(", "program", "node", "node", ")", "{", "list", "<", "tree", "path", ">", "list", "=", "get", "expanded", "paths", "(", "node", ")", ";", "tree", "path", "[", "]", "paths", "=", "get", "selection", "paths", "(", ")", ";", "tree", "model", "reload", "(", "node", ")", ";", "expand", "paths", "(", "list", ")", ";", "add", "selection", "paths", "(", "paths", ")", ";", "}" ]