Datasets:

Anonymous2023

/

KGSum

like 0

[ "test", "behavior", "if", "the", "first", "operation", "on", "a", "connection", "(", "get", "auto", "commit", ")", "throws", "s", "q", "l", "exception" ]

[ "public", "void", "test", "transaction", "with", "exception", "on", "begin", "(", ")", "throws", "exception", "{", "will", "throw", "(", "new", "s", "q", "l", "exception", "(", "\"", "cannot", "begin", "\"", ")", ")", "given", "(", "con", ")", "get", "auto", "commit", "(", ")", ";", "transaction", "template", "tt", "=", "new", "transaction", "template", "(", "tm", ")", ";", "assert", "that", "exception", "of", "type", "(", "cannot", "create", "transaction", "exception", "class", ")", "is", "thrown", "by", "(", "(", ")", "-", ">", "tt", "execute", "(", "new", "transaction", "callback", "without", "result", "(", ")", "{", "@", "override", "protected", "void", "do", "in", "transaction", "without", "result", "(", "transaction", "status", "status", ")", "{", "/", "/", "something", "transactional", "}", "}", ")", ")", ";", "boolean", "condition", "=", "!", "transaction", "synchronization", "manager", "has", "resource", "(", "ds", ")", ";", "assert", "that", "(", "condition", ")", "as", "(", "\"", "hasn", "'", "t", "thread", "connection", "\"", ")", "is", "true", "(", ")", ";", "verify", "(", "con", ")", "close", "(", ")", ";", "}" ]

[ "returns", "the", "value", "of", "one", "gauge" ]

[ "public", "com", "google", "common", "util", "concurrent", "listenable", "future", "<", "io", "grpc", "testing", "integration", "metrics", "gauge", "response", ">", "get", "gauge", "(", "io", "grpc", "testing", "integration", "metrics", "gauge", "request", "request", ")", "{", "return", "io", "grpc", "stub", "client", "calls", "future", "unary", "call", "(", "get", "channel", "(", ")", "new", "call", "(", "get", "get", "gauge", "method", "(", ")", ",", "get", "call", "options", "(", ")", ")", ",", "request", ")", ";", "}" ]

[ "creates", "a", "new", "configuration", "key", "based", "on", "the", "given", "diff", ",", "after", "applying", "a", "platform", "mapping", "transformation" ]

[ "public", "static", "key", "key", "with", "platform", "mapping", "(", "platform", "mapping", "value", "platform", "mapping", "value", ",", "build", "options", "default", "build", "options", ",", "set", "<", "class", "<", "?", "extends", "fragment", ">", ">", "fragments", ",", "build", "options", "options", "diff", "for", "reconstruction", "options", "diff", ")", "throws", "options", "parsing", "exception", "{", "return", "platform", "mapping", "value", "map", "(", "key", "without", "platform", "mapping", "(", "fragments", ",", "options", "diff", ")", ",", "default", "build", "options", ")", ";", "}" ]

[ "regression", "test", "for", "bug", "#", "3445835" ]

[ "public", "void", "test", "package", "group", "in", "deps", "(", ")", "throws", "exception", "{", "check", "error", "(", "\"", "foo", "\"", ",", "\"", "bar", "\"", ",", "\"", "in", "deps", "attribute", "of", "cc", "library", "rule", "/", "/", "foo", ":", "bar", ":", "\"", "+", "\"", "package", "group", "'", "/", "/", "foo", ":", "foo", "'", "is", "misplaced", "here", "\"", ",", "\"", "package", "group", "(", "name", "=", "'", "foo", "'", ",", "packages", "=", "[", "'", "/", "/", "none", "'", "]", ")", "\"", ",", "\"", "cc", "library", "(", "name", "=", "'", "bar", "'", ",", "deps", "=", "[", "'", ":", "foo", "'", "]", ")", "\"", ")", ";", "}" ]

[ "<", "code", ">", "optional", "bool", "sex", "=", "5", ";", "<", "code", ">" ]

[ "public", "boolean", "get", "sex", "(", ")", "{", "return", "sex", ";", "}" ]

[ "indicates", "whether", "some", "other", "object", "is", "\"", "equal", "to", "\"", "this", "one" ]

[ "public", "boolean", "equals", "(", "object", "obj", ")", "{", "if", "(", "obj", "=", "=", "null", ")", "{", "return", "false", ";", "}", "if", "(", "obj", "=", "=", "this", ")", "{", "return", "true", ";", "}", "if", "(", "get", "class", "(", ")", "!", "=", "obj", "get", "class", "(", ")", ")", "{", "return", "false", ";", "}", "ghidra", "tool", "template", "other", "template", "=", "(", "ghidra", "tool", "template", ")", "obj", ";", "if", "(", "hash", "code", "(", ")", "!", "=", "other", "template", "hash", "code", "(", ")", ")", "{", "return", "false", ";", "}", "return", "get", "name", "(", ")", "equals", "(", "other", "template", "get", "name", "(", ")", ")", ";", "}" ]

[ "randomly", "updates", "index", "routing", "table", "in", "the", "cluster", "state" ]

[ "private", "index", "routing", "table", "random", "change", "to", "index", "routing", "table", "(", "index", "routing", "table", "original", ",", "string", "[", "]", "nodes", ")", "{", "index", "routing", "table", "builder", "builder", "=", "index", "routing", "table", "builder", "(", "original", "get", "index", "(", ")", ")", ";", "for", "(", "object", "cursor", "<", "index", "shard", "routing", "table", ">", "index", "shard", "routing", "table", ":", "original", "shards", "(", ")", "values", "(", ")", ")", "{", "set", "<", "string", ">", "available", "nodes", "=", "sets", "new", "hash", "set", "(", "nodes", ")", ";", "for", "(", "shard", "routing", "shard", "routing", ":", "index", "shard", "routing", "table", "value", "shards", "(", ")", ")", "{", "available", "nodes", "remove", "(", "shard", "routing", "current", "node", "id", "(", ")", ")", ";", "if", "(", "shard", "routing", "relocating", "(", ")", ")", "{", "available", "nodes", "remove", "(", "shard", "routing", "relocating", "node", "id", "(", ")", ")", ";", "}", "}", "for", "(", "shard", "routing", "shard", "routing", ":", "index", "shard", "routing", "table", "value", "shards", "(", ")", ")", "{", "final", "shard", "routing", "updated", "shard", "routing", "=", "random", "change", "(", "shard", "routing", ",", "available", "nodes", ")", ";", "available", "nodes", "remove", "(", "updated", "shard", "routing", "current", "node", "id", "(", ")", ")", ";", "if", "(", "shard", "routing", "relocating", "(", ")", ")", "{", "available", "nodes", "remove", "(", "updated", "shard", "routing", "relocating", "node", "id", "(", ")", ")", ";", "}", "builder", "add", "shard", "(", "updated", "shard", "routing", ")", ";", "}", "}", "return", "builder", "build", "(", ")", ";", "}" ]

[ "asynchronously", "execute", "the", "http", "method", "to", "the", "given", "url", ",", "preparing", "the", "request", "with", "the", "{", "@", "link", "async", "request", "callback", "}", ",", "and", "reading", "the", "response", "with", "a", "{", "@", "link", "response", "extractor", "}" ]

[ "<", "t", ">", "listenable", "future", "<", "t", ">", "execute", "(", "uri", "url", ",", "http", "method", "method", ",", "@", "nullable", "async", "request", "callback", "request", "callback", ",", "@", "nullable", "response", "extractor", "<", "t", ">", "response", "extractor", ")", "throws", "rest", "client", "exception", ";" ]

[ "attempts", "to", "sign", "in", "or", "register", "the", "account", "specified", "by", "the", "login", "form", "if", "there", "are", "form", "errors", "(", "invalid", "email", ",", "missing", "fields", ",", "etc", ")", ",", "the", "errors", "are", "presented", "and", "no", "actual", "login", "attempt", "is", "made" ]

[ "private", "void", "attempt", "login", "(", ")", "{", "if", "(", "m", "auth", "task", "!", "=", "null", ")", "{", "return", ";", "}", "/", "/", "reset", "errors", "m", "email", "view", "set", "error", "(", "null", ")", ";", "m", "password", "view", "set", "error", "(", "null", ")", ";", "/", "/", "store", "values", "at", "the", "time", "of", "the", "login", "attempt", "string", "email", "=", "m", "email", "view", "get", "text", "(", ")", "to", "string", "(", ")", ";", "string", "password", "=", "m", "password", "view", "get", "text", "(", ")", "to", "string", "(", ")", ";", "boolean", "cancel", "=", "false", ";", "view", "focus", "view", "=", "null", ";", "/", "/", "check", "for", "a", "valid", "password", ",", "if", "the", "user", "entered", "one", "if", "(", "!", "text", "utils", "is", "empty", "(", "password", ")", "&", "&", "!", "is", "password", "valid", "(", "password", ")", ")", "{", "m", "password", "view", "set", "error", "(", "get", "string", "(", "r", "string", "error", "invalid", "password", ")", ")", ";", "focus", "view", "=", "m", "password", "view", ";", "cancel", "=", "true", ";", "}", "/", "/", "check", "for", "a", "valid", "email", "address", "if", "(", "text", "utils", "is", "empty", "(", "email", ")", ")", "{", "m", "email", "view", "set", "error", "(", "get", "string", "(", "r", "string", "error", "field", "required", ")", ")", ";", "focus", "view", "=", "m", "email", "view", ";", "cancel", "=", "true", ";", "}", "else", "if", "(", "!", "is", "email", "valid", "(", "email", ")", ")", "{", "m", "email", "view", "set", "error", "(", "get", "string", "(", "r", "string", "error", "invalid", "email", ")", ")", ";", "focus", "view", "=", "m", "email", "view", ";", "cancel", "=", "true", ";", "}", "if", "(", "cancel", ")", "{", "/", "/", "there", "was", "an", "error", ";", "don", "'", "t", "attempt", "login", "and", "focus", "the", "first", "/", "/", "form", "field", "with", "an", "error", "focus", "view", "request", "focus", "(", ")", ";", "}", "else", "{", "/", "/", "show", "a", "progress", "spinner", ",", "and", "kick", "off", "a", "background", "task", "to", "/", "/", "perform", "the", "user", "login", "attempt", "show", "progress", "(", "true", ")", ";", "m", "auth", "task", "=", "new", "user", "login", "task", "(", "email", ",", "password", ")", ";", "m", "auth", "task", "execute", "(", "(", "void", ")", "null", ")", ";", "}", "}" ]

