Datasets:

Anonymous2023

/

KGSum

like 0

[ "get", "enum", "number" ]

[ "public", "double", "get", "enum", "number", "(", ")", "{", "if", "(", "enum", "number", "=", "=", "null", ")", "{", "return", "null", ";", "}", "return", "enum", "number", "value", "(", ")", ";", "}" ]

[ "the", "{", "@", "code", "to", "string", "(", ")", "}", "of", "{", "@", "link", "component", "}", "implementations", "appear", "in", "health", "check", "endpoints", "since", "these", "are", "likely", "to", "be", "exposed", "in", "logs", "and", "other", "monitoring", "tools", ",", "care", "should", "be", "taken", "to", "ensure", "{", "@", "code", "to", "string", "(", ")", "}", "output", "is", "a", "reasonable", "length", "and", "does", "not", "contain", "sensitive", "information" ]

[ "@", "test", "public", "void", "to", "string", "contains", "only", "summary", "information", "(", ")", "{", "data", "source", "datasource", "=", "mock", "(", "data", "source", "class", ")", ";", "when", "(", "datasource", "to", "string", "(", ")", ")", "then", "return", "(", "\"", "blamo", "\"", ")", ";", "assert", "that", "(", "storage", "(", "datasource", ")", ")", "has", "to", "string", "(", "\"", "my", "s", "q", "l", "storage", "{", "datasource", "=", "blamo", "}", "\"", ")", ";", "}" ]

[ "finds", "the", "child", "with", "the", "specified", "index", "and", "returns", "it", "as", "a", "float" ]

[ "public", "float", "get", "float", "(", "int", "index", ")", "{", "json", "value", "child", "=", "get", "(", "index", ")", ";", "if", "(", "child", "=", "=", "null", ")", "throw", "new", "illegal", "argument", "exception", "(", "\"", "indexed", "value", "not", "found", ":", "\"", "+", "name", ")", ";", "return", "child", "as", "float", "(", ")", ";", "}" ]

[ "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", "\"", ")", ";", "}" ]

[ "provides", "an", "{", "@", "link", "indices", "client", "}", "which", "can", "be", "used", "to", "access", "the", "indices", "api", "see", "<", "a", "href", "=", "\"", "https", ":", "www", "elastic", "coguideenelasticsearchreferencecurrentindices", "html", "\"", ">", "indices", "api", "on", "elastic", "co" ]

[ "public", "final", "indices", "client", "indices", "(", ")", "{", "return", "indices", "client", ";", "}" ]

[ "check", "if", "there", "was", "any", "{", "@", "link", "throwable", "}", "received", "and", "if", "so", "rethrow", "it" ]

[ "public", "void", "check", "exception", "(", ")", "{", "check", "exception", "(", "void", "promise", "(", ")", ")", ";", "}" ]

[ "get", "the", "selected", "domain", "files" ]

[ "domain", "file", "[", "]", "get", "selected", "domain", "files", "(", ")", "{", "list", "<", "domain", "file", ">", "list", "=", "new", "array", "list", "<", ">", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "checkboxes", "length", ";", "i", "+", "+", ")", "{", "if", "(", "checkboxes", "[", "i", "]", "is", "selected", "(", ")", ")", "{", "list", "add", "(", "file", "list", "get", "(", "i", ")", ")", ";", "}", "}", "domain", "file", "[", "]", "files", "=", "new", "domain", "file", "[", "list", "size", "(", ")", "]", ";", "return", "list", "to", "array", "(", "files", ")", ";", "}" ]

[ "verifies", "that", "{", "@", "link", "scheduler", "n", "g", "#", "update", "task", "execution", "state", "(", "task", "execution", "state", ")", "}", "updates", "the", "accumulators", "and", "metrics", "for", "an", "execution", "that", "failed", "or", "was", "canceled" ]

[ "public", "void", "test", "accumulators", "and", "metrics", "forwarding", "(", ")", "throws", "exception", "{", "final", "job", "vertex", "i", "d", "jid", "1", "=", "new", "job", "vertex", "i", "d", "(", ")", ";", "final", "job", "vertex", "i", "d", "jid", "2", "=", "new", "job", "vertex", "i", "d", "(", ")", ";", "job", "vertex", "v", "1", "=", "new", "job", "vertex", "(", "\"", "v", "1", "\"", ",", "jid", "1", ")", ";", "job", "vertex", "v", "2", "=", "new", "job", "vertex", "(", "\"", "v", "2", "\"", ",", "jid", "2", ")", ";", "scheduler", "base", "scheduler", "=", "setup", "scheduler", "(", "v", "1", ",", "1", ",", "v", "2", ",", "1", ")", ";", "execution", "graph", "graph", "=", "scheduler", "get", "execution", "graph", "(", ")", ";", "map", "<", "execution", "attempt", "i", "d", ",", "execution", ">", "executions", "=", "graph", "get", "registered", "executions", "(", ")", ";", "/", "/", "verify", "behavior", "for", "canceled", "executions", "execution", "execution", "1", "=", "executions", "values", "(", ")", "iterator", "(", ")", "next", "(", ")", ";", "i", "o", "metrics", "io", "metrics", "=", "new", "i", "o", "metrics", "(", "0", ",", "0", ",", "0", ",", "0", ")", ";", "map", "<", "string", ",", "accumulator", "<", "?", ",", "?", ">", ">", "accumulators", "=", "new", "hash", "map", "<", ">", "(", ")", ";", "accumulators", "put", "(", "\"", "acc", "\"", ",", "new", "int", "counter", "(", "4", ")", ")", ";", "accumulator", "snapshot", "accumulator", "snapshot", "=", "new", "accumulator", "snapshot", "(", "graph", "get", "job", "i", "d", "(", ")", ",", "execution", "1", "get", "attempt", "id", "(", ")", ",", "accumulators", ")", ";", "task", "execution", "state", "state", "=", "new", "task", "execution", "state", "(", "graph", "get", "job", "i", "d", "(", ")", ",", "execution", "1", "get", "attempt", "id", "(", ")", ",", "execution", "state", "canceled", ",", "null", ",", "accumulator", "snapshot", ",", "io", "metrics", ")", ";", "scheduler", "update", "task", "execution", "state", "(", "state", ")", ";", "assert", "equals", "(", "io", "metrics", ",", "execution", "1", "get", "i", "o", "metrics", "(", ")", ")", ";", "assert", "not", "null", "(", "execution", "1", "get", "user", "accumulators", "(", ")", ")", ";", "assert", "equals", "(", "4", ",", "execution", "1", "get", "user", "accumulators", "(", ")", "get", "(", "\"", "acc", "\"", ")", "get", "local", "value", "(", ")", ")", ";", "/", "/", "verify", "behavior", "for", "failed", "executions", "execution", "execution", "2", "=", "executions", "values", "(", ")", "iterator", "(", ")", "next", "(", ")", ";", "i", "o", "metrics", "io", "metrics", "2", "=", "new", "i", "o", "metrics", "(", "0", ",", "0", ",", "0", ",", "0", ")", ";", "map", "<", "string", ",", "accumulator", "<", "?", ",", "?", ">", ">", "accumulators", "2", "=", "new", "hash", "map", "<", ">", "(", ")", ";", "accumulators", "2", "put", "(", "\"", "acc", "\"", ",", "new", "int", "counter", "(", "8", ")", ")", ";", "accumulator", "snapshot", "accumulator", "snapshot", "2", "=", "new", "accumulator", "snapshot", "(", "graph", "get", "job", "i", "d", "(", ")", ",", "execution", "2", "get", "attempt", "id", "(", ")", ",", "accumulators", "2", ")", ";", "task", "execution", "state", "state", "2", "=", "new", "task", "execution", "state", "(", "graph", "get", "job", "i", "d", "(", ")", ",", "execution", "2", "get", "attempt", "id", "(", ")", ",", "execution", "state", "failed", ",", "null", ",", "accumulator", "snapshot", "2", ",", "io", "metrics", "2", ")", ";", "scheduler", "update", "task", "execution", "state", "(", "state", "2", ")", ";", "assert", "equals", "(", "io", "metrics", "2", ",", "execution", "2", "get", "i", "o", "metrics", "(", ")", ")", ";", "assert", "not", "null", "(", "execution", "2", "get", "user", "accumulators", "(", ")", ")", ";", "assert", "equals", "(", "8", ",", "execution", "2", "get", "user", "accumulators", "(", ")", "get", "(", "\"", "acc", "\"", ")", "get", "local", "value", "(", ")", ")", ";", "}" ]

[ "mark", "a", "key", "whose", "value", "should", "be", "made", "accessible", "in", "agent", "j", "v", "ms" ]

[ "public", "static", "void", "allow", "on", "agent", "(", "string", "key", ")", "{", "allow", "on", "agent", "add", "(", "key", ")", ";", "}" ]

[ "closes", "the", "given", "{", "@", "link", "reader", "}", ",", "logging", "any", "{", "@", "code", "i", "o", "exception", "}", "that", "'", "s", "thrown", "rather", "than", "propagating", "it", "while", "it", "'", "s", "not", "safe", "in", "the", "general", "case", "to", "ignore", "exceptions", "that", "are", "thrown", "when", "closing", "an", "io", "resource", ",", "it", "should", "generally", "be", "safe", "in", "the", "case", "of", "a", "resource", "that", "'", "s", "being", "used", "only", "for", "reading", ",", "such", "as", "a", "{", "@", "code", "reader", "}", "unlike", "with", "writable", "resources", ",", "there", "'", "s", "no", "chance", "that", "a", "failure", "that", "occurs", "when", "closing", "the", "reader", "indicates", "a", "meaningful", "problem", "such", "as", "a", "failure", "to", "flush", "all", "bytes", "to", "the", "underlying", "resource" ]

[ "public", "static", "void", "close", "quietly", "(", "@", "nullable", "decl", "reader", "reader", ")", "{", "try", "{", "close", "(", "reader", ",", "true", ")", ";", "}", "catch", "(", "i", "o", "exception", "impossible", ")", "{", "throw", "new", "assertion", "error", "(", "impossible", ")", ";", "}", "}" ]

[ "deletes", "the", "action", "file", "and", "its", "backup" ]

[ "public", "void", "delete", "(", ")", "{", "atomic", "file", "delete", "(", ")", ";", "}" ]

[ "builds", "a", "rest", "client", "that", "will", "tolerate", "warnings", "in", "the", "response", "headers", "the", "default", "is", "to", "throw", "an", "exception" ]

[ "protected", "rest", "client", "build", "client", "(", "settings", "settings", ",", "http", "host", "[", "]", "hosts", ")", "throws", "i", "o", "exception", "{", "rest", "client", "builder", "builder", "=", "rest", "client", "builder", "(", "hosts", ")", ";", "configure", "client", "(", "builder", ",", "settings", ")", ";", "builder", "set", "strict", "deprecation", "mode", "(", "false", ")", ";", "return", "builder", "build", "(", ")", ";", "}" ]

[ "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", "visualized", "routing", "rules" ]

[ "public", "string", "to", "string", "(", ")", "{", "/", "/", "step", "1", "/", "2", ":", "dump", "routers", "and", "any", "method", "router", "in", "order", "int", "num", "routes", "=", "size", "(", ")", ";", "list", "<", "string", ">", "methods", "=", "new", "array", "list", "<", "string", ">", "(", "num", "routes", ")", ";", "list", "<", "string", ">", "patterns", "=", "new", "array", "list", "<", "string", ">", "(", "num", "routes", ")", ";", "list", "<", "string", ">", "targets", "=", "new", "array", "list", "<", "string", ">", "(", "num", "routes", ")", ";", "/", "/", "for", "router", "for", "(", "entry", "<", "http", "method", ",", "methodless", "router", "<", "t", ">", ">", "e", ":", "routers", "entry", "set", "(", ")", ")", "{", "http", "method", "method", "=", "e", "get", "key", "(", ")", ";", "methodless", "router", "<", "t", ">", "router", "=", "e", "get", "value", "(", ")", ";", "aggregate", "routes", "(", "method", "to", "string", "(", ")", ",", "router", "routes", "(", ")", ",", "methods", ",", "patterns", ",", "targets", ")", ";", "}", "/", "/", "for", "any", "method", "router", "aggregate", "routes", "(", "\"", "*", "\"", ",", "any", "method", "router", "routes", "(", ")", ",", "methods", ",", "patterns", ",", "targets", ")", ";", "/", "/", "for", "not", "found", "if", "(", "not", "found", "!", "=", "null", ")", "{", "methods", "add", "(", "\"", "*", "\"", ")", ";", "patterns", "add", "(", "\"", "*", "\"", ")", ";", "targets", "add", "(", "target", "to", "string", "(", "not", "found", ")", ")", ";", "}", "/", "/", "step", "2", "/", "2", ":", "format", "the", "list", "into", "aligned", "columns", ":", "<", "method", ">", "<", "patterns", ">", "<", "target", ">", "int", "max", "length", "method", "=", "max", "length", "(", "methods", ")", ";", "int", "max", "length", "pattern", "=", "max", "length", "(", "patterns", ")", ";", "string", "format", "=", "\"", "%", "-", "\"", "+", "max", "length", "method", "+", "\"", "s", "%", "-", "\"", "+", "max", "length", "pattern", "+", "\"", "s", "%", "s", "\\", "n", "\"", ";", "int", "initial", "capacity", "=", "(", "max", "length", "method", "+", "1", "+", "max", "length", "pattern", "+", "1", "+", "20", ")", "*", "methods", "size", "(", ")", ";", "string", "builder", "b", "=", "new", "string", "builder", "(", "initial", "capacity", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "methods", "size", "(", ")", ";", "i", "+", "+", ")", "{", "string", "method", "=", "methods", "get", "(", "i", ")", ";", "string", "pattern", "=", "patterns", "get", "(", "i", ")", ";", "string", "target", "=", "targets", "get", "(", "i", ")", ";", "b", "append", "(", "string", "format", "(", "format", ",", "method", ",", "pattern", ",", "target", ")", ")", ";", "}", "return", "b", "to", "string", "(", ")", ";", "}" ]

