Anonymous2023/KGSum · Datasets at Hugging Face

docstring_tokens list	code_tokens list
[ "creates", "a", "new", "test", "{", "@", "link", "operator", "stream", "state", "handle", "}", "with", "a", "given", "number", "of", "randomly", "created", "named", "states" ]	[ "public", "static", "operator", "state", "handle", "create", "new", "operator", "state", "handle", "(", "int", "num", "named", "states", ",", "random", "random", ")", "{", "map", "<", "string", ",", "operator", "state", "handle", "state", "meta", "info", ">", "operator", "state", "meta", "data", "=", "new", "hash", "map", "<", ">", "(", "num", "named", "states", ")", ";", "long", "off", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "num", "named", "states", ";", "+", "+", "i", ")", "{", "long", "[", "]", "offsets", "=", "new", "long", "[", "4", "]", ";", "for", "(", "int", "o", "=", "0", ";", "o", "<", "offsets", "length", ";", "+", "+", "o", ")", "{", "offsets", "[", "o", "]", "=", "off", "+", "+", ";", "}", "operator", "state", "handle", "state", "meta", "info", "meta", "info", "=", "new", "operator", "state", "handle", "state", "meta", "info", "(", "offsets", ",", "operator", "state", "handle", "mode", "split", "distribute", ")", ";", "operator", "state", "meta", "data", "put", "(", "string", "value", "of", "(", "uuid", "random", "u", "u", "i", "d", "(", ")", ")", ",", "meta", "info", ")", ";", "}", "return", "new", "operator", "stream", "state", "handle", "(", "operator", "state", "meta", "data", ",", "create", "stream", "state", "handle", "(", "num", "named", "states", ",", "random", ")", ")", ";", "}" ]
[ "release", "the", "provided", "{", "@", "link", "releasable", "}", "s", ",", "ignoring", "exceptions" ]	[ "public", "static", "void", "close", "while", "handling", "exception", "(", "releasable", "releasables", ")", "{", "close", "while", "handling", "exception", "(", "arrays", "as", "list", "(", "releasables", ")", ")", ";", "}" ]
[ "set", "the", "freemarker", "template", "loader", "path", "via", "a", "spring", "resource", "location", "see", "the", "\"", "template", "loader", "paths", "\"", "property", "for", "details", "on", "path", "handling" ]	[ "public", "void", "set", "template", "loader", "path", "(", "string", "template", "loader", "path", ")", "{", "this", "template", "loader", "paths", "=", "new", "string", "[", "]", "{", "template", "loader", "path", "}", ";", "}" ]
[ "{", "@", "inherit", "doc", "}", "the", "default", "implementation", "does", "nothing" ]	[ "@", "override", "public", "void", "enter", "primitive", "data", "type", "(", "sql", "base", "parser", "primitive", "data", "type", "context", "ctx", ")", "{", "}" ]
[ "asserts", "that", "the", "script", "stack", "looks", "right" ]	[ "public", "static", "void", "assert", "script", "stack", "(", "script", "exception", "e", ",", "string", "stack", ")", "{", "/", "/", "this", "particular", "incantation", "of", "assertions", "makes", "the", "error", "messages", "more", "useful", "try", "{", "assert", "that", "(", "e", "get", "script", "stack", "(", ")", ",", "has", "size", "(", "stack", "length", ")", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "stack", "length", ";", "i", "+", "+", ")", "{", "assert", "equals", "(", "stack", "[", "i", "]", ",", "e", "get", "script", "stack", "(", ")", "get", "(", "i", ")", ")", ";", "}", "}", "catch", "(", "assertion", "error", "assertion", ")", "{", "assertion", "init", "cause", "(", "e", ")", ";", "throw", "assertion", ";", "}", "}" ]
[ "set", "this", "to", "true", "if", "this", "component", "should", "be", "enabled", "(", "should", "be", "drawn", ")", ",", "false", "if", "not", "if", "disabled", ",", "nothing", "of", "this", "component", "will", "be", "drawn", "default", ":", "true" ]	[ "public", "void", "set", "enabled", "(", "boolean", "enabled", ")", "{", "m", "enabled", "=", "enabled", ";", "}" ]
[ "choose", "a", "configuration", "from", "the", "list", "implementors", "typically", "implement", "this", "method", "by", "calling", "{", "@", "link", "egl10", "#", "egl", "choose", "config", "}", "and", "iterating", "through", "the", "results", "please", "consult", "the", "egl", "specification", "available", "from", "the", "khronos", "group", "to", "learn", "how", "to", "call", "egl", "choose", "config" ]	[ "e", "g", "l", "config", "choose", "config", "(", "egl10", "egl", ",", "e", "g", "l", "display", "display", ")", ";" ]
[ "sets", "whether", "the", "action", "will", "support", "using", "the", "default", "tool", "context", "if", "the", "focused", "provider", "'", "s", "context", "is", "invalid", "<", "p", ">", "by", "default", ",", "actions", "only", "work", "on", "the", "current", "focused", "provider", "'", "s", "context", "setting", "this", "to", "true", "will", "cause", "the", "action", "to", "be", "evaluated", "against", "the", "default", "tool", "context", "if", "the", "focused", "context", "is", "not", "valid", "for", "this", "action" ]	[ "public", "b", "supports", "default", "tool", "context", "(", "boolean", "b", ")", "{", "supports", "default", "tool", "context", "=", "b", ";", "return", "self", "(", ")", ";", "}" ]
[ "convenience", "method", "to", "get", "the", "specified", "member", "as", "a", "json", "array" ]	[ "public", "json", "array", "get", "as", "json", "array", "(", "string", "member", "name", ")", "{", "return", "(", "json", "array", ")", "members", "get", "(", "member", "name", ")", ";", "}" ]
[ "put", "bytes", "in", "cache" ]	[ "public", "static", "void", "put", "(", "@", "non", "null", "final", "string", "key", ",", "final", "byte", "[", "]", "value", ",", "final", "int", "save", "time", ",", "@", "non", "null", "final", "cache", "double", "utils", "cache", "double", "utils", ")", "{", "cache", "double", "utils", "put", "(", "key", ",", "value", ",", "save", "time", ")", ";", "}" ]
[ "return", "whether", "the", "container", "is", "still", "active" ]	[ "protected", "boolean", "is", "container", "active", "(", "container", "id", "container", "id", ")", "{", "return", "this", "pid", "files", "contains", "key", "(", "container", "id", ")", ";", "}" ]
[ "create", "the", "objects", "we", "need", "for", "this", "plugin", ";", "register", "the", "service", "provided", ",", "create", "the", "actions", ",", "etc" ]	[ "private", "void", "initialize", "(", ")", "{", "editor", "list", "=", "new", "array", "list", "<", ">", "(", ")", ";", "editor", "option", "mgr", "=", "new", "editor", "option", "manager", "(", "plugin", ")", ";", "install", "editor", "actions", "(", ")", ";", "}" ]
[ "convenience", "method", "to", "create", "a", "group", "matcher", "which", "matches", "against", "the", "groups", "of", "the", "user" ]	[ "public", "static", "mapping", "rule", "matcher", "create", "user", "group", "matcher", "(", "string", "group", "name", ")", "{", "return", "new", "user", "group", "matcher", "(", "group", "name", ")", ";", "}" ]
[ "creates", "a", "{", "@", "link", "scheduled", "executor", "service", "}", "whose", "{", "@", "code", "submit", "}", "and", "{", "@", "code", "invoke", "all", "}", "methods", "submit", "{", "@", "link", "listenable", "future", "task", "}", "instances", "to", "the", "given", "delegate", "executor", "those", "methods", ",", "as", "well", "as", "{", "@", "code", "execute", "}", "and", "{", "@", "code", "invoke", "any", "}", ",", "are", "implemented", "in", "terms", "of", "calls", "to", "{", "@", "code", "delegate", "execute", "}", "all", "other", "methods", "are", "forwarded", "unchanged", "to", "the", "delegate", "this", "implies", "that", "the", "returned", "{", "@", "code", "listening", "scheduled", "executor", "service", "}", "never", "calls", "the", "delegate", "'", "s", "{", "@", "code", "submit", "}", ",", "{", "@", "code", "invoke", "all", "}", ",", "and", "{", "@", "code", "invoke", "any", "}", "methods", ",", "so", "any", "special", "handling", "of", "tasks", "must", "be", "implemented", "in", "the", "delegate", "'", "s", "{", "@", "code", "execute", "}", "method", "or", "by", "wrapping", "the", "returned", "{", "@", "code", "listening", "scheduled", "executor", "service", "}", "if", "the", "delegate", "executor", "was", "already", "an", "instance", "of", "{", "@", "code", "listening", "scheduled", "executor", "service", "}", ",", "it", "is", "returned", "untouched", ",", "and", "the", "rest", "of", "this", "documentation", "does", "not", "apply" ]	[ "public", "static", "listening", "scheduled", "executor", "service", "listening", "decorator", "(", "scheduled", "executor", "service", "delegate", ")", "{", "return", "(", "delegate", "instanceof", "listening", "scheduled", "executor", "service", ")", "?", "(", "listening", "scheduled", "executor", "service", ")", "delegate", ":", "new", "scheduled", "listening", "decorator", "(", "delegate", ")", ";", "}" ]
[ "check", "that", "when", "dangling", "indices", "are", "discovered", ",", "then", "they", "can", "be", "listed" ]	[ "public", "void", "test", "dangling", "indices", "can", "be", "listed", "(", ")", "throws", "exception", "{", "internal", "cluster", "(", ")", "start", "nodes", "(", "3", ",", "build", "settings", "(", "0", ",", "true", ")", ")", ";", "final", "string", "stopped", "node", "name", "=", "create", "dangling", "indices", "(", "index", "name", ")", ";", "final", "list", "dangling", "indices", "response", "response", "=", "client", "(", ")", "admin", "(", ")", "cluster", "(", ")", "list", "dangling", "indices", "(", "new", "list", "dangling", "indices", "request", "(", ")", ")", "action", "get", "(", ")", ";", "assert", "that", "(", "response", "status", "(", ")", ",", "equal", "to", "(", "rest", "status", "ok", ")", ")", ";", "final", "list", "<", "node", "list", "dangling", "indices", "response", ">", "node", "responses", "=", "response", "get", "nodes", "(", ")", ";", "assert", "that", "(", "\"", "didn", "'", "t", "get", "responses", "from", "all", "nodes", "\"", ",", "node", "responses", ",", "has", "size", "(", "3", ")", ")", ";", "for", "(", "node", "list", "dangling", "indices", "response", "node", "response", ":", "node", "responses", ")", "{", "if", "(", "node", "response", "get", "node", "(", ")", "get", "name", "(", ")", "equals", "(", "stopped", "node", "name", ")", ")", "{", "assert", "that", "(", "\"", "expected", "node", "that", "was", "stopped", "to", "have", "one", "dangling", "index", "\"", ",", "node", "response", "get", "dangling", "indices", "(", ")", ",", "has", "size", "(", "1", ")", ")", ";", "final", "dangling", "index", "info", "dangling", "index", "info", "=", "node", "response", "get", "dangling", "indices", "(", ")", "get", "(", "0", ")", ";", "assert", "that", "(", "dangling", "index", "info", "get", "index", "name", "(", ")", ",", "equal", "to", "(", "index", "name", ")", ")", ";", "}", "else", "{", "assert", "that", "(", "\"", "expected", "node", "that", "was", "never", "stopped", "to", "have", "no", "dangling", "indices", "\"", ",", "node", "response", "get", "dangling", "indices", "(", ")", ",", "empty", "(", ")", ")", ";", "}", "}", "}" ]
[ "performs", "message", "encoding", "of", "a", "data", "matrix", "message", "using", "the", "algorithm", "described", "in", "annex", "p", "of", "isoiec", "16022", ":", "2000", "(", "e", ")" ]	[ "public", "static", "string", "encode", "high", "level", "(", "string", "msg", ",", "symbol", "shape", "hint", "shape", ",", "dimension", "min", "size", ",", "dimension", "max", "size", ")", "{", "/", "/", "the", "codewords", "0", "255", "are", "encoded", "as", "unicode", "characters", "encoder", "[", "]", "encoders", "=", "{", "new", "a", "s", "c", "i", "i", "encoder", "(", ")", ",", "new", "c", "4", "0", "encoder", "(", ")", ",", "new", "text", "encoder", "(", ")", ",", "new", "x", "1", "2", "encoder", "(", ")", ",", "new", "edifact", "encoder", "(", ")", ",", "new", "base", "2", "5", "6", "encoder", "(", ")", "}", ";", "encoder", "context", "context", "=", "new", "encoder", "context", "(", "msg", ")", ";", "context", "set", "symbol", "shape", "(", "shape", ")", ";", "context", "set", "size", "constraints", "(", "min", "size", ",", "max", "size", ")", ";", "if", "(", "msg", "starts", "with", "(", "macro", "05", "header", ")", "&", "&", "msg", "ends", "with", "(", "macro", "trailer", ")", ")", "{", "context", "write", "codeword", "(", "macro", "05", ")", ";", "context", "set", "skip", "at", "end", "(", "2", ")", ";", "context", "pos", "+", "=", "macro", "05", "header", "length", "(", ")", ";", "}", "else", "if", "(", "msg", "starts", "with", "(", "macro", "06", "header", ")", "&", "&", "msg", "ends", "with", "(", "macro", "trailer", ")", ")", "{", "context", "write", "codeword", "(", "macro", "06", ")", ";", "context", "set", "skip", "at", "end", "(", "2", ")", ";", "context", "pos", "+", "=", "macro", "06", "header", "length", "(", ")", ";", "}", "int", "encoding", "mode", "=", "ascii", "encodation", ";", "/", "/", "default", "mode", "while", "(", "context", "has", "more", "characters", "(", ")", ")", "{", "encoders", "[", "encoding", "mode", "]", "encode", "(", "context", ")", ";", "if", "(", "context", "get", "new", "encoding", "(", ")", ">", "=", "0", ")", "{", "encoding", "mode", "=", "context", "get", "new", "encoding", "(", ")", ";", "context", "reset", "encoder", "signal", "(", ")", ";", "}", "}", "int", "len", "=", "context", "get", "codeword", "count", "(", ")", ";", "context", "update", "symbol", "info", "(", ")", ";", "int", "capacity", "=", "context", "get", "symbol", "info", "(", ")", "get", "data", "capacity", "(", ")", ";", "if", "(", "len", "<", "capacity", "&", "&", "encoding", "mode", "!", "=", "ascii", "encodation", "&", "&", "encoding", "mode", "!", "=", "base256", "encodation", "&", "&", "encoding", "mode", "!", "=", "edifact", "encodation", ")", "{", "context", "write", "codeword", "(", "'", "\\", "u", "0", "0fe", "'", ")", ";", "/", "/", "unlatch", "(", "254", ")", "}", "/", "/", "padding", "string", "builder", "codewords", "=", "context", "get", "codewords", "(", ")", ";", "if", "(", "codewords", "length", "(", ")", "<", "capacity", ")", "{", "codewords", "append", "(", "pad", ")", ";", "}", "while", "(", "codewords", "length", "(", ")", "<", "capacity", ")", "{", "codewords", "append", "(", "randomize", "2", "5", "3", "state", "(", "codewords", "length", "(", ")", "+", "1", ")", ")", ";", "}", "return", "context", "get", "codewords", "(", ")", "to", "string", "(", ")", ";", "}" ]
[ "the", "process", "id" ]	[ "public", "long", "get", "id", "(", ")", "{", "return", "id", ";", "}" ]
[ "return", "the", "transport", "type", "supported", "by", "this", "handler" ]	[ "transport", "type", "get", "transport", "type", "(", ")", ";" ]
[ "release", "properties", "which", "are", "not", "longer", "required", "for", "the", "current", "layout", "pass", "or", "release", "properties", "which", "should", "be", "reset", "during", "reconciliation" ]	[ "private", "void", "clean", "(", ")", "{", "/", "/", "1", "release", "or", "clone", "props", "m", "components", "=", "new", "array", "list", "<", ">", "(", ")", ";", "if", "(", "m", "component", "global", "keys", "!", "=", "null", ")", "{", "m", "component", "global", "keys", "=", "new", "array", "list", "<", ">", "(", ")", ";", "}", "m", "diff", "node", "=", "null", ";", "m", "debug", "components", "=", "null", ";", "/", "/", "2", "reset", "resolved", "layout", "properties", "reset", "resolved", "layout", "properties", "(", ")", ";", "}" ]
[ "returns", "{", "@", "code", "true", "}", "if", "the", "given", "experiment", "is", "enabled", "this", "is", "an", "experimental", "api", ",", "it", "may", "be", "removed", "at", "any", "point", "without", "deprecation", "or", "other", "notice" ]	[ "public", "boolean", "is", "enabled", "(", "class", "<", "?", "extends", "experiment", ">", "clazz", ")", "{", "return", "experiments", "contains", "key", "(", "clazz", ")", ";", "}" ]
[ "returns", "the", "extra", "data", "for", "this", "entry" ]	[ "public", "final", "byte", "[", "]", "get", "extra", "data", "(", ")", "{", "return", "get", "bytes", "(", "size", "+", "get", "(", "locnam", ")", ",", "get", "(", "locext", ")", ")", ";", "}" ]
[ "verifies", "that", "sent", "socks", "messages", "are", "decoded", "correctly" ]	[ "public", "void", "test", "socks", "cmd", "response", "decoder", "(", ")", "{", "for", "(", "socks", "cmd", "status", "cmd", "status", ":", "socks", "cmd", "status", "values", "(", ")", ")", "{", "for", "(", "socks", "address", "type", "address", "type", ":", "socks", "address", "type", "values", "(", ")", ")", "{", "test", "socks", "cmd", "response", "decoder", "with", "different", "params", "(", "cmd", "status", ",", "address", "type", ",", "null", ",", "0", ")", ";", "}", "}", "}" ]
[ "test", "new", "tx" ]	[ "public", "void", "test", "new", "tx", "(", ")", "throws", "exception", "{", "global", "transaction", "tx", "=", "global", "transaction", "context", "get", "current", "or", "create", "(", ")", ";", "assertions", "assert", "equals", "(", "tx", "get", "status", "(", ")", ",", "global", "status", "un", "known", ")", ";", "assertions", "assert", "null", "(", "tx", "get", "xid", "(", ")", ")", ";", "}" ]
[ "resolving", "the", "network", "topology" ]	[ "public", "static", "node", "resolve", "(", "string", "host", "name", ")", "{", "return", "rack", "resolver", "resolve", "(", "host", "name", ")", ";", "}" ]
[ "gets", "the", "list", "of", "instructions" ]	[ "public", "dalv", "insn", "list", "get", "insns", "(", ")", "{", "finish", "processing", "if", "necessary", "(", ")", ";", "return", "insns", ";", "}" ]
[ "deal", "with", "awb", "resources" ]	[ "public", "void", "process", "awb", "resources", "(", "aapt", "aapt", ",", "aapt", "package", "config", "builder", "aapt", "config", "builder", ",", "file", "main", "symbol", "file", ",", "file", "awb", "symbol", "file", ",", "string", "pacakge", "name", ")", "throws", "i", "o", "exception", ",", "process", "exception", "{", "aapt", "config", "builder", "set", "build", "tool", "info", "(", "get", "target", "info", "(", ")", "get", "build", "tools", "(", ")", ")", ";", "aapt", "config", "builder", "set", "android", "target", "(", "get", "target", "info", "(", ")", "get", "target", "(", ")", ")", ";", "aapt", "config", "builder", "set", "logger", "(", "logger", ")", ";", "logger", "info", "(", "\"", "aapt", "output", "file", "{", "}", "\"", ")", ";", "aapt", "package", "config", "aapt", "config", "=", "aapt", "config", "builder", "build", "(", ")", ";", "try", "{", "aapt", "link", "(", "aapt", "config", ")", "get", "(", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "throw", "new", "process", "exception", "(", "\"", "failed", "to", "execute", "aapt", "\"", ",", "e", ")", ";", "}", "file", "source", "out", "=", "aapt", "config", "get", "source", "output", "dir", "(", ")", ";", "if", "(", "source", "out", "!", "=", "null", ")", "{", "/", "/", "figure", "out", "what", "the", "main", "symbol", "file", "'", "s", "package", "is", "string", "main", "package", "name", "=", "aapt", "config", "get", "custom", "package", "for", "r", "(", ")", ";", "if", "(", "main", "package", "name", "=", "=", "null", ")", "{", "main", "package", "name", "=", "symbol", "utils", "get", "package", "name", "from", "manifest", "(", "aapt", "config", "get", "manifest", "file", "(", ")", ")", ";", "}", "/", "/", "load", "the", "main", "symbol", "file", "file", "main", "r", "txt", "=", "new", "file", "(", "aapt", "config", "get", "symbol", "output", "dir", "(", ")", ",", "\"", "r", "txt", "\"", ")", ";", "file", "merged", "symbol", "file", "=", "new", "file", "(", "aapt", "config", "get", "symbol", "output", "dir", "(", ")", ",", "\"", "r", "-", "all", "txt", "\"", ")", ";", "try", "{", "s", "logger", "info", "(", "\"", "awb", "symbol", "file", ":", "\"", "+", "main", "r", "txt", ")", ";", "if", "(", "null", "!", "=", "main", "r", "txt", "&", "&", "main", "r", "txt", "exists", "(", ")", ")", "{", "file", "utils", "copy", "file", "(", "main", "r", "txt", ",", "merged", "symbol", "file", ")", ";", "}", "else", "{", "throw", "new", "process", "exception", "(", "main", "r", "txt", "get", "absolute", "path", "(", ")", "+", "\"", "is", "not", "exist", ",", "maybe", "no", "resources", "in", "this", "bundle", "!", "\"", ")", ";", "}", "symbol", "table", "awb", "symbols", "=", "build", "(", "awb", "symbol", "file", ",", "main", "package", "name", ",", "main", "r", "txt", ",", "main", "symbol", "file", ",", "pacakge", "name", ")", ";", "if", "(", "awb", "symbols", "!", "=", "null", ")", "{", "atlas", "symbol", "io", "write", "(", "awb", "symbols", ",", "merged", "symbol", "file", ")", ";", "}", "/", "/", "why", "do", "this", "?", "youku", "need", "use", "this", "!", "/", "/", "file", "utils", "write", "lines", "(", "merged", "symbol", "file", ",", "file", "utils", "read", "lines", "(", "main", "symbol", "file", ")", ",", "true", ")", ";", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "throw", "new", "runtime", "exception", "(", "\"", "could", "not", "load", "file", "\"", ",", "e", ")", ";", "}", "symbol", "table", "main", "symbols", "=", "merged", "symbol", "file", "is", "file", "(", ")", "?", "atlas", "symbol", "io", "read", "from", "aapt", "(", "merged", "symbol", "file", ",", "main", "package", "name", ")", ":", "symbol", "table", "builder", "(", ")", "table", "package", "(", "main", "package", "name", ")", "build", "(", ")", ";", "/", "/", "for", "each", "dependency", ",", "load", "its", "symbol", "file", "set", "<", "symbol", "table", ">", "dep", "symbol", "tables", "=", "symbol", "utils", "load", "dependencies", "symbol", "tables", "(", "aapt", "config", "get", "library", "symbol", "table", "files", "(", ")", ",", "main", "package", "name", ")", ";", "boolean", "final", "ids", "=", "true", ";", "if", "(", "aapt", "config", "get", "variant", "type", "(", ")", "=", "=", "variant", "type", "library", ")", "{", "final", "ids", "=", "false", ";", "}", "symbol", "io", "export", "to", "java", "(", "main", "symbols", ",", "source", "out", ",", "final", "ids", ")", ";", "r", "generation", "generate", "r", "for", "libraries", "(", "main", "symbols", ",", "dep", "symbol", "tables", ",", "source", "out", ",", "final", "ids", ")", ";", "}", "}" ]
[ "it", "writes", "the", "field", "value", "to", "the", "parquet", "record", "consumer", "it", "detects", "the", "field", "type", ",", "and", "calls", "the", "correct", "write", "function" ]	[ "private", "void", "write", "value", "(", "final", "object", "value", ",", "final", "object", "inspector", "inspector", ",", "final", "type", "type", ")", "{", "if", "(", "type", "is", "primitive", "(", ")", ")", "{", "check", "inspector", "category", "(", "inspector", ",", "object", "inspector", "category", "primitive", ")", ";", "write", "primitive", "(", "value", ",", "(", "primitive", "object", "inspector", ")", "inspector", ")", ";", "}", "else", "{", "group", "type", "group", "type", "=", "type", "as", "group", "type", "(", ")", ";", "original", "type", "original", "type", "=", "type", "get", "original", "type", "(", ")", ";", "if", "(", "original", "type", "!", "=", "null", "&", "&", "original", "type", "equals", "(", "original", "type", "list", ")", ")", "{", "check", "inspector", "category", "(", "inspector", ",", "object", "inspector", "category", "list", ")", ";", "if", "(", "single", "level", "array", ")", "{", "write", "single", "level", "array", "(", "value", ",", "(", "list", "object", "inspector", ")", "inspector", ",", "group", "type", ")", ";", "}", "else", "{", "write", "array", "(", "value", ",", "(", "list", "object", "inspector", ")", "inspector", ",", "group", "type", ")", ";", "}", "}", "else", "if", "(", "original", "type", "!", "=", "null", "&", "&", "(", "original", "type", "equals", "(", "original", "type", "map", ")", "\|", "\|", "original", "type", "equals", "(", "original", "type", "map", "key", "value", ")", ")", ")", "{", "check", "inspector", "category", "(", "inspector", ",", "object", "inspector", "category", "map", ")", ";", "write", "map", "(", "value", ",", "(", "map", "object", "inspector", ")", "inspector", ",", "group", "type", ")", ";", "}", "else", "{", "check", "inspector", "category", "(", "inspector", ",", "object", "inspector", "category", "struct", ")", ";", "write", "group", "(", "value", ",", "(", "struct", "object", "inspector", ")", "inspector", ",", "group", "type", ")", ";", "}", "}", "}" ]
[ "route", "requests", "that", "match", "the", "given", "pattern", "to", "resources", "relative", "to", "the", "given", "root", "location", "for", "instance", "<", "pre", "class", "=", "\"", "code", "\"", ">", "resource", "location", "=", "new", "file", "system", "resource", "(", "\"", "public", "-", "resources", "\"", ")", ";", "router", "function", "&", "lt", ";", "server", "response", "&", "gt", ";", "resources", "=", "router", "functions", "resources", "(", "\"", "resources", "\"", ",", "location", ")", ";" ]	[ "builder", "resources", "(", "string", "pattern", ",", "resource", "location", ")", ";" ]
[ "a", "bit", "simplistic", ":", "just", "wants", "the", "same", "class", "doesn", "'", "t", "worry", "about", "counts" ]	[ "public", "boolean", "equals", "(", "object", "other", ")", "{", "return", "(", "other", "!", "=", "null", "&", "&", "other", "get", "class", "(", ")", "=", "=", "this", "get", "class", "(", ")", ")", ";", "}" ]
[ "updates", "the", "local", "state", "of", "this", "{", "@", "link", "http", "2", "connection", "}", "as", "a", "result", "of", "a", "{", "@", "code", "goaway", "}", "to", "send", "to", "the", "remote", "endpoint" ]	[ "boolean", "go", "away", "sent", "(", "int", "last", "known", "stream", ",", "long", "error", "code", ",", "byte", "buf", "message", ")", "throws", "http", "2", "exception", ";" ]
[ "gets", "the", "register", "spec", "representing", "the", "local", "variable", "introduced", "by", "this", "instance" ]	[ "public", "register", "spec", "get", "local", "(", ")", "{", "return", "local", ";", "}" ]
[ "removes", "all", "default", "acl", "entries", "from", "files", "and", "directories" ]	[ "public", "void", "remove", "default", "acl", "(", "path", "path", ")", "throws", "i", "o", "exception", "{", "throw", "new", "unsupported", "operation", "exception", "(", "get", "class", "(", ")", "get", "simple", "name", "(", ")", "+", "\"", "doesn", "'", "t", "support", "remove", "default", "acl", "\"", ")", ";", "}" ]
[ "set", "the", "value", "with", "the", "given", "name", "replacing", "an", "existing", "value", "(", "if", "any", ")" ]	[ "public", "void", "set", "attribute", "(", "string", "name", ",", "object", "value", ")", "{", "this", "attributes", "put", "(", "name", ",", "value", ")", ";", "}" ]
[ "load", "information", "about", "root", ",", "and", "use", "the", "information", "to", "update", "the", "root", "directory", "of", "name", "system" ]	[ "private", "void", "load", "root", "(", "data", "input", "in", ",", "counter", "counter", ")", "throws", "i", "o", "exception", "{", "/", "/", "load", "root", "if", "(", "in", "read", "short", "(", ")", "!", "=", "0", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "first", "node", "is", "not", "root", "\"", ")", ";", "}", "final", "i", "node", "directory", "root", "=", "load", "i", "node", "(", "null", ",", "false", ",", "in", ",", "counter", ")", "as", "directory", "(", ")", ";", "/", "/", "update", "the", "root", "'", "s", "attributes", "update", "root", "attr", "(", "root", ")", ";", "}" ]
[ "test", "the", "property", "'", "name", "'" ]	[ "public", "void", "name", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "name", "}" ]
[ "uses", "a", "hash", "-", "based", "{", "@", "code", "set", "}", "to", "store", "value", "collections" ]	[ "public", "set", "multimap", "builder", "<", "k0", ",", "object", ">", "hash", "set", "values", "(", ")", "{", "return", "hash", "set", "values", "(", "default", "expected", "values", "per", "key", ")", ";", "}" ]
[ "calculates", "the", "derivative", "of", "the", "catmullrom", "spline", "for", "the", "given", "position", "(", "t", ")" ]	[ "public", "static", "<", "t", "extends", "vector", "<", "t", ">", ">", "t", "derivative", "(", "final", "t", "out", ",", "final", "float", "t", ",", "final", "t", "[", "]", "points", ",", "final", "boolean", "continuous", ",", "final", "t", "tmp", ")", "{", "final", "int", "n", "=", "continuous", "?", "points", "length", ":", "points", "length", "-", "3", ";", "float", "u", "=", "t", "*", "n", ";", "int", "i", "=", "(", "t", ">", "=", "1f", ")", "?", "(", "n", "-", "1", ")", ":", "(", "int", ")", "u", ";", "u", "-", "=", "i", ";", "return", "derivative", "(", "out", ",", "i", ",", "u", ",", "points", ",", "continuous", ",", "tmp", ")", ";", "}" ]
[ "returns", "the", "available", "amount", "of", "memory", "handled", "by", "this", "memory", "manager" ]	[ "public", "long", "available", "memory", "(", ")", "{", "return", "memory", "budget", "get", "available", "memory", "size", "(", ")", ";", "}" ]
[ "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", "\"", ")", ";", "}" ]
[ "refresh", "the", "queue", "-", "configuration", "in", "the", "scheduler", "this", "method", "has", "the", "following", "contract", "before", "this", "method", ",", "{", "@", "link", "queue", "manager", "}", "does", "a", "validation", "of", "the", "new", "queue", "-", "configuration", "for", "e", "g", ",", "currently", "addition", "of", "new", "queues", ",", "or", "removal", "of", "queues", "at", "any", "level", "in", "the", "hierarchy", "is", "not", "supported", "by", "{", "@", "link", "queue", "manager", "}", "and", "so", "are", "not", "supported", "for", "schedulers", "too", "schedulers", "will", "be", "passed", "a", "list", "of", "{", "@", "link", "job", "queue", "info", "}", "s", "of", "the", "root", "queues", "i", "e", "the", "queues", "at", "the", "top", "level", "all", "the", "descendants", "are", "properly", "linked", "from", "these", "top", "-", "level", "queues", "schedulers", "should", "use", "the", "scheduler", "specific", "queue", "properties", "from", "the", "new", "root", "queues", ",", "validate", "the", "properties", "themselves", "and", "apply", "them", "internally", "once", "the", "method", "returns", "successfully", "from", "the", "schedulers", ",", "it", "is", "assumed", "that", "the", "refresh", "of", "queue", "properties", "is", "successful", "throughout", "and", "will", "be", "'", "committed", "'", "internally", "to", "{", "@", "link", "queue", "manager", "}", "too", "it", "is", "guaranteed", "that", "at", "no", "point", ",", "after", "successful", "return", "from", "the", "scheduler", ",", "is", "the", "queue", "refresh", "in", "queue", "manager", "failed", "if", "ever", ",", "such", "abnormalities", "happen", ",", "the", "queue", "framework", "will", "be", "inconsistent", "and", "will", "need", "a", "jt", "restart", "if", "scheduler", "throws", "an", "exception", "during", "{", "@", "link", "#", "refresh", "queues", "(", ")", "}", ",", "{", "@", "link", "queue", "manager", "}", "throws", "away", "the", "newly", "read", "configuration", ",", "retains", "the", "old", "(", "consistent", ")", "configuration", "and", "informs", "the", "request", "issuer", "about", "the", "error", "appropriately" ]	[ "abstract", "void", "refresh", "queues", "(", "list", "<", "job", "queue", "info", ">", "new", "root", "queues", ")", "throws", "throwable", ";" ]
[ "{", "@", "inherit", "doc", "}" ]	[ "public", "void", "close", "(", "task", "attempt", "context", "context", ")", "throws", "i", "o", "exception", "{", "try", "{", "statement", "execute", "batch", "(", ")", ";", "connection", "commit", "(", ")", ";", "}", "catch", "(", "s", "q", "l", "exception", "e", ")", "{", "try", "{", "connection", "rollback", "(", ")", ";", "}", "catch", "(", "s", "q", "l", "exception", "ex", ")", "{", "log", "warn", "(", "string", "utils", "stringify", "exception", "(", "ex", ")", ")", ";", "}", "throw", "new", "i", "o", "exception", "(", "e", "get", "message", "(", ")", ")", ";", "}", "finally", "{", "try", "{", "statement", "close", "(", ")", ";", "connection", "close", "(", ")", ";", "}", "catch", "(", "s", "q", "l", "exception", "ex", ")", "{", "throw", "new", "i", "o", "exception", "(", "ex", "get", "message", "(", ")", ")", ";", "}", "}", "}" ]
[ "sets", "whether", "an", "option", "is", "available", "for", "disabling", "the", "renderer" ]	[ "public", "track", "selection", "dialog", "builder", "set", "show", "disable", "option", "(", "boolean", "show", "disable", "option", ")", "{", "this", "show", "disable", "option", "=", "show", "disable", "option", ";", "return", "this", ";", "}" ]
[ "returns", "a", "registered", "{", "@", "link", "char", "filter", "factory", "}", "provider", "by", "name", "or", "<", "code", ">", "null", "<", "code", ">", "if", "the", "char", "filter", "was", "not", "registered" ]	[ "private", "analysis", "module", "analysis", "provider", "<", "char", "filter", "factory", ">", "get", "char", "filter", "provider", "(", "string", "char", "filter", ")", "{", "return", "char", "filters", "get", "or", "default", "(", "char", "filter", ",", "this", "prebuilt", "analysis", "get", "char", "filter", "factory", "(", "char", "filter", ")", ")", ";", "}" ]
[ "tests", "cluster", "storage", "statistics", "during", "decommissioning", "for", "non", "federated", "cluster" ]	[ "public", "void", "test", "cluster", "stats", "(", ")", "throws", "exception", "{", "test", "cluster", "stats", "(", "1", ")", ";", "}" ]
[ "test", "the", "given", "rmi", "registry", ",", "calling", "some", "operation", "on", "it", "to", "check", "whether", "it", "is", "still", "active", "default", "implementation", "calls", "{", "@", "code", "registry", "list", "(", ")", "}" ]	[ "protected", "void", "test", "registry", "(", "registry", "registry", ")", "throws", "remote", "exception", "{", "registry", "list", "(", ")", ";", "}" ]
[ "create", "an", "instance", "by", "parsing", "the", "\"", "origin", "\"", "header", "of", "an", "http", "request" ]	[ "public", "static", "uri", "components", "builder", "from", "origin", "header", "(", "string", "origin", ")", "{", "matcher", "matcher", "=", "uri", "pattern", "matcher", "(", "origin", ")", ";", "if", "(", "matcher", "matches", "(", ")", ")", "{", "uri", "components", "builder", "builder", "=", "new", "uri", "components", "builder", "(", ")", ";", "string", "scheme", "=", "matcher", "group", "(", "2", ")", ";", "string", "host", "=", "matcher", "group", "(", "6", ")", ";", "string", "port", "=", "matcher", "group", "(", "8", ")", ";", "if", "(", "string", "utils", "has", "length", "(", "scheme", ")", ")", "{", "builder", "scheme", "(", "scheme", ")", ";", "}", "builder", "host", "(", "host", ")", ";", "if", "(", "string", "utils", "has", "length", "(", "port", ")", ")", "{", "builder", "port", "(", "port", ")", ";", "}", "return", "builder", ";", "}", "else", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "[", "\"", "+", "origin", "+", "\"", "]", "is", "not", "a", "valid", "\\", "\"", "origin", "\\", "\"", "header", "value", "\"", ")", ";", "}", "}", "/", "/", "encode", "methods" ]
[ "visit", "the", "module", "corresponding", "to", "the", "class" ]	[ "public", "module", "visitor", "visit", "module", "(", "final", "string", "name", ",", "final", "int", "access", ",", "final", "string", "version", ")", "{", "if", "(", "api", "<", "opcodes", "asm6", ")", "{", "throw", "new", "unsupported", "operation", "exception", "(", "\"", "module", "requires", "asm6", "\"", ")", ";", "}", "if", "(", "cv", "!", "=", "null", ")", "{", "return", "cv", "visit", "module", "(", "name", ",", "access", ",", "version", ")", ";", "}", "return", "null", ";", "}" ]
[ "creates", "a", "cluster", "state", "where", "local", "node", "and", "master", "node", "can", "be", "specified" ]	[ "public", "static", "cluster", "state", "state", "(", "discovery", "node", "local", "node", ",", "discovery", "node", "master", "node", ",", "discovery", "node", "all", "nodes", ")", "{", "discovery", "nodes", "builder", "disco", "builder", "=", "discovery", "nodes", "builder", "(", ")", ";", "for", "(", "discovery", "node", "node", ":", "all", "nodes", ")", "{", "disco", "builder", "add", "(", "node", ")", ";", "}", "if", "(", "master", "node", "!", "=", "null", ")", "{", "disco", "builder", "master", "node", "id", "(", "master", "node", "get", "id", "(", ")", ")", ";", "}", "disco", "builder", "local", "node", "id", "(", "local", "node", "get", "id", "(", ")", ")", ";", "cluster", "state", "builder", "state", "=", "cluster", "state", "builder", "(", "new", "cluster", "name", "(", "\"", "test", "\"", ")", ")", ";", "state", "nodes", "(", "disco", "builder", ")", ";", "state", "metadata", "(", "metadata", "builder", "(", ")", "generate", "cluster", "uuid", "if", "needed", "(", ")", ")", ";", "return", "state", "build", "(", ")", ";", "}" ]
[ "forces", "an", "exporter", "to", "remove", "cluster", "alerts", "immediately", "instead", "of", "waiting", "to", "do", "it", "lazily", "as", "part", "of", "the", "normal", "exporter", "setup" ]	[ "public", "abstract", "void", "remove", "alerts", "(", "consumer", "<", "exporter", "resource", "status", ">", "listener", ")", ";" ]
[ "set", "the", "editor", "text", "font" ]	[ "public", "void", "set", "text", "font", "(", "font", "data", "a", "font", ")", "{", "font", "data", "=", "a", "font", ";", "if", "(", "hex", "edit", "control", "default", "font", "data", "equals", "(", "font", "data", ")", ")", "font", "data", "=", "null", ";", "/", "/", "dispose", "it", "after", "setting", "new", "one", "(", "styled", "text", "renderer", "3", "448", "bug", "in", "line", "994", ")", "font", "font", "to", "dispose", "=", "font", "text", ";", "font", "text", "=", "null", ";", "if", "(", "hex", "edit", "control", "!", "=", "null", ")", "{", "if", "(", "font", "data", "!", "=", "null", ")", "font", "text", "=", "new", "font", "(", "display", "get", "current", "(", ")", ",", "font", "data", ")", ";", "hex", "edit", "control", "set", "font", "(", "font", "text", ")", ";", "}", "if", "(", "font", "to", "dispose", "!", "=", "null", "&", "&", "!", "font", "to", "dispose", "is", "disposed", "(", ")", ")", "font", "to", "dispose", "dispose", "(", ")", ";", "}" ]
[ "closes", "the", "stream", "without", "waiting", "until", "pending", "writes", "are", "committed", ",", "and", "suppressing", "errors", "pending", "writes", "will", "still", "continue", "asynchronously", ",", "but", "any", "errors", "will", "be", "ignored" ]	[ "public", "void", "close", "now", "(", ")", "{", "writer", "thread", "interrupt", "(", ")", ";", "}" ]
[ "make", "sure", "resource", "plugin", "manager", "is", "used", "to", "initialize", "resource", "handler", "chain" ]	[ "public", "void", "test", "linux", "container", "executor", "with", "resource", "plugins", "enabled", "(", ")", "{", "final", "resource", "plugin", "manager", "rpm", "=", "stub", "resource", "pluginmanager", "(", ")", ";", "final", "linux", "container", "executor", "lce", "=", "new", "my", "l", "c", "e", "(", ")", ";", "nm", "=", "new", "node", "manager", "(", ")", "{", "@", "override", "protected", "node", "status", "updater", "create", "node", "status", "updater", "(", "context", "context", ",", "dispatcher", "dispatcher", ",", "node", "health", "checker", "service", "health", "checker", ")", "{", "(", "(", "n", "m", "context", ")", "context", ")", "set", "resource", "plugin", "manager", "(", "rpm", ")", ";", "return", "new", "base", "node", "status", "updater", "for", "test", "(", "context", ",", "dispatcher", ",", "health", "checker", ",", "metrics", ",", "new", "base", "resource", "tracker", "for", "test", "(", ")", ")", ";", "}", "@", "override", "protected", "container", "manager", "impl", "create", "container", "manager", "(", "context", "context", ",", "container", "executor", "exec", ",", "deletion", "service", "del", ",", "node", "status", "updater", "node", "status", "updater", ",", "application", "a", "c", "ls", "manager", "acls", "manager", ",", "local", "dirs", "handler", "service", "dirs", "handler", ")", "{", "return", "new", "my", "container", "manager", "(", "context", ",", "exec", ",", "del", ",", "node", "status", "updater", ",", "metrics", ",", "dirs", "handler", ")", ";", "}", "@", "override", "protected", "container", "executor", "create", "container", "executor", "(", "configuration", "configuration", ")", "{", "(", "(", "n", "m", "context", ")", "this", "get", "n", "m", "context", "(", ")", ")", "set", "resource", "plugin", "manager", "(", "rpm", ")", ";", "lce", "set", "conf", "(", "configuration", ")", ";", "return", "lce", ";", "}", "}", ";", "nm", "init", "(", "conf", ")", ";", "nm", "start", "(", ")", ";", "resource", "handler", "handler", "=", "lce", "get", "resource", "handler", "(", ")", ";", "assert", "that", "(", "handler", ")", "is", "not", "null", "(", ")", ";", "assert", "that", "(", "handler", "instanceof", "resource", "handler", "chain", ")", "is", "true", "(", ")", ";", "boolean", "new", "handler", "added", "=", "false", ";", "for", "(", "resource", "handler", "h", ":", "(", "(", "resource", "handler", "chain", ")", "handler", ")", "get", "resource", "handler", "list", "(", ")", ")", "{", "if", "(", "h", "instanceof", "device", "plugin", "adapter", ")", "{", "fail", "(", "\"", "resource", "handler", "is", "a", "device", "plugin", "adapter", "\"", ")", ";", "}", "if", "(", "h", "instanceof", "customized", "resource", "handler", ")", "{", "new", "handler", "added", "=", "true", ";", "break", ";", "}", "}", "assert", "that", "(", "new", "handler", "added", ")", "with", "fail", "message", "(", "\"", "new", "resource", "handler", "should", "be", "added", "\"", ")", "is", "true", "(", ")", ";", "}" ]
[ "create", "a", "builder", "with", "a", "{", "@", "linkplain", "http", "status", "#", "not", "found", "404", "not", "found", "}", "status" ]	[ "static", "headers", "builder", "<", "?", ">", "not", "found", "(", ")", "{", "return", "status", "(", "http", "status", "not", "found", ")", ";", "}" ]
[ "decompresses", "(", "if", "necessary", ")", "buffered", "data", ",", "optionally", "computes", "and", "validates", "a", "x", "x", "hash", "3", "2", "checksum", ",", "and", "writes", "the", "result", "to", "a", "buffer" ]	[ "private", "void", "read", "block", "(", ")", "throws", "i", "o", "exception", "{", "if", "(", "in", "remaining", "(", ")", "<", "4", ")", "{", "throw", "new", "i", "o", "exception", "(", "premature", "eos", ")", ";", "}", "int", "block", "size", "=", "in", "get", "int", "(", ")", ";", "boolean", "compressed", "=", "(", "block", "size", "&", "lz4", "frame", "incompressible", "mask", ")", "=", "=", "0", ";", "block", "size", "&", "=", "~", "lz4", "frame", "incompressible", "mask", ";", "/", "/", "check", "for", "end", "mark", "if", "(", "block", "size", "=", "=", "0", ")", "{", "finished", "=", "true", ";", "if", "(", "flg", "is", "content", "checksum", "set", "(", ")", ")", "in", "get", "int", "(", ")", ";", "/", "/", "todo", ":", "verify", "this", "content", "checksum", "return", ";", "}", "else", "if", "(", "block", "size", ">", "max", "block", "size", ")", "{", "throw", "new", "i", "o", "exception", "(", "string", "format", "(", "\"", "block", "size", "%", "s", "exceeded", "max", ":", "%", "s", "\"", ",", "block", "size", ",", "max", "block", "size", ")", ")", ";", "}", "if", "(", "in", "remaining", "(", ")", "<", "block", "size", ")", "{", "throw", "new", "i", "o", "exception", "(", "premature", "eos", ")", ";", "}", "if", "(", "compressed", ")", "{", "try", "{", "/", "/", "workaround", "for", "https", ":", "/", "/", "github", "com", "/", "lz", "4", "/", "lz", "4", "-", "java", "/", "pull", "/", "65", "final", "int", "buffer", "size", ";", "if", "(", "in", "has", "array", "(", ")", ")", "{", "buffer", "size", "=", "decompressor", "decompress", "(", "in", "array", "(", ")", ",", "in", "position", "(", ")", "+", "in", "array", "offset", "(", ")", ",", "block", "size", ",", "decompression", "buffer", "array", "(", ")", ",", "0", ",", "max", "block", "size", ")", ";", "}", "else", "{", "/", "/", "decompression", "buffer", "has", "zero", "array", "offset", ",", "so", "we", "don", "'", "t", "need", "to", "worry", "about", "/", "/", "https", ":", "/", "/", "github", "com", "/", "lz", "4", "/", "lz", "4", "-", "java", "/", "pull", "/", "65", "buffer", "size", "=", "decompressor", "decompress", "(", "in", ",", "in", "position", "(", ")", ",", "block", "size", ",", "decompression", "buffer", ",", "0", ",", "max", "block", "size", ")", ";", "}", "decompression", "buffer", "position", "(", "0", ")", ";", "decompression", "buffer", "limit", "(", "buffer", "size", ")", ";", "decompressed", "buffer", "=", "decompression", "buffer", ";", "}", "catch", "(", "l", "z", "4", "exception", "e", ")", "{", "throw", "new", "i", "o", "exception", "(", "e", ")", ";", "}", "}", "else", "{", "decompressed", "buffer", "=", "in", "slice", "(", ")", ";", "decompressed", "buffer", "limit", "(", "block", "size", ")", ";", "}", "/", "/", "verify", "checksum", "if", "(", "flg", "is", "block", "checksum", "set", "(", ")", ")", "{", "/", "/", "workaround", "for", "https", ":", "/", "/", "github", "com", "/", "lz", "4", "/", "lz", "4", "-", "java", "/", "pull", "/", "65", "int", "hash", "=", "in", "has", "array", "(", ")", "?", "checksum", "hash", "(", "in", "array", "(", ")", ",", "in", "array", "offset", "(", ")", "+", "in", "position", "(", ")", ",", "block", "size", ",", "0", ")", ":", "checksum", "hash", "(", "in", ",", "in", "position", "(", ")", ",", "block", "size", ",", "0", ")", ";", "in", "position", "(", "in", "position", "(", ")", "+", "block", "size", ")", ";", "if", "(", "hash", "!", "=", "in", "get", "int", "(", ")", ")", "{", "throw", "new", "i", "o", "exception", "(", "block", "hash", "mismatch", ")", ";", "}", "}", "else", "{", "in", "position", "(", "in", "position", "(", ")", "+", "block", "size", ")", ";", "}", "}" ]
[ "determine", "if", "the", "components", "in", "this", "model", "'", "s", "data", "type", "use", "relative", "offsets", "or", "pointers" ]	[ "protected", "static", "boolean", "is", "relative", "(", "program", "program", ")", "{", "return", "m", "s", "data", "type", "utils", "is", "6", "4", "bit", "(", "program", ")", ";", "/", "/", "may", "need", "more", "here", "later", "}" ]
[ "the", "values", "of", "the", "two", "items", "start", "pc", "and", "end", "pc", "indicate", "the", "ranges", "in", "the", "code", "array", "at", "which", "the", "exception", "handler", "is", "active", "the", "value", "of", "start", "pc", "must", "be", "a", "valid", "index", "into", "the", "code", "array", "of", "the", "opcode", "of", "an", "instruction", "the", "value", "of", "start", "pc", "must", "be", "less", "than", "the", "value", "of", "end", "pc", "the", "start", "pc", "is", "inclusive", "and", "end", "pc", "is", "exclusive", ";", "that", "is", ",", "the", "exception", "handler", "must", "be", "active", "while", "the", "program", "counter", "is", "within", "the", "interval", "[", "start", "pc", ",", "end", "pc", "]" ]	[ "public", "int", "get", "start", "p", "c", "(", ")", "{", "return", "start", "p", "c", "&", "0xffff", ";", "}" ]
[ "get", "the", "current", "zoom", "factor", "the", "image", "is", "being", "drawn", "to" ]	[ "public", "float", "get", "zoom", "factor", "(", ")", "{", "return", "zoom", "levels", "[", "zoom", "level", "index", "]", ";", "}" ]
[ "create", "a", "{", "@", "link", "mount", "spec", "model", "}", "from", "the", "given", "{", "@", "link", "type", "element", "}", "and", "an", "optional", "{", "@", "link", "dependency", "injection", "helper", "}" ]	[ "public", "mount", "spec", "model", "create", "(", "elements", "elements", ",", "types", "types", ",", "type", "element", "element", ",", "messager", "messager", ",", "enum", "set", "<", "run", "mode", ">", "run", "mode", ",", "@", "nullable", "dependency", "injection", "helper", "dependency", "injection", "helper", ",", "@", "nullable", "inter", "stage", "store", "inter", "stage", "store", ")", "{", "return", "new", "mount", "spec", "model", "(", "element", "get", "qualified", "name", "(", ")", "to", "string", "(", ")", ",", "element", "get", "annotation", "(", "mount", "spec", "class", ")", "value", "(", ")", ",", "delegate", "method", "extractor", "get", "delegate", "methods", "(", "element", ",", "delegate", "method", "annotations", ",", "inter", "stage", "input", "annotations", ",", "immutable", "list", "<", "class", "<", "?", "extends", "annotation", ">", ">", "of", "(", "should", "update", "class", ")", ",", "messager", ")", ",", "event", "method", "extractor", "get", "on", "event", "methods", "(", "elements", ",", "element", ",", "inter", "stage", "input", "annotations", ",", "messager", ",", "run", "mode", ")", ",", "trigger", "method", "extractor", "get", "on", "trigger", "methods", "(", "elements", ",", "element", ",", "inter", "stage", "input", "annotations", ",", "messager", ",", "run", "mode", ")", ",", "working", "ranges", "method", "extractor", "get", "register", "method", "(", "element", ",", "inter", "stage", "input", "annotations", ",", "messager", ")", ",", "working", "ranges", "method", "extractor", "get", "ranges", "methods", "(", "elements", ",", "element", ",", "inter", "stage", "input", "annotations", ",", "messager", ")", ",", "update", "state", "method", "extractor", "get", "on", "update", "state", "methods", "(", "element", ",", "inter", "stage", "input", "annotations", ",", "messager", ")", ",", "update", "state", "method", "extractor", "get", "on", "update", "state", "with", "transition", "methods", "(", "element", ",", "inter", "stage", "input", "annotations", ",", "messager", ")", ",", "inter", "stage", "store", "=", "=", "null", "?", "immutable", "list", "of", "(", ")", ":", "cached", "prop", "name", "extractor", "get", "cached", "prop", "names", "(", "inter", "stage", "store", ",", "element", "get", "qualified", "name", "(", ")", ")", ",", "immutable", "list", "copy", "of", "(", "type", "variables", "extractor", "get", "type", "variables", "(", "element", ")", ")", ",", "immutable", "list", "copy", "of", "(", "prop", "defaults", "extractor", "get", "prop", "defaults", "(", "element", ")", ")", ",", "event", "declarations", "extractor", "get", "event", "declarations", "(", "elements", ",", "element", ",", "mount", "spec", "class", ",", "run", "mode", ")", ",", "javadoc", "extractor", "get", "class", "javadoc", "(", "elements", ",", "element", ")", ",", "annotation", "extractor", "extract", "valid", "annotations", "(", "element", ")", ",", "tag", "extractor", "extract", "tags", "from", "spec", "class", "(", "types", ",", "element", ",", "run", "mode", ")", ",", "javadoc", "extractor", "get", "prop", "javadocs", "(", "elements", ",", "element", ")", ",", "element", "get", "annotation", "(", "mount", "spec", "class", ")", "is", "public", "(", ")", ",", "dependency", "injection", "helper", ",", "element", "get", "annotation", "(", "mount", "spec", "class", ")", "is", "pure", "render", "(", ")", ",", "element", "get", "annotation", "(", "mount", "spec", "class", ")", "has", "child", "litho", "views", "(", ")", ",", "element", "get", "annotation", "(", "mount", "spec", "class", ")", "pool", "size", "(", ")", ",", "element", "get", "annotation", "(", "mount", "spec", "class", ")", "can", "preallocate", "(", ")", ",", "get", "mount", "type", "(", "elements", ",", "element", ",", "run", "mode", ")", ",", "spec", "element", "type", "determinator", "determine", "(", "element", ")", ",", "element", ",", "m", "mount", "spec", "generator", ",", "fields", "extractor", "extract", "fields", "(", "element", ")", ",", "bind", "dynamic", "values", "method", "extractor", "get", "on", "bind", "dynamic", "values", "methods", "(", "element", ",", "messager", ")", ")", ";", "}" ]
[ "{", "@", "inherit", "doc", "}", "this", "implementation", "is", "empty" ]	[ "public", "void", "configure", "default", "servlet", "handling", "(", "default", "servlet", "handler", "configurer", "configurer", ")", "{", "}" ]
[ "resolves", "to", "member", "list" ]	[ "public", "static", "collection", "<", "member", ">", "multi", "parse", "(", "collection", "<", "string", ">", "addresses", ")", "{", "list", "<", "member", ">", "members", "=", "new", "array", "list", "<", ">", "(", "addresses", "size", "(", ")", ")", ";", "for", "(", "string", "address", ":", "addresses", ")", "{", "member", "member", "=", "single", "parse", "(", "address", ")", ";", "members", "add", "(", "member", ")", ";", "}", "return", "members", ";", "}" ]
[ "the", "value", "assigned", "to", "this", "element", "<", "code", ">", "optional", "aapt", "pb", "item", "item", "=", "3", ";", "<", "code", ">" ]	[ "public", "com", "android", "aapt", "resources", "item", "get", "item", "(", ")", "{", "return", "item", "=", "=", "null", "?", "com", "android", "aapt", "resources", "item", "get", "default", "instance", "(", ")", ":", "item", ";", "}" ]
[ "sends", "trailers", "to", "the", "remote", "end", "point", "this", "call", "implies", "end", "of", "stream" ]	[ "void", "write", "trailers", "(", "metadata", "trailers", ",", "boolean", "headers", "sent", ",", "status", "status", ")", ";" ]
[ "reads", "the", "next", "word", "of", "the", "configuration", "in", "the", "'", "next", "word", "'", "field", ",", "throwing", "an", "exception", "if", "there", "is", "no", "next", "word" ]	[ "private", "void", "read", "next", "word", "(", "string", "expected", "description", ",", "boolean", "is", "file", "name", ",", "boolean", "expecting", "at", "character", ")", "throws", "parse", "exception", ",", "i", "o", "exception", "{", "read", "next", "word", "(", "is", "file", "name", ")", ";", "if", "(", "configuration", "end", "(", "expecting", "at", "character", ")", ")", "{", "throw", "new", "parse", "exception", "(", "\"", "expecting", "\"", "+", "expected", "description", "+", "\"", "before", "\"", "+", "reader", "location", "description", "(", ")", ")", ";", "}", "}" ]
[ "factory", "for", "labels", "from", "absolute", "string", "form", "e", "g", "foobar", "foobar", ":", "quux", "{", "@", "literal", "@", "}", "foo", "{", "@", "literal", "@", "}", "foobar", "{", "@", "literal", "@", "}", "foobar", ":", "baz", "treats", "labels", "in", "the", "default", "repository", "as", "being", "in", "the", "main", "repository", "instead", "labels", "that", "begin", "with", "a", "repository", "name", "may", "have", "the", "repository", "name", "remapped", "to", "a", "different", "name", "if", "it", "appears", "in", "{", "@", "code", "repository", "mapping", "}", "this", "happens", "if", "the", "current", "repository", "being", "evaluated", "is", "external", "to", "the", "main", "repository", "and", "the", "main", "repository", "set", "the", "{", "@", "code", "repo", "mapping", "}", "attribute", "when", "declaring", "this", "repository" ]	[ "public", "static", "label", "parse", "absolute", "(", "string", "abs", "name", ",", "immutable", "map", "<", "repository", "name", ",", "repository", "name", ">", "repository", "mapping", ")", "throws", "label", "syntax", "exception", "{", "return", "parse", "absolute", "(", "abs", "name", ",", "/", "", "default", "to", "main", "=", "", "/", "true", ",", "repository", "mapping", ")", ";", "}" ]
[ "the", "request", "from", "clients", "to", "get", "a", "report", "of", "applications", "matching", "the", "giving", "application", "states", "in", "the", "cluster", "from", "the", "<", "code", ">", "resource", "manager", "<", "code", ">" ]	[ "public", "static", "get", "applications", "request", "new", "instance", "(", "enum", "set", "<", "yarn", "application", "state", ">", "application", "states", ")", "{", "get", "applications", "request", "request", "=", "records", "new", "record", "(", "get", "applications", "request", "class", ")", ";", "request", "set", "application", "states", "(", "application", "states", ")", ";", "return", "request", ";", "}" ]
[ "similar", "to", "{", "@", "link", "#", "set", "variable", "local", "(", "string", ",", "object", ")", "}", ",", "but", "for", "a", "transient", "variable", "see", "{", "@", "link", "#", "set", "transient", "variable", "(", "string", ",", "object", ")", "}", "for", "the", "rules", "on", "'", "transient", "'", "variables" ]	[ "void", "set", "transient", "variable", "local", "(", "string", "variable", "name", ",", "object", "variable", "value", ")", ";" ]
[ "the", "position", "where", "the", "value", "size", "is", "stored" ]	[ "private", "int", "value", "size", "offset", "(", ")", "{", "if", "(", "magic", "(", ")", "=", "=", "record", "batch", "magic", "value", "v0", ")", "return", "key", "offset", "v0", "+", "math", "max", "(", "0", ",", "key", "size", "(", ")", ")", ";", "else", "return", "key", "offset", "v1", "+", "math", "max", "(", "0", ",", "key", "size", "(", ")", ")", ";", "}" ]
[ "create", "a", "new", "direct", "field", "accessor", "for", "the", "underlying", "target", "object" ]	[ "protected", "configurable", "property", "accessor", "create", "direct", "field", "accessor", "(", ")", "{", "if", "(", "this", "target", "=", "=", "null", ")", "{", "throw", "new", "illegal", "state", "exception", "(", "\"", "cannot", "access", "fields", "on", "null", "target", "instance", "'", "\"", "+", "get", "object", "name", "(", ")", "+", "\"", "'", "\"", ")", ";", "}", "return", "property", "accessor", "factory", "for", "direct", "field", "access", "(", "this", "target", ")", ";", "}" ]
[ "returns", "ending", "address", ",", "exclusive" ]	[ "public", "long", "get", "to", "(", ")", "{", "return", "this", "end", ";", "}" ]
[ "utility", "method", "for", "creating", "baseline", "properties", "for", "unit", "tests" ]	[ "/", "", "package", "", "/", "static", "hystrix", "command", "properties", "setter", "get", "unit", "test", "properties", "setter", "(", ")", "{", "return", "new", "hystrix", "command", "properties", "setter", "(", ")", "with", "execution", "timeout", "in", "milliseconds", "(", "1000", ")", "/", "/", "when", "an", "execution", "will", "be", "timed", "out", "with", "execution", "timeout", "enabled", "(", "true", ")", "with", "execution", "isolation", "strategy", "(", "execution", "isolation", "strategy", "thread", ")", "/", "/", "we", "want", "thread", "execution", "by", "default", "in", "tests", "with", "execution", "isolation", "thread", "interrupt", "on", "timeout", "(", "true", ")", "with", "execution", "isolation", "thread", "interrupt", "on", "future", "cancel", "(", "true", ")", "with", "circuit", "breaker", "force", "open", "(", "false", ")", "/", "/", "we", "don", "'", "t", "want", "short", "-", "circuiting", "by", "default", "with", "circuit", "breaker", "error", "threshold", "percentage", "(", "40", ")", "/", "/", "%", "of", "'", "marks", "'", "that", "must", "be", "failed", "to", "trip", "the", "circuit", "with", "metrics", "rolling", "statistical", "window", "in", "milliseconds", "(", "5000", ")", "/", "/", "milliseconds", "back", "that", "will", "be", "tracked", "with", "metrics", "rolling", "statistical", "window", "buckets", "(", "5", ")", "/", "/", "buckets", "with", "circuit", "breaker", "request", "volume", "threshold", "(", "0", ")", "/", "/", "in", "testing", "we", "will", "not", "have", "a", "threshold", "unless", "we", "'", "re", "specifically", "testing", "that", "feature", "with", "circuit", "breaker", "sleep", "window", "in", "milliseconds", "(", "5000000", ")", "/", "/", "milliseconds", "after", "tripping", "circuit", "before", "allowing", "retry", "(", "by", "default", "set", "very", "long", "as", "we", "want", "it", "to", "effectively", "never", "allow", "a", "single", "test", "for", "most", "unit", "tests", ")", "with", "circuit", "breaker", "enabled", "(", "true", ")", "with", "request", "log", "enabled", "(", "true", ")", "with", "execution", "isolation", "semaphore", "max", "concurrent", "requests", "(", "20", ")", "with", "fallback", "isolation", "semaphore", "max", "concurrent", "requests", "(", "10", ")", "with", "fallback", "enabled", "(", "true", ")", "with", "circuit", "breaker", "force", "closed", "(", "false", ")", "with", "metrics", "rolling", "percentile", "enabled", "(", "true", ")", "with", "request", "cache", "enabled", "(", "true", ")", "with", "metrics", "rolling", "percentile", "window", "in", "milliseconds", "(", "60000", ")", "with", "metrics", "rolling", "percentile", "window", "buckets", "(", "12", ")", "with", "metrics", "rolling", "percentile", "bucket", "size", "(", "1000", ")", "with", "metrics", "health", "snapshot", "interval", "in", "milliseconds", "(", "100", ")", ";", "}" ]
[ "concatenates", "a", "sequence", "to", "the", "end", "of", "another", "sequence", "and", "returns", "a", "new", "sequence" ]	[ "public", "ditted", "bit", "sequence", "concatenate", "(", "ditted", "bit", "sequence", "to", "conat", ")", "{", "ditted", "bit", "sequence", "res", "=", "new", "ditted", "bit", "sequence", "(", ")", ";", "res", "bits", "=", "new", "byte", "[", "bits", "length", "+", "to", "conat", "bits", "length", "]", ";", "res", "dits", "=", "new", "byte", "[", "res", "bits", "length", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "bits", "length", ";", "+", "+", "i", ")", "{", "res", "bits", "[", "i", "]", "=", "bits", "[", "i", "]", ";", "res", "dits", "[", "i", "]", "=", "dits", "[", "i", "]", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "to", "conat", "bits", "length", ";", "+", "+", "i", ")", "{", "res", "bits", "[", "bits", "length", "+", "i", "]", "=", "to", "conat", "bits", "[", "i", "]", ";", "res", "dits", "[", "bits", "length", "+", "i", "]", "=", "to", "conat", "dits", "[", "i", "]", ";", "}", "return", "res", ";", "}" ]
[ "expect", "the", "exact", "head", "and", "list", "requests", "of", "the", "operation", "cost", "supplied" ]	[ "public", "static", "expected", "probe", "expect", "(", "boolean", "enabled", ",", "operation", "cost", "cost", ")", "{", "return", "probes", "(", "enabled", ",", "probe", "(", "object", "metadata", "requests", ",", "cost", "head", "(", ")", ")", ",", "probe", "(", "object", "list", "request", ",", "cost", "list", "(", ")", ")", ")", ";", "}" ]
[ "validate", "all", "required", "params" ]	[ "protected", "void", "validate", "op", "params", "(", "http", "op", "param", "<", "?", ">", "op", ",", "param", "params", ")", "{", "for", "(", "param", "param", ":", "params", ")", "{", "if", "(", "param", "get", "value", "(", ")", "=", "=", "null", "\|", "\|", "param", "get", "value", "string", "(", ")", "=", "=", "null", "\|", "\|", "param", "get", "value", "string", "(", ")", "is", "empty", "(", ")", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "required", "param", "\"", "+", "param", "get", "name", "(", ")", "+", "\"", "for", "op", ":", "\"", "+", "op", "get", "value", "string", "(", ")", "+", "\"", "is", "null", "or", "empty", "\"", ")", ";", "}", "}", "}" ]
[ "creates", "a", "key", "for", "a", "binary", "header", ",", "serializing", "to", "input", "streams" ]	[ "public", "static", "<", "t", ">", "key", "<", "t", ">", "of", "(", "string", "name", ",", "binary", "stream", "marshaller", "<", "t", ">", "marshaller", ")", "{", "return", "new", "lazy", "stream", "binary", "key", "<", ">", "(", "name", ",", "marshaller", ")", ";", "}" ]
[ "reads", "num", "to", "read", "bytes", "from", "the", "stream", "starting", "at", "stream", "offset", "within", "the", "stream", "the", "bytes", "are", "written", "into", "the", "bytes", "array", "starting", "at", "the", "bytes", "offset", "location", "if", "not", "all", "bytes", "are", "available", "to", "be", "read", ",", "an", "i", "o", "exception", "will", "be", "thrown" ]	[ "public", "void", "read", "(", "int", "stream", "offset", ",", "byte", "[", "]", "bytes", ",", "int", "bytes", "offset", ",", "int", "num", "to", "read", ",", "task", "monitor", "monitor", ")", "throws", "i", "o", "exception", ",", "cancelled", "exception", "{", "if", "(", "stream", "offset", "<", "0", "\|", "\|", "stream", "offset", ">", "stream", "length", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "offset", "out", "of", "range", "\"", ")", ";", "}", "if", "(", "num", "to", "read", ">", "stream", "length", "-", "stream", "offset", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "not", "enough", "data", "left", "\"", ")", ";", "}", "if", "(", "num", "to", "read", "<", "=", "0", ")", "{", "return", ";", "}", "int", "remaining", "byte", "count", "=", "num", "to", "read", ";", "int", "page", "number", "=", "stream", "offset", ">", ">", "msf", "get", "log", "2", "page", "size", "(", ")", ";", "int", "offset", "into", "page", "=", "stream", "offset", "&", "msf", "get", "page", "size", "mod", "mask", "(", ")", ";", "/", "/", "read", "any", "partial", "page", "at", "beginning", "first", "if", "(", "offset", "into", "page", "!", "=", "0", ")", "{", "int", "first", "num", "to", "read", "=", "math", "min", "(", "msf", "get", "page", "size", "(", ")", "-", "offset", "into", "page", ",", "remaining", "byte", "count", ")", ";", "msf", "file", "reader", "read", "(", "page", "list", "get", "(", "page", "number", ")", ",", "offset", "into", "page", ",", "first", "num", "to", "read", ",", "bytes", ",", "bytes", "offset", ")", ";", "if", "(", "(", "remaining", "byte", "count", "-", "first", "num", "to", "read", ")", ">", "remaining", "byte", "count", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "integer", "count", "underflow", "when", "preparing", "to", "read", "\"", ")", ";", "}", "remaining", "byte", "count", "-", "=", "first", "num", "to", "read", ";", "page", "number", "+", "+", ";", "bytes", "offset", "+", "=", "first", "num", "to", "read", ";", "}", "/", "/", "read", "remaining", "pages", ",", "including", "last", "as", "possible", "partial", "page", "/", "/", "outer", "loop", "iterates", "over", "possible", "non", "-", "sequential", "groups", "while", "(", "remaining", "byte", "count", ">", "0", ")", "{", "monitor", "check", "canceled", "(", ")", ";", "/", "/", "inner", "loop", "groups", "together", "sequential", "pages", "into", "one", "big", "read", "int", "first", "sequential", "page", "number", "=", "page", "list", "get", "(", "page", "number", ")", ";", "int", "last", "sequential", "page", "number", "=", "first", "sequential", "page", "number", ";", "int", "num", "to", "read", "in", "sequential", "pages", "=", "0", ";", "do", "{", "monitor", "check", "canceled", "(", ")", ";", "page", "number", "+", "+", ";", "last", "sequential", "page", "number", "+", "+", ";", "int", "num", "to", "read", "in", "page", "=", "math", "min", "(", "msf", "get", "page", "size", "(", ")", ",", "remaining", "byte", "count", ")", ";", "num", "to", "read", "in", "sequential", "pages", "+", "=", "num", "to", "read", "in", "page", ";", "remaining", "byte", "count", "-", "=", "num", "to", "read", "in", "page", ";", "}", "while", "(", "remaining", "byte", "count", ">", "0", "&", "&", "page", "list", "get", "(", "page", "number", ")", "=", "=", "last", "sequential", "page", "number", ")", ";", "msf", "file", "reader", "read", "(", "first", "sequential", "page", "number", ",", "0", ",", "num", "to", "read", "in", "sequential", "pages", ",", "bytes", ",", "bytes", "offset", ")", ";", "bytes", "offset", "+", "=", "num", "to", "read", "in", "sequential", "pages", ";", "}", "}" ]
[ "opaque", "annotations", "extending", "the", "node", "identifier", "<", "code", ">", "map", "&", "lt", ";", "string", ",", "string", "&", "gt", ";", "annotations", "=", "2", ";", "<", "code", ">" ]	[ "java", "lang", "string", "get", "annotations", "or", "throw", "(", "java", "lang", "string", "key", ")", ";" ]
[ "sets", "the", "implicit", "outputs", "function", "of", "the", "rule", "class", "the", "default", "implicit", "outputs", "function", "is", "{", "@", "link", "implicit", "outputs", "function", "#", "none", "}", "this", "property", "is", "not", "inherited", "and", "this", "method", "should", "not", "be", "called", "by", "builder", "of", "{", "@", "link", "rule", "class", "type", "#", "abstract", "}", "rule", "class" ]	[ "public", "builder", "set", "implicit", "outputs", "function", "(", "implicit", "outputs", "function", "implicit", "outputs", "function", ")", "{", "preconditions", "check", "state", "(", "type", "!", "=", "rule", "class", "type", "abstract", ",", "\"", "setting", "not", "inherited", "property", "(", "implicit", "output", "function", ")", "of", "abstract", "rule", "class", "'", "%", "s", "'", "\"", ",", "name", ")", ";", "this", "implicit", "outputs", "function", "=", "implicit", "outputs", "function", ";", "return", "this", ";", "}" ]
[ "returns", "true", "iff", "this", "file", "is", "a", "regular", "file" ]	[ "public", "boolean", "is", "regular", "file", "(", ")", "{", "return", "(", "st", "mode", "&", "s", "ifmt", ")", "=", "=", "s", "ifreg", ";", "}" ]
[ "determine", "the", "property", "type", "for", "the", "given", "property", "path", "called", "by", "{", "@", "link", "#", "find", "custom", "editor", "}", "if", "no", "required", "type", "has", "been", "specified", ",", "to", "be", "able", "to", "find", "a", "type", "-", "specific", "editor", "even", "if", "just", "given", "a", "property", "path", "the", "default", "implementation", "always", "returns", "{", "@", "code", "null", "}", "bean", "wrapper", "impl", "overrides", "this", "with", "the", "standard", "{", "@", "code", "get", "property", "type", "}", "method", "as", "defined", "by", "the", "bean", "wrapper", "interface" ]	[ "protected", "class", "<", "?", ">", "get", "property", "type", "(", "string", "property", "path", ")", "{", "return", "null", ";", "}" ]
[ "returns", "a", "copy", "of", "the", "remaining", "bytes" ]	[ "public", "byte", "[", "]", "get", "remaining", "bytes", "(", ")", "{", "byte", "[", "]", "bytes", "=", "new", "byte", "[", "b", "length", "-", "offset", "]", ";", "system", "arraycopy", "(", "b", ",", "offset", ",", "bytes", ",", "0", ",", "b", "length", "-", "offset", ")", ";", "return", "bytes", ";", "}" ]
[ "sends", "the", "response", "headers", "to", "the", "client" ]	[ "private", "void", "send", "response", "headers", "(", "channel", "handler", "context", "ctx", ",", "send", "response", "headers", "command", "cmd", ",", "channel", "promise", "promise", ")", "throws", "http", "2", "exception", "{", "perf", "mark", "start", "task", "(", "\"", "netty", "server", "handler", "send", "response", "headers", "\"", ",", "cmd", "stream", "(", ")", "tag", "(", ")", ")", ";", "perf", "mark", "link", "in", "(", "cmd", "get", "link", "(", ")", ")", ";", "try", "{", "/", "/", "todo", "(", "carl", "-", "mastrangelo", ")", ":", "remove", "this", "check", "once", "https", ":", "/", "/", "github", "com", "/", "netty", "/", "netty", "/", "issues", "/", "6296", "/", "/", "is", "fixed", "int", "stream", "id", "=", "cmd", "stream", "(", ")", "id", "(", ")", ";", "http", "2", "stream", "stream", "=", "connection", "(", ")", "stream", "(", "stream", "id", ")", ";", "if", "(", "stream", "=", "=", "null", ")", "{", "reset", "stream", "(", "ctx", ",", "stream", "id", ",", "http", "2", "error", "cancel", "code", "(", ")", ",", "promise", ")", ";", "return", ";", "}", "if", "(", "cmd", "end", "of", "stream", "(", ")", ")", "{", "close", "stream", "when", "done", "(", "promise", ",", "stream", "id", ")", ";", "}", "encoder", "(", ")", "write", "headers", "(", "ctx", ",", "stream", "id", ",", "cmd", "headers", "(", ")", ",", "0", ",", "cmd", "end", "of", "stream", "(", ")", ",", "promise", ")", ";", "}", "finally", "{", "perf", "mark", "stop", "task", "(", "\"", "netty", "server", "handler", "send", "response", "headers", "\"", ",", "cmd", "stream", "(", ")", "tag", "(", ")", ")", ";", "}", "}" ]
[ "the", "smallest", "integer", "allowed", "for", "this", "xml", "attribute", "only", "makes", "sense", "if", "the", "format", "includes", "format", "flags", ":", ":", "integer", "<", "code", ">", "optional", "int", "3", "2", "min", "int", "=", "2", ";", "<", "code", ">" ]	[ "public", "int", "get", "min", "int", "(", ")", "{", "return", "instance", "get", "min", "int", "(", ")", ";", "}" ]
[ "marks", "this", "event", "as", "handled", "this", "does", "not", "affect", "event", "propagation", "inside", "scene", "2d", ",", "but", "causes", "the", "{", "@", "link", "stage", "}", "{", "@", "link", "input", "processor", "}", "methods", "to", "return", "true", ",", "which", "will", "eat", "the", "event", "so", "it", "is", "not", "passed", "on", "to", "the", "application", "under", "the", "stage" ]	[ "public", "void", "handle", "(", ")", "{", "handled", "=", "true", ";", "}" ]
[ "combine", "the", "value", "of", "records", "in", "this", "stream", "by", "the", "grouped", "key", "records", "with", "{", "@", "code", "null", "}", "key", "or", "value", "are", "ignored", "combining", "implies", "that", "the", "type", "of", "the", "aggregate", "result", "is", "the", "same", "as", "the", "type", "of", "the", "input", "value", "(", "c", "f", "{", "@", "link", "#", "aggregate", "(", "initializer", ",", "aggregator", ",", "materialized", ")", "}", ")", "the", "result", "is", "written", "into", "a", "local", "{", "@", "link", "key", "value", "store", "}", "(", "which", "is", "basically", "an", "ever", "-", "updating", "materialized", "view", ")", "provided", "by", "the", "given", "store", "name", "in", "{", "@", "code", "materialized", "}", "furthermore", ",", "updates", "to", "the", "store", "are", "sent", "downstream", "into", "a", "{", "@", "link", "k", "table", "}", "changelog", "stream", "the", "specified", "{", "@", "link", "reducer", "}", "is", "applied", "for", "each", "input", "record", "and", "computes", "a", "new", "aggregate", "using", "the", "current", "aggregate", "(", "first", "argument", ")", "and", "the", "record", "'", "s", "value", "(", "second", "argument", ")", ":", "{", "@", "code", "at", "the", "example", "of", "a", "reducer", "<", "long", ">", "new", "reducer", "<", "long", ">", "(", ")", "{", "public", "long", "apply", "(", "long", "agg", "value", ",", "long", "curr", "value", ")", "{", "return", "agg", "value", "+", "curr", "value", ";", "}", "}", "}", "if", "there", "is", "no", "current", "aggregate", "the", "{", "@", "link", "reducer", "}", "is", "not", "applied", "and", "the", "new", "aggregate", "will", "be", "the", "record", "'", "s", "value", "as", "-", "is", "thus", ",", "{", "@", "code", "reduce", "(", "reducer", ",", "materialized", ")", "}", "can", "be", "used", "to", "compute", "aggregate", "functions", "like", "sum", ",", "min", ",", "or", "max", "not", "all", "updates", "might", "get", "sent", "downstream", ",", "as", "an", "internal", "cache", "is", "used", "to", "deduplicate", "consecutive", "updates", "to", "the", "same", "key", "the", "rate", "of", "propagated", "updates", "depends", "on", "your", "input", "data", "rate", ",", "the", "number", "of", "distinct", "keys", ",", "the", "number", "of", "parallel", "running", "kafka", "streams", "instances", ",", "and", "the", "{", "@", "link", "streams", "config", "configuration", "}", "parameters", "for", "{", "@", "link", "streams", "config", "#", "cache", "max", "bytes", "buffering", "config", "cache", "size", "}", ",", "and", "{", "@", "link", "streams", "config", "#", "commit", "interval", "ms", "config", "commit", "interval", "}", "to", "query", "the", "local", "{", "@", "link", "read", "only", "key", "value", "store", "}", "it", "must", "be", "obtained", "via", "{", "@", "link", "kafka", "streams", "#", "store", "(", "store", "query", "parameters", ")", "kafka", "streams", "#", "store", "(", ")", "}", "{", "@", "code", "kafka", "streams", "streams", "=", "compute", "sum", "string", "queryable", "store", "name", "=", "\"", "store", "name", "\"", "the", "store", "name", "should", "be", "the", "name", "of", "the", "store", "as", "defined", "by", "the", "materialized", "instance", "read", "only", "key", "value", "store", "<", "k", ",", "value", "and", "timestamp", "<", "v", ">", ">", "local", "store", "=", "streams", "store", "(", "queryable", "store", "name", ",", "queryable", "store", "types", "<", "k", ",", "value", "and", "timestamp", "<", "v", ">", ">", "timestamped", "key", "value", "store", "(", ")", ")", ";", "k", "key", "=", "\"", "some", "-", "key", "\"", ";", "value", "and", "timestamp", "<", "v", ">", "reduce", "for", "key", "=", "local", "store", "get", "(", "key", ")", ";", "key", "must", "be", "local", "(", "application", "state", "is", "shared", "over", "all", "running", "kafka", "streams", "instances", ")", "}", "for", "non", "-", "local", "keys", ",", "a", "custom", "rpc", "mechanism", "must", "be", "implemented", "using", "{", "@", "link", "kafka", "streams", "#", "all", "metadata", "(", ")", "}", "to", "query", "the", "value", "of", "the", "key", "on", "a", "parallel", "running", "instance", "of", "your", "kafka", "streams", "application", "for", "failure", "and", "recovery", "the", "store", "(", "which", "always", "will", "be", "of", "type", "{", "@", "link", "timestamped", "key", "value", "store", "}", "-", "-", "regardless", "of", "what", "is", "specified", "in", "the", "parameter", "{", "@", "code", "materialized", "}", ")", "will", "be", "backed", "by", "an", "internal", "changelog", "topic", "that", "will", "be", "created", "in", "kafka", "the", "changelog", "topic", "will", "be", "named", "\"", "$", "{", "application", "id", "}", "-", "$", "{", "internal", "store", "name", "}", "-", "changelog", "\"", ",", "where", "\"", "application", "id", "\"", "is", "user", "-", "specified", "in", "{", "@", "link", "streams", "config", "}", "via", "parameter", "{", "@", "link", "streams", "config", "#", "application", "id", "config", "application", "id", "config", "}", ",", "\"", "internal", "store", "name", "\"", "is", "an", "internal", "name", "and", "\"", "-", "changelog", "\"", "is", "a", "fixed", "suffix", "note", "that", "the", "internal", "store", "name", "may", "not", "be", "queryable", "through", "interactive", "queries", "you", "can", "retrieve", "all", "generated", "internal", "topic", "names", "via", "{", "@", "link", "topology", "#", "describe", "(", ")", "}" ]	[ "k", "table", "<", "k", ",", "v", ">", "reduce", "(", "final", "reducer", "<", "v", ">", "reducer", ",", "final", "materialized", "<", "k", ",", "v", ",", "key", "value", "store", "<", "bytes", ",", "byte", "[", "]", ">", ">", "materialized", ")", ";" ]
[ "override", "this", "method", "to", "supports", "multiple", "paths", "when", "this", "method", "will", "be", "removed", ",", "all", "file", "input", "formats", "have", "to", "support", "multiple", "paths" ]	[ "public", "boolean", "supports", "multi", "paths", "(", ")", "{", "return", "false", ";", "}" ]
[ "tests", "that", "connections", "can", "be", "made", "with", "t", "l", "sv", "1", "2", "cipher", "suite" ]	[ "public", "void", "test", "ciphers", "suite", "for", "tls", "1", "2", "(", ")", "throws", "exception", "{", "string", "cipher", "suite", "=", "\"", "tls", "ecdhe", "rsa", "with", "aes", "256", "gcm", "sha384", "\"", ";", "ssl", "server", "configs", "put", "(", "ssl", "configs", "ssl", "enabled", "protocols", "config", ",", "arrays", "as", "list", "(", "ssl", "configs", "default", "ssl", "enabled", "protocols", "split", "(", "\"", ",", "\"", ")", ")", ")", ";", "ssl", "server", "configs", "put", "(", "ssl", "configs", "ssl", "cipher", "suites", "config", ",", "collections", "singleton", "list", "(", "cipher", "suite", ")", ")", ";", "server", "=", "network", "test", "utils", "create", "echo", "server", "(", "listener", "name", "for", "security", "protocol", "(", "security", "protocol", "ssl", ")", ",", "security", "protocol", "ssl", ",", "new", "test", "security", "config", "(", "ssl", "server", "configs", ")", ",", "null", ",", "time", ")", ";", "ssl", "client", "configs", "put", "(", "ssl", "configs", "ssl", "enabled", "protocols", "config", ",", "arrays", "as", "list", "(", "ssl", "configs", "default", "ssl", "enabled", "protocols", "split", "(", "\"", ",", "\"", ")", ")", ")", ";", "ssl", "client", "configs", "put", "(", "ssl", "configs", "ssl", "cipher", "suites", "config", ",", "collections", "singleton", "list", "(", "cipher", "suite", ")", ")", ";", "check", "authentication", "succeed", "(", ")", ";", "}" ]
[ "find", "object", "(", "case", "-", "sensitive", ")" ]	[ "public", "static", "<", "t", "extends", "d", "b", "p", "named", "object", ">", "t", "find", "object", "(", "@", "nullable", "t", "[", "]", "the", "list", ",", "string", "object", "name", ")", "{", "if", "(", "the", "list", "!", "=", "null", "&", "&", "the", "list", "length", ">", "0", ")", "{", "for", "(", "t", "object", ":", "the", "list", ")", "{", "if", "(", "object", "get", "name", "(", ")", "equals", "(", "object", "name", ")", ")", "{", "return", "object", ";", "}", "}", "}", "return", "null", ";", "}" ]
[ "transform", "saml", "object", "t" ]	[ "public", "static", "<", "t", "extends", "x", "m", "l", "object", ">", "t", "transform", "saml", "object", "(", "final", "open", "saml", "config", "bean", "config", "bean", ",", "final", "byte", "[", "]", "data", ",", "final", "class", "<", "t", ">", "clazz", ")", "{", "if", "(", "data", "!", "=", "null", "&", "&", "data", "length", ">", "0", ")", "{", "try", "(", "val", "in", "=", "new", "byte", "array", "input", "stream", "(", "data", ")", ")", "{", "val", "document", "=", "config", "bean", "get", "parser", "pool", "(", ")", "parse", "(", "in", ")", ";", "val", "root", "=", "document", "get", "document", "element", "(", ")", ";", "val", "marshaller", "=", "config", "bean", "get", "unmarshaller", "factory", "(", ")", "get", "unmarshaller", "(", "root", ")", ";", "if", "(", "marshaller", "!", "=", "null", ")", "{", "val", "result", "=", "marshaller", "unmarshall", "(", "root", ")", ";", "if", "(", "!", "clazz", "is", "assignable", "from", "(", "result", "get", "class", "(", ")", ")", ")", "{", "throw", "new", "class", "cast", "exception", "(", "\"", "result", "[", "\"", "+", "result", "+", "\"", "is", "of", "type", "\"", "+", "result", "get", "class", "(", ")", "+", "\"", "when", "we", "were", "expecting", "\"", "+", "clazz", ")", ";", "}", "return", "(", "t", ")", "result", ";", "}", "}", "catch", "(", "final", "exception", "e", ")", "{", "throw", "new", "saml", "exception", "(", "e", "get", "message", "(", ")", ",", "e", ")", ";", "}", "}", "return", "null", ";", "}" ]
[ "test", "hdfs", "operations", "that", "change", "disk", "space", "consumed", "by", "a", "directory", "tree", "namely", "create", ",", "rename", ",", "delete", ",", "append", ",", "and", "set", "replication", "this", "is", "based", "on", "test", "namespace", "commands", "(", ")", "above" ]	[ "public", "void", "test", "space", "commands", "(", ")", "throws", "exception", "{", "final", "path", "parent", "=", "new", "path", "(", "path", "utils", "get", "test", "dir", "(", "get", "class", "(", ")", ")", "get", "path", "(", ")", ",", "generic", "test", "utils", "get", "method", "name", "(", ")", ")", ";", "assert", "true", "(", "dfs", "mkdirs", "(", "parent", ")", ")", ";", "int", "file", "len", "=", "1024", ";", "short", "replication", "=", "3", ";", "int", "file", "space", "=", "file", "len", "", "replication", ";", "/", "/", "create", "directory", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "0", "/", "nqdir", "3", "0", "assert", "true", "(", "dfs", "mkdirs", "(", "new", "path", "(", "parent", ",", "\"", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "0", "/", "nqdir", "3", "0", "\"", ")", ")", ")", ";", "/", "/", "set", "the", "quota", "of", "nqdir", "0", "/", "qdir", "1", "to", "4", "", "file", "space", "final", "path", "quota", "dir", "1", "=", "new", "path", "(", "parent", ",", "\"", "nqdir", "0", "/", "qdir", "1", "\"", ")", ";", "dfs", "set", "quota", "(", "quota", "dir", "1", ",", "hdfs", "constants", "quota", "dont", "set", ",", "4", "", "file", "space", ")", ";", "content", "summary", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "1", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "1", ")", ";", "assert", "equals", "(", "c", "get", "space", "quota", "(", ")", ",", "4", "", "file", "space", ")", ";", "/", "/", "set", "the", "quota", "of", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "0", "to", "6", "", "file", "space", "final", "path", "quota", "dir", "2", "0", "=", "new", "path", "(", "parent", ",", "\"", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "0", "\"", ")", ";", "dfs", "set", "quota", "(", "quota", "dir", "2", "0", ",", "hdfs", "constants", "quota", "dont", "set", ",", "6", "", "file", "space", ")", ";", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "0", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "0", ")", ";", "assert", "equals", "(", "c", "get", "space", "quota", "(", ")", ",", "6", "", "file", "space", ")", ";", "/", "/", "create", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "1", "and", "set", "its", "space", "quota", "to", "2", "", "file", "space", "final", "path", "quota", "dir", "2", "1", "=", "new", "path", "(", "parent", ",", "\"", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "1", "\"", ")", ";", "assert", "true", "(", "dfs", "mkdirs", "(", "quota", "dir", "2", "1", ")", ")", ";", "dfs", "set", "quota", "(", "quota", "dir", "2", "1", ",", "hdfs", "constants", "quota", "dont", "set", ",", "2", "", "file", "space", ")", ";", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "1", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "1", ")", ";", "assert", "equals", "(", "c", "get", "space", "quota", "(", ")", ",", "2", "", "file", "space", ")", ";", "/", "/", "5", ":", "create", "directory", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "1", "/", "nqdir", "3", "2", "path", "temp", "path", "=", "new", "path", "(", "quota", "dir", "2", "1", ",", "\"", "nqdir", "3", "2", "\"", ")", ";", "assert", "true", "(", "dfs", "mkdirs", "(", "temp", "path", ")", ")", ";", "/", "/", "create", "a", "file", "under", "nqdir", "3", "2", "/", "file", "dir", "d", "f", "s", "test", "util", "create", "file", "(", "dfs", ",", "new", "path", "(", "temp", "path", ",", "\"", "file", "dir", "/", "file", "1", "\"", ")", ",", "file", "len", ",", "replication", ",", "0", ")", ";", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "1", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "1", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "file", "space", ")", ";", "/", "/", "create", "a", "larger", "file", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "1", "/", "nqdir", "3", "3", "/", "boolean", "has", "exception", "=", "false", ";", "try", "{", "d", "f", "s", "test", "util", "create", "file", "(", "dfs", ",", "new", "path", "(", "quota", "dir", "2", "1", ",", "\"", "nqdir", "3", "3", "/", "file", "2", "\"", ")", ",", "2", "", "file", "len", ",", "replication", ",", "0", ")", ";", "}", "catch", "(", "d", "s", "quota", "exceeded", "exception", "e", ")", "{", "has", "exception", "=", "true", ";", "}", "assert", "true", "(", "has", "exception", ")", ";", "/", "/", "delete", "nqdir", "3", "3", "assert", "true", "(", "dfs", "delete", "(", "new", "path", "(", "quota", "dir", "2", "1", ",", "\"", "nqdir", "3", "3", "\"", ")", ",", "true", ")", ")", ";", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "1", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "1", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "file", "space", ")", ";", "assert", "equals", "(", "c", "get", "space", "quota", "(", ")", ",", "2", "", "file", "space", ")", ";", "/", "/", "verify", "space", "before", "the", "move", ":", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "0", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "0", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "0", ")", ";", "/", "/", "move", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "1", "/", "nqdir", "3", "2", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "0", "/", "nqdir", "3", "0", "path", "dst", "path", "=", "new", "path", "(", "quota", "dir", "2", "0", ",", "\"", "nqdir", "3", "0", "\"", ")", ";", "path", "src", "path", "=", "new", "path", "(", "quota", "dir", "2", "1", ",", "\"", "nqdir", "3", "2", "\"", ")", ";", "assert", "true", "(", "dfs", "rename", "(", "src", "path", ",", "dst", "path", ")", ")", ";", "/", "/", "verify", "space", "after", "the", "move", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "0", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "file", "space", ")", ";", "/", "/", "verify", "space", "for", "its", "parent", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "1", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "1", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "file", "space", ")", ";", "/", "/", "verify", "space", "for", "source", "for", "the", "move", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "1", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "1", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "0", ")", ";", "final", "path", "file", "2", "=", "new", "path", "(", "dst", "path", ",", "\"", "file", "dir", "/", "file", "2", "\"", ")", ";", "int", "file", "2", "len", "=", "2", "", "file", "len", ";", "/", "/", "create", "a", "larger", "file", "under", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "0", "/", "nqdir", "3", "0", "d", "f", "s", "test", "util", "create", "file", "(", "dfs", ",", "file", "2", ",", "file", "2", "len", ",", "replication", ",", "0", ")", ";", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "0", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "3", "", "file", "space", ")", ";", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "1", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "1", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "0", ")", ";", "/", "/", "reverse", ":", "move", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "0", "/", "nqdir", "3", "0", "to", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "1", "/", "has", "exception", "=", "false", ";", "try", "{", "assert", "false", "(", "dfs", "rename", "(", "dst", "path", ",", "src", "path", ")", ")", ";", "}", "catch", "(", "d", "s", "quota", "exceeded", "exception", "e", ")", "{", "has", "exception", "=", "true", ";", "}", "assert", "true", "(", "has", "exception", ")", ";", "/", "/", "make", "sure", "no", "intermediate", "directories", "left", "by", "failed", "rename", "assert", "false", "(", "dfs", "exists", "(", "src", "path", ")", ")", ";", "/", "/", "directory", "should", "exist", "assert", "true", "(", "dfs", "exists", "(", "dst", "path", ")", ")", ";", "/", "/", "verify", "space", "after", "the", "failed", "move", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "0", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "3", "", "file", "space", ")", ";", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "1", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "1", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "0", ")", ";", "/", "/", "test", "append", ":", "/", "/", "verify", "space", "quota", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "1", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "1", ")", ";", "assert", "equals", "(", "c", "get", "space", "quota", "(", ")", ",", "4", "", "file", "space", ")", ";", "/", "/", "verify", "space", "before", "append", ";", "c", "=", "dfs", "get", "content", "summary", "(", "dst", "path", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "dst", "path", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "3", "", "file", "space", ")", ";", "output", "stream", "out", "=", "dfs", "append", "(", "file", "2", ")", ";", "/", "/", "appending", "1", "file", "len", "should", "succeed", "out", "write", "(", "new", "byte", "[", "file", "len", "]", ")", ";", "out", "close", "(", ")", ";", "file", "2", "len", "+", "=", "file", "len", ";", "/", "/", "after", "append", "/", "/", "verify", "space", "after", "append", ";", "c", "=", "dfs", "get", "content", "summary", "(", "dst", "path", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "dst", "path", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "4", "", "file", "space", ")", ";", "/", "/", "now", "increase", "the", "quota", "for", "quota", "dir", "1", "dfs", "set", "quota", "(", "quota", "dir", "1", ",", "hdfs", "constants", "quota", "dont", "set", ",", "5", "", "file", "space", ")", ";", "/", "/", "now", ",", "appending", "more", "than", "1", "file", "len", "should", "result", "in", "an", "error", "out", "=", "dfs", "append", "(", "file", "2", ")", ";", "has", "exception", "=", "false", ";", "try", "{", "out", "write", "(", "new", "byte", "[", "file", "len", "+", "1024", "]", ")", ";", "out", "flush", "(", ")", ";", "out", "close", "(", ")", ";", "}", "catch", "(", "d", "s", "quota", "exceeded", "exception", "e", ")", "{", "has", "exception", "=", "true", ";", "i", "o", "utils", "close", "stream", "(", "out", ")", ";", "}", "assert", "true", "(", "has", "exception", ")", ";", "file", "2", "len", "+", "=", "file", "len", ";", "/", "/", "after", "partial", "append", "/", "/", "verify", "space", "after", "partial", "append", "c", "=", "dfs", "get", "content", "summary", "(", "dst", "path", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "dst", "path", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "5", "", "file", "space", ")", ";", "/", "/", "test", "set", "replication", ":", "/", "/", "first", "reduce", "the", "replication", "dfs", "set", "replication", "(", "file", "2", ",", "(", "short", ")", "(", "replication", "-", "1", ")", ")", ";", "/", "/", "verify", "that", "space", "is", "reduced", "by", "file", "2", "len", "c", "=", "dfs", "get", "content", "summary", "(", "dst", "path", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "dst", "path", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "5", "", "file", "space", "-", "file", "2", "len", ")", ";", "/", "/", "now", "try", "to", "increase", "the", "replication", "and", "and", "expect", "an", "error", "has", "exception", "=", "false", ";", "try", "{", "dfs", "set", "replication", "(", "file", "2", ",", "(", "short", ")", "(", "replication", "+", "1", ")", ")", ";", "}", "catch", "(", "d", "s", "quota", "exceeded", "exception", "e", ")", "{", "has", "exception", "=", "true", ";", "}", "assert", "true", "(", "has", "exception", ")", ";", "/", "/", "verify", "space", "consumed", "remains", "unchanged", "c", "=", "dfs", "get", "content", "summary", "(", "dst", "path", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "dst", "path", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "5", "", "file", "space", "-", "file", "2", "len", ")", ";", "/", "/", "now", "increase", "the", "quota", "for", "quota", "dir", "1", "and", "quota", "dir", "2", "0", "dfs", "set", "quota", "(", "quota", "dir", "1", ",", "hdfs", "constants", "quota", "dont", "set", ",", "10", "", "file", "space", ")", ";", "dfs", "set", "quota", "(", "quota", "dir", "2", "0", ",", "hdfs", "constants", "quota", "dont", "set", ",", "10", "", "file", "space", ")", ";", "/", "/", "then", "increasing", "replication", "should", "be", "ok", "dfs", "set", "replication", "(", "file", "2", ",", "(", "short", ")", "(", "replication", "+", "1", ")", ")", ";", "/", "/", "verify", "increase", "in", "space", "c", "=", "dfs", "get", "content", "summary", "(", "dst", "path", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "dst", "path", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "5", "", "file", "space", "+", "file", "2", "len", ")", ";", "/", "/", "test", "hdfs", "-", "2053", ":", "/", "/", "create", "directory", "hdfs", "-", "2053", "final", "path", "quota", "dir", "2", "0", "5", "3", "=", "new", "path", "(", "parent", ",", "\"", "hdfs", "-", "2053", "\"", ")", ";", "assert", "true", "(", "dfs", "mkdirs", "(", "quota", "dir", "2", "0", "5", "3", ")", ")", ";", "/", "/", "create", "subdirectories", "/", "hdfs", "-", "2053", "/", "{", "a", ",", "b", ",", "c", "}", "final", "path", "quota", "dir", "2", "0", "5", "3", "a", "=", "new", "path", "(", "quota", "dir", "2", "0", "5", "3", ",", "\"", "a", "\"", ")", ";", "assert", "true", "(", "dfs", "mkdirs", "(", "quota", "dir", "2", "0", "5", "3", "a", ")", ")", ";", "final", "path", "quota", "dir", "2", "0", "5", "3", "b", "=", "new", "path", "(", "quota", "dir", "2", "0", "5", "3", ",", "\"", "b", "\"", ")", ";", "assert", "true", "(", "dfs", "mkdirs", "(", "quota", "dir", "2", "0", "5", "3", "b", ")", ")", ";", "final", "path", "quota", "dir", "2", "0", "5", "3", "c", "=", "new", "path", "(", "quota", "dir", "2", "0", "5", "3", ",", "\"", "c", "\"", ")", ";", "assert", "true", "(", "dfs", "mkdirs", "(", "quota", "dir", "2", "0", "5", "3", "c", ")", ")", ";", "/", "/", "factors", "to", "vary", "the", "sizes", "of", "test", "files", "created", "in", "each", "subdir", "/", "/", "the", "actual", "factors", "are", "not", "really", "important", "but", "they", "allow", "us", "to", "create", "/", "/", "identifiable", "file", "sizes", "per", "subdir", ",", "which", "helps", "during", "debugging", "int", "size", "factor", "a", "=", "1", ";", "int", "size", "factor", "b", "=", "2", ";", "int", "size", "factor", "c", "=", "4", ";", "/", "/", "set", "space", "quota", "for", "subdirectory", "c", "dfs", "set", "quota", "(", "quota", "dir", "2", "0", "5", "3", "c", ",", "hdfs", "constants", "quota", "dont", "set", ",", "(", "size", "factor", "c", "+", "1", ")", "", "file", "space", ")", ";", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "0", "5", "3", "c", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "0", "5", "3", "c", ")", ";", "assert", "equals", "(", "c", "get", "space", "quota", "(", ")", ",", "(", "size", "factor", "c", "+", "1", ")", "", "file", "space", ")", ";", "/", "/", "create", "a", "file", "under", "subdirectory", "a", "d", "f", "s", "test", "util", "create", "file", "(", "dfs", ",", "new", "path", "(", "quota", "dir", "2", "0", "5", "3", "a", ",", "\"", "file", "a", "\"", ")", ",", "size", "factor", "a", "", "file", "len", ",", "replication", ",", "0", ")", ";", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "0", "5", "3", "a", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "0", "5", "3", "a", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "size", "factor", "a", "", "file", "space", ")", ";", "/", "/", "create", "a", "file", "under", "subdirectory", "b", "d", "f", "s", "test", "util", "create", "file", "(", "dfs", ",", "new", "path", "(", "quota", "dir", "2", "0", "5", "3", "b", ",", "\"", "file", "b", "\"", ")", ",", "size", "factor", "b", "", "file", "len", ",", "replication", ",", "0", ")", ";", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "0", "5", "3", "b", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "0", "5", "3", "b", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "size", "factor", "b", "", "file", "space", ")", ";", "/", "/", "create", "a", "file", "under", "subdirectory", "c", "(", "which", "has", "a", "space", "quota", ")", "d", "f", "s", "test", "util", "create", "file", "(", "dfs", ",", "new", "path", "(", "quota", "dir", "2", "0", "5", "3", "c", ",", "\"", "file", "c", "\"", ")", ",", "size", "factor", "c", "", "file", "len", ",", "replication", ",", "0", ")", ";", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "0", "5", "3", "c", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "0", "5", "3", "c", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "size", "factor", "c", "", "file", "space", ")", ";", "/", "/", "check", "space", "consumed", "for", "/", "hdfs", "-", "2053", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "0", "5", "3", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "0", "5", "3", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "(", "size", "factor", "a", "+", "size", "factor", "b", "+", "size", "factor", "c", ")", "", "file", "space", ")", ";", "}" ]
[ "spherical", "linear", "interpolation", "between", "this", "quaternion", "and", "the", "other", "quaternion", ",", "based", "on", "the", "alpha", "value", "in", "the", "range", "[", "0", ",", "1", "]", "taken", "from", "bones", "framework", "for", "jpct", ",", "see", "http", ":", "www", "aptalkarga", "combones" ]	[ "public", "quaternion", "slerp", "(", "quaternion", "end", ",", "float", "alpha", ")", "{", "final", "float", "d", "=", "this", "x", "", "end", "x", "+", "this", "y", "", "end", "y", "+", "this", "z", "", "end", "z", "+", "this", "w", "", "end", "w", ";", "float", "abs", "dot", "=", "d", "<", "0", "f", "?", "-", "d", ":", "d", ";", "/", "/", "set", "the", "first", "and", "second", "scale", "for", "the", "interpolation", "float", "scale", "0", "=", "1f", "-", "alpha", ";", "float", "scale", "1", "=", "alpha", ";", "/", "/", "check", "if", "the", "angle", "between", "the", "2", "quaternions", "was", "big", "enough", "to", "/", "/", "warrant", "such", "calculations", "if", "(", "(", "1", "-", "abs", "dot", ")", ">", "0", "1", ")", "{", "/", "/", "get", "the", "angle", "between", "the", "2", "quaternions", ",", "/", "/", "and", "then", "store", "the", "sin", "(", ")", "of", "that", "angle", "final", "float", "angle", "=", "(", "float", ")", "math", "acos", "(", "abs", "dot", ")", ";", "final", "float", "inv", "sin", "theta", "=", "1f", "/", "(", "float", ")", "math", "sin", "(", "angle", ")", ";", "/", "/", "calculate", "the", "scale", "for", "q", "1", "and", "q", "2", ",", "according", "to", "the", "angle", "and", "/", "/", "it", "'", "s", "sine", "value", "scale", "0", "=", "(", "(", "float", ")", "math", "sin", "(", "(", "1f", "-", "alpha", ")", "", "angle", ")", "", "inv", "sin", "theta", ")", ";", "scale", "1", "=", "(", "(", "float", ")", "math", "sin", "(", "(", "alpha", "", "angle", ")", ")", "", "inv", "sin", "theta", ")", ";", "}", "if", "(", "d", "<", "0", "f", ")", "scale", "1", "=", "-", "scale", "1", ";", "/", "/", "calculate", "the", "x", ",", "y", ",", "z", "and", "w", "values", "for", "the", "quaternion", "by", "using", "a", "/", "/", "special", "form", "of", "linear", "interpolation", "for", "quaternions", "x", "=", "(", "scale", "0", "", "x", ")", "+", "(", "scale", "1", "", "end", "x", ")", ";", "y", "=", "(", "scale", "0", "", "y", ")", "+", "(", "scale", "1", "", "end", "y", ")", ";", "z", "=", "(", "scale", "0", "", "z", ")", "+", "(", "scale", "1", "", "end", "z", ")", ";", "w", "=", "(", "scale", "0", "", "w", ")", "+", "(", "scale", "1", "", "end", "w", ")", ";", "/", "/", "return", "the", "interpolated", "quaternion", "return", "this", ";", "}" ]
[ "check", "whether", "a", "list", "of", "partition", "values", "are", "valid", "based", "on", "the", "given", "list", "of", "partition", "keys" ]	[ "private", "void", "check", "valid", "partition", "spec", "(", "catalog", "partition", "spec", "partition", "spec", ",", "list", "<", "string", ">", "partition", "keys", ",", "object", "path", "table", "path", ")", "throws", "partition", "spec", "invalid", "exception", "{", "for", "(", "string", "key", ":", "partition", "spec", "get", "partition", "spec", "(", ")", "key", "set", "(", ")", ")", "{", "if", "(", "!", "partition", "keys", "contains", "(", "key", ")", ")", "{", "throw", "new", "partition", "spec", "invalid", "exception", "(", "get", "name", "(", ")", ",", "partition", "keys", ",", "table", "path", ",", "partition", "spec", ")", ";", "}", "}", "}" ]
[ "return", "buffers", "to", "the", "pool", "if", "they", "are", "of", "the", "poolable", "size", "add", "them", "to", "the", "free", "list", ",", "otherwise", "just", "mark", "the", "memory", "as", "free" ]	[ "public", "void", "deallocate", "(", "byte", "buffer", "buffer", ",", "int", "size", ")", "{", "lock", "lock", "(", ")", ";", "try", "{", "if", "(", "size", "=", "=", "this", "poolable", "size", "&", "&", "size", "=", "=", "buffer", "capacity", "(", ")", ")", "{", "buffer", "clear", "(", ")", ";", "this", "free", "add", "(", "buffer", ")", ";", "}", "else", "{", "this", "non", "pooled", "available", "memory", "+", "=", "size", ";", "}", "condition", "more", "mem", "=", "this", "waiters", "peek", "first", "(", ")", ";", "if", "(", "more", "mem", "!", "=", "null", ")", "more", "mem", "signal", "(", ")", ";", "}", "finally", "{", "lock", "unlock", "(", ")", ";", "}", "}" ]
[ "gets", "the", "{", "@", "link", "loader", "}", "'", "s", "language", "service", "the", "default", "behavior", "of", "this", "method", "is", "to", "return", "the", "{", "@", "link", "default", "language", "service", "}" ]	[ "protected", "language", "service", "get", "language", "service", "(", ")", "{", "return", "default", "language", "service", "get", "language", "service", "(", ")", ";", "}" ]
[ "the", "strength", "of", "the", "value", "type", "in", "each", "entry" ]	[ "strength", "value", "strength", "(", ")", ";" ]
[ "get", "{", "@", "link", "mutable", "quantiles", "}", "metrics", "for", "the", "file", "read", "time" ]	[ "protected", "mutable", "quantiles", "[", "]", "get", "file", "read", "quantiles", "(", ")", "{", "return", "file", "read", "quantiles", ";", "}" ]
[ "sends", "a", "message" ]	[ "void", "send", "message", "(", "player", "message", "message", ")", ";" ]
[ "model", "tests", "for", "child", "schema", "all", "of" ]	[ "public", "void", "test", "child", "schema", "all", "of", "(", ")", "{", "/", "/", "todo", ":", "test", "child", "schema", "all", "of", "}" ]
[ "returns", "the", "declaring", "class", "of", "{", "@", "code", "type", "variable", "}", ",", "or", "{", "@", "code", "null", "}", "if", "it", "was", "not", "declared", "by", "a", "class" ]	[ "private", "static", "class", "<", "?", ">", "declaring", "class", "of", "(", "type", "variable", "type", "variable", ")", "{", "generic", "declaration", "generic", "declaration", "=", "type", "variable", "get", "generic", "declaration", "(", ")", ";", "return", "generic", "declaration", "instanceof", "class", "?", "(", "class", "<", "?", ">", ")", "generic", "declaration", ":", "null", ";", "}" ]
[ "test", "if", "the", "given", "annotation", "matches", "the", "filter" ]	[ "default", "boolean", "matches", "(", "annotation", "annotation", ")", "{", "return", "matches", "(", "annotation", "annotation", "type", "(", ")", ")", ";", "}" ]
[ "write", "v1", "rainbow", "fish", "to", "file" ]	[ "public", "static", "void", "write", "v", "1", "(", "rainbow", "fish", "rainbow", "fish", ",", "string", "filename", ")", "throws", "i", "o", "exception", "{", "var", "map", "=", "map", "of", "(", "\"", "name", "\"", ",", "rainbow", "fish", "get", "name", "(", ")", ",", "\"", "age", "\"", ",", "string", "format", "(", "\"", "%", "d", "\"", ",", "rainbow", "fish", "get", "age", "(", ")", ")", ",", "length", "meters", ",", "string", "format", "(", "\"", "%", "d", "\"", ",", "rainbow", "fish", "get", "length", "meters", "(", ")", ")", ",", "weight", "tons", ",", "string", "format", "(", "\"", "%", "d", "\"", ",", "rainbow", "fish", "get", "weight", "tons", "(", ")", ")", ")", ";", "try", "(", "var", "file", "out", "=", "new", "file", "output", "stream", "(", "filename", ")", ";", "var", "obj", "out", "=", "new", "object", "output", "stream", "(", "file", "out", ")", ")", "{", "obj", "out", "write", "object", "(", "map", ")", ";", "}", "}" ]