[ "adds", "the", "given", "variable", "to", "the", "end", "of", "the", "parameters", "list", "the", "variable", "storage", "specified", "for", "the", "new", "parameter", "will", "be", "ignored", "if", "custom", "storage", "mode", "is", "not", "enabled", "the", "{", "@", "link", "variable", "utilities", "#", "check", "variable", "conflict", "(", "function", ",", "variable", ",", "variable", "storage", ",", "boolean", ")", "}", "method", "may", "be", "used", "to", "check", "and", "remove", "conflicting", "variables", "which", "already", "exist", "in", "the", "function" ]

[ "public", "parameter", "add", "parameter", "(", "variable", "var", ",", "source", "type", "source", ")", "throws", "duplicate", "name", "exception", ",", "invalid", "input", "exception", ";" ]

[ "get", "name", "integer" ]

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

[ "returns", "true", "if", "field", "success", "is", "set", "(", "has", "been", "assigned", "a", "value", ")", "and", "false", "otherwise" ]

[ "public", "boolean", "is", "set", "success", "(", ")", "{", "return", "this", "success", "!", "=", "null", ";", "}" ]

[ "the", "offset", "from", "the", "start", "of", "the", "section", "name", "table", "to", "the", "name", "of", "this", "section", "a", "value", "of", "-", "1", "indicates", "an", "unnamed", "section" ]

[ "public", "int", "get", "name", "offset", "(", ")", "{", "return", "name", "offset", ";", "}" ]

[ "sets", "a", "{", "@", "link", "media", "format", "}", "{", "@", "link", "byte", "buffer", "}", "value", "does", "nothing", "if", "{", "@", "code", "value", "}", "is", "null" ]

[ "public", "static", "void", "maybe", "set", "byte", "buffer", "(", "media", "format", "format", ",", "string", "key", ",", "@", "nullable", "byte", "[", "]", "value", ")", "{", "if", "(", "value", "!", "=", "null", ")", "{", "format", "set", "byte", "buffer", "(", "key", ",", "byte", "buffer", "wrap", "(", "value", ")", ")", ";", "}", "}" ]

[ "submit", "a", "new", "async", "search", "request", "see", "<", "a", "href", "=", "\"", "https", ":", "www", "elastic", "coguideenelasticsearchreferencecurrentasync", "-", "search", "html", "\"", ">", "the", "docs", "for", "more" ]

[ "public", "async", "search", "response", "submit", "(", "submit", "async", "search", "request", "request", ",", "request", "options", "options", ")", "throws", "i", "o", "exception", "{", "return", "rest", "high", "level", "client", "perform", "request", "and", "parse", "entity", "(", "request", ",", "async", "search", "request", "converters", ":", ":", "submit", "async", "search", ",", "options", ",", "async", "search", "response", ":", ":", "from", "x", "content", ",", "empty", "set", "(", ")", ")", ";", "}" ]

[ "register", "soft", "input", "changed", "listener" ]

[ "public", "static", "void", "register", "soft", "input", "changed", "listener", "(", "@", "non", "null", "final", "window", "window", ",", "@", "non", "null", "final", "on", "soft", "input", "changed", "listener", "listener", ")", "{", "final", "int", "flags", "=", "window", "get", "attributes", "(", ")", "flags", ";", "if", "(", "(", "flags", "&", "window", "manager", "layout", "params", "flag", "layout", "no", "limits", ")", "!", "=", "0", ")", "{", "window", "clear", "flags", "(", "window", "manager", "layout", "params", "flag", "layout", "no", "limits", ")", ";", "}", "final", "frame", "layout", "content", "view", "=", "window", "find", "view", "by", "id", "(", "android", "r", "id", "content", ")", ";", "final", "int", "[", "]", "decor", "view", "invisible", "height", "pre", "=", "{", "get", "decor", "view", "invisible", "height", "(", "window", ")", "}", ";", "on", "global", "layout", "listener", "on", "global", "layout", "listener", "=", "new", "on", "global", "layout", "listener", "(", ")", "{", "@", "override", "public", "void", "on", "global", "layout", "(", ")", "{", "int", "height", "=", "get", "decor", "view", "invisible", "height", "(", "window", ")", ";", "if", "(", "decor", "view", "invisible", "height", "pre", "[", "0", "]", "!", "=", "height", ")", "{", "listener", "on", "soft", "input", "changed", "(", "height", ")", ";", "decor", "view", "invisible", "height", "pre", "[", "0", "]", "=", "height", ";", "}", "}", "}", ";", "content", "view", "get", "view", "tree", "observer", "(", ")", "add", "on", "global", "layout", "listener", "(", "on", "global", "layout", "listener", ")", ";", "content", "view", "set", "tag", "(", "tag", "on", "global", "layout", "listener", ",", "on", "global", "layout", "listener", ")", ";", "}" ]

[ "gets", "the", "list", "of", "items", "active", "at", "the", "given", "address", "the", "result", "is", "automatically", "made", "immutable" ]

[ "public", "byte", "catch", "list", "list", "for", "(", "int", "pc", ")", "{", "int", "sz", "=", "size", "(", ")", ";", "item", "[", "]", "result", "arr", "=", "new", "item", "[", "sz", "]", ";", "int", "result", "sz", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "sz", ";", "i", "+", "+", ")", "{", "item", "one", "=", "get", "(", "i", ")", ";", "if", "(", "one", "covers", "(", "pc", ")", "&", "&", "type", "not", "found", "(", "one", ",", "result", "arr", ",", "result", "sz", ")", ")", "{", "result", "arr", "[", "result", "sz", "]", "=", "one", ";", "result", "sz", "+", "+", ";", "}", "}", "if", "(", "result", "sz", "=", "=", "0", ")", "{", "return", "empty", ";", "}", "byte", "catch", "list", "result", "=", "new", "byte", "catch", "list", "(", "result", "sz", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "result", "sz", ";", "i", "+", "+", ")", "{", "result", "set", "(", "i", ",", "result", "arr", "[", "i", "]", ")", ";", "}", "result", "set", "immutable", "(", ")", ";", "return", "result", ";", "}" ]

[ "get", "the", "connector", "'", "s", "name", "corresponding", "to", "this", "handle" ]

[ "public", "string", "name", "(", ")", "{", "return", "connector", "name", ";", "}" ]

[ "return", "the", "number", "of", "terabytes", "in", "this", "instance" ]

[ "public", "long", "to", "terabytes", "(", ")", "{", "return", "this", "bytes", "/", "bytes", "per", "tb", ";", "}" ]

[ "type", "of", "resource", "collection", "that", "is", "being", "requested", ",", "e", "g", "istionetworkingv", "1alpha", "3", "virtual", "service", "k", "8s", "&", "lt", ";", "api", "version", "&", "gt", ";", "&", "lt", ";", "kind", "&", "gt", ";", "<", "code", ">", "string", "collection", "=", "2", ";", "<", "code", ">" ]

[ "public", "java", "lang", "string", "get", "collection", "(", ")", "{", "java", "lang", "object", "ref", "=", "collection", ";", "if", "(", "!", "(", "ref", "instanceof", "java", "lang", "string", ")", ")", "{", "com", "google", "protobuf", "byte", "string", "bs", "=", "(", "com", "google", "protobuf", "byte", "string", ")", "ref", ";", "java", "lang", "string", "s", "=", "bs", "to", "string", "utf", "8", "(", ")", ";", "collection", "=", "s", ";", "return", "s", ";", "}", "else", "{", "return", "(", "java", "lang", "string", ")", "ref", ";", "}", "}" ]

[ "register", "logout", "handler" ]

[ "default", "void", "register", "logout", "post", "processor", "(", "final", "logout", "post", "processor", "handler", ")", "{", "}" ]

[ "get", "the", "parameter", "portion", "of", "the", "stack", "frame", "in", "bytes" ]

[ "public", "int", "get", "parameter", "size", "(", ")", "{", "synchronized", "(", "function", ")", "{", "if", "(", "grows", "negative", "(", ")", ")", "{", "return", "get", "positive", "size", "(", ")", "-", "get", "parameter", "offset", "(", ")", ";", "}", "return", "get", "negative", "size", "(", ")", "+", "get", "parameter", "offset", "(", ")", ";", "}", "}" ]

[ "generate", "a", "string", "listing", "the", "switch", "mapping", "implementation", ",", "the", "mapping", "for", "every", "known", "node", "and", "the", "number", "of", "nodes", "and", "unique", "switches", "known", "about", "-", "each", "entry", "to", "a", "separate", "line" ]

[ "public", "string", "dump", "topology", "(", ")", "{", "map", "<", "string", ",", "string", ">", "rack", "=", "get", "switch", "map", "(", ")", ";", "string", "builder", "builder", "=", "new", "string", "builder", "(", ")", ";", "builder", "append", "(", "\"", "mapping", ":", "\"", ")", "append", "(", "to", "string", "(", ")", ")", "append", "(", "\"", "\\", "n", "\"", ")", ";", "if", "(", "rack", "!", "=", "null", ")", "{", "builder", "append", "(", "\"", "map", ":", "\\", "n", "\"", ")", ";", "set", "<", "string", ">", "switches", "=", "new", "hash", "set", "<", "string", ">", "(", ")", ";", "for", "(", "map", "entry", "<", "string", ",", "string", ">", "entry", ":", "rack", "entry", "set", "(", ")", ")", "{", "builder", "append", "(", "\"", "\"", ")", "append", "(", "entry", "get", "key", "(", ")", ")", "append", "(", "\"", "-", ">", "\"", ")", "append", "(", "entry", "get", "value", "(", ")", ")", "append", "(", "\"", "\\", "n", "\"", ")", ";", "switches", "add", "(", "entry", "get", "value", "(", ")", ")", ";", "}", "builder", "append", "(", "\"", "nodes", ":", "\"", ")", "append", "(", "rack", "size", "(", ")", ")", "append", "(", "\"", "\\", "n", "\"", ")", "append", "(", "\"", "switches", ":", "\"", ")", "append", "(", "switches", "size", "(", ")", ")", "append", "(", "\"", "\\", "n", "\"", ")", ";", "}", "else", "{", "builder", "append", "(", "\"", "no", "topology", "information", "\"", ")", ";", "}", "return", "builder", "to", "string", "(", ")", ";", "}" ]

