Datasets:

---

Anonymous2023

/

KGSum

like 0

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

[ "public", "string", "to", "string", "(", ")", "{", "return", "\"", "throttled", "input", "stream", "{", "\"", "+", "\"", "bytes", "read", "=", "\"", "+", "bytes", "read", "+", "\"", ",", "max", "bytes", "per", "sec", "=", "\"", "+", "max", "bytes", "per", "sec", "+", "\"", ",", "bytes", "per", "sec", "=", "\"", "+", "get", "bytes", "per", "sec", "(", ")", "+", "\"", ",", "total", "sleep", "time", "=", "\"", "+", "total", "sleep", "time", "+", "'", "}", "'", ";", "}" ]

[ "get", "all", "the", "journals", "this", "edit", "log", "is", "currently", "operating", "on" ]

[ "list", "<", "journal", "and", "stream", ">", "get", "journals", "(", ")", "{", "/", "/", "the", "list", "implementation", "is", "copy", "on", "write", "array", "list", ",", "/", "/", "so", "we", "don", "'", "t", "need", "to", "synchronize", "this", "method", "return", "journal", "set", "get", "all", "journal", "streams", "(", ")", ";", "}" ]

[ "never", "serialize", "this", "parameter", ",", "no", "matter", "its", "value" ]

[ "public", "parameter", "<", "t", ">", "never", "serialize", "(", ")", "{", "this", "serializer", "check", "=", "(", "id", ",", "ic", ",", "v", ")", "-", ">", "false", ";", "return", "this", ";", "}" ]

[ "perform", "the", "actual", "reading", "of", "an", "invocation", "result", "object", "from", "the", "given", "object", "input", "stream", "the", "default", "implementation", "simply", "calls", "{", "@", "link", "java", "io", "object", "input", "stream", "#", "read", "object", "(", ")", "}", "can", "be", "overridden", "for", "deserialization", "of", "a", "custom", "wrapper", "object", "rather", "than", "the", "plain", "invocation", ",", "for", "example", "an", "encryption", "-", "aware", "holder" ]

[ "protected", "remote", "invocation", "do", "read", "remote", "invocation", "(", "object", "input", "stream", "ois", ")", "throws", "i", "o", "exception", ",", "class", "not", "found", "exception", "{", "object", "obj", "=", "ois", "read", "object", "(", ")", ";", "if", "(", "!", "(", "obj", "instanceof", "remote", "invocation", ")", ")", "{", "throw", "new", "remote", "exception", "(", "\"", "deserialized", "object", "needs", "to", "be", "assignable", "to", "type", "[", "\"", "+", "remote", "invocation", "class", "get", "name", "(", ")", "+", "\"", "]", ":", "\"", "+", "class", "utils", "get", "descriptive", "type", "(", "obj", ")", ")", ";", "}", "return", "(", "remote", "invocation", ")", "obj", ";", "}" ]

[ "prints", "an", "error", "message", "&", "fails", "the", "compilation" ]

[ "public", "void", "error", "(", "element", "e", ",", "string", "msg", ")", "{", "messager", "print", "message", "(", "diagnostic", "kind", "error", ",", "msg", ",", "e", ")", ";", "}" ]

[ "get", "the", "number", "of", "joints" ]

[ "public", "int", "get", "joint", "count", "(", ")", "{", "return", "world", "get", "joint", "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", "\"", ")", ";", "}" ]

[ "return", "the", "j", "s", "o", "n", "object", "in", "cache" ]

[ "public", "j", "s", "o", "n", "object", "get", "j", "s", "o", "n", "object", "(", "@", "non", "null", "final", "string", "key", ",", "final", "j", "s", "o", "n", "object", "default", "value", ")", "{", "j", "s", "o", "n", "object", "obj", "=", "m", "cache", "memory", "utils", "get", "(", "key", ")", ";", "if", "(", "obj", "!", "=", "null", ")", "return", "obj", ";", "return", "m", "cache", "disk", "utils", "get", "j", "s", "o", "n", "object", "(", "key", ",", "default", "value", ")", ";", "}" ]

[ "get", "the", "scheme", "for", "this", "specific", "fetcher" ]

[ "protected", "string", "get", "scheme", "(", ")", "{", "return", "file", "system", "uri", "schemes", "abfs", "scheme", ";", "}" ]

[ "return", "the", "configured", "task", "scheduler" ]

[ "public", "task", "scheduler", "get", "task", "scheduler", "(", ")", "{", "return", "this", "task", "scheduler", ";", "}" ]

[ "look", "up", "the", "3", "bits", "base", "6", "4", "-", "encoded", "by", "the", "specified", "character", ",", "range", "-", "checking", "againt", "conversion", "table" ]

[ "private", "static", "byte", "char", "6", "4", "(", "char", "x", ")", "{", "if", "(", "(", "int", ")", "x", "<", "0", "|", "|", "(", "int", ")", "x", ">", "index", "64", "length", ")", "return", "-", "1", ";", "return", "index", "64", "[", "(", "int", ")", "x", "]", ";", "}" ]

[ "add", "a", "listener", "for", "updated", "cluster", "states" ]

[ "public", "void", "add", "listener", "(", "cluster", "state", "listener", "listener", ")", "{", "cluster", "state", "listeners", "add", "(", "listener", ")", ";", "}" ]

[ "read", "an", "unsigned", "byte", "note", ":", "returns", "an", "int", ",", "even", "though", "says", "byte", "(", "non", "-", "javadoc", ")" ]

[ "public", "final", "int", "read", "unsigned", "byte", "(", ")", "throws", "i", "o", "exception", "{", "return", "dis", "read", "unsigned", "byte", "(", ")", ";", "}" ]

[ "obtains", "seek", "points", "for", "the", "specified", "seek", "time", "in", "microseconds", "the", "returned", "{", "@", "link", "seek", "points", "}", "will", "contain", "one", "or", "two", "distinct", "seek", "points", "two", "seek", "points", "[", "a", ",", "b", "]", "are", "returned", "in", "the", "case", "that", "seeking", "can", "only", "be", "performed", "to", "discrete", "points", "in", "time", ",", "there", "does", "not", "exist", "a", "seek", "point", "at", "exactly", "the", "requested", "time", ",", "and", "there", "exist", "seek", "points", "on", "both", "sides", "of", "it", "in", "this", "case", "a", "and", "b", "are", "the", "closest", "seek", "points", "before", "and", "after", "the", "requested", "time", "a", "single", "seek", "point", "is", "returned", "in", "all", "other", "cases" ]

[ "seek", "points", "get", "seek", "points", "(", "long", "time", "us", ")", ";" ]

[ "the", "entries", "defined", "for", "this", "type", "<", "code", ">", "repeated", "aapt", "pb", "entry", "entry", "=", "3", ";", "<", "code", ">" ]

[ "private", "void", "add", "entry", "(", "com", "android", "aapt", "resources", "entry", "value", ")", "{", "if", "(", "value", "=", "=", "null", ")", "{", "throw", "new", "null", "pointer", "exception", "(", ")", ";", "}", "ensure", "entry", "is", "mutable", "(", ")", ";", "entry", "add", "(", "value", ")", ";", "}" ]

[ "starts", "a", "transaction", "on", "the", "current", "program" ]

[ "public", "final", "void", "start", "(", ")", "{", "if", "(", "current", "program", "=", "=", "null", ")", "{", "return", ";", "}", "if", "(", "transaction", "i", "d", "=", "=", "-", "1", ")", "{", "transaction", "i", "d", "=", "current", "program", "start", "transaction", "(", "get", "class", "(", ")", "get", "name", "(", ")", ")", ";", "}", "}" ]

[ "persist", "the", "memory", "usage", "data" ]

[ "public", "void", "persist", "model", "size", "stats", "(", "model", "size", "stats", "model", "size", "stats", ",", "write", "request", "refresh", "policy", "refresh", "policy", ",", "action", "listener", "<", "index", "response", ">", "listener", ")", "{", "string", "job", "id", "=", "model", "size", "stats", "get", "job", "id", "(", ")", ";", "logger", "trace", "(", "\"", "[", "{", "}", "]", "persisting", "model", "size", "stats", ",", "for", "size", "{", "}", "\"", ",", "job", "id", ",", "model", "size", "stats", "get", "model", "bytes", "(", ")", ")", ";", "persistable", "persistable", "=", "new", "persistable", "(", "anomaly", "detectors", "index", "results", "write", "alias", "(", "job", "id", ")", ",", "job", "id", ",", "model", "size", "stats", ",", "model", "size", "stats", "get", "id", "(", ")", ")", ";", "persistable", "set", "refresh", "policy", "(", "refresh", "policy", ")", ";", "persistable", "persist", "(", "listener", ",", "true", ")", ";", "}" ]

[ "execute", "a", "{", "@", "link", "callable", "}", ",", "retrying", "execution", "in", "case", "of", "failure", "and", "returning", "the", "result", "in", "case", "of", "success", "with", "give", "{", "@", "link", "backoff", "}", "{", "@", "link", "interrupted", "exception", "}", "is", "not", "retried" ]