[ "creates", "a", "new", "test", "{", "@", "link", "operator", "stream", "state", "handle", "}", "with", "a", "given", "number", "of", "randomly", "created", "named", "states" ]

[ "public", "static", "operator", "state", "handle", "create", "new", "operator", "state", "handle", "(", "int", "num", "named", "states", ",", "random", "random", ")", "{", "map", "<", "string", ",", "operator", "state", "handle", "state", "meta", "info", ">", "operator", "state", "meta", "data", "=", "new", "hash", "map", "<", ">", "(", "num", "named", "states", ")", ";", "long", "off", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "num", "named", "states", ";", "+", "+", "i", ")", "{", "long", "[", "]", "offsets", "=", "new", "long", "[", "4", "]", ";", "for", "(", "int", "o", "=", "0", ";", "o", "<", "offsets", "length", ";", "+", "+", "o", ")", "{", "offsets", "[", "o", "]", "=", "off", "+", "+", ";", "}", "operator", "state", "handle", "state", "meta", "info", "meta", "info", "=", "new", "operator", "state", "handle", "state", "meta", "info", "(", "offsets", ",", "operator", "state", "handle", "mode", "split", "distribute", ")", ";", "operator", "state", "meta", "data", "put", "(", "string", "value", "of", "(", "uuid", "random", "u", "u", "i", "d", "(", ")", ")", ",", "meta", "info", ")", ";", "}", "return", "new", "operator", "stream", "state", "handle", "(", "operator", "state", "meta", "data", ",", "create", "stream", "state", "handle", "(", "num", "named", "states", ",", "random", ")", ")", ";", "}" ]