[ "the", "value", "of", "the", "num", "values", "item", "gives", "the", "number", "of", "elements", "in", "the", "array", "-", "typed", "value", "represented", "by", "this", "element", "value", "structure", "note", "that", "a", "maximum", "of", "65535", "elements", "are", "permitted", "in", "an", "array", "-", "typed", "element", "value", "each", "value", "of", "the", "values", "table", "gives", "the", "value", "of", "an", "element", "of", "the", "array", "-", "typed", "value", "represented", "by", "this", "element", "value", "structure" ]

[ "public", "annotation", "element", "value", "[", "]", "get", "values", "(", ")", "{", "return", "values", ";", "}" ]

[ "return", "the", "bitmap", "in", "cache" ]

[ "public", "static", "bitmap", "get", "bitmap", "(", "@", "non", "null", "final", "string", "key", ",", "final", "bitmap", "default", "value", ")", "{", "return", "get", "bitmap", "(", "key", ",", "default", "value", ",", "get", "default", "cache", "double", "utils", "(", ")", ")", ";", "}" ]

[ "subscribes", "a", "{", "@", "link", "url", "}" ]

[ "boolean", "subscribe", "u", "r", "l", "(", "url", "url", ")", ";" ]

[ "put", "string", "value", "in", "cache" ]

[ "public", "void", "put", "(", "@", "non", "null", "final", "string", "key", ",", "final", "string", "value", ",", "final", "int", "save", "time", ")", "{", "m", "cache", "memory", "utils", "put", "(", "key", ",", "value", ",", "save", "time", ")", ";", "m", "cache", "disk", "utils", "put", "(", "key", ",", "value", ",", "save", "time", ")", ";", "}" ]

[ "set", "the", "default", "autowire", "setting", "for", "the", "document", "that", "'", "s", "currently", "parsed" ]

[ "public", "void", "set", "autowire", "(", "@", "nullable", "string", "autowire", ")", "{", "this", "autowire", "=", "autowire", ";", "}" ]

[ "sets", "the", "array", "of", "first", "-", "available", "image", "requests", "that", "will", "be", "probed", "in", "order", "for", "performance", "reasons", ",", "the", "array", "is", "not", "deep", "-", "copied", ",", "but", "only", "stored", "by", "reference", "please", "don", "'", "t", "modify", "once", "submitted" ]

[ "public", "builder", "set", "first", "available", "image", "requests", "(", "request", "[", "]", "first", "available", "image", "requests", ")", "{", "return", "set", "first", "available", "image", "requests", "(", "first", "available", "image", "requests", ",", "true", ")", ";", "}" ]

[ "helper", "method", "for", "inserting", "a", "mock", "object" ]

[ "public", "void", "insert", "command", "(", "string", "command", "name", ",", "command", "command", ")", "{", "register", "one", "command", "(", "\"", "core", "/", "\"", "+", "command", "name", ",", "command", ")", ";", "}" ]

[ "returns", "true", "if", "field", "corresponding", "to", "field", "i", "d", "is", "set", "(", "has", "been", "assigned", "a", "value", ")", "and", "false", "otherwise" ]

[ "public", "boolean", "is", "set", "(", "fields", "field", ")", "{", "if", "(", "field", "=", "=", "null", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", ")", ";", "}", "switch", "(", "field", ")", "{", "case", "spouts", ":", "return", "is", "set", "spouts", "(", ")", ";", "case", "bolts", ":", "return", "is", "set", "bolts", "(", ")", ";", "case", "state", "spouts", ":", "return", "is", "set", "state", "spouts", "(", ")", ";", "}", "throw", "new", "illegal", "state", "exception", "(", ")", ";", "}" ]

[ "configures", "the", "type", "of", "generator" ]

[ "public", "codegen", "type", "get", "tag", "(", ")", "{", "return", "codegen", "type", "client", ";", "}" ]

[ "reads", "window", "state", "generated", "using", "an", "{", "@", "link", "aggregate", "function", "}" ]

[ "public", "<", "k", ",", "t", ",", "acc", ",", "r", ",", "out", ">", "data", "set", "<", "out", ">", "aggregate", "(", "string", "uid", ",", "aggregate", "function", "<", "t", ",", "acc", ",", "r", ">", "aggregate", "function", ",", "window", "reader", "function", "<", "r", ",", "out", ",", "k", ",", "w", ">", "reader", "function", ",", "type", "information", "<", "k", ">", "key", "type", ",", "type", "information", "<", "acc", ">", "acc", "type", ",", "type", "information", "<", "out", ">", "output", "type", ")", "throws", "i", "o", "exception", "{", "window", "reader", "operator", "<", "?", ",", "k", ",", "r", ",", "w", ",", "out", ">", "operator", "=", "window", "reader", "operator", "aggregate", "(", "aggregate", "function", ",", "reader", "function", ",", "key", "type", ",", "window", "serializer", ",", "acc", "type", ")", ";", "return", "read", "window", "operator", "(", "uid", ",", "output", "type", ",", "operator", ")", ";", "}" ]

[ "retrieve", "the", "vertex", "out", "-", "degree", "(", "number", "of", "out", "-", "going", "edges", ")" ]

[ "public", "long", "get", "out", "degree", "(", ")", "{", "return", "out", "degree", ";", "}" ]

[ "gets", "the", "number", "of", "pointers", "after", "the", "current", "gesture" ]

[ "public", "int", "get", "new", "pointer", "count", "(", ")", "{", "return", "m", "detector", "get", "new", "pointer", "count", "(", ")", ";", "}" ]

[ "loads", "the", "bean", "definitions", "via", "an", "xml", "bean", "definition", "reader" ]

[ "protected", "void", "load", "bean", "definitions", "(", "default", "listable", "bean", "factory", "bean", "factory", ")", "throws", "beans", "exception", ",", "i", "o", "exception", "{", "/", "/", "create", "a", "new", "xml", "bean", "definition", "reader", "for", "the", "given", "bean", "factory", "xml", "bean", "definition", "reader", "bean", "definition", "reader", "=", "new", "xml", "bean", "definition", "reader", "(", "bean", "factory", ")", ";", "/", "/", "configure", "the", "bean", "definition", "reader", "with", "this", "context", "'", "s", "/", "/", "resource", "loading", "environment", "bean", "definition", "reader", "set", "environment", "(", "get", "environment", "(", ")", ")", ";", "bean", "definition", "reader", "set", "resource", "loader", "(", "this", ")", ";", "bean", "definition", "reader", "set", "entity", "resolver", "(", "new", "resource", "entity", "resolver", "(", "this", ")", ")", ";", "/", "/", "allow", "a", "subclass", "to", "provide", "custom", "initialization", "of", "the", "reader", ",", "/", "/", "then", "proceed", "with", "actually", "loading", "the", "bean", "definitions", "init", "bean", "definition", "reader", "(", "bean", "definition", "reader", ")", ";", "load", "bean", "definitions", "(", "bean", "definition", "reader", ")", ";", "}" ]

[ "parse", "the", "given", "string", "value", "into", "a", "{", "@", "code", "media", "type", "}", "object", ",", "with", "this", "method", "name", "following", "the", "'", "value", "of", "'", "naming", "convention", "(", "as", "supported", "by", "{", "@", "link", "org", "springframework", "core", "convert", "conversion", "service", "}" ]

[ "public", "static", "media", "type", "value", "of", "(", "string", "value", ")", "{", "return", "parse", "media", "type", "(", "value", ")", ";", "}" ]

[ "retrieves", "the", "{", "@", "link", "cluster", "client", "}", "from", "the", "given", "{", "@", "link", "custom", "command", "line", "}", "and", "runs", "the", "given", "{", "@", "link", "cluster", "action", "}", "against", "it" ]

[ "private", "<", "cluster", "i", "d", ">", "void", "run", "cluster", "action", "(", "custom", "command", "line", "active", "command", "line", ",", "command", "line", "command", "line", ",", "cluster", "action", "<", "cluster", "i", "d", ">", "cluster", "action", ")", "throws", "flink", "exception", "{", "final", "configuration", "effective", "configuration", "=", "get", "effective", "configuration", "(", "active", "command", "line", ",", "command", "line", ")", ";", "log", "debug", "(", "\"", "effective", "configuration", "after", "flink", "conf", ",", "and", "custom", "commandline", ":", "{", "}", "\"", ",", "effective", "configuration", ")", ";", "final", "cluster", "client", "factory", "<", "cluster", "i", "d", ">", "cluster", "client", "factory", "=", "cluster", "client", "service", "loader", "get", "cluster", "client", "factory", "(", "effective", "configuration", ")", ";", "final", "cluster", "i", "d", "cluster", "id", "=", "cluster", "client", "factory", "get", "cluster", "id", "(", "effective", "configuration", ")", ";", "if", "(", "cluster", "id", "=", "=", "null", ")", "{", "throw", "new", "flink", "exception", "(", "\"", "no", "cluster", "id", "was", "specified", "please", "specify", "a", "cluster", "to", "which", "you", "would", "like", "to", "connect", "\"", ")", ";", "}", "try", "(", "final", "cluster", "descriptor", "<", "cluster", "i", "d", ">", "cluster", "descriptor", "=", "cluster", "client", "factory", "create", "cluster", "descriptor", "(", "effective", "configuration", ")", ")", "{", "try", "(", "final", "cluster", "client", "<", "cluster", "i", "d", ">", "cluster", "client", "=", "cluster", "descriptor", "retrieve", "(", "cluster", "id", ")", "get", "cluster", "client", "(", ")", ")", "{", "cluster", "action", "run", "action", "(", "cluster", "client", ")", ";", "}", "}", "}" ]

[ "creates", "and", "stores", "a", "list", ",", "returns", "with", "the", "id" ]

[ "public", "int", "create", "list", "(", ")", "{", "lists", "add", "(", "new", "array", "list", "<", "comparable", ">", "(", ")", ")", ";", "return", "lists", "size", "(", ")", "-", "1", ";", "}" ]