[ "public", "<", "t", ">", "t", "execute", "(", "callable", "<", "t", ">", "call", ",", "backoff", "backoff", ")", "throws", "exception", "{", "while", "(", "true", ")", "{", "final", "state", "circuit", "state", ";", "circuit", "state", "=", "circuit", "breaker", "state", "(", ")", ";", "if", "(", "state", "reject", "calls", "equals", "(", "circuit", "state", ")", ")", "{", "throw", "new", "circuit", "breaker", "exception", "(", ")", ";", "}", "try", "{", "if", "(", "thread", "interrupted", "(", ")", ")", "{", "throw", "new", "interrupted", "exception", "(", ")", ";", "}", "t", "r", "=", "call", "call", "(", ")", ";", "circuit", "breaker", "record", "success", "(", ")", ";", "return", "r", ";", "}", "catch", "(", "exception", "e", ")", "{", "circuit", "breaker", "record", "failure", "(", ")", ";", "throwables", "throw", "if", "instance", "of", "(", "e", ",", "interrupted", "exception", "class", ")", ";", "if", "(", "state", "trial", "call", "equals", "(", "circuit", "state", ")", ")", "{", "throw", "e", ";", "}", "if", "(", "!", "should", "retry", "test", "(", "e", ")", ")", "{", "throw", "e", ";", "}", "final", "long", "delay", "millis", "=", "backoff", "next", "delay", "millis", "(", "e", ")", ";", "if", "(", "delay", "millis", "<", "0", ")", "{", "throw", "e", ";", "}", "sleeper", "sleep", "(", "delay", "millis", ")", ";", "}", "}", "}" ]

[ "writes", "the", "{", "@", "link", "pixmap", "}", "to", "the", "given", "file", "using", "a", "custom", "compression", "scheme", "first", "three", "integers", "define", "the", "width", ",", "height", "and", "format", ",", "remaining", "bytes", "are", "zlib", "compressed", "pixels", "to", "be", "able", "to", "load", "the", "pixmap", "to", "a", "texture", ",", "use", "\"", "cim", "\"", "as", "the", "file", "suffix", "throws", "a", "gdx", "runtime", "exception", "in", "case", "the", "pixmap", "couldn", "'", "t", "be", "written", "to", "the", "file" ]

[ "static", "public", "void", "write", "c", "i", "m", "(", "file", "handle", "file", ",", "pixmap", "pixmap", ")", "{", "cim", "write", "(", "file", ",", "pixmap", ")", ";", "}" ]

[ "retrieves", "the", "result", "of", "a", "{", "@", "code", "future", "}", "known", "to", "be", "done", "but", "uses", "the", "{", "@", "code", "get", "(", "long", ",", "time", "unit", ")", "}", "overload", "in", "order", "to", "test", "that", "method" ]

[ "static", "<", "v", ">", "v", "get", "done", "from", "timeout", "overload", "(", "future", "<", "v", ">", "future", ")", "throws", "execution", "exception", "{", "check", "state", "(", "future", "is", "done", "(", ")", ",", "\"", "future", "was", "expected", "to", "be", "done", ":", "%", "s", "\"", ",", "future", ")", ";", "try", "{", "return", "get", "uninterruptibly", "(", "future", ",", "0", ",", "seconds", ")", ";", "}", "catch", "(", "timeout", "exception", "e", ")", "{", "assertion", "failed", "error", "error", "=", "new", "assertion", "failed", "error", "(", "e", "get", "message", "(", ")", ")", ";", "error", "init", "cause", "(", "e", ")", ";", "throw", "error", ";", "}", "}" ]

[ "drops", "the", "underlying", "database", "table" ]

[ "public", "static", "void", "drop", "table", "(", "database", "db", ",", "boolean", "if", "exists", ")", "{", "string", "sql", "=", "\"", "drop", "table", "\"", "+", "(", "if", "exists", "?", "\"", "if", "exists", "\"", ":", "\"", "\"", ")", "+", "\"", "\\", "\"", "relation", "source2", "\\", "\"", "\"", ";", "db", "exec", "s", "q", "l", "(", "sql", ")", ";", "}" ]

[ "add", "a", "focus", "listener", "to", "the", "box", "(", "es", ")", "note", ":", "the", "listener", "will", "not", "fire", "when", "focus", "passes", "among", "the", "linked", "boxes", "of", "the", "dual", "variant" ]

[ "public", "void", "add", "focus", "listener", "(", "focus", "listener", "listener", ")", "{", "linker", "add", "focus", "listener", "(", "listener", ")", ";", "assembly", "add", "focus", "listener", "(", "listener", ")", ";", "}" ]

[ "handle", "the", "outcome", "of", "an", "operation", "not", "being", "the", "strictest", "exception", "desired", ",", "but", "one", "that", ",", "while", "still", "within", "the", "boundary", "of", "the", "contract", ",", "is", "a", "bit", "looser", "if", "the", "fs", "contract", "says", "that", "they", "support", "the", "strictest", "exceptions", ",", "that", "is", "what", "they", "must", "return", ",", "and", "the", "exception", "here", "is", "rethrown" ]

[ "protected", "void", "handle", "relaxed", "exception", "(", "string", "action", ",", "string", "expected", "exception", ",", "exception", "e", ")", "throws", "exception", "{", "if", "(", "get", "contract", "(", ")", "is", "supported", "(", "supports", "strict", "exceptions", ",", "false", ")", ")", "{", "throw", "e", ";", "}", "log", "warn", "(", "\"", "the", "expected", "exception", "{", "}", "was", "not", "the", "exception", "class", "\"", "+", "\"", "raised", "on", "{", "}", ":", "{", "}", "\"", ",", "action", ",", "e", "get", "class", "(", ")", ",", "expected", "exception", ",", "e", ")", ";", "}" ]

[ "translate", "an", "exception", "raised", "in", "an", "operation", "into", "an", "i", "o", "exception", "the", "specific", "type", "of", "i", "o", "exception", "depends", "on", "the", "class", "of", "{", "@", "link", "amazon", "client", "exception", "}", "passed", "in", ",", "and", "any", "status", "codes", "included", "in", "the", "operation", "that", "is", ":", "http", "error", "codes", "are", "examined", "and", "can", "be", "used", "to", "build", "a", "more", "specific", "response" ]

[ "public", "static", "i", "o", "exception", "translate", "exception", "(", "string", "operation", ",", "path", "path", ",", "amazon", "client", "exception", "exception", ")", "{", "return", "translate", "exception", "(", "operation", ",", "path", "to", "string", "(", ")", ",", "exception", ")", ";", "}" ]

[ "remove", "a", "cache", "pool" ]

[ "public", "void", "remove", "cache", "pool", "(", "string", "pool", "name", ")", "throws", "i", "o", "exception", "{", "statistics", "increment", "write", "ops", "(", "1", ")", ";", "storage", "statistics", "increment", "op", "counter", "(", "op", "type", "remove", "cache", "pool", ")", ";", "cache", "pool", "info", "validate", "name", "(", "pool", "name", ")", ";", "dfs", "remove", "cache", "pool", "(", "pool", "name", ")", ";", "}" ]

[ "sets", "the", "optional", "subtitles", "{", "@", "code", "null", "}", "or", "an", "empty", "{", "@", "link", "list", "}", "can", "be", "used", "for", "a", "reset", "if", "{", "@", "link", "#", "set", "uri", "}", "is", "passed", "a", "non", "-", "null", "{", "@", "code", "uri", "}", ",", "the", "subtitles", "are", "used", "to", "create", "a", "{", "@", "link", "playback", "properties", "}", "object", "otherwise", "they", "will", "be", "ignored" ]

[ "public", "builder", "set", "subtitles", "(", "@", "nullable", "list", "<", "subtitle", ">", "subtitles", ")", "{", "this", "subtitles", "=", "subtitles", "!", "=", "null", "&", "&", "!", "subtitles", "is", "empty", "(", ")", "?", "collections", "unmodifiable", "list", "(", "new", "array", "list", "<", ">", "(", "subtitles", ")", ")", ":", "collections", "empty", "list", "(", ")", ";", "return", "this", ";", "}" ]

[ "return", "the", "list", "of", "view", "view", "resolvers", "to", "delegate", "to" ]

[ "public", "list", "<", "view", "resolver", ">", "get", "view", "resolvers", "(", ")", "{", "return", "collections", "unmodifiable", "list", "(", "this", "view", "resolvers", ")", ";", "}" ]

[ "prepare", "block", "list", "commit", "command", "and", "queue", "the", "command", "in", "thread", "pool", "executor" ]

[ "private", "synchronized", "upload", "command", "add", "flush", "command", "(", ")", "throws", "i", "o", "exception", "{", "maybe", "throw", "first", "error", "(", ")", ";", "if", "(", "blob", "exist", "&", "&", "lease", "is", "freed", "(", ")", ")", "{", "throw", "new", "azure", "exception", "(", "string", "format", "(", "\"", "attempting", "to", "upload", "block", "list", "on", "blob", ":", "%", "s", "\"", "+", "\"", "that", "does", "not", "have", "lease", "on", "the", "blob", "failing", "upload", "\"", ",", "key", ")", ")", ";", "}", "upload", "command", "command", "=", "new", "upload", "block", "list", "command", "(", ")", ";", "active", "block", "commands", "add", "(", "command", ")", ";", "io", "thread", "pool", "execute", "(", "new", "write", "request", "(", "command", ")", ")", ";", "return", "command", ";", "}" ]

[ "configures", "expire", "after", "write" ]

[ "void", "expire", "after", "write", "(", "string", "key", ",", "@", "nullable", "string", "value", ")", "{", "require", "argument", "(", "expire", "after", "write", "=", "=", "null", ",", "\"", "expire", "after", "write", "was", "already", "set", "\"", ")", ";", "expire", "after", "write", "=", "parse", "duration", "(", "key", ",", "value", ")", ";", "}" ]