[ "release", "the", "provided", "{", "@", "link", "releasable", "}", "s", ",", "ignoring", "exceptions" ]

[ "public", "static", "void", "close", "while", "handling", "exception", "(", "releasable", "releasables", ")", "{", "close", "while", "handling", "exception", "(", "arrays", "as", "list", "(", "releasables", ")", ")", ";", "}" ]

[ "set", "the", "freemarker", "template", "loader", "path", "via", "a", "spring", "resource", "location", "see", "the", "\"", "template", "loader", "paths", "\"", "property", "for", "details", "on", "path", "handling" ]

[ "public", "void", "set", "template", "loader", "path", "(", "string", "template", "loader", "path", ")", "{", "this", "template", "loader", "paths", "=", "new", "string", "[", "]", "{", "template", "loader", "path", "}", ";", "}" ]

[ "{", "@", "inherit", "doc", "}", "the", "default", "implementation", "does", "nothing" ]

[ "@", "override", "public", "void", "enter", "primitive", "data", "type", "(", "sql", "base", "parser", "primitive", "data", "type", "context", "ctx", ")", "{", "}" ]

[ "asserts", "that", "the", "script", "stack", "looks", "right" ]

[ "public", "static", "void", "assert", "script", "stack", "(", "script", "exception", "e", ",", "string", "stack", ")", "{", "/", "/", "this", "particular", "incantation", "of", "assertions", "makes", "the", "error", "messages", "more", "useful", "try", "{", "assert", "that", "(", "e", "get", "script", "stack", "(", ")", ",", "has", "size", "(", "stack", "length", ")", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "stack", "length", ";", "i", "+", "+", ")", "{", "assert", "equals", "(", "stack", "[", "i", "]", ",", "e", "get", "script", "stack", "(", ")", "get", "(", "i", ")", ")", ";", "}", "}", "catch", "(", "assertion", "error", "assertion", ")", "{", "assertion", "init", "cause", "(", "e", ")", ";", "throw", "assertion", ";", "}", "}" ]