[ "execute", "the", "command" ]

[ "public", "static", "command", "result", "exec", "cmd", "(", "final", "list", "<", "string", ">", "commands", ",", "final", "boolean", "is", "rooted", ")", "{", "return", "exec", "cmd", "(", "commands", "=", "=", "null", "?", "null", ":", "commands", "to", "array", "(", "new", "string", "[", "]", "{", "}", ")", ",", "is", "rooted", ",", "true", ")", ";", "}" ]

[ "allocates", "some", "unpooled", "memory", "and", "creates", "a", "new", "memory", "segment", "that", "represents", "that", "memory", "this", "method", "is", "similar", "to", "{", "@", "link", "#", "allocate", "unpooled", "segment", "(", "int", ",", "object", ")", "}", ",", "but", "the", "memory", "segment", "will", "have", "null", "as", "the", "owner" ]

[ "public", "static", "memory", "segment", "allocate", "unpooled", "segment", "(", "int", "size", ")", "{", "return", "allocate", "unpooled", "segment", "(", "size", ",", "null", ")", ";", "}" ]

[ "deletes", "a", "pet" ]

[ "public", "void", "delete", "pet", "test", "(", ")", "{", "long", "pet", "id", "=", "null", ";", "string", "api", "key", "=", "null", ";", "/", "/", "api", "delete", "pet", "(", "pet", "id", ",", "api", "key", ")", ";", "/", "/", "todo", ":", "test", "validations", "}" ]

[ "returns", "a", "matrix", "that", "maps", "points", "from", "the", "crop", "on", "to", "the", "visible", "image", "i", "e", "if", "a", "mapped", "point", "is", "in", "bounds", ",", "then", "the", "point", "is", "on", "the", "visible", "image" ]

[ "@", "nullable", "matrix", "image", "matrix", "relative", "to", "crop", "(", ")", "{", "editor", "element", "main", "image", "=", "get", "main", "image", "(", ")", ";", "if", "(", "main", "image", "=", "=", "null", ")", "return", "null", ";", "matrix", "matrix", "1", "=", "new", "matrix", "(", "image", "crop", "get", "local", "matrix", "(", ")", ")", ";", "matrix", "1", "pre", "concat", "(", "crop", "editor", "element", "get", "local", "matrix", "(", ")", ")", ";", "matrix", "1", "pre", "concat", "(", "crop", "editor", "element", "get", "editor", "matrix", "(", ")", ")", ";", "matrix", "matrix", "2", "=", "new", "matrix", "(", "main", "image", "get", "local", "matrix", "(", ")", ")", ";", "matrix", "2", "pre", "concat", "(", "main", "image", "get", "editor", "matrix", "(", ")", ")", ";", "matrix", "2", "pre", "concat", "(", "image", "crop", "get", "local", "matrix", "(", ")", ")", ";", "matrix", "inverse", "=", "new", "matrix", "(", ")", ";", "matrix", "2", "invert", "(", "inverse", ")", ";", "inverse", "pre", "concat", "(", "matrix", "1", ")", ";", "return", "inverse", ";", "}" ]

[ "prune", "method", "with", "two", "modes", "of", "operation", ":", "{", "@", "link", "prune", "mode", "#", "all", "by", "modtime", "}", "clear", "any", "metadata", "older", "than", "a", "specified", "mod", "time", "from", "the", "store", "note", "that", "this", "modification", "time", "is", "the", "s3", "modification", "time", "from", "the", "object", "'", "s", "metadata", "-", "from", "the", "object", "store", "implementations", "must", "clear", "file", "metadata", ",", "and", "may", "clear", "directory", "metadata", "(", "s", "3a", "itself", "does", "not", "track", "modification", "time", "for", "directories", ")", "implementations", "may", "also", "choose", "to", "throw", "unsupported", "operation", "exception", "instead", "note", "that", "modification", "times", "must", "be", "in", "utc", ",", "as", "returned", "by", "system", "current", "time", "millis", "at", "the", "time", "of", "modification", "{", "@", "link", "prune", "mode", "#", "tombstones", "by", "lastupdated", "}", "clear", "any", "tombstone", "updated", "earlier", "than", "a", "specified", "time", "from", "the", "store", "note", "that", "this", "last", "updated", "is", "the", "time", "when", "the", "metadata", "entry", "was", "last", "updated", "and", "maintained", "by", "the", "metadata", "store", "implementations", "must", "clear", "file", "metadata", ",", "and", "may", "clear", "directory", "metadata", "(", "s", "3a", "itself", "does", "not", "track", "modification", "time", "for", "directories", ")", "implementations", "may", "also", "choose", "to", "throw", "unsupported", "operation", "exception", "instead", "note", "that", "last", "updated", "must", "be", "in", "utc", ",", "as", "returned", "by", "system", "current", "time", "millis", "at", "the", "time", "of", "modification" ]

[ "void", "prune", "(", "prune", "mode", "prune", "mode", ",", "long", "cutoff", ")", "throws", "i", "o", "exception", ",", "unsupported", "operation", "exception", ";" ]

[ "gets", "the", "next", "address", "in", "memory", "after", "this", "fde", "record" ]

[ "public", "address", "get", "next", "address", "(", ")", "{", "return", "next", "address", ";", "}" ]

[ "insert", "a", "new", "pcode", "op", "before", "a", "specific", "point", "in", "the", "list", "of", "pcode", "ops" ]

[ "protected", "void", "insert", "before", "(", "iterator", "<", "pcode", "op", ">", "iter", ",", "pcode", "op", "op", ")", "{", "pcode", "op", "a", "s", "t", "opast", "=", "(", "pcode", "op", "a", "s", "t", ")", "op", ";", "opast", "set", "parent", "(", "this", ")", ";", "iterator", "<", "pcode", "op", ">", "newiter", "=", "oplist", "insert", "before", "(", "iter", ",", "op", ")", ";", "opast", "set", "basic", "iter", "(", "newiter", ")", ";", "}" ]

[ "helper", "method", "to", "print", "a", "debugging", "message", ",", "if", "the", "given", "{", "@", "link", "event", "handler", "}", "is", "not", "{", "@", "code", "null", "}" ]

[ "private", "static", "void", "debug", "message", "(", "@", "nullable", "event", "handler", "event", "handler", ",", "@", "format", "string", "string", "template", ",", "object", "args", ")", "{", "if", "(", "event", "handler", "=", "=", "null", ")", "{", "return", ";", "}", "event", "handler", "handle", "(", "event", "info", "(", "\"", "toolchain", "resolution", ":", "\"", "+", "string", "format", "(", "template", ",", "args", ")", ")", ")", ";", "}" ]

[ "sets", "the", "correlation", "id", "and", "the", "delivery", "tag", "that", "corresponds", "to", "the", "records", "originating", "from", "the", "rmq", "event", "if", "the", "correlation", "id", "has", "been", "processed", "before", ",", "records", "will", "not", "be", "emitted", "downstream", "if", "not", "set", "explicitly", ",", "the", "{", "@", "link", "amqp", "basic", "properties", "#", "get", "correlation", "id", "(", ")", "}", "and", "{", "@", "link", "envelope", "#", "get", "delivery", "tag", "(", ")", "}", "will", "be", "used", "<", "b", ">", "note", ":", "<", "b", ">", "can", "be", "called", "once", "for", "a", "single", "invokation", "of", "a", "{", "@", "link", "r", "m", "q", "deserialization", "schema", "#", "deserialize", "(", "envelope", ",", "amqp", "basic", "properties", ",", "byte", "[", "]", ",", "r", "m", "q", "collector", ")", "}", "method" ]

[ "boolean", "set", "message", "identifiers", "(", "string", "correlation", "id", ",", "long", "delivery", "tag", ")", ";" ]

[ "returns", "the", "{", "@", "link", "menu", "data", "}", "to", "be", "used", "to", "put", "this", "action", "in", "a", "popup", "menu", "the", "menu", "data", "will", "be", "null", "if", "the", "action", "in", "not", "set", "to", "be", "in", "a", "popup", "menu" ]

[ "public", "menu", "data", "get", "popup", "menu", "data", "(", ")", ";" ]

[ "check", "that", "the", "given", "char", "sequence", "is", "either", "<", "code", ">", "null", "<", "code", ">", "or", "of", "length", "0", "note", ":", "will", "return", "<", "code", ">", "false", "<", "code", ">", "for", "a", "char", "sequence", "that", "purely", "consists", "of", "whitespace", "string", "utils", "is", "empty", "(", "null", ")", "=", "true", "string", "utils", "is", "empty", "(", "\"", "\"", ")", "=", "true", "string", "utils", "is", "empty", "(", "\"", "\"", ")", "=", "false", "string", "utils", "is", "empty", "(", "\"", "hello", "\"", ")", "=", "false" ]

[ "public", "static", "boolean", "is", "empty", "(", "char", "sequence", "str", ")", "{", "return", "!", "has", "length", "(", "str", ")", ";", "}" ]

[ "get", "prefix", "ns", "number" ]

[ "public", "big", "decimal", "get", "prefix", "ns", "number", "(", ")", "{", "return", "prefix", "ns", "number", ";", "}" ]

[ "model", "tests", "for", "array", "of", "array", "of", "number", "only" ]

[ "public", "void", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "array", "of", "array", "of", "number", "only", "}" ]

[ "returns", "x", "plus", "width" ]

[ "public", "float", "get", "right", "(", ")", "{", "return", "x", "+", "width", ";", "}" ]

[ "change", "the", "force", "-", "relation", "property", "for", "all", "functions", "with", "given", "name" ]

[ "public", "void", "set", "force", "relation", "by", "name", "(", "string", "library", ",", "string", "version", ",", "string", "variant", ",", "string", "function", "name", ",", "boolean", "value", ")", "throws", "i", "o", "exception", "{", "check", "update", "allowed", "(", ")", ";", "list", "<", "library", "record", ">", "library", "list", "=", "find", "libraries", "by", "name", "(", "library", ",", "version", ",", "variant", ")", ";", "for", "(", "library", "record", "lib", "rec", ":", "library", "list", ")", "{", "list", "<", "function", "record", ">", "func", "list", "=", "find", "functions", "by", "library", "and", "name", "(", "lib", "rec", ",", "function", "name", ")", ";", "modify", "flags", "(", "func", "list", ",", "function", "record", "force", "relation", "flag", ",", "value", ")", ";", "}", "}" ]