[ "block", "the", "given", "source", "to", "block", "address", "for", "the", "given", "multicast", "address", "on", "the", "given", "network", "interface", "and", "notifies", "the", "{", "@", "link", "channel", "future", "}", "once", "the", "operation", "completes", "the", "given", "{", "@", "link", "channel", "future", "}", "will", "be", "notified", "and", "also", "returned" ]

[ "channel", "future", "block", "(", "inet", "address", "multicast", "address", ",", "network", "interface", "network", "interface", ",", "inet", "address", "source", "to", "block", ")", ";" ]

[ "adds", "the", "file", "with", "the", "given", "name", "to", "this", "fake", "project", "the", "file", "must", "exist", "in", "the", "test", "data", "area", "the", "file", "will", "be", "put", "in", "the", "root", "folder", "of", "the", "project", "<", "p", ">", "note", ":", "this", "does", "not", "add", "the", "file", "to", "version", "control", "thus", ",", "the", "file", "will", "not", "be", "visible", "to", "other", "projects", "in", "the", "parent", "repo", "to", "add", "to", "version", "control", ",", "call", "{", "@", "link", "#", "add", "to", "version", "control", "(", "domain", "file", ",", "boolean", ")", "}" ]

[ "public", "domain", "file", "add", "domain", "file", "(", "string", "filename", ")", "throws", "exception", "{", "project", "project", "=", "get", "ghidra", "project", "(", ")", "get", "project", "(", ")", ";", "domain", "file", "df", "=", "program", "manager", "add", "program", "to", "project", "(", "project", ",", "filename", ")", ";", "return", "df", ";", "}" ]

[ "gets", "column", "meta" ]

[ "public", "column", "meta", "get", "column", "meta", "(", "string", "col", "name", ")", "{", "return", "all", "columns", "get", "(", "col", "name", ")", ";", "}" ]

[ "load", "bean", "definitions", "from", "the", "specified", "resource", "location", "the", "location", "can", "also", "be", "a", "location", "pattern", ",", "provided", "that", "the", "resource", "loader", "of", "this", "bean", "definition", "reader", "is", "a", "resource", "pattern", "resolver" ]

[ "public", "int", "load", "bean", "definitions", "(", "string", "location", ",", "@", "nullable", "set", "<", "resource", ">", "actual", "resources", ")", "throws", "bean", "definition", "store", "exception", "{", "resource", "loader", "resource", "loader", "=", "get", "resource", "loader", "(", ")", ";", "if", "(", "resource", "loader", "=", "=", "null", ")", "{", "throw", "new", "bean", "definition", "store", "exception", "(", "\"", "cannot", "load", "bean", "definitions", "from", "location", "[", "\"", "+", "location", "+", "\"", "]", ":", "no", "resource", "loader", "available", "\"", ")", ";", "}", "if", "(", "resource", "loader", "instanceof", "resource", "pattern", "resolver", ")", "{", "/", "/", "resource", "pattern", "matching", "available", "try", "{", "resource", "[", "]", "resources", "=", "(", "(", "resource", "pattern", "resolver", ")", "resource", "loader", ")", "get", "resources", "(", "location", ")", ";", "int", "count", "=", "load", "bean", "definitions", "(", "resources", ")", ";", "if", "(", "actual", "resources", "!", "=", "null", ")", "{", "collections", "add", "all", "(", "actual", "resources", ",", "resources", ")", ";", "}", "if", "(", "logger", "is", "trace", "enabled", "(", ")", ")", "{", "logger", "trace", "(", "\"", "loaded", "\"", "+", "count", "+", "\"", "bean", "definitions", "from", "location", "pattern", "[", "\"", "+", "location", "+", "\"", "]", "\"", ")", ";", "}", "return", "count", ";", "}", "catch", "(", "i", "o", "exception", "ex", ")", "{", "throw", "new", "bean", "definition", "store", "exception", "(", "\"", "could", "not", "resolve", "bean", "definition", "resource", "pattern", "[", "\"", "+", "location", "+", "\"", "]", "\"", ",", "ex", ")", ";", "}", "}", "else", "{", "/", "/", "can", "only", "load", "single", "resources", "by", "absolute", "url", "resource", "resource", "=", "resource", "loader", "get", "resource", "(", "location", ")", ";", "int", "count", "=", "load", "bean", "definitions", "(", "resource", ")", ";", "if", "(", "actual", "resources", "!", "=", "null", ")", "{", "actual", "resources", "add", "(", "resource", ")", ";", "}", "if", "(", "logger", "is", "trace", "enabled", "(", ")", ")", "{", "logger", "trace", "(", "\"", "loaded", "\"", "+", "count", "+", "\"", "bean", "definitions", "from", "location", "[", "\"", "+", "location", "+", "\"", "]", "\"", ")", ";", "}", "return", "count", ";", "}", "}" ]

[ "test", "the", "property", "'", "indirect", "map", "'" ]

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

[ "test", "if", "mock", "policy", "works", "fine", ":", "fail", "-", "mock" ]

[ "public", "void", "test", "mock", "invoker", "invoke", "normal", "(", ")", "{", "url", "url", "=", "url", "value", "of", "(", "\"", "remote", ":", "/", "/", "1", "2", "3", "4", "/", "\"", "+", "i", "hello", "service", "class", "get", "name", "(", ")", ")", ";", "url", "=", "url", "add", "parameter", "(", "mock", "key", ",", "\"", "fail", "\"", ")", "add", "parameter", "(", "refer", "key", ",", "url", "encode", "(", "path", "key", "+", "\"", "=", "\"", "+", "i", "hello", "service", "class", "get", "name", "(", ")", ")", ")", ";", "invoker", "<", "i", "hello", "service", ">", "cluster", "=", "get", "cluster", "invoker", "(", "url", ")", ";", "url", "mock", "url", "=", "url", "value", "of", "(", "\"", "mock", ":", "/", "/", "localhost", "/", "\"", "+", "i", "hello", "service", "class", "get", "name", "(", ")", "+", "\"", "?", "get", "something", "mock", "=", "return", "aa", "\"", ")", ";", "protocol", "protocol", "=", "new", "mock", "protocol", "(", ")", ";", "invoker", "<", "i", "hello", "service", ">", "m", "invoker", "1", "=", "protocol", "refer", "(", "i", "hello", "service", "class", ",", "mock", "url", ")", ";", "invokers", "add", "(", "m", "invoker", "1", ")", ";", "/", "/", "configured", "with", "mock", "rpc", "invocation", "invocation", "=", "new", "rpc", "invocation", "(", ")", ";", "invocation", "set", "method", "name", "(", "\"", "get", "something", "\"", ")", ";", "result", "ret", "=", "cluster", "invoke", "(", "invocation", ")", ";", "assertions", "assert", "equals", "(", "\"", "something", "\"", ",", "ret", "get", "value", "(", ")", ")", ";", "/", "/", "if", "no", "mock", "was", "configured", ",", "return", "null", "directly", "invocation", "=", "new", "rpc", "invocation", "(", ")", ";", "invocation", "set", "method", "name", "(", "\"", "say", "hello", "\"", ")", ";", "ret", "=", "cluster", "invoke", "(", "invocation", ")", ";", "assertions", "assert", "null", "(", "ret", "get", "value", "(", ")", ")", ";", "}" ]

[ "dumps", "the", "debug", "stream", "list", "this", "package", "-", "protected", "method", "is", "for", "debugging", "only" ]

[ "private", "void", "dump", "debug", "stream", "list", "(", "writer", "writer", ")", "throws", "i", "o", "exception", "{", "writer", "write", "(", "\"", "stream", "list", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "\\", "n", "\"", ")", ";", "int", "i", "=", "0", ";", "for", "(", "int", "strm", "number", ":", "debug", "streams", ")", "{", "writer", "write", "(", "string", "format", "(", "\"", "strm", "number", "[", "%", "0", "2d", "]", ":", "%", "0", "4x", "\\", "n", "\"", ",", "i", "+", "+", ",", "strm", "number", ")", ")", ";", "}", "writer", "write", "(", "\"", "end", "stream", "list", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "\\", "n", "\"", ")", ";", "}" ]

[ "constructs", "a", "new", "{", "@", "link", "resolution", "result", "}", "from", "this", "builder" ]

[ "public", "resolution", "result", "build", "(", ")", "{", "return", "new", "resolution", "result", "(", "addresses", ",", "attributes", ",", "service", "config", ")", ";", "}" ]

[ "moves", "the", "cursor", "upwards", "by", "a", "specified", "number", "of", "lines", "this", "will", "not", "cause", "any", "scrolling", "if", "it", "tries", "to", "move", "above", "the", "top", "of", "the", "terminal", "window" ]

[ "public", "void", "cursor", "up", "(", "int", "num", "lines", ")", "throws", "i", "o", "exception", "{", "write", "bytes", "(", "esc", ",", "(", "\"", "\"", "+", "num", "lines", ")", "get", "bytes", "(", ")", ",", "new", "byte", "[", "]", "{", "up", "}", ")", ";", "}" ]

[ "sets", "the", "stored", "fields", "to", "load", "from", "the", "docvalue", "and", "return" ]

[ "public", "inner", "hit", "builder", "set", "doc", "value", "fields", "(", "list", "<", "field", "and", "format", ">", "doc", "value", "fields", ")", "{", "this", "doc", "value", "fields", "=", "doc", "value", "fields", ";", "return", "this", ";", "}" ]