[ "set", "this", "to", "true", "if", "this", "component", "should", "be", "enabled", "(", "should", "be", "drawn", ")", ",", "false", "if", "not", "if", "disabled", ",", "nothing", "of", "this", "component", "will", "be", "drawn", "default", ":", "true" ]

[ "public", "void", "set", "enabled", "(", "boolean", "enabled", ")", "{", "m", "enabled", "=", "enabled", ";", "}" ]

[ "choose", "a", "configuration", "from", "the", "list", "implementors", "typically", "implement", "this", "method", "by", "calling", "{", "@", "link", "egl10", "#", "egl", "choose", "config", "}", "and", "iterating", "through", "the", "results", "please", "consult", "the", "egl", "specification", "available", "from", "the", "khronos", "group", "to", "learn", "how", "to", "call", "egl", "choose", "config" ]

[ "e", "g", "l", "config", "choose", "config", "(", "egl10", "egl", ",", "e", "g", "l", "display", "display", ")", ";" ]

[ "sets", "whether", "the", "action", "will", "support", "using", "the", "default", "tool", "context", "if", "the", "focused", "provider", "'", "s", "context", "is", "invalid", "<", "p", ">", "by", "default", ",", "actions", "only", "work", "on", "the", "current", "focused", "provider", "'", "s", "context", "setting", "this", "to", "true", "will", "cause", "the", "action", "to", "be", "evaluated", "against", "the", "default", "tool", "context", "if", "the", "focused", "context", "is", "not", "valid", "for", "this", "action" ]