[ "builds", "audio", "renderers", "for", "use", "by", "the", "player" ]

[ "protected", "void", "build", "audio", "renderers", "(", "context", "context", ",", "@", "extension", "renderer", "mode", "int", "extension", "renderer", "mode", ",", "media", "codec", "selector", "media", "codec", "selector", ",", "boolean", "enable", "decoder", "fallback", ",", "audio", "sink", "audio", "sink", ",", "handler", "event", "handler", ",", "audio", "renderer", "event", "listener", "event", "listener", ",", "array", "list", "<", "renderer", ">", "out", ")", "{", "media", "codec", "audio", "renderer", "audio", "renderer", "=", "new", "media", "codec", "audio", "renderer", "(", "context", ",", "media", "codec", "selector", ",", "enable", "decoder", "fallback", ",", "event", "handler", ",", "event", "listener", ",", "audio", "sink", ")", ";", "audio", "renderer", "experimental", "set", "media", "codec", "operation", "mode", "(", "audio", "media", "codec", "operation", "mode", ")", ";", "out", "add", "(", "audio", "renderer", ")", ";", "if", "(", "extension", "renderer", "mode", "=", "=", "extension", "renderer", "mode", "off", ")", "{", "return", ";", "}", "int", "extension", "renderer", "index", "=", "out", "size", "(", ")", ";", "if", "(", "extension", "renderer", "mode", "=", "=", "extension", "renderer", "mode", "prefer", ")", "{", "extension", "renderer", "index", "-", "-", ";", "}", "try", "{", "/", "/", "full", "class", "names", "used", "for", "constructor", "args", "so", "the", "lint", "rule", "triggers", "if", "any", "of", "them", "move", "/", "/", "lint", "if", "change", "class", "<", "?", ">", "clazz", "=", "class", "for", "name", "(", "\"", "com", "google", "android", "exoplayer", "2", "ext", "opus", "libopus", "audio", "renderer", "\"", ")", ";", "constructor", "<", "?", ">", "constructor", "=", "clazz", "get", "constructor", "(", "android", "os", "handler", "class", ",", "com", "google", "android", "exoplayer", "2", "audio", "audio", "renderer", "event", "listener", "class", ",", "com", "google", "android", "exoplayer", "2", "audio", "audio", "sink", "class", ")", ";", "/", "/", "lint", "then", "change", "(", "/", "/", "/", "/", "/", "/", "/", "proguard", "-", "rules", "txt", ")", "renderer", "renderer", "=", "(", "renderer", ")", "constructor", "new", "instance", "(", "event", "handler", ",", "event", "listener", ",", "audio", "sink", ")", ";", "out", "add", "(", "extension", "renderer", "index", "+", "+", ",", "renderer", ")", ";", "log", "i", "(", "tag", ",", "\"", "loaded", "libopus", "audio", "renderer", "\"", ")", ";", "}", "catch", "(", "class", "not", "found", "exception", "e", ")", "{", "/", "/", "expected", "if", "the", "app", "was", "built", "without", "the", "extension", "}", "catch", "(", "exception", "e", ")", "{", "/", "/", "the", "extension", "is", "present", ",", "but", "instantiation", "failed", "throw", "new", "runtime", "exception", "(", "\"", "error", "instantiating", "opus", "extension", "\"", ",", "e", ")", ";", "}", "try", "{", "/", "/", "full", "class", "names", "used", "for", "constructor", "args", "so", "the", "lint", "rule", "triggers", "if", "any", "of", "them", "move", "/", "/", "lint", "if", "change", "class", "<", "?", ">", "clazz", "=", "class", "for", "name", "(", "\"", "com", "google", "android", "exoplayer", "2", "ext", "flac", "libflac", "audio", "renderer", "\"", ")", ";", "constructor", "<", "?", ">", "constructor", "=", "clazz", "get", "constructor", "(", "android", "os", "handler", "class", ",", "com", "google", "android", "exoplayer", "2", "audio", "audio", "renderer", "event", "listener", "class", ",", "com", "google", "android", "exoplayer", "2", "audio", "audio", "sink", "class", ")", ";", "/", "/", "lint", "then", "change", "(", "/", "/", "/", "/", "/", "/", "/", "proguard", "-", "rules", "txt", ")", "renderer", "renderer", "=", "(", "renderer", ")", "constructor", "new", "instance", "(", "event", "handler", ",", "event", "listener", ",", "audio", "sink", ")", ";", "out", "add", "(", "extension", "renderer", "index", "+", "+", ",", "renderer", ")", ";", "log", "i", "(", "tag", ",", "\"", "loaded", "libflac", "audio", "renderer", "\"", ")", ";", "}", "catch", "(", "class", "not", "found", "exception", "e", ")", "{", "/", "/", "expected", "if", "the", "app", "was", "built", "without", "the", "extension", "}", "catch", "(", "exception", "e", ")", "{", "/", "/", "the", "extension", "is", "present", ",", "but", "instantiation", "failed", "throw", "new", "runtime", "exception", "(", "\"", "error", "instantiating", "flac", "extension", "\"", ",", "e", ")", ";", "}", "try", "{", "/", "/", "full", "class", "names", "used", "for", "constructor", "args", "so", "the", "lint", "rule", "triggers", "if", "any", "of", "them", "move", "/", "/", "lint", "if", "change", "class", "<", "?", ">", "clazz", "=", "class", "for", "name", "(", "\"", "com", "google", "android", "exoplayer", "2", "ext", "ffmpeg", "ffmpeg", "audio", "renderer", "\"", ")", ";", "constructor", "<", "?", ">", "constructor", "=", "clazz", "get", "constructor", "(", "android", "os", "handler", "class", ",", "com", "google", "android", "exoplayer", "2", "audio", "audio", "renderer", "event", "listener", "class", ",", "com", "google", "android", "exoplayer", "2", "audio", "audio", "sink", "class", ")", ";", "/", "/", "lint", "then", "change", "(", "/", "/", "/", "/", "/", "/", "/", "proguard", "-", "rules", "txt", ")", "renderer", "renderer", "=", "(", "renderer", ")", "constructor", "new", "instance", "(", "event", "handler", ",", "event", "listener", ",", "audio", "sink", ")", ";", "out", "add", "(", "extension", "renderer", "index", "+", "+", ",", "renderer", ")", ";", "log", "i", "(", "tag", ",", "\"", "loaded", "ffmpeg", "audio", "renderer", "\"", ")", ";", "}", "catch", "(", "class", "not", "found", "exception", "e", ")", "{", "/", "/", "expected", "if", "the", "app", "was", "built", "without", "the", "extension", "}", "catch", "(", "exception", "e", ")", "{", "/", "/", "the", "extension", "is", "present", ",", "but", "instantiation", "failed", "throw", "new", "runtime", "exception", "(", "\"", "error", "instantiating", "f", "fmpeg", "extension", "\"", ",", "e", ")", ";", "}", "}" ]

[ "check", "for", "available", "values", "and", "set", "them", "on", "the", "given", "prepared", "statement", "if", "no", "values", "are", "available", "anymore", ",", "return", "{", "@", "code", "false", "}" ]

[ "protected", "abstract", "boolean", "set", "values", "if", "available", "(", "prepared", "statement", "ps", ",", "int", "i", ")", "throws", "s", "q", "l", "exception", ";" ]

[ "attempt", "to", "create", "{", "@", "code", "count", "}", "filesystems", "in", "parallel", ",", "then", "assert", "that", "they", "are", "all", "equal" ]

[ "private", "void", "create", "file", "systems", "(", "final", "file", "system", "cache", "cache", ",", "final", "int", "count", ")", "throws", "u", "r", "i", "syntax", "exception", ",", "interrupted", "exception", ",", "java", "util", "concurrent", "execution", "exception", "{", "final", "configuration", "conf", "=", "new", "configuration", "(", ")", ";", "conf", "set", "(", "\"", "fs", "blocking", "impl", "\"", ",", "blocking", "initializer", "name", ")", ";", "/", "/", "only", "one", "instance", "can", "be", "created", "at", "a", "time", "uri", "uri", "=", "new", "uri", "(", "\"", "blocking", ":", "/", "/", "a", "\"", ")", ";", "listening", "executor", "service", "pool", "=", "blocking", "thread", "pool", "executor", "service", "new", "instance", "(", "count", "*", "2", ",", "0", ",", "10", ",", "time", "unit", "seconds", ",", "\"", "creation", "-", "threads", "\"", ")", ";", "/", "/", "submit", "a", "set", "of", "requests", "to", "create", "an", "fs", "instance", "/", "/", "the", "semaphore", "will", "block", "all", "but", "one", ",", "and", "that", "will", "block", "until", "/", "/", "it", "is", "allowed", "to", "continue", "list", "<", "listenable", "future", "<", "file", "system", ">", ">", "futures", "=", "new", "array", "list", "<", ">", "(", "count", ")", ";", "/", "/", "acquire", "the", "semaphore", "so", "blocking", "all", "fs", "instances", "from", "/", "/", "being", "initialized", "semaphore", "semaphore", "=", "blocking", "initializer", "sem", ";", "semaphore", "acquire", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "count", ";", "i", "+", "+", ")", "{", "futures", "add", "(", "pool", "submit", "(", "(", ")", "-", ">", "cache", "get", "(", "uri", ",", "conf", ")", ")", ")", ";", "}", "/", "/", "now", "let", "all", "blocked", "initializers", "free", "semaphore", "release", "(", ")", ";", "/", "/", "get", "that", "first", "fs", "file", "system", "created", "f", "s", "=", "futures", "get", "(", "0", ")", "get", "(", ")", ";", "/", "/", "verify", "all", "the", "others", "are", "the", "same", "instance", "for", "(", "int", "i", "=", "1", ";", "i", "<", "count", ";", "i", "+", "+", ")", "{", "file", "system", "fs", "=", "futures", "get", "(", "i", ")", "get", "(", ")", ";", "assertions", "assert", "that", "(", "fs", ")", "is", "same", "as", "(", "created", "f", "s", ")", ";", "}", "}" ]