[ "returns", "the", "enabled", "and", "activated", "administrative", "monitors", "accessible", "to", "the", "current", "user" ]

[ "public", "list", "<", "administrative", "monitor", ">", "get", "active", "administrative", "monitors", "(", ")", "{", "if", "(", "!", "jenkins", "get", "(", ")", "has", "permission", "(", "system", "read", ")", ")", "{", "return", "collections", "empty", "list", "(", ")", ";", "}", "return", "administrative", "monitors", "stream", "(", ")", "filter", "(", "m", "-", ">", "{", "try", "{", "return", "jenkins", "get", "(", ")", "has", "permission", "(", "m", "get", "required", "permission", "(", ")", ")", "&", "&", "m", "is", "enabled", "(", ")", "&", "&", "m", "is", "activated", "(", ")", ";", "}", "catch", "(", "throwable", "x", ")", "{", "logger", "log", "(", "level", "warning", ",", "null", ",", "x", ")", ";", "return", "false", ";", "}", "}", ")", "collect", "(", "collectors", "to", "list", "(", ")", ")", ";", "}" ]

[ "creates", "a", "new", "long", "property", "map", "with", "the", "given", "name" ]

[ "public", "long", "property", "map", "create", "long", "property", "map", "(", "string", "property", "name", ")", "throws", "duplicate", "name", "exception", "{", "lock", "acquire", "(", ")", ";", "try", "{", "if", "(", "property", "map", "cache", "contains", "key", "(", "property", "name", ")", ")", "{", "throw", "new", "duplicate", "name", "exception", "(", ")", ";", "}", "long", "property", "map", "pm", "=", "null", ";", "try", "{", "pm", "=", "new", "long", "property", "map", "d", "b", "(", "db", "handle", ",", "d", "b", "constants", "create", ",", "program", ",", "change", "mgr", ",", "addr", "map", ",", "property", "name", ",", "task", "monitor", "adapter", "dummy", "monitor", ")", ";", "properties", "d", "b", "adapter", "put", "record", "(", "property", "name", ",", "long", "property", "type", ",", "null", ")", ";", "property", "map", "cache", "put", "(", "property", "name", ",", "pm", ")", ";", "}", "catch", "(", "version", "exception", "e", ")", "{", "throw", "new", "assert", "exception", "(", ")", ";", "}", "catch", "(", "cancelled", "exception", "e", ")", "{", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "program", "db", "error", "(", "e", ")", ";", "}", "return", "pm", ";", "}", "finally", "{", "lock", "release", "(", ")", ";", "}", "}" ]

[ "the", "series", "of", "types", "defined", "by", "the", "package", "<", "code", ">", "repeated", "aapt", "pb", "type", "type", "=", "3", ";", "<", "code", ">" ]

[ "private", "void", "add", "all", "type", "(", "java", "lang", "iterable", "<", "?", "extends", "com", "android", "aapt", "resources", "type", ">", "values", ")", "{", "ensure", "type", "is", "mutable", "(", ")", ";", "com", "google", "protobuf", "abstract", "message", "lite", "add", "all", "(", "values", ",", "type", ")", ";", "}" ]

[ "get", "the", "float", "value", "contained", "with", "this", "field" ]

[ "public", "float", "get", "float", "value", "(", ")", "{", "if", "(", "float", "!", "=", "data", "[", "data", "type", "offset", "]", ")", "{", "throw", "new", "illegal", "field", "access", "exception", "(", ")", ";", "}", "binary", "data", "buffer", "buffer", "=", "new", "binary", "data", "buffer", "(", "data", ")", ";", "return", "float", "int", "bits", "to", "float", "(", "buffer", "get", "int", "(", "data", "offset", ")", ")", ";", "}" ]

[ "set", "the", "coefficient", "of", "friction", "this", "will", "not", "change", "the", "friction", "of", "existing", "contacts" ]

[ "public", "void", "set", "friction", "(", "float", "friction", ")", "{", "m", "friction", "=", "friction", ";", "}" ]

[ "test", "the", "property", "'", "password", "'" ]

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

[ "writes", "a", "{", "@", "code", "float", "}", "as", "specified", "by", "{", "@", "link", "data", "output", "stream", "#", "write", "float", "(", "float", ")", "}", ",", "except", "using", "little", "-", "endian", "byte", "order" ]

[ "public", "void", "write", "float", "(", "float", "v", ")", "throws", "i", "o", "exception", "{", "write", "int", "(", "float", "float", "to", "int", "bits", "(", "v", ")", ")", ";", "}" ]

[ "a", "variant", "of", "{", "@", "link", "#", "bind", "to", "server", "(", ")", "}", "with", "a", "pre", "-", "configured", "connector" ]

[ "static", "builder", "bind", "to", "server", "(", "client", "http", "connector", "connector", ")", "{", "return", "new", "default", "web", "test", "client", "builder", "(", "connector", ")", ";", "}" ]

[ "create", "a", "new", "{", "@", "link", "filter", "}", "aggregation", "with", "the", "given", "name" ]

[ "public", "static", "filter", "aggregation", "builder", "filter", "(", "string", "name", ",", "query", "builder", "filter", ")", "{", "return", "new", "filter", "aggregation", "builder", "(", "name", ",", "filter", ")", ";", "}" ]

[ "put", "the", "original", "tabbing", "stream", "back" ]

[ "public", "tabbing", "output", "stream", "reset", "output", "stream", "(", "tabbing", "output", "stream", "s", ")", "{", "flush", "(", ")", ";", "tabbing", "output", "stream", "old", "=", "(", "tabbing", "output", "stream", ")", "this", "out", ";", "this", "out", "=", "s", ";", "return", "old", ";", "}" ]

[ "just", "like", "{", "@", "link", "#", "stash", "context", "(", ")", "}", "but", "no", "default", "context", "is", "set" ]

[ "public", "stored", "context", "new", "stored", "context", "(", "boolean", "preserve", "response", "headers", ")", "{", "return", "new", "stored", "context", "(", "preserve", "response", "headers", ",", "list", "of", "(", ")", ")", ";", "}" ]

[ "find", "widget", "type", "by", "tenant", "id", ",", "bundle", "alias", "and", "alias" ]

[ "widget", "type", "find", "by", "tenant", "id", "bundle", "alias", "and", "alias", "(", "uuid", "tenant", "id", ",", "string", "bundle", "alias", ",", "string", "alias", ")", ";" ]

[ "add", "a", "state", "change", "event", "to", "the", "lifecycle", "history" ]

[ "private", "void", "record", "lifecycle", "event", "(", ")", "{", "lifecycle", "event", "event", "=", "new", "lifecycle", "event", "(", ")", ";", "event", "time", "=", "system", "current", "time", "millis", "(", ")", ";", "event", "state", "=", "get", "service", "state", "(", ")", ";", "lifecycle", "history", "add", "(", "event", ")", ";", "}" ]

[ "entry", "point", "for", "'", "gradle", "build", "ghidra", "jar", "'" ]

[ "public", "static", "void", "main", "(", "string", "[", "]", "args", ")", "throws", "i", "o", "exception", "{", "new", "ghidra", "jar", "builder", "(", ")", "launch", "(", "new", "ghidra", "application", "layout", "(", ")", ",", "args", ")", ";", "}" ]

[ "returns", "{", "@", "code", "true", "}", "if", "this", "provider", "set", "can", "have", "any", "provider", ",", "or", "if", "it", "advertises", "the", "specific", "starlark", "provider", "requested" ]

[ "public", "boolean", "advertises", "(", "starlark", "provider", "identifier", "starlark", "provider", ")", "{", "if", "(", "can", "have", "any", "provider", "(", ")", ")", "{", "return", "true", ";", "}", "return", "starlark", "providers", "contains", "(", "starlark", "provider", ")", ";", "}" ]

[ "with", "the", "custom", "provider", "configured", ",", "verify", "file", "status", "attributes", "a", "superuser", "can", "bypass", "permission", "check", "while", "resolving", "paths", "so", ",", "verify", "file", "status", "for", "both", "superuser", "and", "non", "-", "superuser" ]

[ "public", "void", "test", "custom", "provider", "(", ")", "throws", "exception", "{", "final", "user", "group", "information", "[", "]", "users", "=", "new", "user", "group", "information", "[", "]", "{", "user", "group", "information", "create", "user", "for", "testing", "(", "system", "get", "property", "(", "\"", "user", "name", "\"", ")", ",", "new", "string", "[", "]", "{", "\"", "supergroup", "\"", "}", ")", ",", "user", "group", "information", "create", "user", "for", "testing", "(", "\"", "normaluser", "\"", ",", "new", "string", "[", "]", "{", "\"", "normalusergroup", "\"", "}", ")", ",", "}", ";", "for", "(", "final", "user", "group", "information", "user", ":", "users", ")", "{", "user", "do", "as", "(", "(", "privileged", "exception", "action", "<", "object", ">", ")", "(", ")", "-", ">", "{", "verify", "file", "status", "(", "user", ")", ";", "return", "null", ";", "}", ")", ";", "}", "}" ]

[ "create", "user", "this", "can", "only", "be", "done", "by", "the", "logged", "in", "user" ]

[ "public", "single", "<", "void", ">", "rx", "create", "user", "(", "user", "body", ",", "api", "client", "auth", "info", "auth", "info", ")", "{", "return", "single", "create", "(", "new", "io", "vertx", "rx", "java", "single", "on", "subscribe", "adapter", "<", ">", "(", "fut", "-", ">", "delegate", "create", "user", "(", "body", ",", "auth", "info", ",", "fut", ")", ")", ")", ";", "}" ]

[ "generate", "random", "query", "results", "received", "from", "the", "provided", "number", "of", "shards", ",", "including", "the", "provided", "number", "of", "search", "hits", "and", "randomly", "generated", "completion", "suggestions", "based", "on", "the", "name", "and", "size", "of", "the", "provided", "ones", "note", "that", "<", "code", ">", "shard", "index", "<", "code", ">", "is", "already", "set", "to", "the", "generated", "completion", "suggestions", "to", "simulate", "what", "{", "@", "link", "search", "phase", "controller", "#", "reduced", "query", "phase", "}", "does", ",", "meaning", "that", "the", "returned", "query", "results", "can", "be", "fed", "directly", "to", "{", "@", "link", "search", "phase", "controller", "#", "sort", "docs", "}" ]