[ "gets", "a", "value", "as", "a", "{", "@", "link", "slice", "}" ]

[ "slice", "get", "slice", "(", "int", "channel", ",", "int", "position", ")", ";" ]

[ "produces", "a", "merge", "map", "where", "`", "merge", "map", "[", "i", "]", "`", "represents", "the", "index", "that", "<", "code", ">", "values", "[", "i", "]", "<", "code", ">", "would", "be", "moved", "to", "<", "b", ">", "if", "<", "b", ">", "<", "code", ">", "values", "<", "code", ">", "were", "sorted", "in", "other", "words", ",", "this", "method", "produces", "a", "merge", "map", "that", "will", "sort", "<", "code", ">", "values", "<", "code", ">", "see", "buckets", "aggregator", ":", ":", "merge", "buckets", "to", "learn", "more", "about", "the", "merge", "map" ]

[ "public", "long", "[", "]", "generate", "merge", "map", "(", ")", "{", "sort", "(", "0", ",", "indexes", "length", ")", ";", "return", "indexes", ";", "}" ]

[ "if", "dead", "node", "detection", "enabled", "is", "true", ",", "return", "the", "dead", "nodes", "that", "detected", "by", "all", "the", "d", "f", "s", "input", "streams", "in", "the", "same", "client", "otherwise", "return", "the", "dead", "nodes", "that", "detected", "by", "given", "d", "f", "s", "input", "stream" ]

[ "public", "concurrent", "hash", "map", "<", "datanode", "info", ",", "datanode", "info", ">", "get", "dead", "nodes", "(", "d", "f", "s", "input", "stream", "dfs", "input", "stream", ")", "{", "if", "(", "client", "context", "is", "dead", "node", "detection", "enabled", "(", ")", ")", "{", "concurrent", "hash", "map", "<", "datanode", "info", ",", "datanode", "info", ">", "dead", "nodes", "=", "new", "concurrent", "hash", "map", "<", "datanode", "info", ",", "datanode", "info", ">", "(", ")", ";", "if", "(", "dfs", "input", "stream", "!", "=", "null", ")", "{", "dead", "nodes", "put", "all", "(", "dfs", "input", "stream", "get", "local", "dead", "nodes", "(", ")", ")", ";", "}", "set", "<", "datanode", "info", ">", "detect", "dead", "nodes", "=", "client", "context", "get", "dead", "node", "detector", "(", ")", "clear", "and", "get", "detected", "dead", "nodes", "(", ")", ";", "for", "(", "datanode", "info", "detect", "dead", "node", ":", "detect", "dead", "nodes", ")", "{", "dead", "nodes", "put", "(", "detect", "dead", "node", ",", "detect", "dead", "node", ")", ";", "}", "return", "dead", "nodes", ";", "}", "else", "{", "return", "dfs", "input", "stream", "get", "local", "dead", "nodes", "(", ")", ";", "}", "}" ]

[ "return", "the", "order", "position", "to", "be", "used" ]

[ "protected", "int", "get", "order", "(", ")", "{", "return", "this", "order", ";", "}" ]

[ "set", "the", "validator", "to", "apply", "after", "each", "binding", "step" ]

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

[ "return", "the", "j", "s", "o", "n", "object", "in", "cache" ]

[ "public", "static", "j", "s", "o", "n", "object", "get", "j", "s", "o", "n", "object", "(", "@", "non", "null", "final", "string", "key", ")", "{", "return", "get", "j", "s", "o", "n", "object", "(", "key", ",", "get", "default", "cache", "disk", "utils", "(", ")", ")", ";", "}" ]

[ "returns", "a", "module", "which", "creates", "bindings", "for", "provider", "methods", "from", "the", "given", "object", "this", "is", "useful", "notably", "for", "<", "a", "href", "=", "\"", "http", ":", "code", "google", "compgoogle", "-", "gin", "\"", ">", "gin" ]

[ "public", "static", "module", "for", "object", "(", "object", "object", ")", "{", "/", "/", "avoid", "infinite", "recursion", ",", "since", "installing", "a", "module", "always", "installs", "itself", "if", "(", "object", "instanceof", "provider", "methods", "module", ")", "{", "return", "modules", "empty", "module", ";", "}", "return", "new", "provider", "methods", "module", "(", "object", ")", ";", "}" ]

[ "switches", "the", "{", "@", "link", "thread", "#", "get", "context", "class", "loader", "(", ")", "context", "class", "loader", "}", "for", "the", "managed", "resources", "{", "@", "link", "class", "loader", "}", "before", "allowing", "the", "invocation", "to", "occur" ]

[ "public", "void", "set", "attribute", "(", "attribute", "attribute", ")", "throws", "attribute", "not", "found", "exception", ",", "invalid", "attribute", "value", "exception", ",", "m", "bean", "exception", ",", "reflection", "exception", "{", "class", "loader", "current", "class", "loader", "=", "thread", "current", "thread", "(", ")", "get", "context", "class", "loader", "(", ")", ";", "try", "{", "thread", "current", "thread", "(", ")", "set", "context", "class", "loader", "(", "this", "managed", "resource", "class", "loader", ")", ";", "super", "set", "attribute", "(", "attribute", ")", ";", "}", "finally", "{", "thread", "current", "thread", "(", ")", "set", "context", "class", "loader", "(", "current", "class", "loader", ")", ";", "}", "}" ]

[ "model", "tests", "for", "special", "model", "name" ]

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

[ "add", "the", "given", "filter", "to", "the", "end", "of", "the", "filter", "chain", "filter", "functions", "are", "typically", "used", "to", "invoke", "methods", "on", "the", "statement", "before", "it", "is", "executed", "for", "example", ":", "<", "pre", "class", "=", "\"", "code", "\"", ">", "database", "client", "client", "=", "…", ";", "client", "sql", "(", "\"", "select", "book", "id", "from", "book", "\"", ")", "filter", "(", "(", "statement", ",", "next", ")", "-", ">", "next", "execute", "(", "statement", "fetch", "size", "(", "100", ")", ")", ")" ]

[ "generic", "execute", "spec", "filter", "(", "statement", "filter", "function", "filter", ")", ";" ]

[ "return", "the", "constructed", "raw", "path", "for", "the", "give", "{", "@", "link", "uri", "}" ]

[ "protected", "string", "upgrade", "url", "(", "uri", "ws", "u", "r", "l", ")", "{", "if", "(", "absolute", "upgrade", "url", ")", "{", "return", "ws", "u", "r", "l", "to", "string", "(", ")", ";", "}", "string", "path", "=", "ws", "u", "r", "l", "get", "raw", "path", "(", ")", ";", "path", "=", "path", "=", "=", "null", "|", "|", "path", "is", "empty", "(", ")", "?", "\"", "/", "\"", ":", "path", ";", "string", "query", "=", "ws", "u", "r", "l", "get", "raw", "query", "(", ")", ";", "return", "query", "!", "=", "null", "&", "&", "!", "query", "is", "empty", "(", ")", "?", "path", "+", "'", "?", "'", "+", "query", ":", "path", ";", "}" ]

[ "notifies", "the", "master", "node", "about", "the", "completion", "of", "a", "persistent", "task", "when", "{", "@", "code", "failure", "}", "is", "{", "@", "code", "null", "}", ",", "the", "persistent", "task", "is", "considered", "as", "successfully", "completed" ]

[ "public", "void", "send", "completion", "request", "(", "final", "string", "task", "id", ",", "final", "long", "task", "allocation", "id", ",", "final", "@", "nullable", "exception", "task", "failure", ",", "final", "action", "listener", "<", "persistent", "task", "<", "?", ">", ">", "listener", ")", "{", "completion", "persistent", "task", "action", "request", "request", "=", "new", "completion", "persistent", "task", "action", "request", "(", "task", "id", ",", "task", "allocation", "id", ",", "task", "failure", ")", ";", "execute", "(", "request", ",", "completion", "persistent", "task", "action", "instance", ",", "listener", ")", ";", "}" ]

[ "provide", "default", "formatted", "string", "representation", "of", "this", "instruction" ]

[ "public", "string", "to", "string", "(", ")", "{", "string", "value", "representation", "=", "get", "default", "value", "representation", "(", ")", ";", "string", "mnemonic", "string", "=", "get", "mnemonic", "string", "(", ")", ";", "if", "(", "value", "representation", "=", "=", "null", ")", "{", "return", "mnemonic", "string", ";", "}", "return", "mnemonic", "string", "+", "\"", "\"", "+", "value", "representation", ";", "}" ]

[ "adds", "the", "given", "nodes", "to", "this", "node", "'", "s", "children", "must", "be", "called", "from", "the", "swing", "thread" ]

[ "protected", "synchronized", "void", "do", "add", "nodes", "(", "list", "<", "g", "tree", "node", ">", "nodes", ")", "{", "for", "(", "g", "tree", "node", "node", ":", "nodes", ")", "{", "node", "set", "parent", "(", "(", "g", "tree", "node", ")", "this", ")", ";", "}", "children", "(", ")", "add", "all", "(", "nodes", ")", ";", "do", "fire", "node", "structure", "changed", "(", ")", ";", "}" ]

[ "sends", "a", "sasl", "negotiation", "message", "indicating", "an", "invalid", "key", "error" ]

[ "private", "static", "void", "send", "invalid", "key", "sasl", "error", "message", "(", "data", "output", "stream", "out", ",", "string", "message", ")", "throws", "i", "o", "exception", "{", "send", "sasl", "message", "(", "out", ",", "data", "transfer", "encryptor", "status", "error", "unknown", "key", ",", "null", ",", "message", ")", ";", "}" ]