[ "recycles", "all", "the", "exclusive", "and", "floating", "buffers", "from", "the", "given", "buffer", "queue" ]

[ "void", "release", "all", "buffers", "(", "array", "deque", "<", "buffer", ">", "buffers", ")", "throws", "i", "o", "exception", "{", "/", "/", "gather", "all", "exclusive", "buffers", "and", "recycle", "them", "to", "global", "pool", "in", "batch", ",", "because", "/", "/", "we", "do", "not", "want", "to", "trigger", "redistribution", "of", "buffers", "after", "each", "recycle", "final", "list", "<", "memory", "segment", ">", "exclusive", "recycling", "segments", "=", "new", "array", "list", "<", ">", "(", ")", ";", "buffer", "buffer", ";", "while", "(", "(", "buffer", "=", "buffers", "poll", "(", ")", ")", "!", "=", "null", ")", "{", "if", "(", "buffer", "get", "recycler", "(", ")", "=", "=", "this", ")", "{", "exclusive", "recycling", "segments", "add", "(", "buffer", "get", "memory", "segment", "(", ")", ")", ";", "}", "else", "{", "buffer", "recycle", "buffer", "(", ")", ";", "}", "}", "synchronized", "(", "buffer", "queue", ")", "{", "buffer", "queue", "release", "all", "(", "exclusive", "recycling", "segments", ")", ";", "buffer", "queue", "notify", "all", "(", ")", ";", "}", "if", "(", "exclusive", "recycling", "segments", "size", "(", ")", ">", "0", ")", "{", "global", "pool", "recycle", "memory", "segments", "(", "exclusive", "recycling", "segments", ")", ";", "}", "}" ]

[ "sets", "the", "animation", "play", "mode" ]

[ "public", "void", "set", "play", "mode", "(", "play", "mode", "play", "mode", ")", "{", "this", "play", "mode", "=", "play", "mode", ";", "}" ]

[ "creates", "a", "detached", "map", "from", "the", "current", "snapshot", "of", "the", "data", ",", "keyed", "from", "a", "descriptor", "to", "an", "instance" ]

[ "public", "map", "<", "d", ",", "t", ">", "to", "map", "(", ")", "{", "return", "(", "map", ")", "descriptor", "to", "map", "(", "data", ")", ";", "}" ]

[ "get", "the", "{", "@", "link", "application", "events", "}", "for", "the", "current", "thread" ]

[ "public", "static", "application", "events", "get", "application", "events", "(", ")", "{", "return", "application", "events", "get", "(", ")", ";", "}" ]

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

[ "no", "changes", "were", "made", "to", "the", "models" ]

[ "static", "diff", "result", "no", "op", "(", "@", "nullable", "list", "<", "?", "extends", "epoxy", "model", "<", "?", ">", ">", "models", ")", "{", "if", "(", "models", "=", "=", "null", ")", "{", "models", "=", "collections", "empty", "list", "(", ")", ";", "}", "return", "new", "diff", "result", "(", "models", ",", "models", ",", "null", ")", ";", "}" ]

[ "verify", "that", "the", "default", "retry", "policy", "correctly", "retries", "a", "retriable", "exception", "wrapped", "in", "a", "remote", "exception", "when", "default", "retry", "policy", "enabled", "is", "enabled" ]

[ "public", "void", "test", "with", "wrapped", "retriable", "(", ")", "throws", "exception", "{", "configuration", "conf", "=", "new", "configuration", "(", ")", ";", "retry", "policy", "policy", "=", "retry", "utils", "get", "default", "retry", "policy", "(", "conf", ",", "\"", "test", "no", "such", "key", "\"", ",", "true", ",", "/", "/", "default", "retry", "policy", "enabled", "=", "true", "\"", "test", "no", "such", "key", "\"", ",", "\"", "10000", ",", "6", "\"", ",", "null", ")", ";", "retry", "policy", "retry", "action", "action", "=", "policy", "should", "retry", "(", "new", "remote", "exception", "(", "retriable", "exception", "class", "get", "name", "(", ")", ",", "\"", "dummy", "exception", "\"", ")", ",", "0", ",", "0", ",", "true", ")", ";", "assert", "that", "(", "action", "action", ",", "is", "(", "retry", "policy", "retry", "action", "retry", "decision", "retry", ")", ")", ";", "}" ]

[ "returns", "an", "input", "source", "that", "reads", "from", "a", "latin", "1", "-", "encoded", "byte", "array", "the", "caller", "is", "free", "to", "subsequently", "mutate", "the", "array", "this", "function", "exists", "to", "support", "legacy", "uses", "of", "latin", "1", "in", "bazel", "do", "not", "use", "latin", "1", "in", "new", "applications", "(", "consider", "this", "deprecated", ",", "without", "the", "fussy", "warnings", ")" ]

[ "public", "static", "parser", "input", "from", "latin", "1", "(", "byte", "[", "]", "bytes", ",", "string", "file", ")", "{", "char", "[", "]", "chars", "=", "new", "char", "[", "bytes", "length", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "bytes", "length", ";", "i", "+", "+", ")", "{", "chars", "[", "i", "]", "=", "(", "char", ")", "(", "0xff", "&", "bytes", "[", "i", "]", ")", ";", "}", "return", "new", "parser", "input", "(", "chars", ",", "file", ")", ";", "}" ]

[ "unsafely", "returns", "a", "fresh", "entry" ]

[ "e", "new", "entry", "for", "testing", "(", "k", "key", ",", "int", "hash", ",", "@", "nullable", "internal", "entry", "<", "k", ",", "v", ",", "?", ">", "next", ")", "{", "return", "this", "map", "entry", "helper", "new", "entry", "(", "self", "(", ")", ",", "key", ",", "hash", ",", "cast", "for", "testing", "(", "next", ")", ")", ";", "}" ]

[ "replay", "the", "top", "buckets", "from", "the", "matching", "documents" ]

[ "private", "leaf", "bucket", "collector", "get", "second", "pass", "collector", "(", "leaf", "bucket", "collector", "sub", "collector", ")", "{", "return", "new", "leaf", "bucket", "collector", "(", ")", "{", "@", "override", "public", "void", "collect", "(", "int", "doc", ",", "long", "zero", "bucket", ")", "throws", "i", "o", "exception", "{", "assert", "zero", "bucket", "=", "=", "0", ";", "integer", "slot", "=", "queue", "compare", "current", "(", ")", ";", "if", "(", "slot", "!", "=", "null", ")", "{", "/", "/", "the", "candidate", "key", "is", "a", "top", "bucket", "/", "/", "we", "can", "defer", "the", "collection", "of", "this", "document", "/", "bucket", "to", "the", "sub", "collector", "sub", "collector", "collect", "(", "doc", ",", "slot", ")", ";", "}", "}", "}", ";", "}" ]

[ "return", "the", "path", "that", "this", "tag", "applies", "to" ]

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

[ "attach", "the", "autocompleter", "to", "the", "given", "text", "field", "if", "this", "method", "is", "never", "called", ",", "then", "the", "autocompleter", "can", "never", "appear" ]

[ "public", "boolean", "attach", "to", "(", "j", "text", "field", "field", ")", "{", "if", "(", "!", "attachees", "add", "(", "field", ")", ")", "{", "return", "false", ";", "}", "boolean", "keep", "=", "false", ";", "try", "{", "field", "add", "focus", "listener", "(", "listener", ")", ";", "field", "add", "caret", "listener", "(", "listener", ")", ";", "field", "add", "key", "listener", "(", "listener", ")", ";", "field", "get", "document", "(", ")", "add", "document", "listener", "(", "listener", ")", ";", "keep", "=", "true", ";", "}", "finally", "{", "if", "(", "!", "keep", ")", "{", "attachees", "remove", "(", "field", ")", ";", "}", "}", "return", "keep", ";", "}" ]

[ "add", "a", "new", "match", "rule", "the", "rule", "will", "follow", "the", "order", "of", "being", "added" ]

[ "public", "void", "add", "rule", "(", "string", "name", ",", "string", "rule", "regex", ")", "{", "for", "(", "pattern", "rule", "rule", ":", "rules", ")", "{", "if", "(", "rule", "name", "equals", "(", "name", ")", ")", "{", "return", ";", "}", "}", "pattern", "rule", "rule", "=", "new", "pattern", "rule", "(", "name", ",", "rule", "regex", ")", ";", "rules", "add", "(", "rule", ")", ";", "}" ]

[ "returns", "all", "colors", "specified", "for", "the", "circles" ]

[ "public", "list", "<", "integer", ">", "get", "circle", "colors", "(", ")", "{", "return", "m", "circle", "colors", ";", "}" ]

[ "get", "prefix", "integer" ]

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

[ "determines", "whether", "a", "character", "is", "a", "bmp", "letter", "or", "digit", "according", "to", "{", "@", "linkplain", "character", "#", "is", "letter", "or", "digit", "(", "char", ")", "java", "'", "s", "definition", "}" ]

[ "public", "static", "char", "matcher", "java", "letter", "or", "digit", "(", ")", "{", "return", "java", "letter", "or", "digit", "instance", ";", "}" ]

[ "determine", "whether", "the", "underlying", "class", "is", "independent", ",", "i", "e", "whether", "it", "is", "a", "top", "-", "level", "class", "or", "a", "nested", "class", "(", "static", "inner", "class", ")", "that", "can", "be", "constructed", "independently", "from", "an", "enclosing", "class" ]

[ "boolean", "is", "independent", "(", ")", ";" ]

[ "returns", "the", "segment" ]

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

[ "returns", "a", "future", "holding", "the", "request", "result" ]

[ "public", "<", "k", ",", "s", "extends", "state", ",", "v", ">", "completable", "future", "<", "s", ">", "get", "kv", "state", "(", "final", "job", "i", "d", "job", "id", ",", "final", "string", "queryable", "state", "name", ",", "final", "k", "key", ",", "final", "type", "information", "<", "k", ">", "key", "type", "info", ",", "final", "state", "descriptor", "<", "s", ",", "v", ">", "state", "descriptor", ")", "{", "return", "get", "kv", "state", "(", "job", "id", ",", "queryable", "state", "name", ",", "key", ",", "void", "namespace", "instance", ",", "key", "type", "info", ",", "void", "namespace", "type", "info", "instance", ",", "state", "descriptor", ")", ";", "}" ]