[ "private", "static", "atomic", "array", "<", "search", "phase", "result", ">", "generate", "query", "results", "(", "int", "n", "shards", ",", "list", "<", "completion", "suggestion", ">", "suggestions", ",", "int", "search", "hits", "size", ",", "boolean", "use", "constant", "score", ")", "{", "atomic", "array", "<", "search", "phase", "result", ">", "query", "results", "=", "new", "atomic", "array", "<", ">", "(", "n", "shards", ")", ";", "for", "(", "int", "shard", "index", "=", "0", ";", "shard", "index", "<", "n", "shards", ";", "shard", "index", "+", "+", ")", "{", "string", "cluster", "alias", "=", "random", "boolean", "(", ")", "?", "null", ":", "\"", "remote", "\"", ";", "search", "shard", "target", "search", "shard", "target", "=", "new", "search", "shard", "target", "(", "\"", "\"", ",", "new", "shard", "id", "(", "\"", "\"", ",", "\"", "\"", ",", "shard", "index", ")", ",", "cluster", "alias", ",", "original", "indices", "none", ")", ";", "query", "search", "result", "query", "search", "result", "=", "new", "query", "search", "result", "(", "new", "shard", "search", "context", "id", "(", "\"", "\"", ",", "shard", "index", ")", ",", "search", "shard", "target", ",", "null", ")", ";", "final", "top", "docs", "top", "docs", ";", "float", "max", "score", "=", "0", ";", "if", "(", "search", "hits", "size", "=", "=", "0", ")", "{", "top", "docs", "=", "lucene", "empty", "top", "docs", ";", "}", "else", "{", "int", "n", "docs", "=", "random", "int", "between", "(", "0", ",", "search", "hits", "size", ")", ";", "score", "doc", "[", "]", "score", "docs", "=", "new", "score", "doc", "[", "n", "docs", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "n", "docs", ";", "i", "+", "+", ")", "{", "float", "score", "=", "use", "constant", "score", "?", "1", "0f", ":", "math", "abs", "(", "random", "float", "(", ")", ")", ";", "score", "docs", "[", "i", "]", "=", "new", "score", "doc", "(", "i", ",", "score", ")", ";", "max", "score", "=", "math", "max", "(", "score", ",", "max", "score", ")", ";", "}", "top", "docs", "=", "new", "top", "docs", "(", "new", "total", "hits", "(", "score", "docs", "length", ",", "total", "hits", "relation", "equal", "to", ")", ",", "score", "docs", ")", ";", "}", "list", "<", "completion", "suggestion", ">", "shard", "suggestion", "=", "new", "array", "list", "<", ">", "(", ")", ";", "for", "(", "completion", "suggestion", "completion", "suggestion", ":", "suggestions", ")", "{", "completion", "suggestion", "suggestion", "=", "new", "completion", "suggestion", "(", "completion", "suggestion", "get", "name", "(", ")", ",", "completion", "suggestion", "get", "size", "(", ")", ",", "false", ")", ";", "final", "completion", "suggestion", "entry", "completion", "entry", "=", "new", "completion", "suggestion", "entry", "(", "new", "text", "(", "\"", "\"", ")", ",", "0", ",", "5", ")", ";", "suggestion", "add", "term", "(", "completion", "entry", ")", ";", "int", "option", "size", "=", "random", "int", "between", "(", "1", ",", "suggestion", "get", "size", "(", ")", ")", ";", "float", "max", "score", "value", "=", "random", "int", "between", "(", "suggestion", "get", "size", "(", ")", ",", "(", "int", ")", "float", "max", "value", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "option", "size", ";", "i", "+", "+", ")", "{", "completion", "entry", "add", "option", "(", "new", "completion", "suggestion", "entry", "option", "(", "i", ",", "new", "text", "(", "\"", "\"", ")", ",", "max", "score", "value", ",", "collections", "empty", "map", "(", ")", ")", ")", ";", "float", "dec", "=", "random", "int", "between", "(", "0", ",", "option", "size", ")", ";", "if", "(", "dec", "<", "=", "max", "score", "value", ")", "{", "max", "score", "value", "-", "=", "dec", ";", "}", "}", "suggestion", "set", "shard", "index", "(", "shard", "index", ")", ";", "shard", "suggestion", "add", "(", "suggestion", ")", ";", "}", "query", "search", "result", "top", "docs", "(", "new", "top", "docs", "and", "max", "score", "(", "top", "docs", ",", "max", "score", ")", ",", "null", ")", ";", "query", "search", "result", "size", "(", "search", "hits", "size", ")", ";", "query", "search", "result", "suggest", "(", "new", "suggest", "(", "new", "array", "list", "<", ">", "(", "shard", "suggestion", ")", ")", ")", ";", "query", "search", "result", "set", "shard", "index", "(", "shard", "index", ")", ";", "query", "results", "set", "(", "shard", "index", ",", "query", "search", "result", ")", ";", "}", "return", "query", "results", ";", "}" ]

[ "create", "a", "{", "@", "link", "mock", "http", "servlet", "request", "builder", "}", "for", "a", "head", "request" ]

[ "public", "static", "mock", "http", "servlet", "request", "builder", "head", "(", "uri", "uri", ")", "{", "return", "new", "mock", "http", "servlet", "request", "builder", "(", "http", "method", "head", ",", "uri", ")", ";", "}" ]

[ "an", "implementation", "of", "{", "@", "link", "executor", "service", "#", "invoke", "any", "}", "for", "{", "@", "link", "listening", "executor", "service", "}", "implementations" ]

[ "static", "<", "t", ">", "t", "invoke", "any", "impl", "(", "listening", "executor", "service", "executor", "service", ",", "collection", "<", "?", "extends", "callable", "<", "t", ">", ">", "tasks", ",", "boolean", "timed", ",", "long", "timeout", ",", "time", "unit", "unit", ")", "throws", "interrupted", "exception", ",", "execution", "exception", ",", "timeout", "exception", "{", "check", "not", "null", "(", "executor", "service", ")", ";", "check", "not", "null", "(", "unit", ")", ";", "int", "ntasks", "=", "tasks", "size", "(", ")", ";", "check", "argument", "(", "ntasks", ">", "0", ")", ";", "list", "<", "future", "<", "t", ">", ">", "futures", "=", "lists", "new", "array", "list", "with", "capacity", "(", "ntasks", ")", ";", "blocking", "queue", "<", "future", "<", "t", ">", ">", "future", "queue", "=", "queues", "new", "linked", "blocking", "queue", "(", ")", ";", "long", "timeout", "nanos", "=", "unit", "to", "nanos", "(", "timeout", ")", ";", "/", "/", "for", "efficiency", ",", "especially", "in", "executors", "with", "limited", "/", "/", "parallelism", ",", "check", "to", "see", "if", "previously", "submitted", "tasks", "are", "/", "/", "done", "before", "submitting", "more", "of", "them", "this", "interleaving", "/", "/", "plus", "the", "exception", "mechanics", "account", "for", "messiness", "of", "main", "/", "/", "loop", "try", "{", "/", "/", "record", "exceptions", "so", "that", "if", "we", "fail", "to", "obtain", "any", "/", "/", "result", ",", "we", "can", "throw", "the", "last", "exception", "we", "got", "execution", "exception", "ee", "=", "null", ";", "long", "last", "time", "=", "timed", "?", "system", "nano", "time", "(", ")", ":", "0", ";", "iterator", "<", "?", "extends", "callable", "<", "t", ">", ">", "it", "=", "tasks", "iterator", "(", ")", ";", "futures", "add", "(", "submit", "and", "add", "queue", "listener", "(", "executor", "service", ",", "it", "next", "(", ")", ",", "future", "queue", ")", ")", ";", "-", "-", "ntasks", ";", "int", "active", "=", "1", ";", "while", "(", "true", ")", "{", "future", "<", "t", ">", "f", "=", "future", "queue", "poll", "(", ")", ";", "if", "(", "f", "=", "=", "null", ")", "{", "if", "(", "ntasks", ">", "0", ")", "{", "-", "-", "ntasks", ";", "futures", "add", "(", "submit", "and", "add", "queue", "listener", "(", "executor", "service", ",", "it", "next", "(", ")", ",", "future", "queue", ")", ")", ";", "+", "+", "active", ";", "}", "else", "if", "(", "active", "=", "=", "0", ")", "{", "break", ";", "}", "else", "if", "(", "timed", ")", "{", "f", "=", "future", "queue", "poll", "(", "timeout", "nanos", ",", "time", "unit", "nanoseconds", ")", ";", "if", "(", "f", "=", "=", "null", ")", "{", "throw", "new", "timeout", "exception", "(", ")", ";", "}", "long", "now", "=", "system", "nano", "time", "(", ")", ";", "timeout", "nanos", "-", "=", "now", "-", "last", "time", ";", "last", "time", "=", "now", ";", "}", "else", "{", "f", "=", "future", "queue", "take", "(", ")", ";", "}", "}", "if", "(", "f", "!", "=", "null", ")", "{", "-", "-", "active", ";", "try", "{", "return", "f", "get", "(", ")", ";", "}", "catch", "(", "execution", "exception", "eex", ")", "{", "ee", "=", "eex", ";", "}", "catch", "(", "runtime", "exception", "rex", ")", "{", "ee", "=", "new", "execution", "exception", "(", "rex", ")", ";", "}", "}", "}", "if", "(", "ee", "=", "=", "null", ")", "{", "ee", "=", "new", "execution", "exception", "(", "null", ")", ";", "}", "throw", "ee", ";", "}", "finally", "{", "for", "(", "future", "<", "t", ">", "f", ":", "futures", ")", "{", "f", "cancel", "(", "true", ")", ";", "}", "}", "}" ]

[ "reads", "all", "input", "entries", "from", "the", "given", "class", "path" ]

[ "private", "void", "read", "input", "(", "string", "message", "prefix", ",", "class", "path", "class", "path", ",", "data", "entry", "reader", "reader", ")", "throws", "i", "o", "exception", "{", "read", "input", "(", "message", "prefix", ",", "class", "path", ",", "0", ",", "class", "path", "size", "(", ")", ",", "reader", ")", ";", "}" ]

[ "test", "the", "property", "'", "string", "'" ]

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

[ "the", "collection", "of", "index", "deletions", "in", "the", "cluster" ]

[ "public", "index", "graveyard", "index", "graveyard", "(", ")", "{", "return", "custom", "(", "index", "graveyard", "type", ")", ";", "}" ]

[ "create", "a", "target", "pattern", "{", "@", "link", "sky", "key", "}", "throws", "{", "@", "link", "target", "parsing", "exception", "}", "if", "the", "provided", "{", "@", "code", "pattern", "}", "cannot", "be", "parsed" ]

[ "public", "static", "target", "pattern", "key", "key", "(", "string", "pattern", ",", "filtering", "policy", "policy", ",", "path", "fragment", "offset", ")", "throws", "target", "parsing", "exception", "{", "return", "iterables", "get", "only", "element", "(", "keys", "(", "immutable", "list", "of", "(", "pattern", ")", ",", "policy", ",", "offset", ")", ")", "get", "sky", "key", "(", ")", ";", "}" ]

[ "this", "method", "overrides", "method", "invocation", "to", "create", "beans", "for", "each", "method", "name", "that", "takes", "a", "class", "argument" ]

[ "public", "object", "invoke", "method", "(", "string", "name", ",", "object", "arg", ")", "{", "object", "[", "]", "args", "=", "(", "object", "[", "]", ")", "arg", ";", "if", "(", "\"", "beans", "\"", "equals", "(", "name", ")", "&", "&", "args", "length", "=", "=", "1", "&", "&", "args", "[", "0", "]", "instanceof", "closure", ")", "{", "return", "beans", "(", "(", "closure", "<", "?", ">", ")", "args", "[", "0", "]", ")", ";", "}", "else", "if", "(", "\"", "ref", "\"", "equals", "(", "name", ")", ")", "{", "string", "ref", "name", ";", "if", "(", "args", "[", "0", "]", "=", "=", "null", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "argument", "to", "ref", "(", ")", "is", "not", "a", "valid", "bean", "or", "was", "not", "found", "\"", ")", ";", "}", "if", "(", "args", "[", "0", "]", "instanceof", "runtime", "bean", "reference", ")", "{", "ref", "name", "=", "(", "(", "runtime", "bean", "reference", ")", "args", "[", "0", "]", ")", "get", "bean", "name", "(", ")", ";", "}", "else", "{", "ref", "name", "=", "args", "[", "0", "]", "to", "string", "(", ")", ";", "}", "boolean", "parent", "ref", "=", "false", ";", "if", "(", "args", "length", ">", "1", "&", "&", "args", "[", "1", "]", "instanceof", "boolean", ")", "{", "parent", "ref", "=", "(", "boolean", ")", "args", "[", "1", "]", ";", "}", "return", "new", "runtime", "bean", "reference", "(", "ref", "name", ",", "parent", "ref", ")", ";", "}", "else", "if", "(", "this", "namespaces", "contains", "key", "(", "name", ")", "&", "&", "args", "length", ">", "0", "&", "&", "args", "[", "0", "]", "instanceof", "closure", ")", "{", "groovy", "dynamic", "element", "reader", "reader", "=", "create", "dynamic", "element", "reader", "(", "name", ")", ";", "reader", "invoke", "method", "(", "\"", "do", "call", "\"", ",", "args", ")", ";", "}", "else", "if", "(", "args", "length", ">", "0", "&", "&", "args", "[", "0", "]", "instanceof", "closure", ")", "{", "/", "/", "abstract", "bean", "definition", "return", "invoke", "bean", "defining", "method", "(", "name", ",", "args", ")", ";", "}", "else", "if", "(", "args", "length", ">", "0", "&", "&", "(", "args", "[", "0", "]", "instanceof", "class", "|", "|", "args", "[", "0", "]", "instanceof", "runtime", "bean", "reference", "|", "|", "args", "[", "0", "]", "instanceof", "map", ")", ")", "{", "return", "invoke", "bean", "defining", "method", "(", "name", ",", "args", ")", ";", "}", "else", "if", "(", "args", "length", ">", "1", "&", "&", "args", "[", "args", "length", "-", "1", "]", "instanceof", "closure", ")", "{", "return", "invoke", "bean", "defining", "method", "(", "name", ",", "args", ")", ";", "}", "meta", "class", "mc", "=", "default", "groovy", "methods", "get", "meta", "class", "(", "get", "registry", "(", ")", ")", ";", "if", "(", "!", "mc", "responds", "to", "(", "get", "registry", "(", ")", ",", "name", ",", "args", ")", "is", "empty", "(", ")", ")", "{", "return", "mc", "invoke", "method", "(", "get", "registry", "(", ")", ",", "name", ",", "args", ")", ";", "}", "return", "this", ";", "}" ]

[ "test", "the", "property", "'", "byte", "'" ]

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

[ "get", "all", "the", "used", "ports", "of", "this", "supervisor" ]

[ "public", "set", "<", "integer", ">", "get", "used", "ports", "(", "supervisor", "details", "supervisor", ")", "{", "map", "<", "string", ",", "scheduler", "assignment", ">", "assignments", "=", "this", "get", "assignments", "(", ")", ";", "set", "<", "integer", ">", "used", "ports", "=", "new", "hash", "set", "<", "integer", ">", "(", ")", ";", "for", "(", "scheduler", "assignment", "assignment", ":", "assignments", "values", "(", ")", ")", "{", "for", "(", "worker", "slot", "slot", ":", "assignment", "get", "executor", "to", "slot", "(", ")", "values", "(", ")", ")", "{", "if", "(", "slot", "get", "node", "id", "(", ")", "equals", "(", "supervisor", "get", "id", "(", ")", ")", ")", "{", "used", "ports", "add", "(", "slot", "get", "port", "(", ")", ")", ";", "}", "}", "}", "return", "used", "ports", ";", "}" ]