[ "get", "result", "code" ]

[ "public", "static", "result", "code", "get", "(", "byte", "ordinal", ")", "{", "return", "get", "(", "(", "int", ")", "ordinal", ")", ";", "}" ]

[ "set", "the", "error", "code", "to", "the", "given", "error", "code" ]

[ "public", "void", "set", "error", "code", "(", "int", "error", "code", ")", "{", "this", "error", "code", "=", "error", "code", ";", "}" ]

[ "get", "previous", "bytecode", "offset" ]

[ "public", "int", "get", "previous", "offset", "(", ")", ";" ]

[ "private", "helper", "method", "to", "load", "delegation", "keys", "from", "fsimage" ]

[ "private", "synchronized", "void", "load", "all", "keys", "(", "data", "input", "in", ")", "throws", "i", "o", "exception", "{", "startup", "progress", "prog", "=", "name", "node", "get", "startup", "progress", "(", ")", ";", "step", "step", "=", "new", "step", "(", "step", "type", "delegation", "keys", ")", ";", "prog", "begin", "step", "(", "phase", "loading", "fsimage", ",", "step", ")", ";", "int", "number", "of", "keys", "=", "in", "read", "int", "(", ")", ";", "prog", "set", "total", "(", "phase", "loading", "fsimage", ",", "step", ",", "number", "of", "keys", ")", ";", "counter", "counter", "=", "prog", "get", "counter", "(", "phase", "loading", "fsimage", ",", "step", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "number", "of", "keys", ";", "i", "+", "+", ")", "{", "delegation", "key", "value", "=", "new", "delegation", "key", "(", ")", ";", "value", "read", "fields", "(", "in", ")", ";", "add", "key", "(", "value", ")", ";", "counter", "increment", "(", ")", ";", "}", "prog", "end", "step", "(", "phase", "loading", "fsimage", ",", "step", ")", ";", "}" ]

[ "returns", "the", "{", "@", "link", "mapped", "field", "type", "}", "for", "this", "config" ]

[ "mapped", "field", "type", "field", "type", "(", ")", "{", "return", "field", "type", ";", "}" ]

[ "get", "the", "token", "passwordsecret" ]

[ "public", "byte", "[", "]", "get", "password", "(", ")", "{", "return", "password", ";", "}" ]

[ "return", "the", "class", "for", "a", "name", "default", "is", "{", "@", "link", "class", "#", "for", "name", "(", "string", ")", "}" ]

[ "public", "static", "synchronized", "class", "<", "?", ">", "get", "class", "(", "string", "name", ",", "configuration", "conf", ")", "throws", "i", "o", "exception", "{", "class", "<", "?", ">", "writable", "class", "=", "name", "to", "class", "get", "(", "name", ")", ";", "if", "(", "writable", "class", "!", "=", "null", ")", "return", "writable", "class", "as", "subclass", "(", "writable", "class", ")", ";", "try", "{", "return", "conf", "get", "class", "by", "name", "(", "name", ")", ";", "}", "catch", "(", "class", "not", "found", "exception", "e", ")", "{", "i", "o", "exception", "new", "e", "=", "new", "i", "o", "exception", "(", "\"", "writable", "name", "can", "'", "t", "load", "class", ":", "\"", "+", "name", ")", ";", "new", "e", "init", "cause", "(", "e", ")", ";", "throw", "new", "e", ";", "}", "}" ]

[ "where", "there", "any", "search", "failures", "?" ]

[ "public", "final", "list", "<", "search", "failure", ">", "get", "failures", "(", ")", "{", "return", "failures", ";", "}" ]

[ "return", "true", "if", "this", "additional", "properties", "any", "type", "object", "is", "equal", "to", "o" ]

[ "public", "boolean", "equals", "(", "object", "o", ")", "{", "if", "(", "this", "=", "=", "o", ")", "{", "return", "true", ";", "}", "if", "(", "o", "=", "=", "null", "|", "|", "get", "class", "(", ")", "!", "=", "o", "get", "class", "(", ")", ")", "{", "return", "false", ";", "}", "additional", "properties", "any", "type", "additional", "properties", "any", "type", "=", "(", "additional", "properties", "any", "type", ")", "o", ";", "return", "objects", "equals", "(", "this", "name", ",", "additional", "properties", "any", "type", "name", ")", "&", "&", "objects", "equals", "(", "this", "additional", "properties", ",", "additional", "properties", "any", "type", "additional", "properties", ")", ";", "}" ]

[ "the", "supplier", "which", "provides", "processor", "with", "k", "table", "-", "k", "table", "join", "merge", "functionality" ]

[ "public", "k", "table", "k", "table", "join", "merger", "<", "k", ",", "vr", ">", "join", "merger", "(", ")", "{", "final", "k", "table", "k", "table", "join", "merger", "<", "k", ",", "change", "<", "vr", ">", ">", "merger", "=", "merge", "processor", "parameters", "(", ")", "k", "table", "k", "table", "join", "merger", "processor", "supplier", "(", ")", ";", "/", "/", "this", "incorrect", "cast", "should", "be", "corrected", "by", "the", "end", "of", "the", "kip", "-", "478", "implementation", "return", "(", "k", "table", "k", "table", "join", "merger", "<", "k", ",", "vr", ">", ")", "merger", ";", "}" ]

[ "retrieves", "a", "blob", "via", "a", "{", "@", "link", "blob", "cache", "service", "}", "which", "cannot", "create", "incoming", "files", "file", "transfers", "should", "fail" ]

[ "private", "void", "test", "get", "fails", "incoming", "(", "@", "nullable", "final", "job", "i", "d", "job", "id", ",", "blob", "key", "blob", "type", "blob", "type", ")", "throws", "i", "o", "exception", "{", "assume", "true", "(", "!", "operating", "system", "is", "windows", "(", ")", ")", ";", "/", "/", "set", "writable", "doesn", "'", "t", "work", "on", "windows", "final", "configuration", "config", "=", "new", "configuration", "(", ")", ";", "config", "set", "string", "(", "blob", "server", "options", "storage", "directory", ",", "temporary", "folder", "new", "folder", "(", ")", "get", "absolute", "path", "(", ")", ")", ";", "file", "temp", "file", "dir", "=", "null", ";", "try", "(", "blob", "server", "server", "=", "new", "blob", "server", "(", "config", ",", "new", "void", "blob", "store", "(", ")", ")", ";", "blob", "cache", "service", "cache", "=", "new", "blob", "cache", "service", "(", "config", ",", "new", "void", "blob", "store", "(", ")", ",", "new", "inet", "socket", "address", "(", "\"", "localhost", "\"", ",", "server", "get", "port", "(", ")", ")", ")", ")", "{", "server", "start", "(", ")", ";", "/", "/", "store", "the", "data", "on", "the", "server", "byte", "[", "]", "data", "=", "new", "byte", "[", "2000000", "]", ";", "rnd", "next", "bytes", "(", "data", ")", ";", "blob", "key", "blob", "key", "=", "put", "(", "server", ",", "job", "id", ",", "data", ",", "blob", "type", ")", ";", "verify", "type", "(", "blob", "type", ",", "blob", "key", ")", ";", "/", "/", "make", "sure", "the", "blob", "cache", "cannot", "create", "any", "files", "in", "its", "storage", "dir", "if", "(", "blob", "type", "=", "=", "permanent", "blob", ")", "{", "temp", "file", "dir", "=", "cache", "get", "permanent", "blob", "service", "(", ")", "create", "temporary", "filename", "(", ")", "get", "parent", "file", "(", ")", ";", "}", "else", "{", "temp", "file", "dir", "=", "cache", "get", "transient", "blob", "service", "(", ")", "create", "temporary", "filename", "(", ")", "get", "parent", "file", "(", ")", ";", "}", "assert", "true", "(", "temp", "file", "dir", "set", "executable", "(", "true", ",", "false", ")", ")", ";", "assert", "true", "(", "temp", "file", "dir", "set", "readable", "(", "true", ",", "false", ")", ")", ";", "assert", "true", "(", "temp", "file", "dir", "set", "writable", "(", "false", ",", "false", ")", ")", ";", "/", "/", "request", "the", "file", "from", "the", "server", "via", "the", "cache", "exception", "expect", "(", "i", "o", "exception", "class", ")", ";", "exception", "expect", "message", "(", "\"", "failed", "to", "fetch", "blob", "\"", ")", ";", "try", "{", "get", "(", "cache", ",", "job", "id", ",", "blob", "key", ")", ";", "}", "finally", "{", "hash", "set", "<", "string", ">", "expected", "dirs", "=", "new", "hash", "set", "<", ">", "(", ")", ";", "expected", "dirs", "add", "(", "\"", "incoming", "\"", ")", ";", "if", "(", "job", "id", "!", "=", "null", ")", "{", "/", "/", "only", "the", "incoming", "and", "job", "directory", "should", "exist", "(", "no", "job", "directory", "!", ")", "expected", "dirs", "add", "(", "job", "dir", "prefix", "+", "job", "id", ")", ";", "file", "storage", "dir", "=", "temp", "file", "dir", "get", "parent", "file", "(", ")", ";", "string", "[", "]", "actual", "dirs", "=", "storage", "dir", "list", "(", ")", ";", "assert", "not", "null", "(", "actual", "dirs", ")", ";", "assert", "equals", "(", "expected", "dirs", ",", "new", "hash", "set", "<", ">", "(", "arrays", "as", "list", "(", "actual", "dirs", ")", ")", ")", ";", "/", "/", "job", "directory", "should", "be", "empty", "file", "job", "dir", "=", "new", "file", "(", "temp", "file", "dir", "get", "parent", "file", "(", ")", ",", "job", "dir", "prefix", "+", "job", "id", ")", ";", "assert", "array", "equals", "(", "new", "string", "[", "]", "{", "}", ",", "job", "dir", "list", "(", ")", ")", ";", "}", "else", "{", "/", "/", "only", "the", "incoming", "and", "no", "job", "directory", "should", "exist", "(", "no", "job", "directory", "!", ")", "expected", "dirs", "add", "(", "no", "job", "dir", "prefix", ")", ";", "file", "storage", "dir", "=", "temp", "file", "dir", "get", "parent", "file", "(", ")", ";", "string", "[", "]", "actual", "dirs", "=", "storage", "dir", "list", "(", ")", ";", "assert", "not", "null", "(", "actual", "dirs", ")", ";", "assert", "equals", "(", "expected", "dirs", ",", "new", "hash", "set", "<", ">", "(", "arrays", "as", "list", "(", "actual", "dirs", ")", ")", ")", ";", "/", "/", "no", "job", "directory", "should", "be", "empty", "file", "no", "job", "dir", "=", "new", "file", "(", "temp", "file", "dir", "get", "parent", "file", "(", ")", ",", "no", "job", "dir", "prefix", ")", ";", "assert", "array", "equals", "(", "new", "string", "[", "]", "{", "}", ",", "no", "job", "dir", "list", "(", ")", ")", ";", "}", "/", "/", "file", "should", "still", "be", "there", "on", "the", "server", "(", "even", "if", "transient", ")", "assert", "true", "(", "server", "get", "storage", "location", "(", "job", "id", ",", "blob", "key", ")", "exists", "(", ")", ")", ";", "}", "}", "finally", "{", "/", "/", "set", "writable", "again", "to", "make", "sure", "we", "can", "remove", "the", "directory", "if", "(", "temp", "file", "dir", "!", "=", "null", ")", "{", "/", "/", "noinspection", "result", "of", "method", "call", "ignored", "temp", "file", "dir", "set", "writable", "(", "true", ",", "false", ")", ";", "}", "}", "}" ]