[ "public", "b", "supports", "default", "tool", "context", "(", "boolean", "b", ")", "{", "supports", "default", "tool", "context", "=", "b", ";", "return", "self", "(", ")", ";", "}" ]

[ "convenience", "method", "to", "get", "the", "specified", "member", "as", "a", "json", "array" ]

[ "public", "json", "array", "get", "as", "json", "array", "(", "string", "member", "name", ")", "{", "return", "(", "json", "array", ")", "members", "get", "(", "member", "name", ")", ";", "}" ]

[ "put", "bytes", "in", "cache" ]

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

[ "return", "whether", "the", "container", "is", "still", "active" ]

[ "protected", "boolean", "is", "container", "active", "(", "container", "id", "container", "id", ")", "{", "return", "this", "pid", "files", "contains", "key", "(", "container", "id", ")", ";", "}" ]

[ "create", "the", "objects", "we", "need", "for", "this", "plugin", ";", "register", "the", "service", "provided", ",", "create", "the", "actions", ",", "etc" ]

[ "private", "void", "initialize", "(", ")", "{", "editor", "list", "=", "new", "array", "list", "<", ">", "(", ")", ";", "editor", "option", "mgr", "=", "new", "editor", "option", "manager", "(", "plugin", ")", ";", "install", "editor", "actions", "(", ")", ";", "}" ]

[ "convenience", "method", "to", "create", "a", "group", "matcher", "which", "matches", "against", "the", "groups", "of", "the", "user" ]

[ "public", "static", "mapping", "rule", "matcher", "create", "user", "group", "matcher", "(", "string", "group", "name", ")", "{", "return", "new", "user", "group", "matcher", "(", "group", "name", ")", ";", "}" ]

[ "creates", "a", "{", "@", "link", "scheduled", "executor", "service", "}", "whose", "{", "@", "code", "submit", "}", "and", "{", "@", "code", "invoke", "all", "}", "methods", "submit", "{", "@", "link", "listenable", "future", "task", "}", "instances", "to", "the", "given", "delegate", "executor", "those", "methods", ",", "as", "well", "as", "{", "@", "code", "execute", "}", "and", "{", "@", "code", "invoke", "any", "}", ",", "are", "implemented", "in", "terms", "of", "calls", "to", "{", "@", "code", "delegate", "execute", "}", "all", "other", "methods", "are", "forwarded", "unchanged", "to", "the", "delegate", "this", "implies", "that", "the", "returned", "{", "@", "code", "listening", "scheduled", "executor", "service", "}", "never", "calls", "the", "delegate", "'", "s", "{", "@", "code", "submit", "}", ",", "{", "@", "code", "invoke", "all", "}", ",", "and", "{", "@", "code", "invoke", "any", "}", "methods", ",", "so", "any", "special", "handling", "of", "tasks", "must", "be", "implemented", "in", "the", "delegate", "'", "s", "{", "@", "code", "execute", "}", "method", "or", "by", "wrapping", "the", "returned", "{", "@", "code", "listening", "scheduled", "executor", "service", "}", "if", "the", "delegate", "executor", "was", "already", "an", "instance", "of", "{", "@", "code", "listening", "scheduled", "executor", "service", "}", ",", "it", "is", "returned", "untouched", ",", "and", "the", "rest", "of", "this", "documentation", "does", "not", "apply" ]

[ "public", "static", "listening", "scheduled", "executor", "service", "listening", "decorator", "(", "scheduled", "executor", "service", "delegate", ")", "{", "return", "(", "delegate", "instanceof", "listening", "scheduled", "executor", "service", ")", "?", "(", "listening", "scheduled", "executor", "service", ")", "delegate", ":", "new", "scheduled", "listening", "decorator", "(", "delegate", ")", ";", "}" ]

[ "check", "that", "when", "dangling", "indices", "are", "discovered", ",", "then", "they", "can", "be", "listed" ]

[ "public", "void", "test", "dangling", "indices", "can", "be", "listed", "(", ")", "throws", "exception", "{", "internal", "cluster", "(", ")", "start", "nodes", "(", "3", ",", "build", "settings", "(", "0", ",", "true", ")", ")", ";", "final", "string", "stopped", "node", "name", "=", "create", "dangling", "indices", "(", "index", "name", ")", ";", "final", "list", "dangling", "indices", "response", "response", "=", "client", "(", ")", "admin", "(", ")", "cluster", "(", ")", "list", "dangling", "indices", "(", "new", "list", "dangling", "indices", "request", "(", ")", ")", "action", "get", "(", ")", ";", "assert", "that", "(", "response", "status", "(", ")", ",", "equal", "to", "(", "rest", "status", "ok", ")", ")", ";", "final", "list", "<", "node", "list", "dangling", "indices", "response", ">", "node", "responses", "=", "response", "get", "nodes", "(", ")", ";", "assert", "that", "(", "\"", "didn", "'", "t", "get", "responses", "from", "all", "nodes", "\"", ",", "node", "responses", ",", "has", "size", "(", "3", ")", ")", ";", "for", "(", "node", "list", "dangling", "indices", "response", "node", "response", ":", "node", "responses", ")", "{", "if", "(", "node", "response", "get", "node", "(", ")", "get", "name", "(", ")", "equals", "(", "stopped", "node", "name", ")", ")", "{", "assert", "that", "(", "\"", "expected", "node", "that", "was", "stopped", "to", "have", "one", "dangling", "index", "\"", ",", "node", "response", "get", "dangling", "indices", "(", ")", ",", "has", "size", "(", "1", ")", ")", ";", "final", "dangling", "index", "info", "dangling", "index", "info", "=", "node", "response", "get", "dangling", "indices", "(", ")", "get", "(", "0", ")", ";", "assert", "that", "(", "dangling", "index", "info", "get", "index", "name", "(", ")", ",", "equal", "to", "(", "index", "name", ")", ")", ";", "}", "else", "{", "assert", "that", "(", "\"", "expected", "node", "that", "was", "never", "stopped", "to", "have", "no", "dangling", "indices", "\"", ",", "node", "response", "get", "dangling", "indices", "(", ")", ",", "empty", "(", ")", ")", ";", "}", "}", "}" ]

[ "performs", "message", "encoding", "of", "a", "data", "matrix", "message", "using", "the", "algorithm", "described", "in", "annex", "p", "of", "isoiec", "16022", ":", "2000", "(", "e", ")" ]

[ "public", "static", "string", "encode", "high", "level", "(", "string", "msg", ",", "symbol", "shape", "hint", "shape", ",", "dimension", "min", "size", ",", "dimension", "max", "size", ")", "{", "/", "/", "the", "codewords", "0", "255", "are", "encoded", "as", "unicode", "characters", "encoder", "[", "]", "encoders", "=", "{", "new", "a", "s", "c", "i", "i", "encoder", "(", ")", ",", "new", "c", "4", "0", "encoder", "(", ")", ",", "new", "text", "encoder", "(", ")", ",", "new", "x", "1", "2", "encoder", "(", ")", ",", "new", "edifact", "encoder", "(", ")", ",", "new", "base", "2", "5", "6", "encoder", "(", ")", "}", ";", "encoder", "context", "context", "=", "new", "encoder", "context", "(", "msg", ")", ";", "context", "set", "symbol", "shape", "(", "shape", ")", ";", "context", "set", "size", "constraints", "(", "min", "size", ",", "max", "size", ")", ";", "if", "(", "msg", "starts", "with", "(", "macro", "05", "header", ")", "&", "&", "msg", "ends", "with", "(", "macro", "trailer", ")", ")", "{", "context", "write", "codeword", "(", "macro", "05", ")", ";", "context", "set", "skip", "at", "end", "(", "2", ")", ";", "context", "pos", "+", "=", "macro", "05", "header", "length", "(", ")", ";", "}", "else", "if", "(", "msg", "starts", "with", "(", "macro", "06", "header", ")", "&", "&", "msg", "ends", "with", "(", "macro", "trailer", ")", ")", "{", "context", "write", "codeword", "(", "macro", "06", ")", ";", "context", "set", "skip", "at", "end", "(", "2", ")", ";", "context", "pos", "+", "=", "macro", "06", "header", "length", "(", ")", ";", "}", "int", "encoding", "mode", "=", "ascii", "encodation", ";", "/", "/", "default", "mode", "while", "(", "context", "has", "more", "characters", "(", ")", ")", "{", "encoders", "[", "encoding", "mode", "]", "encode", "(", "context", ")", ";", "if", "(", "context", "get", "new", "encoding", "(", ")", ">", "=", "0", ")", "{", "encoding", "mode", "=", "context", "get", "new", "encoding", "(", ")", ";", "context", "reset", "encoder", "signal", "(", ")", ";", "}", "}", "int", "len", "=", "context", "get", "codeword", "count", "(", ")", ";", "context", "update", "symbol", "info", "(", ")", ";", "int", "capacity", "=", "context", "get", "symbol", "info", "(", ")", "get", "data", "capacity", "(", ")", ";", "if", "(", "len", "<", "capacity", "&", "&", "encoding", "mode", "!", "=", "ascii", "encodation", "&", "&", "encoding", "mode", "!", "=", "base256", "encodation", "&", "&", "encoding", "mode", "!", "=", "edifact", "encodation", ")", "{", "context", "write", "codeword", "(", "'", "\\", "u", "0", "0fe", "'", ")", ";", "/", "/", "unlatch", "(", "254", ")", "}", "/", "/", "padding", "string", "builder", "codewords", "=", "context", "get", "codewords", "(", ")", ";", "if", "(", "codewords", "length", "(", ")", "<", "capacity", ")", "{", "codewords", "append", "(", "pad", ")", ";", "}", "while", "(", "codewords", "length", "(", ")", "<", "capacity", ")", "{", "codewords", "append", "(", "randomize", "2", "5", "3", "state", "(", "codewords", "length", "(", ")", "+", "1", ")", ")", ";", "}", "return", "context", "get", "codewords", "(", ")", "to", "string", "(", ")", ";", "}" ]

[ "the", "process", "id" ]

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

[ "return", "the", "transport", "type", "supported", "by", "this", "handler" ]

[ "transport", "type", "get", "transport", "type", "(", ")", ";" ]

[ "release", "properties", "which", "are", "not", "longer", "required", "for", "the", "current", "layout", "pass", "or", "release", "properties", "which", "should", "be", "reset", "during", "reconciliation" ]

[ "private", "void", "clean", "(", ")", "{", "/", "/", "1", "release", "or", "clone", "props", "m", "components", "=", "new", "array", "list", "<", ">", "(", ")", ";", "if", "(", "m", "component", "global", "keys", "!", "=", "null", ")", "{", "m", "component", "global", "keys", "=", "new", "array", "list", "<", ">", "(", ")", ";", "}", "m", "diff", "node", "=", "null", ";", "m", "debug", "components", "=", "null", ";", "/", "/", "2", "reset", "resolved", "layout", "properties", "reset", "resolved", "layout", "properties", "(", ")", ";", "}" ]

[ "returns", "{", "@", "code", "true", "}", "if", "the", "given", "experiment", "is", "enabled", "this", "is", "an", "experimental", "api", ",", "it", "may", "be", "removed", "at", "any", "point", "without", "deprecation", "or", "other", "notice" ]

[ "public", "boolean", "is", "enabled", "(", "class", "<", "?", "extends", "experiment", ">", "clazz", ")", "{", "return", "experiments", "contains", "key", "(", "clazz", ")", ";", "}" ]

[ "returns", "the", "extra", "data", "for", "this", "entry" ]

[ "public", "final", "byte", "[", "]", "get", "extra", "data", "(", ")", "{", "return", "get", "bytes", "(", "size", "+", "get", "(", "locnam", ")", ",", "get", "(", "locext", ")", ")", ";", "}" ]

[ "verifies", "that", "sent", "socks", "messages", "are", "decoded", "correctly" ]

[ "public", "void", "test", "socks", "cmd", "response", "decoder", "(", ")", "{", "for", "(", "socks", "cmd", "status", "cmd", "status", ":", "socks", "cmd", "status", "values", "(", ")", ")", "{", "for", "(", "socks", "address", "type", "address", "type", ":", "socks", "address", "type", "values", "(", ")", ")", "{", "test", "socks", "cmd", "response", "decoder", "with", "different", "params", "(", "cmd", "status", ",", "address", "type", ",", "null", ",", "0", ")", ";", "}", "}", "}" ]

[ "test", "new", "tx" ]

[ "public", "void", "test", "new", "tx", "(", ")", "throws", "exception", "{", "global", "transaction", "tx", "=", "global", "transaction", "context", "get", "current", "or", "create", "(", ")", ";", "assertions", "assert", "equals", "(", "tx", "get", "status", "(", ")", ",", "global", "status", "un", "known", ")", ";", "assertions", "assert", "null", "(", "tx", "get", "xid", "(", ")", ")", ";", "}" ]

[ "resolving", "the", "network", "topology" ]

[ "public", "static", "node", "resolve", "(", "string", "host", "name", ")", "{", "return", "rack", "resolver", "resolve", "(", "host", "name", ")", ";", "}" ]

[ "gets", "the", "list", "of", "instructions" ]

[ "public", "dalv", "insn", "list", "get", "insns", "(", ")", "{", "finish", "processing", "if", "necessary", "(", ")", ";", "return", "insns", ";", "}" ]

[ "deal", "with", "awb", "resources" ]

[ "public", "void", "process", "awb", "resources", "(", "aapt", "aapt", ",", "aapt", "package", "config", "builder", "aapt", "config", "builder", ",", "file", "main", "symbol", "file", ",", "file", "awb", "symbol", "file", ",", "string", "pacakge", "name", ")", "throws", "i", "o", "exception", ",", "process", "exception", "{", "aapt", "config", "builder", "set", "build", "tool", "info", "(", "get", "target", "info", "(", ")", "get", "build", "tools", "(", ")", ")", ";", "aapt", "config", "builder", "set", "android", "target", "(", "get", "target", "info", "(", ")", "get", "target", "(", ")", ")", ";", "aapt", "config", "builder", "set", "logger", "(", "logger", ")", ";", "logger", "info", "(", "\"", "aapt", "output", "file", "{", "}", "\"", ")", ";", "aapt", "package", "config", "aapt", "config", "=", "aapt", "config", "builder", "build", "(", ")", ";", "try", "{", "aapt", "link", "(", "aapt", "config", ")", "get", "(", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "throw", "new", "process", "exception", "(", "\"", "failed", "to", "execute", "aapt", "\"", ",", "e", ")", ";", "}", "file", "source", "out", "=", "aapt", "config", "get", "source", "output", "dir", "(", ")", ";", "if", "(", "source", "out", "!", "=", "null", ")", "{", "/", "/", "figure", "out", "what", "the", "main", "symbol", "file", "'", "s", "package", "is", "string", "main", "package", "name", "=", "aapt", "config", "get", "custom", "package", "for", "r", "(", ")", ";", "if", "(", "main", "package", "name", "=", "=", "null", ")", "{", "main", "package", "name", "=", "symbol", "utils", "get", "package", "name", "from", "manifest", "(", "aapt", "config", "get", "manifest", "file", "(", ")", ")", ";", "}", "/", "/", "load", "the", "main", "symbol", "file", "file", "main", "r", "txt", "=", "new", "file", "(", "aapt", "config", "get", "symbol", "output", "dir", "(", ")", ",", "\"", "r", "txt", "\"", ")", ";", "file", "merged", "symbol", "file", "=", "new", "file", "(", "aapt", "config", "get", "symbol", "output", "dir", "(", ")", ",", "\"", "r", "-", "all", "txt", "\"", ")", ";", "try", "{", "s", "logger", "info", "(", "\"", "awb", "symbol", "file", ":", "\"", "+", "main", "r", "txt", ")", ";", "if", "(", "null", "!", "=", "main", "r", "txt", "&", "&", "main", "r", "txt", "exists", "(", ")", ")", "{", "file", "utils", "copy", "file", "(", "main", "r", "txt", ",", "merged", "symbol", "file", ")", ";", "}", "else", "{", "throw", "new", "process", "exception", "(", "main", "r", "txt", "get", "absolute", "path", "(", ")", "+", "\"", "is", "not", "exist", ",", "maybe", "no", "resources", "in", "this", "bundle", "!", "\"", ")", ";", "}", "symbol", "table", "awb", "symbols", "=", "build", "(", "awb", "symbol", "file", ",", "main", "package", "name", ",", "main", "r", "txt", ",", "main", "symbol", "file", ",", "pacakge", "name", ")", ";", "if", "(", "awb", "symbols", "!", "=", "null", ")", "{", "atlas", "symbol", "io", "write", "(", "awb", "symbols", ",", "merged", "symbol", "file", ")", ";", "}", "/", "/", "why", "do", "this", "?", "youku", "need", "use", "this", "!", "/", "/", "file", "utils", "write", "lines", "(", "merged", "symbol", "file", ",", "file", "utils", "read", "lines", "(", "main", "symbol", "file", ")", ",", "true", ")", ";", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "throw", "new", "runtime", "exception", "(", "\"", "could", "not", "load", "file", "\"", ",", "e", ")", ";", "}", "symbol", "table", "main", "symbols", "=", "merged", "symbol", "file", "is", "file", "(", ")", "?", "atlas", "symbol", "io", "read", "from", "aapt", "(", "merged", "symbol", "file", ",", "main", "package", "name", ")", ":", "symbol", "table", "builder", "(", ")", "table", "package", "(", "main", "package", "name", ")", "build", "(", ")", ";", "/", "/", "for", "each", "dependency", ",", "load", "its", "symbol", "file", "set", "<", "symbol", "table", ">", "dep", "symbol", "tables", "=", "symbol", "utils", "load", "dependencies", "symbol", "tables", "(", "aapt", "config", "get", "library", "symbol", "table", "files", "(", ")", ",", "main", "package", "name", ")", ";", "boolean", "final", "ids", "=", "true", ";", "if", "(", "aapt", "config", "get", "variant", "type", "(", ")", "=", "=", "variant", "type", "library", ")", "{", "final", "ids", "=", "false", ";", "}", "symbol", "io", "export", "to", "java", "(", "main", "symbols", ",", "source", "out", ",", "final", "ids", ")", ";", "r", "generation", "generate", "r", "for", "libraries", "(", "main", "symbols", ",", "dep", "symbol", "tables", ",", "source", "out", ",", "final", "ids", ")", ";", "}", "}" ]

[ "it", "writes", "the", "field", "value", "to", "the", "parquet", "record", "consumer", "it", "detects", "the", "field", "type", ",", "and", "calls", "the", "correct", "write", "function" ]

[ "private", "void", "write", "value", "(", "final", "object", "value", ",", "final", "object", "inspector", "inspector", ",", "final", "type", "type", ")", "{", "if", "(", "type", "is", "primitive", "(", ")", ")", "{", "check", "inspector", "category", "(", "inspector", ",", "object", "inspector", "category", "primitive", ")", ";", "write", "primitive", "(", "value", ",", "(", "primitive", "object", "inspector", ")", "inspector", ")", ";", "}", "else", "{", "group", "type", "group", "type", "=", "type", "as", "group", "type", "(", ")", ";", "original", "type", "original", "type", "=", "type", "get", "original", "type", "(", ")", ";", "if", "(", "original", "type", "!", "=", "null", "&", "&", "original", "type", "equals", "(", "original", "type", "list", ")", ")", "{", "check", "inspector", "category", "(", "inspector", ",", "object", "inspector", "category", "list", ")", ";", "if", "(", "single", "level", "array", ")", "{", "write", "single", "level", "array", "(", "value", ",", "(", "list", "object", "inspector", ")", "inspector", ",", "group", "type", ")", ";", "}", "else", "{", "write", "array", "(", "value", ",", "(", "list", "object", "inspector", ")", "inspector", ",", "group", "type", ")", ";", "}", "}", "else", "if", "(", "original", "type", "!", "=", "null", "&", "&", "(", "original", "type", "equals", "(", "original", "type", "map", ")", "|", "|", "original", "type", "equals", "(", "original", "type", "map", "key", "value", ")", ")", ")", "{", "check", "inspector", "category", "(", "inspector", ",", "object", "inspector", "category", "map", ")", ";", "write", "map", "(", "value", ",", "(", "map", "object", "inspector", ")", "inspector", ",", "group", "type", ")", ";", "}", "else", "{", "check", "inspector", "category", "(", "inspector", ",", "object", "inspector", "category", "struct", ")", ";", "write", "group", "(", "value", ",", "(", "struct", "object", "inspector", ")", "inspector", ",", "group", "type", ")", ";", "}", "}", "}" ]

[ "route", "requests", "that", "match", "the", "given", "pattern", "to", "resources", "relative", "to", "the", "given", "root", "location", "for", "instance", "<", "pre", "class", "=", "\"", "code", "\"", ">", "resource", "location", "=", "new", "file", "system", "resource", "(", "\"", "public", "-", "resources", "\"", ")", ";", "router", "function", "&", "lt", ";", "server", "response", "&", "gt", ";", "resources", "=", "router", "functions", "resources", "(", "\"", "resources", "\"", ",", "location", ")", ";" ]

[ "builder", "resources", "(", "string", "pattern", ",", "resource", "location", ")", ";" ]

[ "a", "bit", "simplistic", ":", "just", "wants", "the", "same", "class", "doesn", "'", "t", "worry", "about", "counts" ]

[ "public", "boolean", "equals", "(", "object", "other", ")", "{", "return", "(", "other", "!", "=", "null", "&", "&", "other", "get", "class", "(", ")", "=", "=", "this", "get", "class", "(", ")", ")", ";", "}" ]

[ "updates", "the", "local", "state", "of", "this", "{", "@", "link", "http", "2", "connection", "}", "as", "a", "result", "of", "a", "{", "@", "code", "goaway", "}", "to", "send", "to", "the", "remote", "endpoint" ]

[ "boolean", "go", "away", "sent", "(", "int", "last", "known", "stream", ",", "long", "error", "code", ",", "byte", "buf", "message", ")", "throws", "http", "2", "exception", ";" ]

[ "gets", "the", "register", "spec", "representing", "the", "local", "variable", "introduced", "by", "this", "instance" ]

[ "public", "register", "spec", "get", "local", "(", ")", "{", "return", "local", ";", "}" ]

[ "removes", "all", "default", "acl", "entries", "from", "files", "and", "directories" ]

[ "public", "void", "remove", "default", "acl", "(", "path", "path", ")", "throws", "i", "o", "exception", "{", "throw", "new", "unsupported", "operation", "exception", "(", "get", "class", "(", ")", "get", "simple", "name", "(", ")", "+", "\"", "doesn", "'", "t", "support", "remove", "default", "acl", "\"", ")", ";", "}" ]

[ "set", "the", "value", "with", "the", "given", "name", "replacing", "an", "existing", "value", "(", "if", "any", ")" ]

[ "public", "void", "set", "attribute", "(", "string", "name", ",", "object", "value", ")", "{", "this", "attributes", "put", "(", "name", ",", "value", ")", ";", "}" ]