[ "check", "the", "single", "value", "message" ]

[ "private", "void", "validate", "meter", "data", "(", "string", "name", ",", "list", "<", "label", ">", "labels", ",", "double", "value", ",", "meter", "data", "builder", "validate", ")", "{", "assert", "assert", "not", "null", "(", "validate", ")", ";", "assert", "assert", "equals", "(", "validate", "get", "metric", "case", "(", ")", "get", "number", "(", ")", ",", "meter", "data", "singlevalue", "field", "number", ")", ";", "meter", "single", "value", "single", "value", "=", "validate", "get", "single", "value", "(", ")", ";", "assert", "assert", "not", "null", "(", "single", "value", ")", ";", "assert", "assert", "equals", "(", "value", ",", "single", "value", "get", "value", "(", ")", ",", "0", "0", ")", ";", "assert", "assert", "equals", "(", "name", ",", "single", "value", "get", "name", "(", ")", ")", ";", "assert", "assert", "equals", "(", "labels", ",", "single", "value", "get", "labels", "list", "(", ")", ")", ";", "}" ]

[ "sets", "the", "{", "@", "link", "texture", "filter", "}", "for", "this", "texture", "for", "minification", "and", "magnification", "this", "will", "bind", "this", "texture", "!" ]

[ "public", "void", "set", "filter", "(", "texture", "filter", "min", "filter", ",", "texture", "filter", "mag", "filter", ")", "{", "this", "min", "filter", "=", "min", "filter", ";", "this", "mag", "filter", "=", "mag", "filter", ";", "bind", "(", ")", ";", "gdx", "gl", "gl", "tex", "parameteri", "(", "gl", "target", ",", "gl20", "gl", "texture", "min", "filter", ",", "min", "filter", "get", "g", "l", "enum", "(", ")", ")", ";", "gdx", "gl", "gl", "tex", "parameteri", "(", "gl", "target", ",", "gl20", "gl", "texture", "mag", "filter", ",", "mag", "filter", "get", "g", "l", "enum", "(", ")", ")", ";", "}" ]

[ "a", "graph", "that", "has", "at", "least", "one", "vertex", "with", "no", "ingoingoutgoing", "edges" ]

[ "public", "static", "data", "set", "<", "edge", "<", "long", ",", "long", ">", ">", "get", "long", "long", "edge", "data", "with", "zero", "degree", "(", "execution", "environment", "env", ")", "{", "list", "<", "edge", "<", "long", ",", "long", ">", ">", "edges", "=", "new", "array", "list", "<", ">", "(", ")", ";", "edges", "add", "(", "new", "edge", "<", ">", "(", "1l", ",", "2l", ",", "12l", ")", ")", ";", "edges", "add", "(", "new", "edge", "<", ">", "(", "1l", ",", "4l", ",", "14l", ")", ")", ";", "edges", "add", "(", "new", "edge", "<", ">", "(", "1l", ",", "5l", ",", "15l", ")", ")", ";", "edges", "add", "(", "new", "edge", "<", ">", "(", "2l", ",", "3l", ",", "23l", ")", ")", ";", "edges", "add", "(", "new", "edge", "<", ">", "(", "3l", ",", "5l", ",", "35l", ")", ")", ";", "edges", "add", "(", "new", "edge", "<", ">", "(", "4l", ",", "5l", ",", "45l", ")", ")", ";", "return", "env", "from", "collection", "(", "edges", ")", ";", "}" ]

[ "sets", "a", "gesture", "-", "listener", "for", "the", "chart", "for", "custom", "callbacks", "when", "executing", "gestures", "on", "the", "chart", "surface" ]

[ "public", "void", "set", "on", "chart", "gesture", "listener", "(", "on", "chart", "gesture", "listener", "l", ")", "{", "this", "m", "gesture", "listener", "=", "l", ";", "}" ]

[ "returns", "the", "reference", "count", "of", "an", "asset" ]

[ "public", "synchronized", "int", "get", "reference", "count", "(", "string", "file", "name", ")", "{", "class", "type", "=", "asset", "types", "get", "(", "file", "name", ")", ";", "if", "(", "type", "=", "=", "null", ")", "throw", "new", "gdx", "runtime", "exception", "(", "\"", "asset", "not", "loaded", ":", "\"", "+", "file", "name", ")", ";", "return", "assets", "get", "(", "type", ")", "get", "(", "file", "name", ")", "get", "ref", "count", "(", ")", ";", "}" ]

[ "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", "\"", ")", ";", "}" ]

[ "model", "tests", "for", "dog" ]

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

[ "prepares", "a", "child", "source", "{", "@", "link", "#", "on", "child", "source", "info", "refreshed", "(", "object", ",", "media", "source", ",", "timeline", ")", "}", "will", "be", "called", "when", "the", "child", "source", "updates", "its", "timeline", "with", "the", "same", "{", "@", "code", "id", "}", "passed", "to", "this", "method", "any", "child", "sources", "that", "aren", "'", "t", "explicitly", "released", "with", "{", "@", "link", "#", "release", "child", "source", "(", "object", ")", "}", "will", "be", "released", "in", "{", "@", "link", "#", "release", "source", "internal", "(", ")", "}" ]

[ "protected", "final", "void", "prepare", "child", "source", "(", "@", "unknown", "null", "t", "id", ",", "media", "source", "media", "source", ")", "{", "assertions", "check", "argument", "(", "!", "child", "sources", "contains", "key", "(", "id", ")", ")", ";", "media", "source", "caller", "caller", "=", "(", "source", ",", "timeline", ")", "-", ">", "on", "child", "source", "info", "refreshed", "(", "id", ",", "source", ",", "timeline", ")", ";", "forwarding", "event", "listener", "event", "listener", "=", "new", "forwarding", "event", "listener", "(", "id", ")", ";", "child", "sources", "put", "(", "id", ",", "new", "media", "source", "and", "listener", "(", "media", "source", ",", "caller", ",", "event", "listener", ")", ")", ";", "media", "source", "add", "event", "listener", "(", "assertions", "check", "not", "null", "(", "event", "handler", ")", ",", "event", "listener", ")", ";", "media", "source", "add", "drm", "event", "listener", "(", "assertions", "check", "not", "null", "(", "event", "handler", ")", ",", "event", "listener", ")", ";", "media", "source", "prepare", "source", "(", "caller", ",", "media", "transfer", "listener", ")", ";", "if", "(", "!", "is", "enabled", "(", ")", ")", "{", "media", "source", "disable", "(", "caller", ")", ";", "}", "}" ]

[ "configuration", "entries", "for", "a", "resource" ]

[ "public", "collection", "<", "config", "entry", ">", "entries", "(", ")", "{", "return", "collections", "unmodifiable", "collection", "(", "entries", "values", "(", ")", ")", ";", "}" ]

[ "writes", "an", "attribute" ]

[ "public", "void", "attribute", "(", "string", "name", ",", "string", "value", ")", "{", "print", "att", "(", "out", ",", "name", ",", "value", ")", ";", "}" ]

[ "closes", "the", "concrete", "data", "type", "if", "necessary" ]

[ "protected", "abstract", "void", "close", "(", "t", "data", ")", "throws", "i", "o", "exception", ";" ]

[ "create", "a", "new", "{", "@", "code", "k", "table", "}", "by", "transforming", "the", "value", "of", "each", "record", "in", "this", "{", "@", "code", "k", "table", "}", "into", "a", "new", "value", "(", "with", "possibly", "a", "new", "type", ")", ",", "with", "default", "serializers", ",", "deserializers", ",", "and", "state", "store", "a", "{", "@", "link", "value", "transformer", "with", "key", "}", "(", "provided", "by", "the", "given", "{", "@", "link", "value", "transformer", "with", "key", "supplier", "}", ")", "is", "applied", "to", "each", "input", "record", "value", "and", "computes", "a", "new", "value", "for", "it", "thus", ",", "an", "input", "record", "{", "@", "code", "<", "k", ",", "v", ">", "}", "can", "be", "transformed", "into", "an", "output", "record", "{", "@", "code", "<", "k", ":", "v", "'", ">", "}", "this", "is", "similar", "to", "{", "@", "link", "#", "map", "values", "(", "value", "mapper", "with", "key", ")", "}", ",", "but", "more", "flexible", ",", "allowing", "access", "to", "additional", "state", "-", "stores", ",", "and", "access", "to", "the", "{", "@", "link", "processor", "context", "}", "furthermore", ",", "via", "{", "@", "link", "org", "apache", "kafka", "streams", "processor", "punctuator", "#", "punctuate", "(", "long", ")", "}", "the", "processing", "progress", "can", "be", "observed", "and", "additional", "periodic", "actions", "can", "be", "performed", "if", "the", "downstream", "topology", "uses", "aggregation", "functions", ",", "(", "e", "g", "{", "@", "link", "k", "grouped", "table", "#", "reduce", "}", ",", "{", "@", "link", "k", "grouped", "table", "#", "aggregate", "}", ",", "etc", ")", ",", "care", "must", "be", "taken", "when", "dealing", "with", "state", ",", "(", "either", "held", "in", "state", "-", "stores", "or", "transformer", "instances", ")", ",", "to", "ensure", "correct", "aggregate", "results", "in", "contrast", ",", "if", "the", "resulting", "k", "table", "is", "materialized", ",", "(", "cf", "{", "@", "link", "#", "transform", "values", "(", "value", "transformer", "with", "key", "supplier", ",", "materialized", ",", "string", ")", "}", ")", ",", "such", "concerns", "are", "handled", "for", "you", "in", "order", "to", "assign", "a", "state", ",", "the", "state", "must", "be", "created", "and", "registered", "beforehand", ":", "{", "@", "code", "create", "store", "store", "builder", "<", "key", "value", "store", "<", "string", ",", "string", ">", ">", "key", "value", "store", "builder", "=", "stores", "key", "value", "store", "builder", "(", "stores", "persistent", "key", "value", "store", "(", "\"", "my", "value", "transform", "state", "\"", ")", ",", "serdes", "string", "(", ")", ",", "serdes", "string", "(", ")", ")", ";", "register", "store", "builder", "add", "state", "store", "(", "key", "value", "store", "builder", ")", ";", "k", "table", "output", "table", "=", "input", "table", "transform", "values", "(", "new", "value", "transformer", "with", "key", "supplier", "(", ")", "{", "}", ",", "\"", "my", "value", "transform", "state", "\"", ")", ";", "}", "within", "the", "{", "@", "link", "value", "transformer", "with", "key", "}", ",", "the", "state", "is", "obtained", "via", "the", "{", "@", "link", "processor", "context", "}", "to", "trigger", "periodic", "actions", "via", "{", "@", "link", "org", "apache", "kafka", "streams", "processor", "punctuator", "#", "punctuate", "(", "long", ")", "punctuate", "(", ")", "}", ",", "a", "schedule", "must", "be", "registered", "{", "@", "code", "new", "value", "transformer", "with", "key", "supplier", "(", ")", "{", "value", "transformer", "with", "key", "get", "(", ")", "{", "return", "new", "value", "transformer", "with", "key", "(", ")", "{", "private", "key", "value", "store", "<", "string", ",", "string", ">", "state", ";", "void", "init", "(", "processor", "context", "context", ")", "{", "this", "state", "=", "(", "key", "value", "store", "<", "string", ",", "string", ">", ")", "context", "get", "state", "store", "(", "\"", "my", "value", "transform", "state", "\"", ")", ";", "context", "schedule", "(", "duration", "of", "seconds", "(", "1", ")", ",", "punctuation", "type", "wall", "clock", "time", ",", "new", "punctuator", "(", ")", ")", ";", "punctuate", "each", "1", "0", "0", "0ms", ",", "can", "access", "this", "state", "}", "new", "value", "type", "transform", "(", "k", "read", "only", "key", ",", "v", "value", ")", "{", "can", "access", "this", "state", "and", "use", "read", "-", "only", "key", "return", "new", "new", "value", "type", "(", "read", "only", "key", ")", ";", "or", "null", "}", "void", "close", "(", ")", "{", "can", "access", "this", "state", "}", "}", "}", "}", "}", "note", "that", "the", "key", "is", "read", "-", "only", "and", "should", "not", "be", "modified", ",", "as", "this", "can", "lead", "to", "corrupt", "partitioning", "setting", "a", "new", "value", "preserves", "data", "co", "-", "location", "with", "respect", "to", "the", "key" ]

[ "<", "vr", ">", "k", "table", "<", "k", ",", "vr", ">", "transform", "values", "(", "final", "value", "transformer", "with", "key", "supplier", "<", "?", "super", "k", ",", "?", "super", "v", ",", "?", "extends", "vr", ">", "transformer", "supplier", ",", "final", "string", "state", "store", "names", ")", ";" ]

[ "set", "the", "<", "code", ">", "application", "a", "c", "l", "<", "code", ">", "s", "for", "the", "application" ]

[ "public", "abstract", "void", "set", "application", "a", "c", "ls", "(", "map", "<", "application", "access", "type", ",", "string", ">", "acls", ")", ";" ]

[ "check", "if", "provided", "context", "is", "a", "default", "auto", "-", "created", "context" ]