[ "updates", "the", "(", "potentially", "stale", ")", "priority", "value", "cached", "in", "this", "object", "this", "should", "be", "called", "when", "this", "object", "is", "outside", "the", "queue" ]

[ "public", "boolean", "update", "level", "priority", "(", ")", "{", "priority", "new", "priority", "=", "task", "handle", "get", "priority", "(", ")", ";", "priority", "old", "priority", "=", "priority", "get", "and", "set", "(", "new", "priority", ")", ";", "return", "new", "priority", "get", "level", "(", ")", "!", "=", "old", "priority", "get", "level", "(", ")", ";", "}" ]

[ "test", "the", "property", "'", "map", "map", "anytype", "'" ]

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

[ "starts", "a", "mini", "hadoop", "cluster" ]

[ "public", "static", "void", "main", "(", "string", "[", "]", "args", ")", "throws", "i", "o", "exception", ",", "u", "r", "i", "syntax", "exception", "{", "new", "mini", "hadoop", "cluster", "manager", "(", ")", "run", "(", "args", ")", ";", "}" ]

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

[ "raise", "a", "non", "-", "critical", "warning" ]

[ "public", "void", "warning", "(", "string", "message", ",", "@", "nullable", "object", "source", ",", "@", "nullable", "parse", "state", "parse", "state", ")", "{", "warning", "(", "message", ",", "source", ",", "parse", "state", ",", "null", ")", ";", "}" ]

[ "converts", "a", "bit", "set", "of", "ssa", "registers", "into", "a", "register", "spec", "list", "containing", "the", "definition", "specs", "of", "all", "the", "registers" ]

[ "register", "spec", "list", "ssa", "set", "to", "specs", "(", "int", "set", "ssa", "set", ")", "{", "register", "spec", "list", "result", "=", "new", "register", "spec", "list", "(", "ssa", "set", "elements", "(", ")", ")", ";", "int", "iterator", "iter", "=", "ssa", "set", "iterator", "(", ")", ";", "int", "i", "=", "0", ";", "while", "(", "iter", "has", "next", "(", ")", ")", "{", "result", "set", "(", "i", "+", "+", ",", "get", "definition", "spec", "for", "ssa", "reg", "(", "iter", "next", "(", ")", ")", ")", ";", "}", "return", "result", ";", "}" ]

[ "provide", "custom", "argument", "resolvers", "this", "is", "delegated", "to", "{", "@", "link", "standalone", "mock", "mvc", "builder", "#", "set", "custom", "argument", "resolvers", "(", "handler", "method", "argument", "resolver", ")", "}" ]

[ "controller", "spec", "custom", "argument", "resolvers", "(", "handler", "method", "argument", "resolver", "argument", "resolvers", ")", ";" ]

[ "updates", "a", "pet", "in", "the", "store", "with", "form", "data" ]

[ "public", "void", "update", "pet", "with", "form", "(", "long", "pet", "id", ",", "string", "name", ",", "string", "status", ")", "{", "/", "/", "todo", ":", "implement", "}" ]

[ "get", "the", "capacity", ",", "which", "is", "the", "maximum", "count", "that", "could", "handled", "without", "resizing", "the", "backing", "storage" ]

[ "public", "int", "get", "capacity", "(", ")", "{", "return", "this", "get", "(", ")", "length", ";", "}" ]

[ "evaluate", "this", "predicate", "on", "the", "given", "request" ]

[ "boolean", "test", "(", "server", "request", "request", ")", ";" ]

[ "checks", "whether", "the", "given", "class", "version", "number", "is", "supported" ]

[ "public", "static", "void", "check", "version", "numbers", "(", "int", "class", "version", ")", "throws", "unsupported", "operation", "exception", "{", "if", "(", "class", "version", "<", "class", "constants", "class", "version", "1", "0", "|", "|", "class", "version", ">", "class", "constants", "class", "version", "1", "8", ")", "{", "throw", "new", "unsupported", "operation", "exception", "(", "\"", "unsupported", "class", "version", "number", "[", "\"", "+", "internal", "major", "class", "version", "(", "class", "version", ")", "+", "\"", "\"", "+", "internal", "minor", "class", "version", "(", "class", "version", ")", "+", "\"", "]", "(", "maximum", "\"", "+", "class", "constants", "class", "version", "1", "8", "major", "+", "\"", "\"", "+", "class", "constants", "class", "version", "1", "8", "minor", "+", "\"", ",", "java", "\"", "+", "java", "constants", "class", "version", "1", "8", "+", "\"", ")", "\"", ")", ";", "}", "}" ]

[ "creates", "a", "new", "async", "stub", "that", "supports", "all", "call", "types", "for", "the", "service" ]

[ "public", "static", "unimplemented", "service", "stub", "new", "stub", "(", "io", "grpc", "channel", "channel", ")", "{", "io", "grpc", "stub", "abstract", "stub", "stub", "factory", "<", "unimplemented", "service", "stub", ">", "factory", "=", "new", "io", "grpc", "stub", "abstract", "stub", "stub", "factory", "<", "unimplemented", "service", "stub", ">", "(", ")", "{", "@", "java", "lang", "override", "public", "unimplemented", "service", "stub", "new", "stub", "(", "io", "grpc", "channel", "channel", ",", "io", "grpc", "call", "options", "call", "options", ")", "{", "return", "new", "unimplemented", "service", "stub", "(", "channel", ",", "call", "options", ")", ";", "}", "}", ";", "return", "unimplemented", "service", "stub", "new", "stub", "(", "factory", ",", "channel", ")", ";", "}" ]

[ "to", "array", "(", "integer", "array", ")", "returns", "an", "integer", "array", "containing", "all", "elements", "from", "the", "set" ]

[ "public", "void", "test", "to", "array", "2", "(", ")", "{", "collection", "empty", "=", "set", "(", ")", ";", "integer", "[", "]", "a", ";", "int", "size", "=", "20", ";", "a", "=", "new", "integer", "[", "0", "]", ";", "assert", "same", "(", "a", ",", "empty", "to", "array", "(", "a", ")", ")", ";", "a", "=", "new", "integer", "[", "size", "/", "2", "]", ";", "arrays", "fill", "(", "a", ",", "42", ")", ";", "assert", "same", "(", "a", ",", "empty", "to", "array", "(", "a", ")", ")", ";", "assert", "null", "(", "a", "[", "0", "]", ")", ";", "for", "(", "int", "i", "=", "1", ";", "i", "<", "a", "length", ";", "i", "+", "+", ")", "{", "assert", "equals", "(", "42", ",", "(", "int", ")", "a", "[", "i", "]", ")", ";", "}", "integer", "[", "]", "elements", "=", "new", "integer", "[", "size", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "size", ";", "i", "+", "+", ")", "{", "elements", "[", "i", "]", "=", "i", ";", "}", "collections", "shuffle", "(", "arrays", "as", "list", "(", "elements", ")", ")", ";", "collection", "<", "integer", ">", "full", "=", "populated", "set", "(", "elements", ")", ";", "arrays", "fill", "(", "a", ",", "42", ")", ";", "assert", "true", "(", "arrays", "as", "list", "(", "elements", ")", "contains", "all", "(", "arrays", "as", "list", "(", "full", "to", "array", "(", "a", ")", ")", ")", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "a", "length", ";", "i", "+", "+", ")", "{", "assert", "equals", "(", "42", ",", "(", "int", ")", "a", "[", "i", "]", ")", ";", "}", "assert", "same", "(", "integer", "[", "]", "class", ",", "full", "to", "array", "(", "a", ")", "get", "class", "(", ")", ")", ";", "a", "=", "new", "integer", "[", "size", "]", ";", "arrays", "fill", "(", "a", ",", "42", ")", ";", "assert", "same", "(", "a", ",", "full", "to", "array", "(", "a", ")", ")", ";", "assert", "true", "(", "arrays", "as", "list", "(", "elements", ")", "contains", "all", "(", "arrays", "as", "list", "(", "full", "to", "array", "(", "a", ")", ")", ")", ")", ";", "}" ]