[ "an", "expectation", "for", "checking", "given", "web", "element", "has", "attribute", "with", "a", "specific", "value" ]

[ "public", "static", "expected", "condition", "<", "boolean", ">", "attribute", "to", "be", "(", "final", "web", "element", "element", ",", "final", "string", "attribute", ",", "final", "string", "value", ")", "{", "return", "new", "expected", "condition", "<", "boolean", ">", "(", ")", "{", "private", "string", "current", "value", "=", "null", ";", "@", "override", "public", "boolean", "apply", "(", "web", "driver", "driver", ")", "{", "current", "value", "=", "element", "get", "attribute", "(", "attribute", ")", ";", "if", "(", "current", "value", "=", "=", "null", "|", "|", "current", "value", "is", "empty", "(", ")", ")", "{", "current", "value", "=", "element", "get", "css", "value", "(", "attribute", ")", ";", "}", "return", "value", "equals", "(", "current", "value", ")", ";", "}", "@", "override", "public", "string", "to", "string", "(", ")", "{", "return", "string", "format", "(", "\"", "attribute", "or", "property", "'", "%", "s", "'", "to", "be", "'", "%", "s", "'", "current", "value", ":", "'", "%", "s", "'", "\"", ",", "attribute", ",", "value", ",", "current", "value", ")", ";", "}", "}", ";", "}" ]

[ "write", "header", "information", "for", "this", "edit", "log", "file", "output", "stream", "to", "the", "provided", "data", "output", "sream" ]

[ "public", "static", "void", "write", "header", "(", "int", "layout", "version", ",", "data", "output", "stream", "out", ")", "throws", "i", "o", "exception", "{", "out", "write", "int", "(", "layout", "version", ")", ";", "layout", "flags", "write", "(", "out", ")", ";", "}" ]

[ "returns", "the", "class", "of", "values", "in", "this", "file" ]

[ "public", "class", "<", "?", ">", "get", "value", "class", "(", ")", "{", "return", "data", "get", "value", "class", "(", ")", ";", "}" ]

[ "notification", "that", "a", "program", "tree", "was", "added" ]

[ "public", "void", "program", "tree", "added", "(", "long", "id", ",", "int", "type", ",", "object", "old", "value", ",", "object", "new", "value", ")", "{", "if", "(", "record", "changes", ")", "{", "(", "(", "program", "d", "b", "change", "set", ")", "change", "set", ")", "program", "tree", "added", "(", "id", ")", ";", "}", "changed", "=", "true", ";", "fire", "event", "(", "new", "program", "change", "record", "(", "type", ",", "null", ",", "null", ",", "null", ",", "old", "value", ",", "new", "value", ")", ")", ";", "}" ]

[ "<", "code", ">", "optional", "bytes", "data", "=", "1", ";", "<", "code", ">" ]

[ "public", "builder", "set", "data", "(", "com", "google", "protobuf", "byte", "string", "value", ")", "{", "copy", "on", "write", "(", ")", ";", "instance", "set", "data", "(", "value", ")", ";", "return", "this", ";", "}" ]

[ "get", "attribute", "string" ]

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

[ "removal", "shouldn", "'", "t", "affect", "existing", "nodes" ]

[ "public", "void", "removal", "(", ")", "{", "consistent", "hash", "<", "integer", ">", "hash", "=", "new", "consistent", "hash", "<", ">", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "10", ";", "i", "+", "+", ")", "{", "hash", "add", "(", "i", ")", ";", "}", "/", "/", "what", "was", "the", "mapping", "before", "the", "mutation", "?", "map", "<", "integer", ",", "integer", ">", "before", "=", "new", "hash", "map", "<", ">", "(", ")", ";", "random", "r", "=", "new", "random", "(", "0", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "1000", ";", "i", "+", "+", ")", "{", "int", "q", "=", "r", "next", "int", "(", ")", ";", "before", "put", "(", "q", ",", "hash", "lookup", "(", "q", ")", ")", ";", "}", "/", "/", "remove", "a", "node", "hash", "remove", "(", "0", ")", ";", "/", "/", "verify", "that", "the", "mapping", "remains", "consistent", "for", "(", "entry", "<", "integer", ",", "integer", ">", "e", ":", "before", "entry", "set", "(", ")", ")", "{", "int", "m", "=", "hash", "lookup", "(", "e", "get", "key", "(", ")", ")", ";", "assert", "true", "(", "e", "get", "value", "(", ")", "=", "=", "0", "|", "|", "e", "get", "value", "(", ")", "=", "=", "m", ")", ";", "}", "}" ]

[ "look", "up", "the", "object", "with", "the", "given", "name", "in", "the", "current", "jndi", "context" ]

[ "public", "<", "t", ">", "t", "lookup", "(", "string", "name", ",", "@", "nullable", "class", "<", "t", ">", "required", "type", ")", "throws", "naming", "exception", "{", "object", "jndi", "object", "=", "lookup", "(", "name", ")", ";", "if", "(", "required", "type", "!", "=", "null", "&", "&", "!", "required", "type", "is", "instance", "(", "jndi", "object", ")", ")", "{", "throw", "new", "type", "mismatch", "naming", "exception", "(", "name", ",", "required", "type", ",", "jndi", "object", "get", "class", "(", ")", ")", ";", "}", "return", "(", "t", ")", "jndi", "object", ";", "}" ]

[ "returns", "the", "ratio", "of", "cache", "loading", "attempts", "which", "threw", "exceptions", "this", "is", "defined", "as", "{", "@", "code", "load", "exception", "count", "(", "load", "success", "count", "+", "load", "exception", "count", ")", "}", ",", "or", "{", "@", "code", "0", "0", "}", "when", "{", "@", "code", "load", "success", "count", "+", "load", "exception", "count", "=", "=", "0", "}", "<", "b", ">", "note", ":", "<", "b", ">", "the", "values", "of", "the", "metrics", "are", "undefined", "in", "case", "of", "overflow", "(", "though", "it", "is", "guaranteed", "not", "to", "throw", "an", "exception", ")", "if", "you", "require", "specific", "handling", ",", "we", "recommend", "implementing", "your", "own", "stats", "collector" ]

[ "public", "double", "load", "exception", "rate", "(", ")", "{", "long", "total", "load", "count", "=", "saturated", "add", "(", "load", "success", "count", ",", "load", "exception", "count", ")", ";", "return", "(", "total", "load", "count", "=", "=", "0", ")", "?", "0", "0", ":", "(", "double", ")", "load", "exception", "count", "/", "total", "load", "count", ";", "}" ]

[ "called", "after", "a", "transactional", "event", "listener", "invocation" ]

[ "default", "void", "post", "process", "event", "(", "application", "event", "event", ",", "@", "nullable", "throwable", "ex", ")", "{", "}" ]

[ "see", "{", "@", "link", "socket", "#", "shutdown", "input", "(", ")", "}", "calling", "this", "method", "does", "not", "trigger", "mode", "detection" ]

[ "public", "void", "shutdown", "input", "(", ")", "throws", "i", "o", "exception", "{", "get", "socket", "allow", "unknown", "mode", "(", ")", "shutdown", "input", "(", ")", ";", "}" ]

[ "does", "a", "regular", "basic", "block", "dump" ]

[ "private", "void", "regular", "dump", "(", "concrete", "method", "meth", ")", "{", "bytecode", "array", "code", "=", "meth", "get", "code", "(", ")", ";", "byte", "array", "bytes", "=", "code", "get", "bytes", "(", ")", ";", "byte", "block", "list", "list", "=", "basic", "blocker", "identify", "blocks", "(", "meth", ")", ";", "int", "sz", "=", "list", "size", "(", ")", ";", "code", "observer", "code", "observer", "=", "new", "code", "observer", "(", "bytes", ",", "block", "dumper", "this", ")", ";", "/", "/", "reset", "the", "dump", "cursor", "to", "the", "start", "of", "the", "bytecode", "set", "at", "(", "bytes", ",", "0", ")", ";", "suppress", "dump", "=", "false", ";", "int", "byte", "at", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "sz", ";", "i", "+", "+", ")", "{", "byte", "block", "bb", "=", "list", "get", "(", "i", ")", ";", "int", "start", "=", "bb", "get", "start", "(", ")", ";", "int", "end", "=", "bb", "get", "end", "(", ")", ";", "if", "(", "byte", "at", "<", "start", ")", "{", "parsed", "(", "bytes", ",", "byte", "at", ",", "start", "-", "byte", "at", ",", "\"", "dead", "code", "\"", "+", "hex", "u", "2", "(", "byte", "at", ")", "+", "\"", "\"", "+", "hex", "u", "2", "(", "start", ")", ")", ";", "}", "parsed", "(", "bytes", ",", "start", ",", "0", ",", "\"", "block", "\"", "+", "hex", "u", "2", "(", "bb", "get", "label", "(", ")", ")", "+", "\"", ":", "\"", "+", "hex", "u", "2", "(", "start", ")", "+", "\"", "\"", "+", "hex", "u", "2", "(", "end", ")", ")", ";", "change", "indent", "(", "1", ")", ";", "int", "len", ";", "for", "(", "int", "j", "=", "start", ";", "j", "<", "end", ";", "j", "+", "=", "len", ")", "{", "len", "=", "code", "parse", "instruction", "(", "j", ",", "code", "observer", ")", ";", "code", "observer", "set", "previous", "offset", "(", "j", ")", ";", "}", "int", "list", "successors", "=", "bb", "get", "successors", "(", ")", ";", "int", "ssz", "=", "successors", "size", "(", ")", ";", "if", "(", "ssz", "=", "=", "0", ")", "{", "parsed", "(", "bytes", ",", "end", ",", "0", ",", "\"", "returns", "\"", ")", ";", "}", "else", "{", "for", "(", "int", "j", "=", "0", ";", "j", "<", "ssz", ";", "j", "+", "+", ")", "{", "int", "succ", "=", "successors", "get", "(", "j", ")", ";", "parsed", "(", "bytes", ",", "end", ",", "0", ",", "\"", "next", "\"", "+", "hex", "u", "2", "(", "succ", ")", ")", ";", "}", "}", "byte", "catch", "list", "catches", "=", "bb", "get", "catches", "(", ")", ";", "int", "csz", "=", "catches", "size", "(", ")", ";", "for", "(", "int", "j", "=", "0", ";", "j", "<", "csz", ";", "j", "+", "+", ")", "{", "byte", "catch", "list", "item", "one", "=", "catches", "get", "(", "j", ")", ";", "cst", "type", "exception", "class", "=", "one", "get", "exception", "class", "(", ")", ";", "parsed", "(", "bytes", ",", "end", ",", "0", ",", "\"", "catch", "\"", "+", "(", "(", "exception", "class", "=", "=", "cst", "type", "object", ")", "?", "\"", "<", "any", ">", "\"", ":", "exception", "class", "to", "human", "(", ")", ")", "+", "\"", "-", ">", "\"", "+", "hex", "u", "2", "(", "one", "get", "handler", "pc", "(", ")", ")", ")", ";", "}", "change", "indent", "(", "-", "1", ")", ";", "byte", "at", "=", "end", ";", "}", "int", "end", "=", "bytes", "size", "(", ")", ";", "if", "(", "byte", "at", "<", "end", ")", "{", "parsed", "(", "bytes", ",", "byte", "at", ",", "end", "-", "byte", "at", ",", "\"", "dead", "code", "\"", "+", "hex", "u", "2", "(", "byte", "at", ")", "+", "\"", "\"", "+", "hex", "u", "2", "(", "end", ")", ")", ";", "}", "suppress", "dump", "=", "true", ";", "}" ]