[ "public", "static", "boolean", "is", "default", "context", "(", "context", "context", ")", "{", "if", "(", "context", "=", "=", "null", ")", "{", "return", "false", ";", "}", "return", "constants", "context", "default", "name", "equals", "(", "context", "get", "name", "(", ")", ")", ";", "}" ]

[ "test", "for", "b", "6", "2", "0", "6", "0", "7", "9", "3", "verifies", "constant", "lambda", "arguments", "that", "were", "pushed", "using", "const", "0", "instructions" ]

[ "public", "void", "test", "call", "lambda", "with", "constants", "(", ")", "throws", "exception", "{", "assert", "that", "(", "constant", "arguments", "in", "lambda", "lambda", "with", "constant", "arguments", "(", ")", "call", "(", "\"", "test", "\"", ")", ")", "is", "equal", "to", "(", "\"", "testfalse", "\\", "00120", "00", "0", "0", "4", "9nulltrue", "\"", ")", ";", "}" ]

[ "get", "integer", "item" ]

[ "public", "integer", "get", "integer", "item", "(", ")", "{", "return", "integer", "item", ";", "}" ]

[ "check", "the", "source", "behind", "this", "error", ":", "possibly", "an", "{", "@", "link", "exception", "}", "(", "typically", "{", "@", "link", "org", "springframework", "beans", "property", "access", "exception", "}", ")", "or", "a", "bean", "validation", "{", "@", "link", "javax", "validation", "constraint", "violation", "}", "the", "cause", "of", "the", "outermost", "exception", "will", "be", "introspected", "as", "well", ",", "e", "g", "the", "underlying", "conversion", "exception", "or", "exception", "thrown", "from", "a", "setter", "(", "instead", "of", "having", "to", "unwrap", "the", "{", "@", "code", "property", "access", "exception", "}", "in", "turn", ")" ]

[ "public", "boolean", "contains", "(", "class", "<", "?", ">", "source", "type", ")", "{", "return", "(", "source", "type", "is", "instance", "(", "this", "source", ")", "|", "|", "(", "this", "source", "instanceof", "throwable", "&", "&", "source", "type", "is", "instance", "(", "(", "(", "throwable", ")", "this", "source", ")", "get", "cause", "(", ")", ")", ")", ")", ";", "}" ]

[ "check", "the", "source", "and", "target", "paths", "to", "ensure", "that", "they", "are", "either", "both", "in", "reservedraw", "or", "neither", "in", "reservedraw", "if", "neither", "src", "nor", "target", "are", "in", "reservedraw", ",", "then", "return", "false", ",", "indicating", "not", "to", "preserve", "raw", "xattrs", "if", "both", "srctarget", "are", "in", "reservedraw", ",", "then", "return", "true", ",", "indicating", "raw", "xattrs", "should", "be", "preserved", "if", "only", "one", "of", "srctarget", "is", "in", "reservedraw", "then", "throw", "an", "exception" ]

[ "private", "boolean", "check", "paths", "for", "reserved", "raw", "(", "path", "src", ",", "path", "target", ")", "throws", "path", "operation", "exception", "{", "final", "boolean", "src", "is", "r", "r", "=", "path", "get", "path", "without", "scheme", "and", "authority", "(", "src", ")", "to", "string", "(", ")", "starts", "with", "(", "reserved", "raw", ")", ";", "final", "boolean", "dst", "is", "r", "r", "=", "path", "get", "path", "without", "scheme", "and", "authority", "(", "target", ")", "to", "string", "(", ")", "starts", "with", "(", "reserved", "raw", ")", ";", "boolean", "preserve", "raw", "xattrs", "=", "false", ";", "if", "(", "src", "is", "r", "r", "&", "&", "!", "dst", "is", "r", "r", ")", "{", "final", "string", "s", "=", "\"", "'", "copy", "from", "'", "\"", "+", "reserved", "raw", "+", "\"", "'", "to", "non", "'", "\"", "+", "reserved", "raw", "+", "\"", "'", "either", "both", "source", "and", "target", "must", "be", "in", "'", "\"", "+", "reserved", "raw", "+", "\"", "'", "or", "neither", "\"", ";", "throw", "new", "path", "operation", "exception", "(", "\"", "'", "\"", "+", "src", "to", "string", "(", ")", "+", "s", ")", ";", "}", "else", "if", "(", "!", "src", "is", "r", "r", "&", "&", "dst", "is", "r", "r", ")", "{", "final", "string", "s", "=", "\"", "'", "copy", "from", "non", "'", "\"", "+", "reserved", "raw", "+", "\"", "'", "to", "'", "\"", "+", "reserved", "raw", "+", "\"", "'", "either", "both", "source", "and", "target", "must", "be", "in", "'", "\"", "+", "reserved", "raw", "+", "\"", "'", "or", "neither", "\"", ";", "throw", "new", "path", "operation", "exception", "(", "\"", "'", "\"", "+", "dst", "to", "string", "(", ")", "+", "s", ")", ";", "}", "else", "if", "(", "src", "is", "r", "r", "&", "&", "dst", "is", "r", "r", ")", "{", "preserve", "raw", "xattrs", "=", "true", ";", "}", "return", "preserve", "raw", "xattrs", ";", "}" ]

[ "disposes", "the", "result", ",", "which", "releases", "the", "reference", "to", "any", "bitmaps" ]

[ "public", "synchronized", "void", "dispose", "(", ")", "{", "closeable", "reference", "close", "safely", "(", "m", "preview", "bitmap", ")", ";", "m", "preview", "bitmap", "=", "null", ";", "closeable", "reference", "close", "safely", "(", "m", "decoded", "frames", ")", ";", "m", "decoded", "frames", "=", "null", ";", "}" ]

[ "convert", "tabs", "in", "the", "given", "string", "to", "spaces" ]

[ "public", "static", "string", "convert", "tabs", "to", "spaces", "(", "string", "str", ",", "int", "tab", "size", ")", "{", "if", "(", "str", "=", "=", "null", ")", "{", "return", "null", ";", "}", "string", "buffer", "buffer", "=", "new", "string", "buffer", "(", ")", ";", "int", "linepos", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "str", "length", "(", ")", ";", "i", "+", "+", ")", "{", "char", "c", "=", "str", "char", "at", "(", "i", ")", ";", "if", "(", "c", "=", "=", "'", "\\", "t", "'", ")", "{", "int", "n", "spaces", "=", "tab", "size", "-", "(", "linepos", "%", "tab", "size", ")", ";", "string", "pad", "=", "pad", "(", "\"", "\"", ",", "'", "'", ",", "n", "spaces", ")", ";", "buffer", "append", "(", "pad", ")", ";", "linepos", "+", "=", "n", "spaces", ";", "}", "else", "{", "buffer", "append", "(", "c", ")", ";", "linepos", "+", "+", ";", "if", "(", "c", "=", "=", "'", "\\", "n", "'", ")", "{", "linepos", "=", "0", ";", "}", "}", "}", "return", "buffer", "to", "string", "(", ")", ";", "}" ]

[ "{", "@", "inherit", "doc", "}" ]

[ "public", "url", "get", "u", "r", "l", "(", "int", "column", "index", ")", "throws", "s", "q", "l", "exception", "{", "return", "null", ";", "}" ]

[ "returns", "{", "@", "code", "true", "}", "if", "the", "metric", "matches", "the", "filter", ";", "{", "@", "code", "false", "}", "otherwise" ]

[ "boolean", "matches", "(", "string", "name", ",", "metric", "metric", ")", ";" ]

[ "appends", "the", "value", "to", "the", "specified", "{", "@", "link", "string", "builder", "}", ",", "escaping", "if", "necessary" ]

[ "char", "sequence", "escape", "(", "t", "value", ")", ";" ]

[ "set", "git", "user", "id" ]

[ "public", "void", "set", "git", "user", "id", "(", "string", "git", "user", "id", ")", "{", "this", "git", "user", "id", "=", "git", "user", "id", ";", "}" ]

[ "adds", "the", "costs", "for", "network", "to", "the", "current", "network", "costs", "for", "this", "costs", "object" ]

[ "public", "void", "add", "network", "cost", "(", "double", "bytes", ")", "{", "this", "network", "cost", "=", "(", "this", "network", "cost", "<", "0", "|", "|", "bytes", "<", "0", ")", "?", "unknown", ":", "this", "network", "cost", "+", "bytes", ";", "}" ]

[ "creates", "a", "builder", "operating", "on", "a", "clone", "of", "this", "build", "options" ]

[ "public", "builder", "to", "builder", "(", ")", "{", "return", "builder", "(", ")", "merge", "(", "clone", "(", ")", ")", ";", "}" ]

[ "who", "is", "allowed", "to", "add", "to", "the", "membership", "of", "this", "group" ]

[ "public", "group", "access", "control", "get", "membership", "addition", "access", "control", "(", ")", "{", "if", "(", "is", "v", "2", "group", "(", ")", ")", "{", "if", "(", "require", "v", "2", "group", "properties", "(", ")", "get", "decrypted", "group", "(", ")", "get", "access", "control", "(", ")", "get", "members", "(", ")", "=", "=", "access", "control", "access", "required", "member", ")", "{", "return", "group", "access", "control", "all", "members", ";", "}", "return", "group", "access", "control", "only", "admins", ";", "}", "else", "{", "return", "id", "is", "v", "1", "(", ")", "?", "group", "access", "control", "all", "members", ":", "group", "access", "control", "only", "admins", ";", "}", "}" ]

[ "tests", "that", "remove", "states", "physically", "when", "put", "is", "invoked" ]

[ "public", "void", "test", "physically", "remove", "with", "put", "(", ")", "throws", "i", "o", "exception", "{", "test", "physically", "remove", "with", "function", "(", "(", "map", ",", "reference", ",", "i", ")", "-", ">", "{", "map", "put", "(", "i", ",", "(", "long", ")", "i", ",", "string", "value", "of", "(", "i", ")", ")", ";", "add", "to", "reference", "state", "(", "reference", ",", "i", ",", "(", "long", ")", "i", ",", "string", "value", "of", "(", "i", ")", ")", ";", "return", "1", ";", "}", ")", ";", "}" ]

[ "gets", "all", "logs", "for", "a", "session" ]

[ "public", "synchronized", "session", "logs", "get", "all", "logs", "for", "session", "(", "session", "id", "session", "id", ")", "{", "session", "logs", "session", "logs", "=", "new", "session", "logs", "(", ")", ";", "if", "(", "per", "session", "driver", "entries", "contains", "key", "(", "session", "id", ")", ")", "{", "map", "<", "string", ",", "log", "entries", ">", "type", "to", "entries", "map", "=", "per", "session", "driver", "entries", "get", "(", "session", "id", ")", ";", "for", "(", "map", "entry", "<", "string", ",", "log", "entries", ">", "entry", ":", "type", "to", "entries", "map", "entry", "set", "(", ")", ")", "{", "session", "logs", "add", "log", "(", "entry", "get", "key", "(", ")", ",", "entry", "get", "value", "(", ")", ")", ";", "}", "per", "session", "driver", "entries", "remove", "(", "session", "id", ")", ";", "}", "return", "session", "logs", ";", "}" ]

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

[ "default", "response", "entity", "<", "boolean", ">", "fake", "outer", "boolean", "serialize", "(", "@", "api", "param", "(", "value", "=", "\"", "input", "boolean", "as", "post", "body", "\"", ")", "@", "valid", "@", "request", "body", "(", "required", "=", "false", ")", "boolean", "body", ")", "{", "return", "get", "delegate", "(", ")", "fake", "outer", "boolean", "serialize", "(", "body", ")", ";", "}" ]

[ "returns", "the", "path", "of", "the", "ccc", "source", "for", "gcc" ]

[ "public", "final", "artifact", "get", "source", "file", "(", ")", "{", "return", "compile", "command", "line", "get", "source", "file", "(", ")", ";", "}" ]

[ "asynchronous", "version", "of", "{", "@", "link", "query", "#", "list", "(", ")", "}" ]

[ "public", "async", "operation", "query", "list", "(", "query", "<", "?", ">", "query", ")", "{", "return", "query", "list", "(", "query", ",", "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", "\"", ")", ";", "}" ]

[ "gets", "the", "number", "of", "i", "ds", "in", "the", "checkpoint" ]

[ "public", "int", "get", "num", "ids", "(", ")", "{", "return", "num", "ids", ";", "}" ]

[ "returns", "a", "value", "that", "is", "unique", "for", "a", "given", "table", "column", "this", "is", "different", "than", "getting", "the", "display", "name", ",", "which", "may", "be", "shared", "by", "different", "columns" ]

[ "public", "string", "get", "unique", "identifier", "(", "int", "column", ")", ";" ]

[ "get", "the", "runtime", "for", "the", "<", "b", ">", "shuffle", "<", "b", ">", "phase", "of", "the", "reduce", "task", "-", "attempt" ]

[ "public", "long", "get", "shuffle", "runtime", "(", ")", "{", "return", "shuffle", "time", ";", "}" ]

[ "test", "the", "property", "'", "name", "'" ]

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

[ "returns", "the", "square", "root", "of", "{", "@", "code", "x", "}", ",", "rounded", "with", "the", "specified", "rounding", "mode" ]