[ "load", "information", "about", "root", ",", "and", "use", "the", "information", "to", "update", "the", "root", "directory", "of", "name", "system" ]

[ "private", "void", "load", "root", "(", "data", "input", "in", ",", "counter", "counter", ")", "throws", "i", "o", "exception", "{", "/", "/", "load", "root", "if", "(", "in", "read", "short", "(", ")", "!", "=", "0", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "first", "node", "is", "not", "root", "\"", ")", ";", "}", "final", "i", "node", "directory", "root", "=", "load", "i", "node", "(", "null", ",", "false", ",", "in", ",", "counter", ")", "as", "directory", "(", ")", ";", "/", "/", "update", "the", "root", "'", "s", "attributes", "update", "root", "attr", "(", "root", ")", ";", "}" ]

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

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

[ "uses", "a", "hash", "-", "based", "{", "@", "code", "set", "}", "to", "store", "value", "collections" ]

[ "public", "set", "multimap", "builder", "<", "k0", ",", "object", ">", "hash", "set", "values", "(", ")", "{", "return", "hash", "set", "values", "(", "default", "expected", "values", "per", "key", ")", ";", "}" ]

[ "calculates", "the", "derivative", "of", "the", "catmullrom", "spline", "for", "the", "given", "position", "(", "t", ")" ]

[ "public", "static", "<", "t", "extends", "vector", "<", "t", ">", ">", "t", "derivative", "(", "final", "t", "out", ",", "final", "float", "t", ",", "final", "t", "[", "]", "points", ",", "final", "boolean", "continuous", ",", "final", "t", "tmp", ")", "{", "final", "int", "n", "=", "continuous", "?", "points", "length", ":", "points", "length", "-", "3", ";", "float", "u", "=", "t", "*", "n", ";", "int", "i", "=", "(", "t", ">", "=", "1f", ")", "?", "(", "n", "-", "1", ")", ":", "(", "int", ")", "u", ";", "u", "-", "=", "i", ";", "return", "derivative", "(", "out", ",", "i", ",", "u", ",", "points", ",", "continuous", ",", "tmp", ")", ";", "}" ]

[ "returns", "the", "available", "amount", "of", "memory", "handled", "by", "this", "memory", "manager" ]

[ "public", "long", "available", "memory", "(", ")", "{", "return", "memory", "budget", "get", "available", "memory", "size", "(", ")", ";", "}" ]

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

[ "refresh", "the", "queue", "-", "configuration", "in", "the", "scheduler", "this", "method", "has", "the", "following", "contract", "before", "this", "method", ",", "{", "@", "link", "queue", "manager", "}", "does", "a", "validation", "of", "the", "new", "queue", "-", "configuration", "for", "e", "g", ",", "currently", "addition", "of", "new", "queues", ",", "or", "removal", "of", "queues", "at", "any", "level", "in", "the", "hierarchy", "is", "not", "supported", "by", "{", "@", "link", "queue", "manager", "}", "and", "so", "are", "not", "supported", "for", "schedulers", "too", "schedulers", "will", "be", "passed", "a", "list", "of", "{", "@", "link", "job", "queue", "info", "}", "s", "of", "the", "root", "queues", "i", "e", "the", "queues", "at", "the", "top", "level", "all", "the", "descendants", "are", "properly", "linked", "from", "these", "top", "-", "level", "queues", "schedulers", "should", "use", "the", "scheduler", "specific", "queue", "properties", "from", "the", "new", "root", "queues", ",", "validate", "the", "properties", "themselves", "and", "apply", "them", "internally", "once", "the", "method", "returns", "successfully", "from", "the", "schedulers", ",", "it", "is", "assumed", "that", "the", "refresh", "of", "queue", "properties", "is", "successful", "throughout", "and", "will", "be", "'", "committed", "'", "internally", "to", "{", "@", "link", "queue", "manager", "}", "too", "it", "is", "guaranteed", "that", "at", "no", "point", ",", "after", "successful", "return", "from", "the", "scheduler", ",", "is", "the", "queue", "refresh", "in", "queue", "manager", "failed", "if", "ever", ",", "such", "abnormalities", "happen", ",", "the", "queue", "framework", "will", "be", "inconsistent", "and", "will", "need", "a", "jt", "restart", "if", "scheduler", "throws", "an", "exception", "during", "{", "@", "link", "#", "refresh", "queues", "(", ")", "}", ",", "{", "@", "link", "queue", "manager", "}", "throws", "away", "the", "newly", "read", "configuration", ",", "retains", "the", "old", "(", "consistent", ")", "configuration", "and", "informs", "the", "request", "issuer", "about", "the", "error", "appropriately" ]

[ "abstract", "void", "refresh", "queues", "(", "list", "<", "job", "queue", "info", ">", "new", "root", "queues", ")", "throws", "throwable", ";" ]

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

[ "public", "void", "close", "(", "task", "attempt", "context", "context", ")", "throws", "i", "o", "exception", "{", "try", "{", "statement", "execute", "batch", "(", ")", ";", "connection", "commit", "(", ")", ";", "}", "catch", "(", "s", "q", "l", "exception", "e", ")", "{", "try", "{", "connection", "rollback", "(", ")", ";", "}", "catch", "(", "s", "q", "l", "exception", "ex", ")", "{", "log", "warn", "(", "string", "utils", "stringify", "exception", "(", "ex", ")", ")", ";", "}", "throw", "new", "i", "o", "exception", "(", "e", "get", "message", "(", ")", ")", ";", "}", "finally", "{", "try", "{", "statement", "close", "(", ")", ";", "connection", "close", "(", ")", ";", "}", "catch", "(", "s", "q", "l", "exception", "ex", ")", "{", "throw", "new", "i", "o", "exception", "(", "ex", "get", "message", "(", ")", ")", ";", "}", "}", "}" ]

[ "sets", "whether", "an", "option", "is", "available", "for", "disabling", "the", "renderer" ]

[ "public", "track", "selection", "dialog", "builder", "set", "show", "disable", "option", "(", "boolean", "show", "disable", "option", ")", "{", "this", "show", "disable", "option", "=", "show", "disable", "option", ";", "return", "this", ";", "}" ]

[ "returns", "a", "registered", "{", "@", "link", "char", "filter", "factory", "}", "provider", "by", "name", "or", "<", "code", ">", "null", "<", "code", ">", "if", "the", "char", "filter", "was", "not", "registered" ]

[ "private", "analysis", "module", "analysis", "provider", "<", "char", "filter", "factory", ">", "get", "char", "filter", "provider", "(", "string", "char", "filter", ")", "{", "return", "char", "filters", "get", "or", "default", "(", "char", "filter", ",", "this", "prebuilt", "analysis", "get", "char", "filter", "factory", "(", "char", "filter", ")", ")", ";", "}" ]

[ "tests", "cluster", "storage", "statistics", "during", "decommissioning", "for", "non", "federated", "cluster" ]

[ "public", "void", "test", "cluster", "stats", "(", ")", "throws", "exception", "{", "test", "cluster", "stats", "(", "1", ")", ";", "}" ]

[ "test", "the", "given", "rmi", "registry", ",", "calling", "some", "operation", "on", "it", "to", "check", "whether", "it", "is", "still", "active", "default", "implementation", "calls", "{", "@", "code", "registry", "list", "(", ")", "}" ]

[ "protected", "void", "test", "registry", "(", "registry", "registry", ")", "throws", "remote", "exception", "{", "registry", "list", "(", ")", ";", "}" ]

[ "create", "an", "instance", "by", "parsing", "the", "\"", "origin", "\"", "header", "of", "an", "http", "request" ]

[ "public", "static", "uri", "components", "builder", "from", "origin", "header", "(", "string", "origin", ")", "{", "matcher", "matcher", "=", "uri", "pattern", "matcher", "(", "origin", ")", ";", "if", "(", "matcher", "matches", "(", ")", ")", "{", "uri", "components", "builder", "builder", "=", "new", "uri", "components", "builder", "(", ")", ";", "string", "scheme", "=", "matcher", "group", "(", "2", ")", ";", "string", "host", "=", "matcher", "group", "(", "6", ")", ";", "string", "port", "=", "matcher", "group", "(", "8", ")", ";", "if", "(", "string", "utils", "has", "length", "(", "scheme", ")", ")", "{", "builder", "scheme", "(", "scheme", ")", ";", "}", "builder", "host", "(", "host", ")", ";", "if", "(", "string", "utils", "has", "length", "(", "port", ")", ")", "{", "builder", "port", "(", "port", ")", ";", "}", "return", "builder", ";", "}", "else", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "[", "\"", "+", "origin", "+", "\"", "]", "is", "not", "a", "valid", "\\", "\"", "origin", "\\", "\"", "header", "value", "\"", ")", ";", "}", "}", "/", "/", "encode", "methods" ]

[ "visit", "the", "module", "corresponding", "to", "the", "class" ]

[ "public", "module", "visitor", "visit", "module", "(", "final", "string", "name", ",", "final", "int", "access", ",", "final", "string", "version", ")", "{", "if", "(", "api", "<", "opcodes", "asm6", ")", "{", "throw", "new", "unsupported", "operation", "exception", "(", "\"", "module", "requires", "asm6", "\"", ")", ";", "}", "if", "(", "cv", "!", "=", "null", ")", "{", "return", "cv", "visit", "module", "(", "name", ",", "access", ",", "version", ")", ";", "}", "return", "null", ";", "}" ]

[ "creates", "a", "cluster", "state", "where", "local", "node", "and", "master", "node", "can", "be", "specified" ]

[ "public", "static", "cluster", "state", "state", "(", "discovery", "node", "local", "node", ",", "discovery", "node", "master", "node", ",", "discovery", "node", "all", "nodes", ")", "{", "discovery", "nodes", "builder", "disco", "builder", "=", "discovery", "nodes", "builder", "(", ")", ";", "for", "(", "discovery", "node", "node", ":", "all", "nodes", ")", "{", "disco", "builder", "add", "(", "node", ")", ";", "}", "if", "(", "master", "node", "!", "=", "null", ")", "{", "disco", "builder", "master", "node", "id", "(", "master", "node", "get", "id", "(", ")", ")", ";", "}", "disco", "builder", "local", "node", "id", "(", "local", "node", "get", "id", "(", ")", ")", ";", "cluster", "state", "builder", "state", "=", "cluster", "state", "builder", "(", "new", "cluster", "name", "(", "\"", "test", "\"", ")", ")", ";", "state", "nodes", "(", "disco", "builder", ")", ";", "state", "metadata", "(", "metadata", "builder", "(", ")", "generate", "cluster", "uuid", "if", "needed", "(", ")", ")", ";", "return", "state", "build", "(", ")", ";", "}" ]

[ "forces", "an", "exporter", "to", "remove", "cluster", "alerts", "immediately", "instead", "of", "waiting", "to", "do", "it", "lazily", "as", "part", "of", "the", "normal", "exporter", "setup" ]

[ "public", "abstract", "void", "remove", "alerts", "(", "consumer", "<", "exporter", "resource", "status", ">", "listener", ")", ";" ]

[ "set", "the", "editor", "text", "font" ]

[ "public", "void", "set", "text", "font", "(", "font", "data", "a", "font", ")", "{", "font", "data", "=", "a", "font", ";", "if", "(", "hex", "edit", "control", "default", "font", "data", "equals", "(", "font", "data", ")", ")", "font", "data", "=", "null", ";", "/", "/", "dispose", "it", "after", "setting", "new", "one", "(", "styled", "text", "renderer", "3", "448", "bug", "in", "line", "994", ")", "font", "font", "to", "dispose", "=", "font", "text", ";", "font", "text", "=", "null", ";", "if", "(", "hex", "edit", "control", "!", "=", "null", ")", "{", "if", "(", "font", "data", "!", "=", "null", ")", "font", "text", "=", "new", "font", "(", "display", "get", "current", "(", ")", ",", "font", "data", ")", ";", "hex", "edit", "control", "set", "font", "(", "font", "text", ")", ";", "}", "if", "(", "font", "to", "dispose", "!", "=", "null", "&", "&", "!", "font", "to", "dispose", "is", "disposed", "(", ")", ")", "font", "to", "dispose", "dispose", "(", ")", ";", "}" ]

[ "closes", "the", "stream", "without", "waiting", "until", "pending", "writes", "are", "committed", ",", "and", "suppressing", "errors", "pending", "writes", "will", "still", "continue", "asynchronously", ",", "but", "any", "errors", "will", "be", "ignored" ]

[ "public", "void", "close", "now", "(", ")", "{", "writer", "thread", "interrupt", "(", ")", ";", "}" ]

[ "make", "sure", "resource", "plugin", "manager", "is", "used", "to", "initialize", "resource", "handler", "chain" ]

[ "public", "void", "test", "linux", "container", "executor", "with", "resource", "plugins", "enabled", "(", ")", "{", "final", "resource", "plugin", "manager", "rpm", "=", "stub", "resource", "pluginmanager", "(", ")", ";", "final", "linux", "container", "executor", "lce", "=", "new", "my", "l", "c", "e", "(", ")", ";", "nm", "=", "new", "node", "manager", "(", ")", "{", "@", "override", "protected", "node", "status", "updater", "create", "node", "status", "updater", "(", "context", "context", ",", "dispatcher", "dispatcher", ",", "node", "health", "checker", "service", "health", "checker", ")", "{", "(", "(", "n", "m", "context", ")", "context", ")", "set", "resource", "plugin", "manager", "(", "rpm", ")", ";", "return", "new", "base", "node", "status", "updater", "for", "test", "(", "context", ",", "dispatcher", ",", "health", "checker", ",", "metrics", ",", "new", "base", "resource", "tracker", "for", "test", "(", ")", ")", ";", "}", "@", "override", "protected", "container", "manager", "impl", "create", "container", "manager", "(", "context", "context", ",", "container", "executor", "exec", ",", "deletion", "service", "del", ",", "node", "status", "updater", "node", "status", "updater", ",", "application", "a", "c", "ls", "manager", "acls", "manager", ",", "local", "dirs", "handler", "service", "dirs", "handler", ")", "{", "return", "new", "my", "container", "manager", "(", "context", ",", "exec", ",", "del", ",", "node", "status", "updater", ",", "metrics", ",", "dirs", "handler", ")", ";", "}", "@", "override", "protected", "container", "executor", "create", "container", "executor", "(", "configuration", "configuration", ")", "{", "(", "(", "n", "m", "context", ")", "this", "get", "n", "m", "context", "(", ")", ")", "set", "resource", "plugin", "manager", "(", "rpm", ")", ";", "lce", "set", "conf", "(", "configuration", ")", ";", "return", "lce", ";", "}", "}", ";", "nm", "init", "(", "conf", ")", ";", "nm", "start", "(", ")", ";", "resource", "handler", "handler", "=", "lce", "get", "resource", "handler", "(", ")", ";", "assert", "that", "(", "handler", ")", "is", "not", "null", "(", ")", ";", "assert", "that", "(", "handler", "instanceof", "resource", "handler", "chain", ")", "is", "true", "(", ")", ";", "boolean", "new", "handler", "added", "=", "false", ";", "for", "(", "resource", "handler", "h", ":", "(", "(", "resource", "handler", "chain", ")", "handler", ")", "get", "resource", "handler", "list", "(", ")", ")", "{", "if", "(", "h", "instanceof", "device", "plugin", "adapter", ")", "{", "fail", "(", "\"", "resource", "handler", "is", "a", "device", "plugin", "adapter", "\"", ")", ";", "}", "if", "(", "h", "instanceof", "customized", "resource", "handler", ")", "{", "new", "handler", "added", "=", "true", ";", "break", ";", "}", "}", "assert", "that", "(", "new", "handler", "added", ")", "with", "fail", "message", "(", "\"", "new", "resource", "handler", "should", "be", "added", "\"", ")", "is", "true", "(", ")", ";", "}" ]

[ "create", "a", "builder", "with", "a", "{", "@", "linkplain", "http", "status", "#", "not", "found", "404", "not", "found", "}", "status" ]

[ "static", "headers", "builder", "<", "?", ">", "not", "found", "(", ")", "{", "return", "status", "(", "http", "status", "not", "found", ")", ";", "}" ]

[ "decompresses", "(", "if", "necessary", ")", "buffered", "data", ",", "optionally", "computes", "and", "validates", "a", "x", "x", "hash", "3", "2", "checksum", ",", "and", "writes", "the", "result", "to", "a", "buffer" ]

[ "private", "void", "read", "block", "(", ")", "throws", "i", "o", "exception", "{", "if", "(", "in", "remaining", "(", ")", "<", "4", ")", "{", "throw", "new", "i", "o", "exception", "(", "premature", "eos", ")", ";", "}", "int", "block", "size", "=", "in", "get", "int", "(", ")", ";", "boolean", "compressed", "=", "(", "block", "size", "&", "lz4", "frame", "incompressible", "mask", ")", "=", "=", "0", ";", "block", "size", "&", "=", "~", "lz4", "frame", "incompressible", "mask", ";", "/", "/", "check", "for", "end", "mark", "if", "(", "block", "size", "=", "=", "0", ")", "{", "finished", "=", "true", ";", "if", "(", "flg", "is", "content", "checksum", "set", "(", ")", ")", "in", "get", "int", "(", ")", ";", "/", "/", "todo", ":", "verify", "this", "content", "checksum", "return", ";", "}", "else", "if", "(", "block", "size", ">", "max", "block", "size", ")", "{", "throw", "new", "i", "o", "exception", "(", "string", "format", "(", "\"", "block", "size", "%", "s", "exceeded", "max", ":", "%", "s", "\"", ",", "block", "size", ",", "max", "block", "size", ")", ")", ";", "}", "if", "(", "in", "remaining", "(", ")", "<", "block", "size", ")", "{", "throw", "new", "i", "o", "exception", "(", "premature", "eos", ")", ";", "}", "if", "(", "compressed", ")", "{", "try", "{", "/", "/", "workaround", "for", "https", ":", "/", "/", "github", "com", "/", "lz", "4", "/", "lz", "4", "-", "java", "/", "pull", "/", "65", "final", "int", "buffer", "size", ";", "if", "(", "in", "has", "array", "(", ")", ")", "{", "buffer", "size", "=", "decompressor", "decompress", "(", "in", "array", "(", ")", ",", "in", "position", "(", ")", "+", "in", "array", "offset", "(", ")", ",", "block", "size", ",", "decompression", "buffer", "array", "(", ")", ",", "0", ",", "max", "block", "size", ")", ";", "}", "else", "{", "/", "/", "decompression", "buffer", "has", "zero", "array", "offset", ",", "so", "we", "don", "'", "t", "need", "to", "worry", "about", "/", "/", "https", ":", "/", "/", "github", "com", "/", "lz", "4", "/", "lz", "4", "-", "java", "/", "pull", "/", "65", "buffer", "size", "=", "decompressor", "decompress", "(", "in", ",", "in", "position", "(", ")", ",", "block", "size", ",", "decompression", "buffer", ",", "0", ",", "max", "block", "size", ")", ";", "}", "decompression", "buffer", "position", "(", "0", ")", ";", "decompression", "buffer", "limit", "(", "buffer", "size", ")", ";", "decompressed", "buffer", "=", "decompression", "buffer", ";", "}", "catch", "(", "l", "z", "4", "exception", "e", ")", "{", "throw", "new", "i", "o", "exception", "(", "e", ")", ";", "}", "}", "else", "{", "decompressed", "buffer", "=", "in", "slice", "(", ")", ";", "decompressed", "buffer", "limit", "(", "block", "size", ")", ";", "}", "/", "/", "verify", "checksum", "if", "(", "flg", "is", "block", "checksum", "set", "(", ")", ")", "{", "/", "/", "workaround", "for", "https", ":", "/", "/", "github", "com", "/", "lz", "4", "/", "lz", "4", "-", "java", "/", "pull", "/", "65", "int", "hash", "=", "in", "has", "array", "(", ")", "?", "checksum", "hash", "(", "in", "array", "(", ")", ",", "in", "array", "offset", "(", ")", "+", "in", "position", "(", ")", ",", "block", "size", ",", "0", ")", ":", "checksum", "hash", "(", "in", ",", "in", "position", "(", ")", ",", "block", "size", ",", "0", ")", ";", "in", "position", "(", "in", "position", "(", ")", "+", "block", "size", ")", ";", "if", "(", "hash", "!", "=", "in", "get", "int", "(", ")", ")", "{", "throw", "new", "i", "o", "exception", "(", "block", "hash", "mismatch", ")", ";", "}", "}", "else", "{", "in", "position", "(", "in", "position", "(", ")", "+", "block", "size", ")", ";", "}", "}" ]

[ "determine", "if", "the", "components", "in", "this", "model", "'", "s", "data", "type", "use", "relative", "offsets", "or", "pointers" ]

[ "protected", "static", "boolean", "is", "relative", "(", "program", "program", ")", "{", "return", "m", "s", "data", "type", "utils", "is", "6", "4", "bit", "(", "program", ")", ";", "/", "/", "may", "need", "more", "here", "later", "}" ]

[ "the", "values", "of", "the", "two", "items", "start", "pc", "and", "end", "pc", "indicate", "the", "ranges", "in", "the", "code", "array", "at", "which", "the", "exception", "handler", "is", "active", "the", "value", "of", "start", "pc", "must", "be", "a", "valid", "index", "into", "the", "code", "array", "of", "the", "opcode", "of", "an", "instruction", "the", "value", "of", "start", "pc", "must", "be", "less", "than", "the", "value", "of", "end", "pc", "the", "start", "pc", "is", "inclusive", "and", "end", "pc", "is", "exclusive", ";", "that", "is", ",", "the", "exception", "handler", "must", "be", "active", "while", "the", "program", "counter", "is", "within", "the", "interval", "[", "start", "pc", ",", "end", "pc", "]" ]

[ "public", "int", "get", "start", "p", "c", "(", ")", "{", "return", "start", "p", "c", "&", "0xffff", ";", "}" ]

[ "get", "the", "current", "zoom", "factor", "the", "image", "is", "being", "drawn", "to" ]

[ "public", "float", "get", "zoom", "factor", "(", ")", "{", "return", "zoom", "levels", "[", "zoom", "level", "index", "]", ";", "}" ]

[ "create", "a", "{", "@", "link", "mount", "spec", "model", "}", "from", "the", "given", "{", "@", "link", "type", "element", "}", "and", "an", "optional", "{", "@", "link", "dependency", "injection", "helper", "}" ]

[ "public", "mount", "spec", "model", "create", "(", "elements", "elements", ",", "types", "types", ",", "type", "element", "element", ",", "messager", "messager", ",", "enum", "set", "<", "run", "mode", ">", "run", "mode", ",", "@", "nullable", "dependency", "injection", "helper", "dependency", "injection", "helper", ",", "@", "nullable", "inter", "stage", "store", "inter", "stage", "store", ")", "{", "return", "new", "mount", "spec", "model", "(", "element", "get", "qualified", "name", "(", ")", "to", "string", "(", ")", ",", "element", "get", "annotation", "(", "mount", "spec", "class", ")", "value", "(", ")", ",", "delegate", "method", "extractor", "get", "delegate", "methods", "(", "element", ",", "delegate", "method", "annotations", ",", "inter", "stage", "input", "annotations", ",", "immutable", "list", "<", "class", "<", "?", "extends", "annotation", ">", ">", "of", "(", "should", "update", "class", ")", ",", "messager", ")", ",", "event", "method", "extractor", "get", "on", "event", "methods", "(", "elements", ",", "element", ",", "inter", "stage", "input", "annotations", ",", "messager", ",", "run", "mode", ")", ",", "trigger", "method", "extractor", "get", "on", "trigger", "methods", "(", "elements", ",", "element", ",", "inter", "stage", "input", "annotations", ",", "messager", ",", "run", "mode", ")", ",", "working", "ranges", "method", "extractor", "get", "register", "method", "(", "element", ",", "inter", "stage", "input", "annotations", ",", "messager", ")", ",", "working", "ranges", "method", "extractor", "get", "ranges", "methods", "(", "elements", ",", "element", ",", "inter", "stage", "input", "annotations", ",", "messager", ")", ",", "update", "state", "method", "extractor", "get", "on", "update", "state", "methods", "(", "element", ",", "inter", "stage", "input", "annotations", ",", "messager", ")", ",", "update", "state", "method", "extractor", "get", "on", "update", "state", "with", "transition", "methods", "(", "element", ",", "inter", "stage", "input", "annotations", ",", "messager", ")", ",", "inter", "stage", "store", "=", "=", "null", "?", "immutable", "list", "of", "(", ")", ":", "cached", "prop", "name", "extractor", "get", "cached", "prop", "names", "(", "inter", "stage", "store", ",", "element", "get", "qualified", "name", "(", ")", ")", ",", "immutable", "list", "copy", "of", "(", "type", "variables", "extractor", "get", "type", "variables", "(", "element", ")", ")", ",", "immutable", "list", "copy", "of", "(", "prop", "defaults", "extractor", "get", "prop", "defaults", "(", "element", ")", ")", ",", "event", "declarations", "extractor", "get", "event", "declarations", "(", "elements", ",", "element", ",", "mount", "spec", "class", ",", "run", "mode", ")", ",", "javadoc", "extractor", "get", "class", "javadoc", "(", "elements", ",", "element", ")", ",", "annotation", "extractor", "extract", "valid", "annotations", "(", "element", ")", ",", "tag", "extractor", "extract", "tags", "from", "spec", "class", "(", "types", ",", "element", ",", "run", "mode", ")", ",", "javadoc", "extractor", "get", "prop", "javadocs", "(", "elements", ",", "element", ")", ",", "element", "get", "annotation", "(", "mount", "spec", "class", ")", "is", "public", "(", ")", ",", "dependency", "injection", "helper", ",", "element", "get", "annotation", "(", "mount", "spec", "class", ")", "is", "pure", "render", "(", ")", ",", "element", "get", "annotation", "(", "mount", "spec", "class", ")", "has", "child", "litho", "views", "(", ")", ",", "element", "get", "annotation", "(", "mount", "spec", "class", ")", "pool", "size", "(", ")", ",", "element", "get", "annotation", "(", "mount", "spec", "class", ")", "can", "preallocate", "(", ")", ",", "get", "mount", "type", "(", "elements", ",", "element", ",", "run", "mode", ")", ",", "spec", "element", "type", "determinator", "determine", "(", "element", ")", ",", "element", ",", "m", "mount", "spec", "generator", ",", "fields", "extractor", "extract", "fields", "(", "element", ")", ",", "bind", "dynamic", "values", "method", "extractor", "get", "on", "bind", "dynamic", "values", "methods", "(", "element", ",", "messager", ")", ")", ";", "}" ]

[ "{", "@", "inherit", "doc", "}", "this", "implementation", "is", "empty" ]

[ "public", "void", "configure", "default", "servlet", "handling", "(", "default", "servlet", "handler", "configurer", "configurer", ")", "{", "}" ]

[ "resolves", "to", "member", "list" ]

[ "public", "static", "collection", "<", "member", ">", "multi", "parse", "(", "collection", "<", "string", ">", "addresses", ")", "{", "list", "<", "member", ">", "members", "=", "new", "array", "list", "<", ">", "(", "addresses", "size", "(", ")", ")", ";", "for", "(", "string", "address", ":", "addresses", ")", "{", "member", "member", "=", "single", "parse", "(", "address", ")", ";", "members", "add", "(", "member", ")", ";", "}", "return", "members", ";", "}" ]

[ "the", "value", "assigned", "to", "this", "element", "<", "code", ">", "optional", "aapt", "pb", "item", "item", "=", "3", ";", "<", "code", ">" ]

[ "public", "com", "android", "aapt", "resources", "item", "get", "item", "(", ")", "{", "return", "item", "=", "=", "null", "?", "com", "android", "aapt", "resources", "item", "get", "default", "instance", "(", ")", ":", "item", ";", "}" ]

[ "sends", "trailers", "to", "the", "remote", "end", "point", "this", "call", "implies", "end", "of", "stream" ]