[ "get", "the", "rolling", "window", "specified", "by", "metric", "and", "user" ]

[ "private", "rolling", "window", "get", "rolling", "window", "(", "string", "metric", ",", "string", "user", ")", "{", "rolling", "window", "map", "rw", "map", "=", "metric", "map", "get", "(", "metric", ")", ";", "if", "(", "rw", "map", "=", "=", "null", ")", "{", "rw", "map", "=", "new", "rolling", "window", "map", "(", ")", ";", "rolling", "window", "map", "prev", "rw", "map", "=", "metric", "map", "put", "if", "absent", "(", "metric", ",", "rw", "map", ")", ";", "if", "(", "prev", "rw", "map", "!", "=", "null", ")", "{", "rw", "map", "=", "prev", "rw", "map", ";", "}", "}", "rolling", "window", "window", "=", "rw", "map", "get", "(", "user", ")", ";", "if", "(", "window", "!", "=", "null", ")", "{", "return", "window", ";", "}", "window", "=", "new", "rolling", "window", "(", "window", "len", "ms", ",", "buckets", "per", "window", ")", ";", "rolling", "window", "prev", "window", "=", "rw", "map", "put", "if", "absent", "(", "user", ",", "window", ")", ";", "if", "(", "prev", "window", "!", "=", "null", ")", "{", "window", "=", "prev", "window", ";", "}", "return", "window", ";", "}" ]

[ "get", "name", "wrapped", "array" ]

[ "public", "list", "<", "integer", ">", "get", "name", "wrapped", "array", "(", ")", "{", "return", "name", "wrapped", "array", ";", "}" ]

[ "get", "parent", "paths", "(", "including", "itself", ")", "and", "quotas", "of", "the", "specified", "federation", "path", "only", "parents", "containing", "quota", "are", "returned" ]

[ "tree", "map", "<", "string", ",", "router", "quota", "usage", ">", "get", "parents", "containing", "quota", "(", "string", "child", "path", ")", "{", "tree", "map", "<", "string", ",", "router", "quota", "usage", ">", "res", "=", "new", "tree", "map", "<", ">", "(", ")", ";", "read", "lock", "lock", "(", ")", ";", "try", "{", "entry", "<", "string", ",", "router", "quota", "usage", ">", "entry", "=", "this", "cache", "floor", "entry", "(", "child", "path", ")", ";", "while", "(", "entry", "!", "=", "null", ")", "{", "string", "mount", "path", "=", "entry", "get", "key", "(", ")", ";", "router", "quota", "usage", "quota", "=", "entry", "get", "value", "(", ")", ";", "if", "(", "is", "quota", "set", "(", "quota", ")", "&", "&", "is", "parent", "entry", "(", "child", "path", ",", "mount", "path", ")", ")", "{", "res", "put", "(", "mount", "path", ",", "quota", ")", ";", "}", "entry", "=", "this", "cache", "lower", "entry", "(", "mount", "path", ")", ";", "}", "return", "res", ";", "}", "finally", "{", "read", "lock", "unlock", "(", ")", ";", "}", "}" ]

[ "ensures", "the", "specified", "plugin", "has", "a", "unique", "name", "among", "all", "plugin", "classes", "found", "in", "the", "current", "class", "searcher", "'", "s", "reach" ]

[ "public", "static", "void", "assert", "unique", "plugin", "name", "(", "class", "<", "?", "extends", "plugin", ">", "plugin", "class", ")", "throws", "plugin", "exception", "{", "string", "plugin", "name", "=", "get", "plugin", "name", "from", "class", "(", "plugin", "class", ")", ";", "for", "(", "class", "<", "?", "extends", "plugin", ">", "other", "plugin", "class", ":", "class", "searcher", "get", "classes", "(", "plugin", "class", ")", ")", "{", "if", "(", "other", "plugin", "class", "!", "=", "plugin", "class", "&", "&", "get", "plugin", "name", "from", "class", "(", "other", "plugin", "class", ")", "equals", "(", "plugin", "name", ")", ")", "{", "throw", "new", "plugin", "exception", "(", "\"", "duplicate", "plugin", "name", ":", "\"", "+", "plugin", "class", "get", "name", "(", ")", "+", "\"", "and", "\"", "+", "other", "plugin", "class", "get", "name", "(", ")", ")", ";", "}", "}", "}" ]

[ "randomize", "the", "split", "order", ",", "then", "take", "the", "specified", "number", "of", "keys", "from", "each", "split", "sampled", ",", "where", "each", "key", "is", "selected", "with", "the", "specified", "probability", "and", "possibly", "replaced", "by", "a", "subsequently", "selected", "key", "when", "the", "quota", "of", "keys", "from", "that", "split", "is", "satisfied" ]

[ "public", "k", "[", "]", "get", "sample", "(", "input", "format", "<", "k", ",", "v", ">", "inf", ",", "job", "conf", "job", ")", "throws", "i", "o", "exception", "{", "input", "split", "[", "]", "splits", "=", "inf", "get", "splits", "(", "job", ",", "job", "get", "num", "map", "tasks", "(", ")", ")", ";", "array", "list", "<", "k", ">", "samples", "=", "new", "array", "list", "<", "k", ">", "(", "num", "samples", ")", ";", "int", "splits", "to", "sample", "=", "math", "min", "(", "max", "splits", "sampled", ",", "splits", "length", ")", ";", "random", "r", "=", "new", "random", "(", ")", ";", "long", "seed", "=", "r", "next", "long", "(", ")", ";", "r", "set", "seed", "(", "seed", ")", ";", "log", "debug", "(", "\"", "seed", ":", "\"", "+", "seed", ")", ";", "/", "/", "shuffle", "splits", "for", "(", "int", "i", "=", "0", ";", "i", "<", "splits", "length", ";", "+", "+", "i", ")", "{", "input", "split", "tmp", "=", "splits", "[", "i", "]", ";", "int", "j", "=", "r", "next", "int", "(", "splits", "length", ")", ";", "splits", "[", "i", "]", "=", "splits", "[", "j", "]", ";", "splits", "[", "j", "]", "=", "tmp", ";", "}", "/", "/", "our", "target", "rate", "is", "in", "terms", "of", "the", "maximum", "number", "of", "sample", "splits", ",", "/", "/", "but", "we", "accept", "the", "possibility", "of", "sampling", "additional", "splits", "to", "hit", "/", "/", "the", "target", "sample", "keyset", "for", "(", "int", "i", "=", "0", ";", "i", "<", "splits", "to", "sample", "|", "|", "(", "i", "<", "splits", "length", "&", "&", "samples", "size", "(", ")", "<", "num", "samples", ")", ";", "+", "+", "i", ")", "{", "record", "reader", "<", "k", ",", "v", ">", "reader", "=", "inf", "get", "record", "reader", "(", "splits", "[", "i", "]", ",", "job", ",", "reporter", "null", ")", ";", "k", "key", "=", "reader", "create", "key", "(", ")", ";", "v", "value", "=", "reader", "create", "value", "(", ")", ";", "while", "(", "reader", "next", "(", "key", ",", "value", ")", ")", "{", "if", "(", "r", "next", "double", "(", ")", "<", "=", "freq", ")", "{", "if", "(", "samples", "size", "(", ")", "<", "num", "samples", ")", "{", "samples", "add", "(", "key", ")", ";", "}", "else", "{", "/", "/", "when", "exceeding", "the", "maximum", "number", "of", "samples", ",", "replace", "a", "/", "/", "random", "element", "with", "this", "one", ",", "then", "adjust", "the", "frequency", "/", "/", "to", "reflect", "the", "possibility", "of", "existing", "elements", "being", "/", "/", "pushed", "out", "int", "ind", "=", "r", "next", "int", "(", "num", "samples", ")", ";", "if", "(", "ind", "!", "=", "num", "samples", ")", "{", "samples", "set", "(", "ind", ",", "key", ")", ";", "}", "freq", "*", "=", "(", "num", "samples", "-", "1", ")", "/", "(", "double", ")", "num", "samples", ";", "}", "key", "=", "reader", "create", "key", "(", ")", ";", "}", "}", "reader", "close", "(", ")", ";", "}", "return", "(", "k", "[", "]", ")", "samples", "to", "array", "(", ")", ";", "}" ]

[ "returns", "a", "new", "{", "@", "link", "charset", "encoder", "}", "for", "the", "{", "@", "link", "charset", "}", "with", "specified", "error", "actions" ]