[ "public", "static", "int", "sqrt", "(", "int", "x", ",", "rounding", "mode", "mode", ")", "{", "check", "non", "negative", "(", "\"", "x", "\"", ",", "x", ")", ";", "int", "sqrt", "floor", "=", "sqrt", "floor", "(", "x", ")", ";", "switch", "(", "mode", ")", "{", "case", "unnecessary", ":", "check", "rounding", "unnecessary", "(", "sqrt", "floor", "*", "sqrt", "floor", "=", "=", "x", ")", ";", "/", "/", "fall", "through", "case", "floor", ":", "case", "down", ":", "return", "sqrt", "floor", ";", "case", "ceiling", ":", "case", "up", ":", "return", "sqrt", "floor", "+", "less", "than", "branch", "free", "(", "sqrt", "floor", "*", "sqrt", "floor", ",", "x", ")", ";", "case", "half", "down", ":", "case", "half", "up", ":", "case", "half", "even", ":", "int", "half", "square", "=", "sqrt", "floor", "*", "sqrt", "floor", "+", "sqrt", "floor", ";", "/", "*", "*", "we", "wish", "to", "test", "whether", "or", "not", "x", "<", "=", "(", "sqrt", "floor", "+", "0", "5", ")", "^", "2", "=", "half", "square", "+", "0", "25", "since", "both", "x", "*", "and", "half", "square", "are", "integers", ",", "this", "is", "equivalent", "to", "testing", "whether", "or", "not", "x", "<", "=", "*", "half", "square", "(", "we", "have", "to", "deal", "with", "overflow", ",", "though", ")", "*", "*", "if", "we", "treat", "half", "square", "as", "an", "unsigned", "int", ",", "we", "know", "that", "*", "sqrt", "floor", "^", "2", "<", "=", "x", "<", "(", "sqrt", "floor", "+", "1", ")", "^", "2", "*", "half", "square", "-", "sqrt", "floor", "<", "=", "x", "<", "half", "square", "+", "sqrt", "floor", "+", "1", "*", "so", "|", "x", "-", "half", "square", "|", "<", "=", "sqrt", "floor", "therefore", ",", "it", "'", "s", "safe", "to", "treat", "x", "-", "half", "square", "as", "a", "*", "signed", "int", ",", "so", "less", "than", "branch", "free", "is", "safe", "for", "use", "*", "/", "return", "sqrt", "floor", "+", "less", "than", "branch", "free", "(", "half", "square", ",", "x", ")", ";", "default", ":", "throw", "new", "assertion", "error", "(", ")", ";", "}", "}" ]

[ "get", "the", "command", "-", "line", "argument", "parser" ]

[ "private", "static", "argument", "parser", "arg", "parser", "(", ")", "{", "argument", "parser", "parser", "=", "argument", "parsers", "new", "argument", "parser", "(", "\"", "transactional", "-", "message", "-", "copier", "\"", ")", "default", "help", "(", "true", ")", "description", "(", "\"", "this", "tool", "copies", "messages", "transactionally", "from", "an", "input", "partition", "to", "an", "output", "topic", ",", "\"", "+", "\"", "committing", "the", "consumed", "offsets", "along", "with", "the", "output", "messages", "\"", ")", ";", "parser", "add", "argument", "(", "\"", "-", "-", "input", "-", "topic", "\"", ")", "action", "(", "store", "(", ")", ")", "required", "(", "true", ")", "type", "(", "string", "class", ")", "metavar", "(", "\"", "input", "-", "topic", "\"", ")", "dest", "(", "\"", "input", "topic", "\"", ")", "help", "(", "\"", "consume", "messages", "from", "this", "topic", "\"", ")", ";", "parser", "add", "argument", "(", "\"", "-", "-", "input", "-", "partition", "\"", ")", "action", "(", "store", "(", ")", ")", "required", "(", "true", ")", "type", "(", "integer", "class", ")", "metavar", "(", "\"", "input", "-", "partition", "\"", ")", "dest", "(", "\"", "input", "partition", "\"", ")", "help", "(", "\"", "consume", "messages", "from", "this", "partition", "of", "the", "input", "topic", "\"", ")", ";", "parser", "add", "argument", "(", "\"", "-", "-", "output", "-", "topic", "\"", ")", "action", "(", "store", "(", ")", ")", "required", "(", "true", ")", "type", "(", "string", "class", ")", "metavar", "(", "\"", "output", "-", "topic", "\"", ")", "dest", "(", "\"", "output", "topic", "\"", ")", "help", "(", "\"", "produce", "messages", "to", "this", "topic", "\"", ")", ";", "parser", "add", "argument", "(", "\"", "-", "-", "broker", "-", "list", "\"", ")", "action", "(", "store", "(", ")", ")", "required", "(", "true", ")", "type", "(", "string", "class", ")", "metavar", "(", "\"", "host1", ":", "port1", "[", ",", "host2", ":", "port2", "[", "]", "]", "\"", ")", "dest", "(", "\"", "broker", "list", "\"", ")", "help", "(", "\"", "comma", "-", "separated", "list", "of", "kafka", "brokers", "in", "the", "form", "host1", ":", "port1", ",", "host2", ":", "port2", ",", "\"", ")", ";", "parser", "add", "argument", "(", "\"", "-", "-", "max", "-", "messages", "\"", ")", "action", "(", "store", "(", ")", ")", "required", "(", "false", ")", "set", "default", "(", "-", "1", ")", "type", "(", "integer", "class", ")", "metavar", "(", "\"", "max", "-", "messages", "\"", ")", "dest", "(", "\"", "max", "messages", "\"", ")", "help", "(", "\"", "process", "these", "many", "messages", "upto", "the", "end", "offset", "at", "the", "time", "this", "program", "was", "launched", "if", "set", "to", "-", "1", "\"", "+", "\"", "we", "will", "just", "read", "to", "the", "end", "offset", "of", "the", "input", "partition", "(", "as", "of", "the", "time", "the", "program", "was", "launched", ")", "\"", ")", ";", "parser", "add", "argument", "(", "\"", "-", "-", "consumer", "-", "group", "\"", ")", "action", "(", "store", "(", ")", ")", "required", "(", "false", ")", "set", "default", "(", "-", "1", ")", "type", "(", "string", "class", ")", "metavar", "(", "\"", "consumer", "-", "group", "\"", ")", "dest", "(", "\"", "consumer", "group", "\"", ")", "help", "(", "\"", "the", "consumer", "group", "id", "to", "use", "for", "storing", "the", "consumer", "offsets", "\"", ")", ";", "parser", "add", "argument", "(", "\"", "-", "-", "transaction", "-", "size", "\"", ")", "action", "(", "store", "(", ")", ")", "required", "(", "false", ")", "set", "default", "(", "200", ")", "type", "(", "integer", "class", ")", "metavar", "(", "\"", "transaction", "-", "size", "\"", ")", "dest", "(", "\"", "messages", "per", "transaction", "\"", ")", "help", "(", "\"", "the", "number", "of", "messages", "to", "put", "in", "each", "transaction", "default", "is", "200", "\"", ")", ";", "parser", "add", "argument", "(", "\"", "-", "-", "transaction", "-", "timeout", "\"", ")", "action", "(", "store", "(", ")", ")", "required", "(", "false", ")", "set", "default", "(", "60000", ")", "type", "(", "integer", "class", ")", "metavar", "(", "\"", "transaction", "-", "timeout", "\"", ")", "dest", "(", "\"", "transaction", "timeout", "\"", ")", "help", "(", "\"", "the", "transaction", "timeout", "in", "milliseconds", "default", "is", "60000", "(", "1", "minute", ")", "\"", ")", ";", "parser", "add", "argument", "(", "\"", "-", "-", "transactional", "-", "id", "\"", ")", "action", "(", "store", "(", ")", ")", "required", "(", "true", ")", "type", "(", "string", "class", ")", "metavar", "(", "\"", "transactional", "-", "id", "\"", ")", "dest", "(", "\"", "transactional", "id", "\"", ")", "help", "(", "\"", "the", "transactional", "id", "to", "assign", "to", "the", "producer", "\"", ")", ";", "parser", "add", "argument", "(", "\"", "-", "-", "enable", "-", "random", "-", "aborts", "\"", ")", "action", "(", "store", "true", "(", ")", ")", "type", "(", "boolean", "class", ")", "metavar", "(", "\"", "enable", "-", "random", "-", "aborts", "\"", ")", "dest", "(", "\"", "enable", "random", "aborts", "\"", ")", "help", "(", "\"", "whether", "or", "not", "to", "enable", "random", "transaction", "aborts", "(", "for", "system", "testing", ")", "\"", ")", ";", "parser", "add", "argument", "(", "\"", "-", "-", "group", "-", "mode", "\"", ")", "action", "(", "store", "true", "(", ")", ")", "type", "(", "boolean", "class", ")", "metavar", "(", "\"", "group", "-", "mode", "\"", ")", "dest", "(", "\"", "group", "mode", "\"", ")", "help", "(", "\"", "whether", "to", "let", "consumer", "subscribe", "to", "the", "input", "topic", "or", "do", "manual", "assign", "if", "we", "do", "\"", "+", "\"", "subscription", "based", "consumption", ",", "the", "input", "partition", "shall", "be", "ignored", "\"", ")", ";", "parser", "add", "argument", "(", "\"", "-", "-", "use", "-", "group", "-", "metadata", "\"", ")", "action", "(", "store", "true", "(", ")", ")", "type", "(", "boolean", "class", ")", "metavar", "(", "\"", "use", "-", "group", "-", "metadata", "\"", ")", "dest", "(", "\"", "use", "group", "metadata", "\"", ")", "help", "(", "\"", "whether", "to", "use", "the", "new", "transactional", "commit", "api", "with", "group", "metadata", "\"", ")", ";", "return", "parser", ";", "}" ]

[ "returns", "the", "set", "of", "configuration", "options", "that", "are", "supported", "in", "this", "module" ]

[ "public", "immutable", "list", "<", "class", "<", "?", "extends", "fragment", "options", ">", ">", "get", "configuration", "options", "(", ")", "{", "return", "configuration", "options", ";", "}" ]

[ "add", "cli", "options", "which", "are", "specific", "to", "the", "failover", "command", "and", "no", "others" ]

[ "private", "void", "add", "failover", "cli", "opts", "(", "options", "failover", "opts", ")", "{", "failover", "opts", "add", "option", "(", "forcefence", ",", "false", ",", "\"", "force", "fencing", "\"", ")", ";", "failover", "opts", "add", "option", "(", "forceactive", ",", "false", ",", "\"", "force", "failover", "\"", ")", ";", "/", "/", "don", "'", "t", "add", "forcemanual", ",", "since", "that", "'", "s", "added", "separately", "for", "all", "commands", "/", "/", "that", "change", "state", "}" ]

[ "gets", "signing", "key", "setting" ]

[ "protected", "string", "get", "signing", "key", "setting", "(", ")", "{", "return", "\"", "n", "/", "a", "\"", ";", "}" ]

[ "the", "main", "driver", "for", "sort", "program", "invoke", "this", "method", "to", "submit", "the", "mapreduce", "job" ]