[ "void", "write", "trailers", "(", "metadata", "trailers", ",", "boolean", "headers", "sent", ",", "status", "status", ")", ";" ]

[ "reads", "the", "next", "word", "of", "the", "configuration", "in", "the", "'", "next", "word", "'", "field", ",", "throwing", "an", "exception", "if", "there", "is", "no", "next", "word" ]

[ "private", "void", "read", "next", "word", "(", "string", "expected", "description", ",", "boolean", "is", "file", "name", ",", "boolean", "expecting", "at", "character", ")", "throws", "parse", "exception", ",", "i", "o", "exception", "{", "read", "next", "word", "(", "is", "file", "name", ")", ";", "if", "(", "configuration", "end", "(", "expecting", "at", "character", ")", ")", "{", "throw", "new", "parse", "exception", "(", "\"", "expecting", "\"", "+", "expected", "description", "+", "\"", "before", "\"", "+", "reader", "location", "description", "(", ")", ")", ";", "}", "}" ]

[ "factory", "for", "labels", "from", "absolute", "string", "form", "e", "g", "foobar", "foobar", ":", "quux", "{", "@", "literal", "@", "}", "foo", "{", "@", "literal", "@", "}", "foobar", "{", "@", "literal", "@", "}", "foobar", ":", "baz", "treats", "labels", "in", "the", "default", "repository", "as", "being", "in", "the", "main", "repository", "instead", "labels", "that", "begin", "with", "a", "repository", "name", "may", "have", "the", "repository", "name", "remapped", "to", "a", "different", "name", "if", "it", "appears", "in", "{", "@", "code", "repository", "mapping", "}", "this", "happens", "if", "the", "current", "repository", "being", "evaluated", "is", "external", "to", "the", "main", "repository", "and", "the", "main", "repository", "set", "the", "{", "@", "code", "repo", "mapping", "}", "attribute", "when", "declaring", "this", "repository" ]

[ "public", "static", "label", "parse", "absolute", "(", "string", "abs", "name", ",", "immutable", "map", "<", "repository", "name", ",", "repository", "name", ">", "repository", "mapping", ")", "throws", "label", "syntax", "exception", "{", "return", "parse", "absolute", "(", "abs", "name", ",", "/", "*", "default", "to", "main", "=", "*", "/", "true", ",", "repository", "mapping", ")", ";", "}" ]

[ "the", "request", "from", "clients", "to", "get", "a", "report", "of", "applications", "matching", "the", "giving", "application", "states", "in", "the", "cluster", "from", "the", "<", "code", ">", "resource", "manager", "<", "code", ">" ]

[ "public", "static", "get", "applications", "request", "new", "instance", "(", "enum", "set", "<", "yarn", "application", "state", ">", "application", "states", ")", "{", "get", "applications", "request", "request", "=", "records", "new", "record", "(", "get", "applications", "request", "class", ")", ";", "request", "set", "application", "states", "(", "application", "states", ")", ";", "return", "request", ";", "}" ]

[ "similar", "to", "{", "@", "link", "#", "set", "variable", "local", "(", "string", ",", "object", ")", "}", ",", "but", "for", "a", "transient", "variable", "see", "{", "@", "link", "#", "set", "transient", "variable", "(", "string", ",", "object", ")", "}", "for", "the", "rules", "on", "'", "transient", "'", "variables" ]

[ "void", "set", "transient", "variable", "local", "(", "string", "variable", "name", ",", "object", "variable", "value", ")", ";" ]

[ "the", "position", "where", "the", "value", "size", "is", "stored" ]

[ "private", "int", "value", "size", "offset", "(", ")", "{", "if", "(", "magic", "(", ")", "=", "=", "record", "batch", "magic", "value", "v0", ")", "return", "key", "offset", "v0", "+", "math", "max", "(", "0", ",", "key", "size", "(", ")", ")", ";", "else", "return", "key", "offset", "v1", "+", "math", "max", "(", "0", ",", "key", "size", "(", ")", ")", ";", "}" ]

[ "create", "a", "new", "direct", "field", "accessor", "for", "the", "underlying", "target", "object" ]

[ "protected", "configurable", "property", "accessor", "create", "direct", "field", "accessor", "(", ")", "{", "if", "(", "this", "target", "=", "=", "null", ")", "{", "throw", "new", "illegal", "state", "exception", "(", "\"", "cannot", "access", "fields", "on", "null", "target", "instance", "'", "\"", "+", "get", "object", "name", "(", ")", "+", "\"", "'", "\"", ")", ";", "}", "return", "property", "accessor", "factory", "for", "direct", "field", "access", "(", "this", "target", ")", ";", "}" ]

[ "returns", "ending", "address", ",", "exclusive" ]

[ "public", "long", "get", "to", "(", ")", "{", "return", "this", "end", ";", "}" ]

[ "utility", "method", "for", "creating", "baseline", "properties", "for", "unit", "tests" ]

[ "/", "*", "package", "*", "/", "static", "hystrix", "command", "properties", "setter", "get", "unit", "test", "properties", "setter", "(", ")", "{", "return", "new", "hystrix", "command", "properties", "setter", "(", ")", "with", "execution", "timeout", "in", "milliseconds", "(", "1000", ")", "/", "/", "when", "an", "execution", "will", "be", "timed", "out", "with", "execution", "timeout", "enabled", "(", "true", ")", "with", "execution", "isolation", "strategy", "(", "execution", "isolation", "strategy", "thread", ")", "/", "/", "we", "want", "thread", "execution", "by", "default", "in", "tests", "with", "execution", "isolation", "thread", "interrupt", "on", "timeout", "(", "true", ")", "with", "execution", "isolation", "thread", "interrupt", "on", "future", "cancel", "(", "true", ")", "with", "circuit", "breaker", "force", "open", "(", "false", ")", "/", "/", "we", "don", "'", "t", "want", "short", "-", "circuiting", "by", "default", "with", "circuit", "breaker", "error", "threshold", "percentage", "(", "40", ")", "/", "/", "%", "of", "'", "marks", "'", "that", "must", "be", "failed", "to", "trip", "the", "circuit", "with", "metrics", "rolling", "statistical", "window", "in", "milliseconds", "(", "5000", ")", "/", "/", "milliseconds", "back", "that", "will", "be", "tracked", "with", "metrics", "rolling", "statistical", "window", "buckets", "(", "5", ")", "/", "/", "buckets", "with", "circuit", "breaker", "request", "volume", "threshold", "(", "0", ")", "/", "/", "in", "testing", "we", "will", "not", "have", "a", "threshold", "unless", "we", "'", "re", "specifically", "testing", "that", "feature", "with", "circuit", "breaker", "sleep", "window", "in", "milliseconds", "(", "5000000", ")", "/", "/", "milliseconds", "after", "tripping", "circuit", "before", "allowing", "retry", "(", "by", "default", "set", "very", "long", "as", "we", "want", "it", "to", "effectively", "never", "allow", "a", "single", "test", "for", "most", "unit", "tests", ")", "with", "circuit", "breaker", "enabled", "(", "true", ")", "with", "request", "log", "enabled", "(", "true", ")", "with", "execution", "isolation", "semaphore", "max", "concurrent", "requests", "(", "20", ")", "with", "fallback", "isolation", "semaphore", "max", "concurrent", "requests", "(", "10", ")", "with", "fallback", "enabled", "(", "true", ")", "with", "circuit", "breaker", "force", "closed", "(", "false", ")", "with", "metrics", "rolling", "percentile", "enabled", "(", "true", ")", "with", "request", "cache", "enabled", "(", "true", ")", "with", "metrics", "rolling", "percentile", "window", "in", "milliseconds", "(", "60000", ")", "with", "metrics", "rolling", "percentile", "window", "buckets", "(", "12", ")", "with", "metrics", "rolling", "percentile", "bucket", "size", "(", "1000", ")", "with", "metrics", "health", "snapshot", "interval", "in", "milliseconds", "(", "100", ")", ";", "}" ]

[ "concatenates", "a", "sequence", "to", "the", "end", "of", "another", "sequence", "and", "returns", "a", "new", "sequence" ]

[ "public", "ditted", "bit", "sequence", "concatenate", "(", "ditted", "bit", "sequence", "to", "conat", ")", "{", "ditted", "bit", "sequence", "res", "=", "new", "ditted", "bit", "sequence", "(", ")", ";", "res", "bits", "=", "new", "byte", "[", "bits", "length", "+", "to", "conat", "bits", "length", "]", ";", "res", "dits", "=", "new", "byte", "[", "res", "bits", "length", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "bits", "length", ";", "+", "+", "i", ")", "{", "res", "bits", "[", "i", "]", "=", "bits", "[", "i", "]", ";", "res", "dits", "[", "i", "]", "=", "dits", "[", "i", "]", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "to", "conat", "bits", "length", ";", "+", "+", "i", ")", "{", "res", "bits", "[", "bits", "length", "+", "i", "]", "=", "to", "conat", "bits", "[", "i", "]", ";", "res", "dits", "[", "bits", "length", "+", "i", "]", "=", "to", "conat", "dits", "[", "i", "]", ";", "}", "return", "res", ";", "}" ]

[ "expect", "the", "exact", "head", "and", "list", "requests", "of", "the", "operation", "cost", "supplied" ]

[ "public", "static", "expected", "probe", "expect", "(", "boolean", "enabled", ",", "operation", "cost", "cost", ")", "{", "return", "probes", "(", "enabled", ",", "probe", "(", "object", "metadata", "requests", ",", "cost", "head", "(", ")", ")", ",", "probe", "(", "object", "list", "request", ",", "cost", "list", "(", ")", ")", ")", ";", "}" ]

[ "validate", "all", "required", "params" ]

[ "protected", "void", "validate", "op", "params", "(", "http", "op", "param", "<", "?", ">", "op", ",", "param", "params", ")", "{", "for", "(", "param", "param", ":", "params", ")", "{", "if", "(", "param", "get", "value", "(", ")", "=", "=", "null", "|", "|", "param", "get", "value", "string", "(", ")", "=", "=", "null", "|", "|", "param", "get", "value", "string", "(", ")", "is", "empty", "(", ")", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "required", "param", "\"", "+", "param", "get", "name", "(", ")", "+", "\"", "for", "op", ":", "\"", "+", "op", "get", "value", "string", "(", ")", "+", "\"", "is", "null", "or", "empty", "\"", ")", ";", "}", "}", "}" ]

[ "creates", "a", "key", "for", "a", "binary", "header", ",", "serializing", "to", "input", "streams" ]

[ "public", "static", "<", "t", ">", "key", "<", "t", ">", "of", "(", "string", "name", ",", "binary", "stream", "marshaller", "<", "t", ">", "marshaller", ")", "{", "return", "new", "lazy", "stream", "binary", "key", "<", ">", "(", "name", ",", "marshaller", ")", ";", "}" ]

[ "reads", "num", "to", "read", "bytes", "from", "the", "stream", "starting", "at", "stream", "offset", "within", "the", "stream", "the", "bytes", "are", "written", "into", "the", "bytes", "array", "starting", "at", "the", "bytes", "offset", "location", "if", "not", "all", "bytes", "are", "available", "to", "be", "read", ",", "an", "i", "o", "exception", "will", "be", "thrown" ]

[ "public", "void", "read", "(", "int", "stream", "offset", ",", "byte", "[", "]", "bytes", ",", "int", "bytes", "offset", ",", "int", "num", "to", "read", ",", "task", "monitor", "monitor", ")", "throws", "i", "o", "exception", ",", "cancelled", "exception", "{", "if", "(", "stream", "offset", "<", "0", "|", "|", "stream", "offset", ">", "stream", "length", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "offset", "out", "of", "range", "\"", ")", ";", "}", "if", "(", "num", "to", "read", ">", "stream", "length", "-", "stream", "offset", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "not", "enough", "data", "left", "\"", ")", ";", "}", "if", "(", "num", "to", "read", "<", "=", "0", ")", "{", "return", ";", "}", "int", "remaining", "byte", "count", "=", "num", "to", "read", ";", "int", "page", "number", "=", "stream", "offset", ">", ">", "msf", "get", "log", "2", "page", "size", "(", ")", ";", "int", "offset", "into", "page", "=", "stream", "offset", "&", "msf", "get", "page", "size", "mod", "mask", "(", ")", ";", "/", "/", "read", "any", "partial", "page", "at", "beginning", "first", "if", "(", "offset", "into", "page", "!", "=", "0", ")", "{", "int", "first", "num", "to", "read", "=", "math", "min", "(", "msf", "get", "page", "size", "(", ")", "-", "offset", "into", "page", ",", "remaining", "byte", "count", ")", ";", "msf", "file", "reader", "read", "(", "page", "list", "get", "(", "page", "number", ")", ",", "offset", "into", "page", ",", "first", "num", "to", "read", ",", "bytes", ",", "bytes", "offset", ")", ";", "if", "(", "(", "remaining", "byte", "count", "-", "first", "num", "to", "read", ")", ">", "remaining", "byte", "count", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "integer", "count", "underflow", "when", "preparing", "to", "read", "\"", ")", ";", "}", "remaining", "byte", "count", "-", "=", "first", "num", "to", "read", ";", "page", "number", "+", "+", ";", "bytes", "offset", "+", "=", "first", "num", "to", "read", ";", "}", "/", "/", "read", "remaining", "pages", ",", "including", "last", "as", "possible", "partial", "page", "/", "/", "outer", "loop", "iterates", "over", "possible", "non", "-", "sequential", "groups", "while", "(", "remaining", "byte", "count", ">", "0", ")", "{", "monitor", "check", "canceled", "(", ")", ";", "/", "/", "inner", "loop", "groups", "together", "sequential", "pages", "into", "one", "big", "read", "int", "first", "sequential", "page", "number", "=", "page", "list", "get", "(", "page", "number", ")", ";", "int", "last", "sequential", "page", "number", "=", "first", "sequential", "page", "number", ";", "int", "num", "to", "read", "in", "sequential", "pages", "=", "0", ";", "do", "{", "monitor", "check", "canceled", "(", ")", ";", "page", "number", "+", "+", ";", "last", "sequential", "page", "number", "+", "+", ";", "int", "num", "to", "read", "in", "page", "=", "math", "min", "(", "msf", "get", "page", "size", "(", ")", ",", "remaining", "byte", "count", ")", ";", "num", "to", "read", "in", "sequential", "pages", "+", "=", "num", "to", "read", "in", "page", ";", "remaining", "byte", "count", "-", "=", "num", "to", "read", "in", "page", ";", "}", "while", "(", "remaining", "byte", "count", ">", "0", "&", "&", "page", "list", "get", "(", "page", "number", ")", "=", "=", "last", "sequential", "page", "number", ")", ";", "msf", "file", "reader", "read", "(", "first", "sequential", "page", "number", ",", "0", ",", "num", "to", "read", "in", "sequential", "pages", ",", "bytes", ",", "bytes", "offset", ")", ";", "bytes", "offset", "+", "=", "num", "to", "read", "in", "sequential", "pages", ";", "}", "}" ]

[ "opaque", "annotations", "extending", "the", "node", "identifier", "<", "code", ">", "map", "&", "lt", ";", "string", ",", "string", "&", "gt", ";", "annotations", "=", "2", ";", "<", "code", ">" ]

[ "java", "lang", "string", "get", "annotations", "or", "throw", "(", "java", "lang", "string", "key", ")", ";" ]

[ "sets", "the", "implicit", "outputs", "function", "of", "the", "rule", "class", "the", "default", "implicit", "outputs", "function", "is", "{", "@", "link", "implicit", "outputs", "function", "#", "none", "}", "this", "property", "is", "not", "inherited", "and", "this", "method", "should", "not", "be", "called", "by", "builder", "of", "{", "@", "link", "rule", "class", "type", "#", "abstract", "}", "rule", "class" ]

[ "public", "builder", "set", "implicit", "outputs", "function", "(", "implicit", "outputs", "function", "implicit", "outputs", "function", ")", "{", "preconditions", "check", "state", "(", "type", "!", "=", "rule", "class", "type", "abstract", ",", "\"", "setting", "not", "inherited", "property", "(", "implicit", "output", "function", ")", "of", "abstract", "rule", "class", "'", "%", "s", "'", "\"", ",", "name", ")", ";", "this", "implicit", "outputs", "function", "=", "implicit", "outputs", "function", ";", "return", "this", ";", "}" ]

[ "returns", "true", "iff", "this", "file", "is", "a", "regular", "file" ]

[ "public", "boolean", "is", "regular", "file", "(", ")", "{", "return", "(", "st", "mode", "&", "s", "ifmt", ")", "=", "=", "s", "ifreg", ";", "}" ]

[ "determine", "the", "property", "type", "for", "the", "given", "property", "path", "called", "by", "{", "@", "link", "#", "find", "custom", "editor", "}", "if", "no", "required", "type", "has", "been", "specified", ",", "to", "be", "able", "to", "find", "a", "type", "-", "specific", "editor", "even", "if", "just", "given", "a", "property", "path", "the", "default", "implementation", "always", "returns", "{", "@", "code", "null", "}", "bean", "wrapper", "impl", "overrides", "this", "with", "the", "standard", "{", "@", "code", "get", "property", "type", "}", "method", "as", "defined", "by", "the", "bean", "wrapper", "interface" ]

[ "protected", "class", "<", "?", ">", "get", "property", "type", "(", "string", "property", "path", ")", "{", "return", "null", ";", "}" ]

[ "returns", "a", "copy", "of", "the", "remaining", "bytes" ]

[ "public", "byte", "[", "]", "get", "remaining", "bytes", "(", ")", "{", "byte", "[", "]", "bytes", "=", "new", "byte", "[", "b", "length", "-", "offset", "]", ";", "system", "arraycopy", "(", "b", ",", "offset", ",", "bytes", ",", "0", ",", "b", "length", "-", "offset", ")", ";", "return", "bytes", ";", "}" ]

[ "sends", "the", "response", "headers", "to", "the", "client" ]

[ "private", "void", "send", "response", "headers", "(", "channel", "handler", "context", "ctx", ",", "send", "response", "headers", "command", "cmd", ",", "channel", "promise", "promise", ")", "throws", "http", "2", "exception", "{", "perf", "mark", "start", "task", "(", "\"", "netty", "server", "handler", "send", "response", "headers", "\"", ",", "cmd", "stream", "(", ")", "tag", "(", ")", ")", ";", "perf", "mark", "link", "in", "(", "cmd", "get", "link", "(", ")", ")", ";", "try", "{", "/", "/", "todo", "(", "carl", "-", "mastrangelo", ")", ":", "remove", "this", "check", "once", "https", ":", "/", "/", "github", "com", "/", "netty", "/", "netty", "/", "issues", "/", "6296", "/", "/", "is", "fixed", "int", "stream", "id", "=", "cmd", "stream", "(", ")", "id", "(", ")", ";", "http", "2", "stream", "stream", "=", "connection", "(", ")", "stream", "(", "stream", "id", ")", ";", "if", "(", "stream", "=", "=", "null", ")", "{", "reset", "stream", "(", "ctx", ",", "stream", "id", ",", "http", "2", "error", "cancel", "code", "(", ")", ",", "promise", ")", ";", "return", ";", "}", "if", "(", "cmd", "end", "of", "stream", "(", ")", ")", "{", "close", "stream", "when", "done", "(", "promise", ",", "stream", "id", ")", ";", "}", "encoder", "(", ")", "write", "headers", "(", "ctx", ",", "stream", "id", ",", "cmd", "headers", "(", ")", ",", "0", ",", "cmd", "end", "of", "stream", "(", ")", ",", "promise", ")", ";", "}", "finally", "{", "perf", "mark", "stop", "task", "(", "\"", "netty", "server", "handler", "send", "response", "headers", "\"", ",", "cmd", "stream", "(", ")", "tag", "(", ")", ")", ";", "}", "}" ]

[ "the", "smallest", "integer", "allowed", "for", "this", "xml", "attribute", "only", "makes", "sense", "if", "the", "format", "includes", "format", "flags", ":", ":", "integer", "<", "code", ">", "optional", "int", "3", "2", "min", "int", "=", "2", ";", "<", "code", ">" ]

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

[ "marks", "this", "event", "as", "handled", "this", "does", "not", "affect", "event", "propagation", "inside", "scene", "2d", ",", "but", "causes", "the", "{", "@", "link", "stage", "}", "{", "@", "link", "input", "processor", "}", "methods", "to", "return", "true", ",", "which", "will", "eat", "the", "event", "so", "it", "is", "not", "passed", "on", "to", "the", "application", "under", "the", "stage" ]

[ "public", "void", "handle", "(", ")", "{", "handled", "=", "true", ";", "}" ]

[ "combine", "the", "value", "of", "records", "in", "this", "stream", "by", "the", "grouped", "key", "records", "with", "{", "@", "code", "null", "}", "key", "or", "value", "are", "ignored", "combining", "implies", "that", "the", "type", "of", "the", "aggregate", "result", "is", "the", "same", "as", "the", "type", "of", "the", "input", "value", "(", "c", "f", "{", "@", "link", "#", "aggregate", "(", "initializer", ",", "aggregator", ",", "materialized", ")", "}", ")", "the", "result", "is", "written", "into", "a", "local", "{", "@", "link", "key", "value", "store", "}", "(", "which", "is", "basically", "an", "ever", "-", "updating", "materialized", "view", ")", "provided", "by", "the", "given", "store", "name", "in", "{", "@", "code", "materialized", "}", "furthermore", ",", "updates", "to", "the", "store", "are", "sent", "downstream", "into", "a", "{", "@", "link", "k", "table", "}", "changelog", "stream", "the", "specified", "{", "@", "link", "reducer", "}", "is", "applied", "for", "each", "input", "record", "and", "computes", "a", "new", "aggregate", "using", "the", "current", "aggregate", "(", "first", "argument", ")", "and", "the", "record", "'", "s", "value", "(", "second", "argument", ")", ":", "{", "@", "code", "at", "the", "example", "of", "a", "reducer", "<", "long", ">", "new", "reducer", "<", "long", ">", "(", ")", "{", "public", "long", "apply", "(", "long", "agg", "value", ",", "long", "curr", "value", ")", "{", "return", "agg", "value", "+", "curr", "value", ";", "}", "}", "}", "if", "there", "is", "no", "current", "aggregate", "the", "{", "@", "link", "reducer", "}", "is", "not", "applied", "and", "the", "new", "aggregate", "will", "be", "the", "record", "'", "s", "value", "as", "-", "is", "thus", ",", "{", "@", "code", "reduce", "(", "reducer", ",", "materialized", ")", "}", "can", "be", "used", "to", "compute", "aggregate", "functions", "like", "sum", ",", "min", ",", "or", "max", "not", "all", "updates", "might", "get", "sent", "downstream", ",", "as", "an", "internal", "cache", "is", "used", "to", "deduplicate", "consecutive", "updates", "to", "the", "same", "key", "the", "rate", "of", "propagated", "updates", "depends", "on", "your", "input", "data", "rate", ",", "the", "number", "of", "distinct", "keys", ",", "the", "number", "of", "parallel", "running", "kafka", "streams", "instances", ",", "and", "the", "{", "@", "link", "streams", "config", "configuration", "}", "parameters", "for", "{", "@", "link", "streams", "config", "#", "cache", "max", "bytes", "buffering", "config", "cache", "size", "}", ",", "and", "{", "@", "link", "streams", "config", "#", "commit", "interval", "ms", "config", "commit", "interval", "}", "to", "query", "the", "local", "{", "@", "link", "read", "only", "key", "value", "store", "}", "it", "must", "be", "obtained", "via", "{", "@", "link", "kafka", "streams", "#", "store", "(", "store", "query", "parameters", ")", "kafka", "streams", "#", "store", "(", ")", "}", "{", "@", "code", "kafka", "streams", "streams", "=", "compute", "sum", "string", "queryable", "store", "name", "=", "\"", "store", "name", "\"", "the", "store", "name", "should", "be", "the", "name", "of", "the", "store", "as", "defined", "by", "the", "materialized", "instance", "read", "only", "key", "value", "store", "<", "k", ",", "value", "and", "timestamp", "<", "v", ">", ">", "local", "store", "=", "streams", "store", "(", "queryable", "store", "name", ",", "queryable", "store", "types", "<", "k", ",", "value", "and", "timestamp", "<", "v", ">", ">", "timestamped", "key", "value", "store", "(", ")", ")", ";", "k", "key", "=", "\"", "some", "-", "key", "\"", ";", "value", "and", "timestamp", "<", "v", ">", "reduce", "for", "key", "=", "local", "store", "get", "(", "key", ")", ";", "key", "must", "be", "local", "(", "application", "state", "is", "shared", "over", "all", "running", "kafka", "streams", "instances", ")", "}", "for", "non", "-", "local", "keys", ",", "a", "custom", "rpc", "mechanism", "must", "be", "implemented", "using", "{", "@", "link", "kafka", "streams", "#", "all", "metadata", "(", ")", "}", "to", "query", "the", "value", "of", "the", "key", "on", "a", "parallel", "running", "instance", "of", "your", "kafka", "streams", "application", "for", "failure", "and", "recovery", "the", "store", "(", "which", "always", "will", "be", "of", "type", "{", "@", "link", "timestamped", "key", "value", "store", "}", "-", "-", "regardless", "of", "what", "is", "specified", "in", "the", "parameter", "{", "@", "code", "materialized", "}", ")", "will", "be", "backed", "by", "an", "internal", "changelog", "topic", "that", "will", "be", "created", "in", "kafka", "the", "changelog", "topic", "will", "be", "named", "\"", "$", "{", "application", "id", "}", "-", "$", "{", "internal", "store", "name", "}", "-", "changelog", "\"", ",", "where", "\"", "application", "id", "\"", "is", "user", "-", "specified", "in", "{", "@", "link", "streams", "config", "}", "via", "parameter", "{", "@", "link", "streams", "config", "#", "application", "id", "config", "application", "id", "config", "}", ",", "\"", "internal", "store", "name", "\"", "is", "an", "internal", "name", "and", "\"", "-", "changelog", "\"", "is", "a", "fixed", "suffix", "note", "that", "the", "internal", "store", "name", "may", "not", "be", "queryable", "through", "interactive", "queries", "you", "can", "retrieve", "all", "generated", "internal", "topic", "names", "via", "{", "@", "link", "topology", "#", "describe", "(", ")", "}" ]

[ "k", "table", "<", "k", ",", "v", ">", "reduce", "(", "final", "reducer", "<", "v", ">", "reducer", ",", "final", "materialized", "<", "k", ",", "v", ",", "key", "value", "store", "<", "bytes", ",", "byte", "[", "]", ">", ">", "materialized", ")", ";" ]

[ "override", "this", "method", "to", "supports", "multiple", "paths", "when", "this", "method", "will", "be", "removed", ",", "all", "file", "input", "formats", "have", "to", "support", "multiple", "paths" ]

[ "public", "boolean", "supports", "multi", "paths", "(", ")", "{", "return", "false", ";", "}" ]

[ "tests", "that", "connections", "can", "be", "made", "with", "t", "l", "sv", "1", "2", "cipher", "suite" ]

[ "public", "void", "test", "ciphers", "suite", "for", "tls", "1", "2", "(", ")", "throws", "exception", "{", "string", "cipher", "suite", "=", "\"", "tls", "ecdhe", "rsa", "with", "aes", "256", "gcm", "sha384", "\"", ";", "ssl", "server", "configs", "put", "(", "ssl", "configs", "ssl", "enabled", "protocols", "config", ",", "arrays", "as", "list", "(", "ssl", "configs", "default", "ssl", "enabled", "protocols", "split", "(", "\"", ",", "\"", ")", ")", ")", ";", "ssl", "server", "configs", "put", "(", "ssl", "configs", "ssl", "cipher", "suites", "config", ",", "collections", "singleton", "list", "(", "cipher", "suite", ")", ")", ";", "server", "=", "network", "test", "utils", "create", "echo", "server", "(", "listener", "name", "for", "security", "protocol", "(", "security", "protocol", "ssl", ")", ",", "security", "protocol", "ssl", ",", "new", "test", "security", "config", "(", "ssl", "server", "configs", ")", ",", "null", ",", "time", ")", ";", "ssl", "client", "configs", "put", "(", "ssl", "configs", "ssl", "enabled", "protocols", "config", ",", "arrays", "as", "list", "(", "ssl", "configs", "default", "ssl", "enabled", "protocols", "split", "(", "\"", ",", "\"", ")", ")", ")", ";", "ssl", "client", "configs", "put", "(", "ssl", "configs", "ssl", "cipher", "suites", "config", ",", "collections", "singleton", "list", "(", "cipher", "suite", ")", ")", ";", "check", "authentication", "succeed", "(", ")", ";", "}" ]