[ "public", "static", "charset", "encoder", "encoder", "(", "charset", "charset", ",", "coding", "error", "action", "malformed", "input", "action", ",", "coding", "error", "action", "unmappable", "character", "action", ")", "{", "check", "not", "null", "(", "charset", ",", "\"", "charset", "\"", ")", ";", "charset", "encoder", "e", "=", "charset", "new", "encoder", "(", ")", ";", "e", "on", "malformed", "input", "(", "malformed", "input", "action", ")", "on", "unmappable", "character", "(", "unmappable", "character", "action", ")", ";", "return", "e", ";", "}" ]

[ "always", "returns", "{", "@", "code", "null", "}", "as", "there", "is", "no", "support", "for", "reading", "a", "saml", "token", "out", "of", "a", "request" ]

[ "public", "authentication", "token", "token", "(", "thread", "context", "thread", "context", ")", "{", "return", "null", ";", "}" ]

[ "record", "the", "saved", "meta", "and", "block", "files", "on", "the", "given", "volume" ]

[ "void", "record", "saved", "block", "files", "(", "file", "[", "]", "files", ")", "{", "this", "saved", "meta", "file", "=", "files", "[", "0", "]", ";", "this", "saved", "block", "file", "=", "files", "[", "1", "]", ";", "}" ]

[ "clears", "all", "text", "from", "the", "error", "buffer" ]

[ "void", "clear", "resolve", "errors", "(", ")", "{", "if", "(", "error", "buf", "length", "(", ")", ">", "0", ")", "{", "error", "buf", "=", "new", "string", "buffer", "(", ")", ";", "}", "}" ]

[ "returns", "internal", "regular", "expression", "syntax", "flag", "value", "see", "{", "@", "link", "regexp", "flag", "#", "value", "(", ")", "}" ]

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

[ "trigger", "a", "browser", "redirect", "with", "specific", "http", "3xx", "status", "code" ]

[ "public", "void", "redirect", "(", "string", "location", ",", "int", "http", "status", "code", ")", "{", "if", "(", "log", "is", "debug", "enabled", "(", ")", ")", "{", "log", "debug", "(", "\"", "redirecting", "(", "{", "}", "to", "{", "}", "\"", ",", "http", "status", "code", ",", "location", ")", ";", "}", "response", "set", "status", "(", "http", "status", "code", ")", ";", "response", "set", "header", "(", "\"", "location", "\"", ",", "location", ")", ";", "response", "set", "header", "(", "\"", "connection", "\"", ",", "\"", "close", "\"", ")", ";", "try", "{", "response", "send", "error", "(", "http", "status", "code", ")", ";", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "log", "warn", "(", "\"", "exception", "when", "trying", "to", "redirect", "permanently", "\"", ",", "e", ")", ";", "}", "}" ]

[ "return", "the", "underlying", "scheduled", "thread", "pool", "executor", ",", "if", "available" ]

[ "public", "scheduled", "thread", "pool", "executor", "get", "scheduled", "thread", "pool", "executor", "(", ")", "throws", "illegal", "state", "exception", "{", "assert", "state", "(", "this", "scheduled", "executor", "instanceof", "scheduled", "thread", "pool", "executor", ",", "\"", "no", "scheduled", "thread", "pool", "executor", "available", "\"", ")", ";", "return", "(", "scheduled", "thread", "pool", "executor", ")", "this", "scheduled", "executor", ";", "}" ]

[ "the", "planned", "capacity", "for", "this", "{", "@", "link", "#", "get", "label", "(", ")", "}" ]

[ "public", "int", "get", "planned", "capacity", "snapshot", "(", ")", "{", "return", "planned", "capacity", "snapshot", ";", "}" ]

[ "return", "true", "if", "this", "additional", "properties", "integer", "object", "is", "equal", "to", "o" ]

[ "public", "boolean", "equals", "(", "object", "o", ")", "{", "if", "(", "this", "=", "=", "o", ")", "{", "return", "true", ";", "}", "if", "(", "o", "=", "=", "null", "|", "|", "get", "class", "(", ")", "!", "=", "o", "get", "class", "(", ")", ")", "{", "return", "false", ";", "}", "additional", "properties", "integer", "additional", "properties", "integer", "=", "(", "additional", "properties", "integer", ")", "o", ";", "return", "objects", "equals", "(", "this", "name", ",", "additional", "properties", "integer", "name", ")", "&", "&", "objects", "equals", "(", "this", "additional", "properties", ",", "additional", "properties", "integer", "additional", "properties", ")", "&", "&", "super", "equals", "(", "o", ")", ";", "}" ]

[ "inserts", "the", "string", "representation", "of", "the", "specified", "{", "@", "code", "char", "}", "value", "at", "the", "specified", "{", "@", "code", "offset", "}", "the", "{", "@", "code", "char", "}", "value", "is", "converted", "to", "a", "string", "according", "to", "the", "rule", "defined", "by", "{", "@", "link", "string", "#", "value", "of", "(", "char", ")", "}" ]

[ "public", "string", "builder", "insert", "(", "int", "offset", ",", "char", "c", ")", "{", "insert", "0", "(", "offset", ",", "c", ")", ";", "return", "this", ";", "}" ]

[ "stop", "the", "shared", "connection" ]

[ "protected", "void", "stop", "shared", "connection", "(", ")", "throws", "j", "m", "s", "exception", "{", "synchronized", "(", "this", "shared", "connection", "monitor", ")", "{", "this", "shared", "connection", "started", "=", "false", ";", "if", "(", "this", "shared", "connection", "!", "=", "null", ")", "{", "try", "{", "this", "shared", "connection", "stop", "(", ")", ";", "}", "catch", "(", "javax", "jms", "illegal", "state", "exception", "ex", ")", "{", "logger", "debug", "(", "\"", "ignoring", "connection", "stop", "exception", "-", "assuming", "already", "stopped", ":", "\"", "+", "ex", ")", ";", "}", "}", "}", "}" ]

[ "returns", "the", "ratio", "of", "cache", "requests", "which", "were", "hits", "this", "is", "defined", "as", "{", "@", "code", "hit", "count", "request", "count", "}", ",", "or", "{", "@", "code", "1", "0", "}", "when", "{", "@", "code", "request", "count", "=", "=", "0", "}", "note", "that", "{", "@", "code", "hit", "rate", "+", "miss", "rate", "=", "~", "1", "0", "}" ]

[ "public", "double", "hit", "rate", "(", ")", "{", "long", "request", "count", "=", "request", "count", "(", ")", ";", "return", "(", "request", "count", "=", "=", "0", ")", "?", "1", "0", ":", "(", "double", ")", "hit", "count", "/", "request", "count", ";", "}" ]

[ "makes", "sure", "'", "<", "'", ",", "'", "&", "'", ",", "are", "escaped" ]

[ "@", "test", "public", "void", "escape", "(", ")", "throws", "exception", "{", "free", "style", "project", "p", "=", "r", "create", "free", "style", "project", "(", ")", ";", "p", "get", "builders", "list", "(", ")", "add", "(", "new", "test", "builder", "(", ")", "{", "@", "override", "public", "boolean", "perform", "(", "abstract", "build", "<", "?", ",", "?", ">", "build", ",", "launcher", "launcher", ",", "build", "listener", "listener", ")", "throws", "interrupted", "exception", ",", "i", "o", "exception", "{", "listener", "get", "logger", "(", ")", "println", "(", "\"", "<", "b", ">", "&", "amp", ";", "<", "/", "b", ">", "\"", ")", ";", "return", "true", ";", "}", "}", ")", ";", "free", "style", "build", "b", "=", "r", "build", "and", "assert", "success", "(", "p", ")", ";", "html", "page", "html", "=", "r", "create", "web", "client", "(", ")", "get", "page", "(", "b", ",", "\"", "console", "\"", ")", ";", "string", "text", "=", "html", "as", "text", "(", ")", ";", "system", "out", "println", "(", "text", ")", ";", "assert", "true", "(", "text", "contains", "(", "\"", "<", "b", ">", "&", "amp", ";", "<", "/", "b", ">", "\"", ")", ")", ";", "assert", "true", "(", "jenkins", "rule", "get", "log", "(", "b", ")", "contains", "(", "\"", "<", "b", ">", "&", "amp", ";", "<", "/", "b", ">", "\"", ")", ")", ";", "}" ]

[ "returns", "current", "restore", "state" ]

[ "public", "state", "state", "(", ")", "{", "return", "state", ";", "}" ]

[ "gets", "the", "wrapped", "hadoop", "input", "stream" ]

[ "public", "org", "apache", "hadoop", "fs", "f", "s", "data", "input", "stream", "get", "hadoop", "input", "stream", "(", ")", "{", "return", "fs", "data", "input", "stream", ";", "}" ]

[ "sets", "the", "number", "of", "label", "entries", "for", "the", "y", "-", "axis", "max", "=", "25", ",", "min", "=", "2", ",", "default", ":", "6", ",", "be", "aware", "that", "this", "number", "is", "not", "fixed" ]

[ "public", "void", "set", "label", "count", "(", "int", "count", ")", "{", "if", "(", "count", ">", "get", "axis", "max", "labels", "(", ")", ")", "count", "=", "get", "axis", "max", "labels", "(", ")", ";", "if", "(", "count", "<", "get", "axis", "min", "labels", "(", ")", ")", "count", "=", "get", "axis", "min", "labels", "(", ")", ";", "m", "label", "count", "=", "count", ";", "m", "force", "labels", "=", "false", ";", "}" ]

[ "has", "the", "underlying", "memory", "required", "to", "complete", "reading", "been", "allocated", "yet", "?" ]

[ "boolean", "memory", "allocated", "(", ")", ";" ]