[ "public", "int", "run", "(", "string", "[", "]", "args", ")", "throws", "exception", "{", "configuration", "conf", "=", "get", "conf", "(", ")", ";", "job", "client", "client", "=", "new", "job", "client", "(", "conf", ")", ";", "cluster", "status", "cluster", "=", "client", "get", "cluster", "status", "(", ")", ";", "int", "num", "reduces", "=", "(", "int", ")", "(", "cluster", "get", "max", "reduce", "tasks", "(", ")", "*", "0", "9", ")", ";", "string", "join", "reduces", "=", "conf", "get", "(", "reduces", "per", "host", ")", ";", "if", "(", "join", "reduces", "!", "=", "null", ")", "{", "num", "reduces", "=", "cluster", "get", "task", "trackers", "(", ")", "*", "integer", "parse", "int", "(", "join", "reduces", ")", ";", "}", "job", "job", "=", "job", "get", "instance", "(", "conf", ")", ";", "job", "set", "job", "name", "(", "\"", "join", "\"", ")", ";", "job", "set", "jar", "by", "class", "(", "sort", "class", ")", ";", "job", "set", "mapper", "class", "(", "mapper", "class", ")", ";", "job", "set", "reducer", "class", "(", "reducer", "class", ")", ";", "class", "<", "?", "extends", "input", "format", ">", "input", "format", "class", "=", "sequence", "file", "input", "format", "class", ";", "class", "<", "?", "extends", "output", "format", ">", "output", "format", "class", "=", "sequence", "file", "output", "format", "class", ";", "class", "<", "?", "extends", "writable", "comparable", ">", "output", "key", "class", "=", "bytes", "writable", "class", ";", "class", "<", "?", "extends", "writable", ">", "output", "value", "class", "=", "tuple", "writable", "class", ";", "string", "op", "=", "\"", "inner", "\"", ";", "list", "<", "string", ">", "other", "args", "=", "new", "array", "list", "<", "string", ">", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "args", "length", ";", "+", "+", "i", ")", "{", "try", "{", "if", "(", "\"", "-", "r", "\"", "equals", "(", "args", "[", "i", "]", ")", ")", "{", "num", "reduces", "=", "integer", "parse", "int", "(", "args", "[", "+", "+", "i", "]", ")", ";", "}", "else", "if", "(", "\"", "-", "in", "format", "\"", "equals", "(", "args", "[", "i", "]", ")", ")", "{", "input", "format", "class", "=", "class", "for", "name", "(", "args", "[", "+", "+", "i", "]", ")", "as", "subclass", "(", "input", "format", "class", ")", ";", "}", "else", "if", "(", "\"", "-", "out", "format", "\"", "equals", "(", "args", "[", "i", "]", ")", ")", "{", "output", "format", "class", "=", "class", "for", "name", "(", "args", "[", "+", "+", "i", "]", ")", "as", "subclass", "(", "output", "format", "class", ")", ";", "}", "else", "if", "(", "\"", "-", "out", "key", "\"", "equals", "(", "args", "[", "i", "]", ")", ")", "{", "output", "key", "class", "=", "class", "for", "name", "(", "args", "[", "+", "+", "i", "]", ")", "as", "subclass", "(", "writable", "comparable", "class", ")", ";", "}", "else", "if", "(", "\"", "-", "out", "value", "\"", "equals", "(", "args", "[", "i", "]", ")", ")", "{", "output", "value", "class", "=", "class", "for", "name", "(", "args", "[", "+", "+", "i", "]", ")", "as", "subclass", "(", "writable", "class", ")", ";", "}", "else", "if", "(", "\"", "-", "join", "op", "\"", "equals", "(", "args", "[", "i", "]", ")", ")", "{", "op", "=", "args", "[", "+", "+", "i", "]", ";", "}", "else", "{", "other", "args", "add", "(", "args", "[", "i", "]", ")", ";", "}", "}", "catch", "(", "number", "format", "exception", "except", ")", "{", "system", "out", "println", "(", "\"", "error", ":", "integer", "expected", "instead", "of", "\"", "+", "args", "[", "i", "]", ")", ";", "return", "print", "usage", "(", ")", ";", "}", "catch", "(", "array", "index", "out", "of", "bounds", "exception", "except", ")", "{", "system", "out", "println", "(", "\"", "error", ":", "required", "parameter", "missing", "from", "\"", "+", "args", "[", "i", "-", "1", "]", ")", ";", "return", "print", "usage", "(", ")", ";", "/", "/", "exits", "}", "}", "/", "/", "set", "user", "-", "supplied", "(", "possibly", "default", ")", "job", "configs", "job", "set", "num", "reduce", "tasks", "(", "num", "reduces", ")", ";", "if", "(", "other", "args", "size", "(", ")", "<", "2", ")", "{", "system", "out", "println", "(", "\"", "error", ":", "wrong", "number", "of", "parameters", ":", "\"", ")", ";", "return", "print", "usage", "(", ")", ";", "}", "file", "output", "format", "set", "output", "path", "(", "job", ",", "new", "path", "(", "other", "args", "remove", "(", "other", "args", "size", "(", ")", "-", "1", ")", ")", ")", ";", "list", "<", "path", ">", "plist", "=", "new", "array", "list", "<", "path", ">", "(", "other", "args", "size", "(", ")", ")", ";", "for", "(", "string", "s", ":", "other", "args", ")", "{", "plist", "add", "(", "new", "path", "(", "s", ")", ")", ";", "}", "job", "set", "input", "format", "class", "(", "composite", "input", "format", "class", ")", ";", "job", "get", "configuration", "(", ")", "set", "(", "composite", "input", "format", "join", "expr", ",", "composite", "input", "format", "compose", "(", "op", ",", "input", "format", "class", ",", "plist", "to", "array", "(", "new", "path", "[", "0", "]", ")", ")", ")", ";", "job", "set", "output", "format", "class", "(", "output", "format", "class", ")", ";", "job", "set", "output", "key", "class", "(", "output", "key", "class", ")", ";", "job", "set", "output", "value", "class", "(", "output", "value", "class", ")", ";", "date", "start", "time", "=", "new", "date", "(", ")", ";", "system", "out", "println", "(", "\"", "job", "started", ":", "\"", "+", "start", "time", ")", ";", "int", "ret", "=", "job", "wait", "for", "completion", "(", "true", ")", "?", "0", ":", "1", ";", "date", "end", "time", "=", "new", "date", "(", ")", ";", "system", "out", "println", "(", "\"", "job", "ended", ":", "\"", "+", "end", "time", ")", ";", "system", "out", "println", "(", "\"", "the", "job", "took", "\"", "+", "(", "end", "time", "get", "time", "(", ")", "-", "start", "time", "get", "time", "(", ")", ")", "/", "1000", "+", "\"", "seconds", "\"", ")", ";", "return", "ret", ";", "}" ]

[ "gets", "a", "description", "of", "the", "state", "which", "is", "more", "human", "-", "readable", "than", "the", "enum", "'", "s", "name" ]

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

[ "configure", "a", "processor", "function", "to", "customize", "marshaller", "instances" ]

[ "public", "void", "set", "marshaller", "processor", "(", "function", "<", "marshaller", ",", "marshaller", ">", "processor", ")", "{", "this", "marshaller", "processor", "=", "this", "marshaller", "processor", "and", "then", "(", "processor", ")", ";", "}" ]

[ "apply", "the", "given", "cache", "seconds", "and", "generate", "respective", "http", "headers", "that", "is", ",", "allow", "caching", "for", "the", "given", "number", "of", "seconds", "in", "the", "case", "of", "a", "positive", "value", ",", "prevent", "caching", "if", "given", "a", "0", "value", ",", "else", "do", "nothing", "(", "i", "e", "leave", "caching", "to", "the", "client", ")" ]

[ "protected", "final", "void", "apply", "cache", "seconds", "(", "http", "servlet", "response", "response", ",", "int", "cache", "seconds", ",", "boolean", "must", "revalidate", ")", "{", "if", "(", "cache", "seconds", ">", "0", ")", "{", "cache", "for", "seconds", "(", "response", ",", "cache", "seconds", ",", "must", "revalidate", ")", ";", "}", "else", "if", "(", "cache", "seconds", "=", "=", "0", ")", "{", "prevent", "caching", "(", "response", ")", ";", "}", "}" ]

[ "called", "when", "the", "renderer", "reads", "a", "new", "format" ]

[ "protected", "void", "on", "format", "changed", "(", "format", "format", ")", "{", "}" ]

[ "register", "a", "sub", "-", "protocol", "handler" ]

[ "public", "void", "add", "protocol", "handler", "(", "sub", "protocol", "handler", "handler", ")", "{", "list", "<", "string", ">", "protocols", "=", "handler", "get", "supported", "protocols", "(", ")", ";", "if", "(", "collection", "utils", "is", "empty", "(", "protocols", ")", ")", "{", "if", "(", "logger", "is", "error", "enabled", "(", ")", ")", "{", "logger", "error", "(", "\"", "no", "sub", "-", "protocols", "for", "\"", "+", "handler", ")", ";", "}", "return", ";", "}", "for", "(", "string", "protocol", ":", "protocols", ")", "{", "sub", "protocol", "handler", "replaced", "=", "this", "protocol", "handler", "lookup", "put", "(", "protocol", ",", "handler", ")", ";", "if", "(", "replaced", "!", "=", "null", "&", "&", "replaced", "!", "=", "handler", ")", "{", "throw", "new", "illegal", "state", "exception", "(", "\"", "cannot", "map", "\"", "+", "handler", "+", "\"", "to", "protocol", "'", "\"", "+", "protocol", "+", "\"", "'", ":", "already", "mapped", "to", "\"", "+", "replaced", "+", "\"", "\"", ")", ";", "}", "}", "this", "protocol", "handlers", "add", "(", "handler", ")", ";", "}" ]

[ "returns", "a", "unique", "class", "member", "name", ",", "based", "on", "the", "given", "name", "and", "descriptor" ]

[ "private", "string", "new", "unique", "member", "name", "(", "string", "name", ",", "string", "descriptor", ")", "{", "return", "name", "equals", "(", "class", "constants", "method", "name", "init", ")", "?", "class", "constants", "method", "name", "init", ":", "name", "+", "class", "constants", "special", "member", "separator", "+", "long", "to", "hex", "string", "(", "math", "abs", "(", "(", "descriptor", ")", "hash", "code", "(", ")", ")", ")", ";", "}" ]

[ "get", "the", "size", "of", "the", "cache" ]

[ "protected", "long", "get", "cache", "size", "(", ")", "throws", "i", "o", "exception", "{", "if", "(", "this", "location", "cache", "!", "=", "null", ")", "{", "return", "this", "location", "cache", "size", "(", ")", ";", "}", "throw", "new", "i", "o", "exception", "(", "\"", "local", "cache", "is", "null", "\"", ")", ";", "}" ]

[ "stops", "the", "object", "called", "after", "the", "application", "is", "no", "longer", "accepting", "requests" ]

[ "void", "stop", "(", ")", "throws", "exception", ";" ]

[ "test", "if", "(", "1", ")", "the", "rpc", "server", "uses", "the", "call", "idretry", "provided", "by", "the", "rpc", "client", ",", "and", "(", "2", ")", "the", "rpc", "client", "receives", "the", "same", "call", "idretry", "from", "the", "rpc", "server" ]

[ "public", "void", "test", "call", "id", "and", "retry", "(", ")", "throws", "i", "o", "exception", "{", "final", "call", "info", "info", "=", "new", "call", "info", "(", ")", ";", "/", "/", "override", "client", "to", "store", "the", "call", "info", "and", "check", "response", "final", "client", "client", "=", "new", "client", "(", "long", "writable", "class", ",", "conf", ")", "{", "@", "override", "call", "create", "call", "(", "rpc", "kind", "rpc", "kind", ",", "writable", "rpc", "request", ")", "{", "final", "call", "call", "=", "super", "create", "call", "(", "rpc", "kind", ",", "rpc", "request", ")", ";", "info", "id", "=", "call", "id", ";", "info", "retry", "=", "call", "retry", ";", "return", "call", ";", "}", "@", "override", "void", "check", "response", "(", "rpc", "response", "header", "proto", "header", ")", "throws", "i", "o", "exception", "{", "super", "check", "response", "(", "header", ")", ";", "assert", "assert", "equals", "(", "info", "id", ",", "header", "get", "call", "id", "(", ")", ")", ";", "assert", "assert", "equals", "(", "info", "retry", ",", "header", "get", "retry", "count", "(", ")", ")", ";", "}", "}", ";", "/", "/", "attach", "a", "listener", "that", "tracks", "every", "call", "received", "by", "the", "server", "final", "test", "server", "server", "=", "new", "test", "server", "(", "1", ",", "false", ")", ";", "server", "call", "listener", "=", "new", "runnable", "(", ")", "{", "@", "override", "public", "void", "run", "(", ")", "{", "assert", "assert", "equals", "(", "info", "id", ",", "server", "get", "call", "id", "(", ")", ")", ";", "assert", "assert", "equals", "(", "info", "retry", ",", "server", "get", "call", "retry", "count", "(", ")", ")", ";", "}", "}", ";", "try", "{", "inet", "socket", "address", "addr", "=", "net", "utils", "get", "connect", "address", "(", "server", ")", ";", "server", "start", "(", ")", ";", "final", "serial", "caller", "caller", "=", "new", "serial", "caller", "(", "client", ",", "addr", ",", "10", ")", ";", "caller", "run", "(", ")", ";", "assert", "false", "(", "caller", "failed", ")", ";", "}", "finally", "{", "client", "stop", "(", ")", ";", "server", "stop", "(", ")", ";", "}", "}" ]

[ "translate", "particle", "given", "amount", "continuous", "collision", "detection", "achieved", "by", "using", "ray", "cast", "from", "old", "pos", "to", "new", "pos" ]

[ "public", "void", "translate", "(", "float", "velocity", "x", ",", "float", "velocity", "y", ")", "{", "/", "*", "*", "if", "velocities", "squares", "summed", "is", "shorter", "than", "epsilon", "it", "could", "lead", "~", "0", "length", "ray", "cast", "that", "cause", "nasty", "c", "+", "+", "assertion", "*", "inside", "box", "2d", "this", "is", "so", "short", "distance", "that", "moving", "particle", "has", "no", "effect", "so", "this", "return", "early", "*", "/", "if", "(", "(", "velocity", "x", "*", "velocity", "x", "+", "velocity", "y", "*", "velocity", "y", ")", "<", "epsilon", ")", "return", ";", "/", "*", "*", "position", "offset", "is", "half", "of", "sprite", "texture", "size", "*", "/", "final", "float", "x", "=", "get", "x", "(", ")", "+", "get", "width", "(", ")", "/", "2f", ";", "final", "float", "y", "=", "get", "y", "(", ")", "+", "get", "height", "(", ")", "/", "2f", ";", "/", "*", "*", "collision", "flag", "to", "false", "*", "/", "particle", "collided", "=", "false", ";", "start", "point", "set", "(", "x", ",", "y", ")", ";", "end", "point", "set", "(", "x", "+", "velocity", "x", ",", "y", "+", "velocity", "y", ")", ";", "if", "(", "world", "!", "=", "null", ")", "world", "ray", "cast", "(", "ray", "call", "back", ",", "start", "point", ",", "end", "point", ")", ";" ]

[ "write", "variable", "length", "bytes", "to", "byte", "buffers" ]

[ "public", "void", "write", "bytes", "(", "final", "byte", "[", "]", "value", ")", "{", "byte", "buf", "write", "bytes", "(", "value", ")", ";", "}" ]