[ "find", "object", "(", "case", "-", "sensitive", ")" ]

[ "public", "static", "<", "t", "extends", "d", "b", "p", "named", "object", ">", "t", "find", "object", "(", "@", "nullable", "t", "[", "]", "the", "list", ",", "string", "object", "name", ")", "{", "if", "(", "the", "list", "!", "=", "null", "&", "&", "the", "list", "length", ">", "0", ")", "{", "for", "(", "t", "object", ":", "the", "list", ")", "{", "if", "(", "object", "get", "name", "(", ")", "equals", "(", "object", "name", ")", ")", "{", "return", "object", ";", "}", "}", "}", "return", "null", ";", "}" ]

[ "transform", "saml", "object", "t" ]

[ "public", "static", "<", "t", "extends", "x", "m", "l", "object", ">", "t", "transform", "saml", "object", "(", "final", "open", "saml", "config", "bean", "config", "bean", ",", "final", "byte", "[", "]", "data", ",", "final", "class", "<", "t", ">", "clazz", ")", "{", "if", "(", "data", "!", "=", "null", "&", "&", "data", "length", ">", "0", ")", "{", "try", "(", "val", "in", "=", "new", "byte", "array", "input", "stream", "(", "data", ")", ")", "{", "val", "document", "=", "config", "bean", "get", "parser", "pool", "(", ")", "parse", "(", "in", ")", ";", "val", "root", "=", "document", "get", "document", "element", "(", ")", ";", "val", "marshaller", "=", "config", "bean", "get", "unmarshaller", "factory", "(", ")", "get", "unmarshaller", "(", "root", ")", ";", "if", "(", "marshaller", "!", "=", "null", ")", "{", "val", "result", "=", "marshaller", "unmarshall", "(", "root", ")", ";", "if", "(", "!", "clazz", "is", "assignable", "from", "(", "result", "get", "class", "(", ")", ")", ")", "{", "throw", "new", "class", "cast", "exception", "(", "\"", "result", "[", "\"", "+", "result", "+", "\"", "is", "of", "type", "\"", "+", "result", "get", "class", "(", ")", "+", "\"", "when", "we", "were", "expecting", "\"", "+", "clazz", ")", ";", "}", "return", "(", "t", ")", "result", ";", "}", "}", "catch", "(", "final", "exception", "e", ")", "{", "throw", "new", "saml", "exception", "(", "e", "get", "message", "(", ")", ",", "e", ")", ";", "}", "}", "return", "null", ";", "}" ]

[ "test", "hdfs", "operations", "that", "change", "disk", "space", "consumed", "by", "a", "directory", "tree", "namely", "create", ",", "rename", ",", "delete", ",", "append", ",", "and", "set", "replication", "this", "is", "based", "on", "test", "namespace", "commands", "(", ")", "above" ]

[ "public", "void", "test", "space", "commands", "(", ")", "throws", "exception", "{", "final", "path", "parent", "=", "new", "path", "(", "path", "utils", "get", "test", "dir", "(", "get", "class", "(", ")", ")", "get", "path", "(", ")", ",", "generic", "test", "utils", "get", "method", "name", "(", ")", ")", ";", "assert", "true", "(", "dfs", "mkdirs", "(", "parent", ")", ")", ";", "int", "file", "len", "=", "1024", ";", "short", "replication", "=", "3", ";", "int", "file", "space", "=", "file", "len", "*", "replication", ";", "/", "/", "create", "directory", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "0", "/", "nqdir", "3", "0", "assert", "true", "(", "dfs", "mkdirs", "(", "new", "path", "(", "parent", ",", "\"", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "0", "/", "nqdir", "3", "0", "\"", ")", ")", ")", ";", "/", "/", "set", "the", "quota", "of", "nqdir", "0", "/", "qdir", "1", "to", "4", "*", "file", "space", "final", "path", "quota", "dir", "1", "=", "new", "path", "(", "parent", ",", "\"", "nqdir", "0", "/", "qdir", "1", "\"", ")", ";", "dfs", "set", "quota", "(", "quota", "dir", "1", ",", "hdfs", "constants", "quota", "dont", "set", ",", "4", "*", "file", "space", ")", ";", "content", "summary", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "1", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "1", ")", ";", "assert", "equals", "(", "c", "get", "space", "quota", "(", ")", ",", "4", "*", "file", "space", ")", ";", "/", "/", "set", "the", "quota", "of", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "0", "to", "6", "*", "file", "space", "final", "path", "quota", "dir", "2", "0", "=", "new", "path", "(", "parent", ",", "\"", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "0", "\"", ")", ";", "dfs", "set", "quota", "(", "quota", "dir", "2", "0", ",", "hdfs", "constants", "quota", "dont", "set", ",", "6", "*", "file", "space", ")", ";", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "0", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "0", ")", ";", "assert", "equals", "(", "c", "get", "space", "quota", "(", ")", ",", "6", "*", "file", "space", ")", ";", "/", "/", "create", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "1", "and", "set", "its", "space", "quota", "to", "2", "*", "file", "space", "final", "path", "quota", "dir", "2", "1", "=", "new", "path", "(", "parent", ",", "\"", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "1", "\"", ")", ";", "assert", "true", "(", "dfs", "mkdirs", "(", "quota", "dir", "2", "1", ")", ")", ";", "dfs", "set", "quota", "(", "quota", "dir", "2", "1", ",", "hdfs", "constants", "quota", "dont", "set", ",", "2", "*", "file", "space", ")", ";", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "1", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "1", ")", ";", "assert", "equals", "(", "c", "get", "space", "quota", "(", ")", ",", "2", "*", "file", "space", ")", ";", "/", "/", "5", ":", "create", "directory", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "1", "/", "nqdir", "3", "2", "path", "temp", "path", "=", "new", "path", "(", "quota", "dir", "2", "1", ",", "\"", "nqdir", "3", "2", "\"", ")", ";", "assert", "true", "(", "dfs", "mkdirs", "(", "temp", "path", ")", ")", ";", "/", "/", "create", "a", "file", "under", "nqdir", "3", "2", "/", "file", "dir", "d", "f", "s", "test", "util", "create", "file", "(", "dfs", ",", "new", "path", "(", "temp", "path", ",", "\"", "file", "dir", "/", "file", "1", "\"", ")", ",", "file", "len", ",", "replication", ",", "0", ")", ";", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "1", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "1", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "file", "space", ")", ";", "/", "/", "create", "a", "larger", "file", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "1", "/", "nqdir", "3", "3", "/", "boolean", "has", "exception", "=", "false", ";", "try", "{", "d", "f", "s", "test", "util", "create", "file", "(", "dfs", ",", "new", "path", "(", "quota", "dir", "2", "1", ",", "\"", "nqdir", "3", "3", "/", "file", "2", "\"", ")", ",", "2", "*", "file", "len", ",", "replication", ",", "0", ")", ";", "}", "catch", "(", "d", "s", "quota", "exceeded", "exception", "e", ")", "{", "has", "exception", "=", "true", ";", "}", "assert", "true", "(", "has", "exception", ")", ";", "/", "/", "delete", "nqdir", "3", "3", "assert", "true", "(", "dfs", "delete", "(", "new", "path", "(", "quota", "dir", "2", "1", ",", "\"", "nqdir", "3", "3", "\"", ")", ",", "true", ")", ")", ";", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "1", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "1", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "file", "space", ")", ";", "assert", "equals", "(", "c", "get", "space", "quota", "(", ")", ",", "2", "*", "file", "space", ")", ";", "/", "/", "verify", "space", "before", "the", "move", ":", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "0", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "0", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "0", ")", ";", "/", "/", "move", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "1", "/", "nqdir", "3", "2", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "0", "/", "nqdir", "3", "0", "path", "dst", "path", "=", "new", "path", "(", "quota", "dir", "2", "0", ",", "\"", "nqdir", "3", "0", "\"", ")", ";", "path", "src", "path", "=", "new", "path", "(", "quota", "dir", "2", "1", ",", "\"", "nqdir", "3", "2", "\"", ")", ";", "assert", "true", "(", "dfs", "rename", "(", "src", "path", ",", "dst", "path", ")", ")", ";", "/", "/", "verify", "space", "after", "the", "move", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "0", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "file", "space", ")", ";", "/", "/", "verify", "space", "for", "its", "parent", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "1", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "1", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "file", "space", ")", ";", "/", "/", "verify", "space", "for", "source", "for", "the", "move", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "1", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "1", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "0", ")", ";", "final", "path", "file", "2", "=", "new", "path", "(", "dst", "path", ",", "\"", "file", "dir", "/", "file", "2", "\"", ")", ";", "int", "file", "2", "len", "=", "2", "*", "file", "len", ";", "/", "/", "create", "a", "larger", "file", "under", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "0", "/", "nqdir", "3", "0", "d", "f", "s", "test", "util", "create", "file", "(", "dfs", ",", "file", "2", ",", "file", "2", "len", ",", "replication", ",", "0", ")", ";", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "0", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "3", "*", "file", "space", ")", ";", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "1", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "1", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "0", ")", ";", "/", "/", "reverse", ":", "move", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "0", "/", "nqdir", "3", "0", "to", "nqdir", "0", "/", "qdir", "1", "/", "qdir", "2", "1", "/", "has", "exception", "=", "false", ";", "try", "{", "assert", "false", "(", "dfs", "rename", "(", "dst", "path", ",", "src", "path", ")", ")", ";", "}", "catch", "(", "d", "s", "quota", "exceeded", "exception", "e", ")", "{", "has", "exception", "=", "true", ";", "}", "assert", "true", "(", "has", "exception", ")", ";", "/", "/", "make", "sure", "no", "intermediate", "directories", "left", "by", "failed", "rename", "assert", "false", "(", "dfs", "exists", "(", "src", "path", ")", ")", ";", "/", "/", "directory", "should", "exist", "assert", "true", "(", "dfs", "exists", "(", "dst", "path", ")", ")", ";", "/", "/", "verify", "space", "after", "the", "failed", "move", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "0", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "3", "*", "file", "space", ")", ";", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "1", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "1", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "0", ")", ";", "/", "/", "test", "append", ":", "/", "/", "verify", "space", "quota", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "1", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "1", ")", ";", "assert", "equals", "(", "c", "get", "space", "quota", "(", ")", ",", "4", "*", "file", "space", ")", ";", "/", "/", "verify", "space", "before", "append", ";", "c", "=", "dfs", "get", "content", "summary", "(", "dst", "path", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "dst", "path", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "3", "*", "file", "space", ")", ";", "output", "stream", "out", "=", "dfs", "append", "(", "file", "2", ")", ";", "/", "/", "appending", "1", "file", "len", "should", "succeed", "out", "write", "(", "new", "byte", "[", "file", "len", "]", ")", ";", "out", "close", "(", ")", ";", "file", "2", "len", "+", "=", "file", "len", ";", "/", "/", "after", "append", "/", "/", "verify", "space", "after", "append", ";", "c", "=", "dfs", "get", "content", "summary", "(", "dst", "path", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "dst", "path", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "4", "*", "file", "space", ")", ";", "/", "/", "now", "increase", "the", "quota", "for", "quota", "dir", "1", "dfs", "set", "quota", "(", "quota", "dir", "1", ",", "hdfs", "constants", "quota", "dont", "set", ",", "5", "*", "file", "space", ")", ";", "/", "/", "now", ",", "appending", "more", "than", "1", "file", "len", "should", "result", "in", "an", "error", "out", "=", "dfs", "append", "(", "file", "2", ")", ";", "has", "exception", "=", "false", ";", "try", "{", "out", "write", "(", "new", "byte", "[", "file", "len", "+", "1024", "]", ")", ";", "out", "flush", "(", ")", ";", "out", "close", "(", ")", ";", "}", "catch", "(", "d", "s", "quota", "exceeded", "exception", "e", ")", "{", "has", "exception", "=", "true", ";", "i", "o", "utils", "close", "stream", "(", "out", ")", ";", "}", "assert", "true", "(", "has", "exception", ")", ";", "file", "2", "len", "+", "=", "file", "len", ";", "/", "/", "after", "partial", "append", "/", "/", "verify", "space", "after", "partial", "append", "c", "=", "dfs", "get", "content", "summary", "(", "dst", "path", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "dst", "path", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "5", "*", "file", "space", ")", ";", "/", "/", "test", "set", "replication", ":", "/", "/", "first", "reduce", "the", "replication", "dfs", "set", "replication", "(", "file", "2", ",", "(", "short", ")", "(", "replication", "-", "1", ")", ")", ";", "/", "/", "verify", "that", "space", "is", "reduced", "by", "file", "2", "len", "c", "=", "dfs", "get", "content", "summary", "(", "dst", "path", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "dst", "path", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "5", "*", "file", "space", "-", "file", "2", "len", ")", ";", "/", "/", "now", "try", "to", "increase", "the", "replication", "and", "and", "expect", "an", "error", "has", "exception", "=", "false", ";", "try", "{", "dfs", "set", "replication", "(", "file", "2", ",", "(", "short", ")", "(", "replication", "+", "1", ")", ")", ";", "}", "catch", "(", "d", "s", "quota", "exceeded", "exception", "e", ")", "{", "has", "exception", "=", "true", ";", "}", "assert", "true", "(", "has", "exception", ")", ";", "/", "/", "verify", "space", "consumed", "remains", "unchanged", "c", "=", "dfs", "get", "content", "summary", "(", "dst", "path", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "dst", "path", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "5", "*", "file", "space", "-", "file", "2", "len", ")", ";", "/", "/", "now", "increase", "the", "quota", "for", "quota", "dir", "1", "and", "quota", "dir", "2", "0", "dfs", "set", "quota", "(", "quota", "dir", "1", ",", "hdfs", "constants", "quota", "dont", "set", ",", "10", "*", "file", "space", ")", ";", "dfs", "set", "quota", "(", "quota", "dir", "2", "0", ",", "hdfs", "constants", "quota", "dont", "set", ",", "10", "*", "file", "space", ")", ";", "/", "/", "then", "increasing", "replication", "should", "be", "ok", "dfs", "set", "replication", "(", "file", "2", ",", "(", "short", ")", "(", "replication", "+", "1", ")", ")", ";", "/", "/", "verify", "increase", "in", "space", "c", "=", "dfs", "get", "content", "summary", "(", "dst", "path", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "dst", "path", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "5", "*", "file", "space", "+", "file", "2", "len", ")", ";", "/", "/", "test", "hdfs", "-", "2053", ":", "/", "/", "create", "directory", "hdfs", "-", "2053", "final", "path", "quota", "dir", "2", "0", "5", "3", "=", "new", "path", "(", "parent", ",", "\"", "hdfs", "-", "2053", "\"", ")", ";", "assert", "true", "(", "dfs", "mkdirs", "(", "quota", "dir", "2", "0", "5", "3", ")", ")", ";", "/", "/", "create", "subdirectories", "/", "hdfs", "-", "2053", "/", "{", "a", ",", "b", ",", "c", "}", "final", "path", "quota", "dir", "2", "0", "5", "3", "a", "=", "new", "path", "(", "quota", "dir", "2", "0", "5", "3", ",", "\"", "a", "\"", ")", ";", "assert", "true", "(", "dfs", "mkdirs", "(", "quota", "dir", "2", "0", "5", "3", "a", ")", ")", ";", "final", "path", "quota", "dir", "2", "0", "5", "3", "b", "=", "new", "path", "(", "quota", "dir", "2", "0", "5", "3", ",", "\"", "b", "\"", ")", ";", "assert", "true", "(", "dfs", "mkdirs", "(", "quota", "dir", "2", "0", "5", "3", "b", ")", ")", ";", "final", "path", "quota", "dir", "2", "0", "5", "3", "c", "=", "new", "path", "(", "quota", "dir", "2", "0", "5", "3", ",", "\"", "c", "\"", ")", ";", "assert", "true", "(", "dfs", "mkdirs", "(", "quota", "dir", "2", "0", "5", "3", "c", ")", ")", ";", "/", "/", "factors", "to", "vary", "the", "sizes", "of", "test", "files", "created", "in", "each", "subdir", "/", "/", "the", "actual", "factors", "are", "not", "really", "important", "but", "they", "allow", "us", "to", "create", "/", "/", "identifiable", "file", "sizes", "per", "subdir", ",", "which", "helps", "during", "debugging", "int", "size", "factor", "a", "=", "1", ";", "int", "size", "factor", "b", "=", "2", ";", "int", "size", "factor", "c", "=", "4", ";", "/", "/", "set", "space", "quota", "for", "subdirectory", "c", "dfs", "set", "quota", "(", "quota", "dir", "2", "0", "5", "3", "c", ",", "hdfs", "constants", "quota", "dont", "set", ",", "(", "size", "factor", "c", "+", "1", ")", "*", "file", "space", ")", ";", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "0", "5", "3", "c", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "0", "5", "3", "c", ")", ";", "assert", "equals", "(", "c", "get", "space", "quota", "(", ")", ",", "(", "size", "factor", "c", "+", "1", ")", "*", "file", "space", ")", ";", "/", "/", "create", "a", "file", "under", "subdirectory", "a", "d", "f", "s", "test", "util", "create", "file", "(", "dfs", ",", "new", "path", "(", "quota", "dir", "2", "0", "5", "3", "a", ",", "\"", "file", "a", "\"", ")", ",", "size", "factor", "a", "*", "file", "len", ",", "replication", ",", "0", ")", ";", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "0", "5", "3", "a", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "0", "5", "3", "a", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "size", "factor", "a", "*", "file", "space", ")", ";", "/", "/", "create", "a", "file", "under", "subdirectory", "b", "d", "f", "s", "test", "util", "create", "file", "(", "dfs", ",", "new", "path", "(", "quota", "dir", "2", "0", "5", "3", "b", ",", "\"", "file", "b", "\"", ")", ",", "size", "factor", "b", "*", "file", "len", ",", "replication", ",", "0", ")", ";", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "0", "5", "3", "b", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "0", "5", "3", "b", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "size", "factor", "b", "*", "file", "space", ")", ";", "/", "/", "create", "a", "file", "under", "subdirectory", "c", "(", "which", "has", "a", "space", "quota", ")", "d", "f", "s", "test", "util", "create", "file", "(", "dfs", ",", "new", "path", "(", "quota", "dir", "2", "0", "5", "3", "c", ",", "\"", "file", "c", "\"", ")", ",", "size", "factor", "c", "*", "file", "len", ",", "replication", ",", "0", ")", ";", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "0", "5", "3", "c", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "0", "5", "3", "c", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "size", "factor", "c", "*", "file", "space", ")", ";", "/", "/", "check", "space", "consumed", "for", "/", "hdfs", "-", "2053", "c", "=", "dfs", "get", "content", "summary", "(", "quota", "dir", "2", "0", "5", "3", ")", ";", "compare", "quota", "usage", "(", "c", ",", "dfs", ",", "quota", "dir", "2", "0", "5", "3", ")", ";", "assert", "equals", "(", "c", "get", "space", "consumed", "(", ")", ",", "(", "size", "factor", "a", "+", "size", "factor", "b", "+", "size", "factor", "c", ")", "*", "file", "space", ")", ";", "}" ]

[ "spherical", "linear", "interpolation", "between", "this", "quaternion", "and", "the", "other", "quaternion", ",", "based", "on", "the", "alpha", "value", "in", "the", "range", "[", "0", ",", "1", "]", "taken", "from", "bones", "framework", "for", "jpct", ",", "see", "http", ":", "www", "aptalkarga", "combones" ]

[ "public", "quaternion", "slerp", "(", "quaternion", "end", ",", "float", "alpha", ")", "{", "final", "float", "d", "=", "this", "x", "*", "end", "x", "+", "this", "y", "*", "end", "y", "+", "this", "z", "*", "end", "z", "+", "this", "w", "*", "end", "w", ";", "float", "abs", "dot", "=", "d", "<", "0", "f", "?", "-", "d", ":", "d", ";", "/", "/", "set", "the", "first", "and", "second", "scale", "for", "the", "interpolation", "float", "scale", "0", "=", "1f", "-", "alpha", ";", "float", "scale", "1", "=", "alpha", ";", "/", "/", "check", "if", "the", "angle", "between", "the", "2", "quaternions", "was", "big", "enough", "to", "/", "/", "warrant", "such", "calculations", "if", "(", "(", "1", "-", "abs", "dot", ")", ">", "0", "1", ")", "{", "/", "/", "get", "the", "angle", "between", "the", "2", "quaternions", ",", "/", "/", "and", "then", "store", "the", "sin", "(", ")", "of", "that", "angle", "final", "float", "angle", "=", "(", "float", ")", "math", "acos", "(", "abs", "dot", ")", ";", "final", "float", "inv", "sin", "theta", "=", "1f", "/", "(", "float", ")", "math", "sin", "(", "angle", ")", ";", "/", "/", "calculate", "the", "scale", "for", "q", "1", "and", "q", "2", ",", "according", "to", "the", "angle", "and", "/", "/", "it", "'", "s", "sine", "value", "scale", "0", "=", "(", "(", "float", ")", "math", "sin", "(", "(", "1f", "-", "alpha", ")", "*", "angle", ")", "*", "inv", "sin", "theta", ")", ";", "scale", "1", "=", "(", "(", "float", ")", "math", "sin", "(", "(", "alpha", "*", "angle", ")", ")", "*", "inv", "sin", "theta", ")", ";", "}", "if", "(", "d", "<", "0", "f", ")", "scale", "1", "=", "-", "scale", "1", ";", "/", "/", "calculate", "the", "x", ",", "y", ",", "z", "and", "w", "values", "for", "the", "quaternion", "by", "using", "a", "/", "/", "special", "form", "of", "linear", "interpolation", "for", "quaternions", "x", "=", "(", "scale", "0", "*", "x", ")", "+", "(", "scale", "1", "*", "end", "x", ")", ";", "y", "=", "(", "scale", "0", "*", "y", ")", "+", "(", "scale", "1", "*", "end", "y", ")", ";", "z", "=", "(", "scale", "0", "*", "z", ")", "+", "(", "scale", "1", "*", "end", "z", ")", ";", "w", "=", "(", "scale", "0", "*", "w", ")", "+", "(", "scale", "1", "*", "end", "w", ")", ";", "/", "/", "return", "the", "interpolated", "quaternion", "return", "this", ";", "}" ]

[ "check", "whether", "a", "list", "of", "partition", "values", "are", "valid", "based", "on", "the", "given", "list", "of", "partition", "keys" ]

[ "private", "void", "check", "valid", "partition", "spec", "(", "catalog", "partition", "spec", "partition", "spec", ",", "list", "<", "string", ">", "partition", "keys", ",", "object", "path", "table", "path", ")", "throws", "partition", "spec", "invalid", "exception", "{", "for", "(", "string", "key", ":", "partition", "spec", "get", "partition", "spec", "(", ")", "key", "set", "(", ")", ")", "{", "if", "(", "!", "partition", "keys", "contains", "(", "key", ")", ")", "{", "throw", "new", "partition", "spec", "invalid", "exception", "(", "get", "name", "(", ")", ",", "partition", "keys", ",", "table", "path", ",", "partition", "spec", ")", ";", "}", "}", "}" ]

[ "return", "buffers", "to", "the", "pool", "if", "they", "are", "of", "the", "poolable", "size", "add", "them", "to", "the", "free", "list", ",", "otherwise", "just", "mark", "the", "memory", "as", "free" ]

[ "public", "void", "deallocate", "(", "byte", "buffer", "buffer", ",", "int", "size", ")", "{", "lock", "lock", "(", ")", ";", "try", "{", "if", "(", "size", "=", "=", "this", "poolable", "size", "&", "&", "size", "=", "=", "buffer", "capacity", "(", ")", ")", "{", "buffer", "clear", "(", ")", ";", "this", "free", "add", "(", "buffer", ")", ";", "}", "else", "{", "this", "non", "pooled", "available", "memory", "+", "=", "size", ";", "}", "condition", "more", "mem", "=", "this", "waiters", "peek", "first", "(", ")", ";", "if", "(", "more", "mem", "!", "=", "null", ")", "more", "mem", "signal", "(", ")", ";", "}", "finally", "{", "lock", "unlock", "(", ")", ";", "}", "}" ]

[ "gets", "the", "{", "@", "link", "loader", "}", "'", "s", "language", "service", "the", "default", "behavior", "of", "this", "method", "is", "to", "return", "the", "{", "@", "link", "default", "language", "service", "}" ]

[ "protected", "language", "service", "get", "language", "service", "(", ")", "{", "return", "default", "language", "service", "get", "language", "service", "(", ")", ";", "}" ]

[ "the", "strength", "of", "the", "value", "type", "in", "each", "entry" ]

[ "strength", "value", "strength", "(", ")", ";" ]

[ "get", "{", "@", "link", "mutable", "quantiles", "}", "metrics", "for", "the", "file", "read", "time" ]

[ "protected", "mutable", "quantiles", "[", "]", "get", "file", "read", "quantiles", "(", ")", "{", "return", "file", "read", "quantiles", ";", "}" ]

[ "sends", "a", "message" ]

[ "void", "send", "message", "(", "player", "message", "message", ")", ";" ]

[ "model", "tests", "for", "child", "schema", "all", "of" ]

[ "public", "void", "test", "child", "schema", "all", "of", "(", ")", "{", "/", "/", "todo", ":", "test", "child", "schema", "all", "of", "}" ]

[ "returns", "the", "declaring", "class", "of", "{", "@", "code", "type", "variable", "}", ",", "or", "{", "@", "code", "null", "}", "if", "it", "was", "not", "declared", "by", "a", "class" ]

[ "private", "static", "class", "<", "?", ">", "declaring", "class", "of", "(", "type", "variable", "type", "variable", ")", "{", "generic", "declaration", "generic", "declaration", "=", "type", "variable", "get", "generic", "declaration", "(", ")", ";", "return", "generic", "declaration", "instanceof", "class", "?", "(", "class", "<", "?", ">", ")", "generic", "declaration", ":", "null", ";", "}" ]

[ "test", "if", "the", "given", "annotation", "matches", "the", "filter" ]

[ "default", "boolean", "matches", "(", "annotation", "annotation", ")", "{", "return", "matches", "(", "annotation", "annotation", "type", "(", ")", ")", ";", "}" ]

[ "write", "v1", "rainbow", "fish", "to", "file" ]

[ "public", "static", "void", "write", "v", "1", "(", "rainbow", "fish", "rainbow", "fish", ",", "string", "filename", ")", "throws", "i", "o", "exception", "{", "var", "map", "=", "map", "of", "(", "\"", "name", "\"", ",", "rainbow", "fish", "get", "name", "(", ")", ",", "\"", "age", "\"", ",", "string", "format", "(", "\"", "%", "d", "\"", ",", "rainbow", "fish", "get", "age", "(", ")", ")", ",", "length", "meters", ",", "string", "format", "(", "\"", "%", "d", "\"", ",", "rainbow", "fish", "get", "length", "meters", "(", ")", ")", ",", "weight", "tons", ",", "string", "format", "(", "\"", "%", "d", "\"", ",", "rainbow", "fish", "get", "weight", "tons", "(", ")", ")", ")", ";", "try", "(", "var", "file", "out", "=", "new", "file", "output", "stream", "(", "filename", ")", ";", "var", "obj", "out", "=", "new", "object", "output", "stream", "(", "file", "out", ")", ")", "{", "obj", "out", "write", "object", "(", "map", ")", ";", "}", "}" ]