[ "sets", "the", "per", "-", "thread", "callback" ]

[ "public", "static", "callback", "set", "test", "case", "for", "thread", "(", "@", "nullable", "callback", "callback", ")", "{", "callback", "previous", "callback", "=", "callback", "for", "thread", "get", "(", ")", ";", "if", "(", "callback", "=", "=", "null", ")", "{", "callback", "for", "thread", "remove", "(", ")", ";", "}", "else", "{", "callback", "for", "thread", "set", "(", "callback", ")", ";", "}", "return", "previous", "callback", ";", "}" ]

[ "returns", "the", "open", "a", "p", "i", "specification" ]

[ "public", "open", "a", "p", "i", "get", "open", "a", "p", "i", "(", ")", "{", "return", "specification", ";", "}" ]

[ "set", "the", "bootstrap", "context", "that", "this", "object", "runs", "in", "invoked", "after", "population", "of", "normal", "bean", "properties", "but", "before", "an", "init", "callback", "like", "initializing", "bean", "'", "s", "{", "@", "code", "after", "properties", "set", "}", "or", "a", "custom", "init", "-", "method", "invoked", "after", "application", "context", "aware", "'", "s", "{", "@", "code", "set", "application", "context", "}" ]

[ "void", "set", "bootstrap", "context", "(", "bootstrap", "context", "bootstrap", "context", ")", ";" ]

[ "return", "whether", "or", "not", "we", "ignore", "s", "q", "l", "warnings" ]

[ "public", "boolean", "is", "ignore", "warnings", "(", ")", "{", "return", "this", "ignore", "warnings", ";", "}" ]

[ "returns", "an", "array", "of", "item", "for", "which", "it", "is", "only", "visible", "the", "name", "of", "the", "task", "generally", "speaking", "the", "array", "is", "sorted", "such", "that", "the", "items", "that", "are", "most", "likely", "built", "sooner", "are", "at", "the", "end" ]

[ "public", "stub", "item", "[", "]", "get", "discoverable", "items", "(", ")", "{", "snapshot", "s", "=", "this", "snapshot", ";", "list", "<", "stub", "item", ">", "r", "=", "new", "array", "list", "<", ">", "(", ")", ";", "for", "(", "waiting", "item", "p", ":", "s", "waiting", "list", ")", "{", "r", "=", "filter", "discoverable", "item", "list", "based", "on", "permissions", "(", "r", ",", "p", ")", ";", "}", "for", "(", "blocked", "item", "p", ":", "s", "blocked", "projects", ")", "{", "r", "=", "filter", "discoverable", "item", "list", "based", "on", "permissions", "(", "r", ",", "p", ")", ";", "}", "for", "(", "buildable", "item", "p", ":", "reverse", "(", "s", "buildables", ")", ")", "{", "r", "=", "filter", "discoverable", "item", "list", "based", "on", "permissions", "(", "r", ",", "p", ")", ";", "}", "for", "(", "buildable", "item", "p", ":", "reverse", "(", "s", "pendings", ")", ")", "{", "r", "=", "filter", "discoverable", "item", "list", "based", "on", "permissions", "(", "r", ",", "p", ")", ";", "}", "stub", "item", "[", "]", "items", "=", "new", "stub", "item", "[", "r", "size", "(", ")", "]", ";", "r", "to", "array", "(", "items", ")", ";", "return", "items", ";", "}" ]

[ "creates", "a", "{", "@", "link", "key", "grouped", "internal", "priority", "queue", "}" ]

[ "<", "t", "extends", "heap", "priority", "queue", "element", "&", "priority", "comparable", "&", "keyed", ">", "key", "grouped", "internal", "priority", "queue", "<", "t", ">", "create", "(", "@", "nonnull", "string", "state", "name", ",", "@", "nonnull", "type", "serializer", "<", "t", ">", "byte", "ordered", "element", "serializer", ")", ";" ]

[ "test", "the", "property", "'", "1", "2", "3number", "'" ]

[ "public", "void", "1", "2", "3number", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "1", "2", "3number", "}" ]

[ "build", "an", "internal", "bean", "factory", "for", "resolving", "target", "beans" ]

[ "protected", "default", "listable", "bean", "factory", "build", "internal", "bean", "factory", "(", "configurable", "bean", "factory", "containing", "factory", ")", "{", "/", "/", "set", "parent", "so", "that", "references", "(", "up", "container", "hierarchies", ")", "are", "correctly", "resolved", "default", "listable", "bean", "factory", "internal", "bean", "factory", "=", "new", "default", "listable", "bean", "factory", "(", "containing", "factory", ")", ";", "/", "/", "required", "so", "that", "all", "bean", "post", "processors", ",", "scopes", ",", "etc", "become", "available", "internal", "bean", "factory", "copy", "configuration", "from", "(", "containing", "factory", ")", ";", "/", "/", "filter", "out", "bean", "post", "processors", "that", "are", "part", "of", "the", "aop", "infrastructure", ",", "/", "/", "since", "those", "are", "only", "meant", "to", "apply", "to", "beans", "defined", "in", "the", "original", "factory", "internal", "bean", "factory", "get", "bean", "post", "processors", "(", ")", "remove", "if", "(", "bean", "post", "processor", "-", ">", "bean", "post", "processor", "instanceof", "aop", "infrastructure", "bean", ")", ";", "return", "internal", "bean", "factory", ";", "}" ]

[ "transform", "a", "rectangle", "with", "all", "matrices", "with", "potential", "animation", "phases" ]

[ "public", "void", "rect", "value", "to", "pixel", "horizontal", "(", "rect", "f", "r", ")", "{", "m", "matrix", "value", "to", "px", "map", "rect", "(", "r", ")", ";", "m", "view", "port", "handler", "get", "matrix", "touch", "(", ")", "map", "rect", "(", "r", ")", ";", "m", "matrix", "offset", "map", "rect", "(", "r", ")", ";", "}" ]

[ "test", "method", "'", "job", "counters", "'", "should", "print", "message", "about", "error", "or", "set", "counters", "page", "class", "for", "rendering" ]

[ "public", "void", "test", "get", "job", "counters", "(", ")", "{", "when", "(", "job", "check", "access", "(", "any", "(", "user", "group", "information", "class", ")", ",", "any", "(", "job", "a", "c", "l", "class", ")", ")", ")", "then", "return", "(", "false", ")", ";", "app", "controller", "job", "counters", "(", ")", ";", "verify", "(", "app", "controller", "response", "(", ")", ")", "set", "content", "type", "(", "mime", "type", "text", ")", ";", "assert", "equals", "(", "\"", "access", "denied", ":", "user", "user", "does", "not", "have", "permission", "to", "view", "job", "job", "01", "01", "\"", ",", "app", "controller", "get", "data", "(", ")", ")", ";", "when", "(", "job", "check", "access", "(", "any", "(", "user", "group", "information", "class", ")", ",", "any", "(", "job", "a", "c", "l", "class", ")", ")", ")", "then", "return", "(", "true", ")", ";", "app", "controller", "get", "property", "(", ")", "remove", "(", "a", "m", "params", "job", "id", ")", ";", "app", "controller", "job", "counters", "(", ")", ";", "assert", "equals", "(", "\"", "access", "denied", ":", "user", "user", "does", "not", "have", "permission", "to", "view", "job", "job", "01", "0", "1", "bad", "request", ":", "missing", "job", "id", "\"", ",", "app", "controller", "get", "data", "(", ")", ")", ";", "app", "controller", "get", "property", "(", ")", "put", "(", "a", "m", "params", "job", "id", ",", "\"", "job", "01", "01", "\"", ")", ";", "app", "controller", "job", "counters", "(", ")", ";", "assert", "equals", "(", "counters", "page", "class", ",", "app", "controller", "get", "clazz", "(", ")", ")", ";", "}" ]

[ "set", "the", "api", "cilent" ]

[ "public", "void", "set", "api", "client", "(", "api", "client", "api", "client", ")", "{", "this", "api", "client", "=", "api", "client", ";", "}" ]

[ "returns", "a", "new", "set", "containing", "the", "first", "n", "elements", "in", "this", "grouped", "{", "@", "link", "data", "set", "}" ]

[ "public", "group", "reduce", "operator", "<", "t", ",", "t", ">", "first", "(", "int", "n", ")", "{", "if", "(", "n", "<", "1", ")", "{", "throw", "new", "invalid", "program", "exception", "(", "\"", "parameter", "n", "of", "first", "(", "n", ")", "must", "be", "at", "least", "1", "\"", ")", ";", "}", "return", "reduce", "group", "(", "new", "first", "reducer", "<", "t", ">", "(", "n", ")", ")", ";", "}" ]