[ "ask", "this", "provider", "for", "the", "name", "servers", "to", "query", "for", "{", "@", "code", "hostname", "}" ]

[ "dns", "server", "address", "stream", "name", "server", "address", "stream", "(", "string", "hostname", ")", ";" ]

[ "set", "the", "owner", "value" ]

[ "public", "list", "result", "entry", "schema", "with", "owner", "(", "final", "string", "owner", ")", "{", "this", "owner", "=", "owner", ";", "return", "this", ";", "}" ]

[ "ensures", "that", "all", "nodes", "in", "the", "cluster", "are", "connected", "to", "each", "other", "some", "network", "disruptions", "may", "leave", "nodes", "that", "are", "not", "the", "master", "disconnected", "from", "each", "other", "{", "@", "link", "org", "elasticsearch", "cluster", "node", "connections", "service", "}", "will", "eventually", "reconnect", "but", "it", "'", "s", "handy", "to", "be", "able", "to", "ensure", "this", "happens", "faster" ]

[ "public", "static", "void", "ensure", "fully", "connected", "cluster", "(", "internal", "test", "cluster", "cluster", ")", "{", "final", "string", "[", "]", "node", "names", "=", "cluster", "get", "node", "names", "(", ")", ";", "final", "count", "down", "latch", "count", "down", "latch", "=", "new", "count", "down", "latch", "(", "node", "names", "length", ")", ";", "for", "(", "string", "node", ":", "node", "names", ")", "{", "cluster", "state", "state", "on", "node", "=", "cluster", "get", "instance", "(", "cluster", "service", "class", ",", "node", ")", "state", "(", ")", ";", "cluster", "get", "instance", "(", "node", "connections", "service", "class", ",", "node", ")", "reconnect", "to", "nodes", "(", "state", "on", "node", "nodes", "(", ")", ",", "count", "down", "latch", ":", ":", "count", "down", ")", ";", "}", "try", "{", "count", "down", "latch", "await", "(", ")", ";", "}", "catch", "(", "interrupted", "exception", "e", ")", "{", "throw", "new", "assertion", "error", "(", "e", ")", ";", "}", "}" ]

[ "create", "the", "main", "panel" ]

[ "private", "void", "create", "(", ")", "{", "key", "listener", "listener", "=", "new", "key", "adapter", "(", ")", "{", "@", "override", "public", "void", "key", "pressed", "(", "key", "event", "e", ")", "{", "if", "(", "e", "get", "key", "code", "(", ")", "=", "=", "key", "event", "vk", "enter", ")", "{", "e", "consume", "(", ")", ";", "ok", "callback", "(", ")", ";", "}", "}", "}", ";", "panel", "=", "new", "j", "panel", "(", ")", ";", "panel", "set", "layout", "(", "new", "border", "layout", "(", "10", ",", "10", ")", ")", ";", "panel", "add", "(", "new", "g", "label", "(", "\"", "clear", "options", ":", "\"", ")", ",", "border", "layout", "north", ")", ";", "j", "panel", "cb", "panel", "=", "new", "j", "panel", "(", ")", ";", "box", "layout", "bl", "=", "new", "box", "layout", "(", "cb", "panel", ",", "box", "layout", "y", "axis", ")", ";", "cb", "panel", "set", "layout", "(", "bl", ")", ";", "symbols", "cb", "=", "new", "g", "check", "box", "(", "\"", "symbols", "\"", ")", ";", "comments", "cb", "=", "new", "g", "html", "check", "box", "(", "\"", "<", "html", ">", "comments", "<", "font", "size", "=", "\\", "\"", "2", "\\", "\"", ">", "(", "does", "not", "affect", "automatic", "comments", ")", "<", "/", "font", ">", "\"", ")", ";", "comments", "cb", "set", "vertical", "text", "position", "(", "swing", "constants", "top", ")", ";", "properties", "cb", "=", "new", "g", "check", "box", "(", "\"", "properties", "\"", ")", ";", "code", "cb", "=", "new", "g", "check", "box", "(", "\"", "code", "\"", ")", ";", "functions", "cb", "=", "new", "g", "check", "box", "(", "\"", "functions", "\"", ")", ";", "registers", "cb", "=", "new", "g", "check", "box", "(", "\"", "registers", "\"", ")", ";", "equates", "cb", "=", "new", "g", "check", "box", "(", "\"", "equates", "\"", ")", ";", "user", "references", "cb", "=", "new", "g", "check", "box", "(", "\"", "user", "-", "defined", "references", "\"", ")", ";", "analysis", "references", "cb", "=", "new", "g", "check", "box", "(", "\"", "analysis", "references", "\"", ")", ";", "import", "references", "cb", "=", "new", "g", "check", "box", "(", "\"", "import", "references", "\"", ")", ";", "system", "references", "cb", "=", "new", "g", "check", "box", "(", "\"", "default", "references", "\"", ")", ";", "bookmarks", "cb", "=", "new", "g", "check", "box", "(", "\"", "bookmarks", "\"", ")", ";", "symbols", "cb", "set", "selected", "(", "true", ")", ";", "symbols", "cb", "add", "key", "listener", "(", "listener", ")", ";", "comments", "cb", "set", "selected", "(", "true", ")", ";", "comments", "cb", "add", "key", "listener", "(", "listener", ")", ";", "properties", "cb", "set", "selected", "(", "true", ")", ";", "properties", "cb", "add", "key", "listener", "(", "listener", ")", ";", "code", "cb", "set", "selected", "(", "true", ")", ";", "code", "cb", "add", "key", "listener", "(", "listener", ")", ";", "functions", "cb", "set", "selected", "(", "true", ")", ";", "functions", "cb", "add", "key", "listener", "(", "listener", ")", ";", "registers", "cb", "set", "selected", "(", "true", ")", ";", "registers", "cb", "add", "key", "listener", "(", "listener", ")", ";", "equates", "cb", "set", "selected", "(", "true", ")", ";", "equates", "cb", "add", "key", "listener", "(", "listener", ")", ";", "user", "references", "cb", "set", "selected", "(", "true", ")", ";", "user", "references", "cb", "add", "key", "listener", "(", "listener", ")", ";", "analysis", "references", "cb", "set", "selected", "(", "true", ")", ";", "analysis", "references", "cb", "add", "key", "listener", "(", "listener", ")", ";", "import", "references", "cb", "set", "selected", "(", "true", ")", ";", "import", "references", "cb", "add", "key", "listener", "(", "listener", ")", ";", "system", "references", "cb", "set", "selected", "(", "true", ")", ";", "system", "references", "cb", "add", "key", "listener", "(", "listener", ")", ";", "bookmarks", "cb", "set", "selected", "(", "true", ")", ";", "bookmarks", "cb", "add", "key", "listener", "(", "listener", ")", ";", "cb", "panel", "add", "(", "symbols", "cb", ")", ";", "cb", "panel", "add", "(", "comments", "cb", ")", ";", "cb", "panel", "add", "(", "properties", "cb", ")", ";", "cb", "panel", "add", "(", "code", "cb", ")", ";", "cb", "panel", "add", "(", "user", "references", "cb", ")", ";", "cb", "panel", "add", "(", "analysis", "references", "cb", ")", ";", "cb", "panel", "add", "(", "import", "references", "cb", ")", ";", "cb", "panel", "add", "(", "system", "references", "cb", ")", ";", "cb", "panel", "add", "(", "functions", "cb", ")", ";", "cb", "panel", "add", "(", "registers", "cb", ")", ";", "cb", "panel", "add", "(", "equates", "cb", ")", ";", "cb", "panel", "add", "(", "bookmarks", "cb", ")", ";", "/", "/", "if", "a", "user", "clears", "the", "code", ",", "then", "we", "will", "force", "them", "/", "/", "to", "clear", "all", "user", "references", "code", "cb", "add", "item", "listener", "(", "new", "item", "listener", "(", ")", "{", "@", "override", "public", "void", "item", "state", "changed", "(", "item", "event", "e", ")", "{", "if", "(", "code", "cb", "is", "selected", "(", ")", ")", "{", "user", "references", "cb", "set", "selected", "(", "true", ")", ";", "user", "references", "cb", "set", "enabled", "(", "false", ")", ";", "analysis", "references", "cb", "set", "selected", "(", "true", ")", ";", "analysis", "references", "cb", "set", "enabled", "(", "false", ")", ";", "import", "references", "cb", "set", "selected", "(", "true", ")", ";", "import", "references", "cb", "set", "enabled", "(", "false", ")", ";", "system", "references", "cb", "set", "selected", "(", "true", ")", ";", "system", "references", "cb", "set", "enabled", "(", "false", ")", ";", "}", "else", "{", "user", "references", "cb", "set", "enabled", "(", "true", ")", ";", "analysis", "references", "cb", "set", "enabled", "(", "true", ")", ";", "import", "references", "cb", "set", "enabled", "(", "true", ")", ";", "system", "references", "cb", "set", "enabled", "(", "true", ")", ";", "}", "}", "}", ")", ";", "user", "references", "cb", "set", "enabled", "(", "false", ")", ";", "analysis", "references", "cb", "set", "enabled", "(", "false", ")", ";", "import", "references", "cb", "set", "enabled", "(", "false", ")", ";", "system", "references", "cb", "set", "enabled", "(", "false", ")", ";", "/", "/", "record", "the", "checkboxes", "for", "later", "use", "final", "list", "<", "j", "check", "box", ">", "check", "box", "list", "=", "new", "array", "list", "<", ">", "(", "10", ")", ";", "check", "box", "list", "add", "(", "symbols", "cb", ")", ";", "check", "box", "list", "add", "(", "comments", "cb", ")", ";", "check", "box", "list", "add", "(", "properties", "cb", ")", ";", "check", "box", "list", "add", "(", "code", "cb", ")", ";", "check", "box", "list", "add", "(", "user", "references", "cb", ")", ";", "check", "box", "list", "add", "(", "analysis", "references", "cb", ")", ";", "check", "box", "list", "add", "(", "import", "references", "cb", ")", ";", "check", "box", "list", "add", "(", "system", "references", "cb", ")", ";", "check", "box", "list", "add", "(", "functions", "cb", ")", ";", "check", "box", "list", "add", "(", "registers", "cb", ")", ";", "check", "box", "list", "add", "(", "equates", "cb", ")", ";", "check", "box", "list", "add", "(", "bookmarks", "cb", ")", ";", "j", "panel", "button", "panel", "=", "new", "j", "panel", "(", ")", ";", "j", "button", "select", "all", "button", "=", "new", "j", "button", "(", "\"", "select", "all", "\"", ")", ";", "select", "all", "button", "add", "action", "listener", "(", "new", "action", "listener", "(", ")", "{", "@", "override", "public", "void", "action", "performed", "(", "action", "event", "e", ")", "{", "set", "all", "check", "boxes", "selected", "(", "true", ",", "check", "box", "list", ")", ";", "}", "}", ")", ";", "j", "button", "deselect", "allbutton", "=", "new", "j", "button", "(", "\"", "deselect", "all", "\"", ")", ";", "deselect", "allbutton", "add", "action", "listener", "(", "new", "action", "listener", "(", ")", "{", "@", "override", "public", "void", "action", "performed", "(", "action", "event", "e", ")", "{", "set", "all", "check", "boxes", "selected", "(", "false", ",", "check", "box", "list", ")", ";", "}", "}", ")", ";", "button", "panel", "add", "(", "select", "all", "button", ")", ";", "button", "panel", "add", "(", "box", "create", "horizontal", "strut", "(", "10", ")", ")", ";", "button", "panel", "add", "(", "deselect", "allbutton", ")", ";", "j", "panel", "lower", "panel", "=", "new", "j", "panel", "(", ")", ";", "lower", "panel", "set", "layout", "(", "new", "box", "layout", "(", "lower", "panel", ",", "box", "layout", "y", "axis", ")", ")", ";", "j", "separator", "separator", "=", "new", "j", "separator", "(", ")", ";", "lower", "panel", "set", "border", "(", "border", "factory", "create", "empty", "border", "(", "0", ",", "10", ",", "5", ",", "10", ")", ")", ";", "lower", "panel", "add", "(", "separator", ")", ";", "lower", "panel", "add", "(", "button", "panel", ")", ";", "j", "panel", "p", "=", "new", "j", "panel", "(", "new", "flow", "layout", "(", "flow", "layout", "center", ")", ")", ";", "p", "add", "(", "cb", "panel", ")", ";", "panel", "add", "(", "p", ",", "border", "layout", "center", ")", ";", "panel", "add", "(", "lower", "panel", ",", "border", "layout", "south", ")", ";", "}" ]

[ "gets", "the", "broadcast", "data", "set", "registered", "under", "the", "given", "name", "broadcast", "data", "sets", "are", "available", "on", "all", "parallel", "instances", "of", "a", "function", "they", "can", "be", "registered", "via", "{", "@", "link", "org", "apache", "flink", "graph", "spargel", "scatter", "gather", "configuration", "#", "add", "broadcast", "set", "for", "gather", "function", "(", "string", ",", "org", "apache", "flink", "api", "java", "data", "set", ")", "}" ]

[ "public", "<", "t", ">", "collection", "<", "t", ">", "get", "broadcast", "set", "(", "string", "name", ")", "{", "return", "this", "runtime", "context", "get", "broadcast", "variable", "(", "name", ")", ";", "}" ]