Datasets:
Anonymous2023
/
KGSum

Dataset card Data Studio Files Community
docstring_tokens
list
code_tokens
list
[ "patch", "fake", ":", "to", "test", "\\", "&", "quot", ";", "client", "\\", "&", "quot", ";", "model", "to", "test", "\\", "&", "quot", ";", "client", "\\", "&", "quot", ";", "model" ]
[ "response", "entity", "<", "client", ">", "test", "client", "model", "(", "@", "api", "param", "(", "value", "=", "\"", "client", "model", "\"", ",", "required", "=", "true", ")", "@", "valid", "@", "request", "body", "client", "body", ")", ";" ]
[ "gets", "the", "number", "of", "partitions", "to", "be", "used", "for", "an", "initial", "hash", "-", "table" ]
[ "private", "int", "get", "partitioning", "fan", "out", "no", "estimates", "(", ")", "{", "return", "math", "max", "(", "11", ",", "find", "smaller", "prime", "(", "(", "int", ")", "math", "min", "(", "build", "row", "count", "*", "avg", "record", "len", "/", "(", "10", "*", "segment", "size", ")", ",", "max", "num", "partitions", ")", ")", ")", ";", "}" ]
[ "all", "the", "dex", "files", "in", "meta", "file", "exist", "?", "fast", "check", ",", "only", "check", "whether", "exist" ]
[ "public", "static", "boolean", "check", "complete", "(", "string", "directory", ",", "share", "security", "check", "security", "check", ",", "string", "oat", "dir", ",", "intent", "intent", "result", ")", "{", "string", "meta", "=", "security", "check", "get", "meta", "content", "map", "(", ")", "get", "(", "dex", "meat", "file", ")", ";", "/", "/", "not", "found", "dex", "if", "(", "meta", "=", "=", "null", ")", "{", "return", "true", ";", "}", "load", "dex", "list", "clear", "(", ")", ";", "class", "n", "dex", "info", "clear", "(", ")", ";", "array", "list", "<", "share", "dex", "diff", "patch", "info", ">", "all", "dex", "info", "=", "new", "array", "list", "<", ">", "(", ")", ";", "share", "dex", "diff", "patch", "info", "parse", "dex", "diff", "patch", "info", "(", "meta", ",", "all", "dex", "info", ")", ";", "if", "(", "all", "dex", "info", "is", "empty", "(", ")", ")", "{", "return", "true", ";", "}", "hash", "map", "<", "string", ",", "string", ">", "dexes", "=", "new", "hash", "map", "<", ">", "(", ")", ";", "share", "dex", "diff", "patch", "info", "test", "info", "=", "null", ";", "for", "(", "share", "dex", "diff", "patch", "info", "info", ":", "all", "dex", "info", ")", "{", "/", "/", "for", "dalvik", ",", "ignore", "art", "support", "dex", "if", "(", "is", "just", "art", "support", "dex", "(", "info", ")", ")", "{", "continue", ";", "}", "if", "(", "!", "share", "dex", "diff", "patch", "info", "check", "dex", "diff", "patch", "info", "(", "info", ")", ")", "{", "intent", "result", "put", "extra", "(", "share", "intent", "util", "intent", "patch", "package", "patch", "check", ",", "share", "constants", "error", "package", "check", "dex", "meta", "corrupted", ")", ";", "share", "intent", "util", "set", "intent", "return", "code", "(", "intent", "result", ",", "share", "constants", "error", "load", "patch", "package", "check", "fail", ")", ";", "return", "false", ";", "}", "if", "(", "is", "vm", "art", "&", "&", "info", "raw", "name", "starts", "with", "(", "share", "constants", "test", "dex", "name", ")", ")", "{", "test", "info", "=", "info", ";", "}", "else", "if", "(", "is", "vm", "art", "&", "&", "share", "constants", "class", "n", "pattern", "matcher", "(", "info", "real", "name", ")", "matches", "(", ")", ")", "{", "class", "n", "dex", "info", "add", "(", "info", ")", ";", "}", "else", "{", "dexes", "put", "(", "info", "real", "name", ",", "get", "info", "md", "5", "(", "info", ")", ")", ";", "load", "dex", "list", "add", "(", "info", ")", ";", "}", "}", "if", "(", "is", "vm", "art", "&", "&", "(", "test", "info", "!", "=", "null", "|", "|", "!", "class", "n", "dex", "info", "is", "empty", "(", ")", ")", ")", "{", "if", "(", "test", "info", "!", "=", "null", ")", "{", "class", "n", "dex", "info", "add", "(", "share", "tinker", "internals", "change", "test", "dex", "to", "class", "n", "(", "test", "info", ",", "class", "n", "dex", "info", "size", "(", ")", "+", "1", ")", ")", ";", "}", "dexes", "put", "(", "share", "constants", "class", "n", "apk", "name", ",", "\"", "\"", ")", ";", "}", "/", "/", "tinker", "/", "patch", "info", "/", "patch", "-", "6", "4", "1e", "6", "3", "4c", "/", "dex", "string", "dex", "directory", "=", "directory", "+", "\"", "/", "\"", "+", "dex", "path", "+", "\"", "/", "\"", ";", "file", "dex", "dir", "=", "new", "file", "(", "dex", "directory", ")", ";", "if", "(", "!", "dex", "dir", "exists", "(", ")", "|", "|", "!", "dex", "dir", "is", "directory", "(", ")", ")", "{", "share", "intent", "util", "set", "intent", "return", "code", "(", "intent", "result", ",", "share", "constants", "error", "load", "patch", "version", "dex", "directory", "not", "exist", ")", ";", "return", "false", ";", "}", "string", "optimize", "dex", "directory", "=", "directory", "+", "\"", "/", "\"", "+", "oat", "dir", "+", "\"", "/", "\"", ";", "file", "optimize", "dex", "directory", "file", "=", "new", "file", "(", "optimize", "dex", "directory", ")", ";", "/", "/", "fast", "check", "whether", "there", "is", "any", "dex", "files", "missing", "for", "(", "string", "name", ":", "dexes", "key", "set", "(", ")", ")", "{", "file", "dex", "file", "=", "new", "file", "(", "dex", "directory", "+", "name", ")", ";", "if", "(", "!", "share", "patch", "file", "util", "is", "legal", "file", "(", "dex", "file", ")", ")", "{", "intent", "result", "put", "extra", "(", "share", "intent", "util", "intent", "patch", "missing", "dex", "path", ",", "dex", "file", "get", "absolute", "path", "(", ")", ")", ";", "share", "intent", "util", "set", "intent", "return", "code", "(", "intent", "result", ",", "share", "constants", "error", "load", "patch", "version", "dex", "file", "not", "exist", ")", ";", "return", "false", ";", "}", "/", "/", "check", "dex", "opt", "whether", "complete", "also", "file", "dex", "opt", "file", "=", "new", "file", "(", "share", "patch", "file", "util", "optimized", "path", "for", "(", "dex", "file", ",", "optimize", "dex", "directory", "file", ")", ")", ";", "if", "(", "!", "share", "patch", "file", "util", "is", "legal", "file", "(", "dex", "opt", "file", ")", ")", "{", "if", "(", "share", "patch", "file", "util", "should", "accept", "even", "if", "illegal", "(", "dex", "opt", "file", ")", ")", "{", "continue", ";", "}", "intent", "result", "put", "extra", "(", "share", "intent", "util", "intent", "patch", "missing", "dex", "path", ",", "dex", "opt", "file", "get", "absolute", "path", "(", ")", ")", ";", "share", "intent", "util", "set", "intent", "return", "code", "(", "intent", "result", ",", "share", "constants", "error", "load", "patch", "version", "dex", "opt", "file", "not", "exist", ")", ";", "return", "false", ";", "}", "/", "/", "/", "/", "find", "test", "dex", "/", "/", "if", "(", "dex", "opt", "file", "get", "name", "(", ")", "starts", "with", "(", "share", "constants", "test", "dex", "name", ")", ")", "{", "/", "/", "test", "opt", "dex", "file", "=", "dex", "opt", "file", ";", "/", "/", "}", "}", "/", "/", "if", "is", "ok", ",", "add", "to", "result", "intent", "intent", "result", "put", "extra", "(", "share", "intent", "util", "intent", "patch", "dexes", "path", ",", "dexes", ")", ";", "return", "true", ";", "}" ]
[ "get", "the", "base", "path" ]
[ "public", "path", "get", "base", "application", "path", "(", ")", "{", "string", "configured", "base", "path", "=", "configuration", "get", "(", "yarn", "service", "conf", "yarn", "service", "base", "path", ",", "get", "home", "directory", "(", ")", "+", "\"", "/", "\"", "+", "yarn", "service", "constants", "service", "base", "directory", ")", ";", "return", "new", "path", "(", "configured", "base", "path", ")", ";", "}" ]
[ "padding", "at", "the", "left", "edge", "of", "the", "table" ]
[ "public", "table", "pad", "left", "(", "float", "pad", "left", ")", "{", "this", "pad", "left", "=", "fixed", "value", "of", "(", "pad", "left", ")", ";", "size", "invalid", "=", "true", ";", "return", "this", ";", "}" ]
[ "shows", "we", "don", "'", "t", "assume", "there", "'", "s", "a", "direct", "link", "between", "producer", "and", "consumer" ]
[ "@", "test", "void", "messaging", "without", "broker", "no", "links", "(", ")", "{", "list", "<", "span", ">", "trace", "=", "as", "list", "(", "span", "(", "\"", "a", "\"", ",", "null", ",", "\"", "a", "\"", ",", "kind", "producer", ",", "\"", "producer", "\"", ",", "null", ",", "false", ")", ",", "span", "(", "\"", "a", "\"", ",", "\"", "a", "\"", ",", "\"", "b", "\"", ",", "kind", "consumer", ",", "\"", "consumer", "\"", ",", "null", ",", "false", ")", ")", ";", "assert", "that", "(", "new", "dependency", "linker", "(", ")", "put", "trace", "(", "trace", ")", "link", "(", ")", ")", "is", "empty", "(", ")", ";", "}" ]
[ "returns", "true", "if", "the", "fragment", "is", "a", "descendant", "of", "our", "parent" ]
[ "private", "boolean", "is", "descendant", "(", "@", "non", "null", "fragment", "fragment", ")", "{", "fragment", "root", "=", "get", "parent", "fragment", "using", "hint", "(", ")", ";", "fragment", "parent", "fragment", ";", "while", "(", "(", "parent", "fragment", "=", "fragment", "get", "parent", "fragment", "(", ")", ")", "!", "=", "null", ")", "{", "if", "(", "parent", "fragment", "equals", "(", "root", ")", ")", "{", "return", "true", ";", "}", "fragment", "=", "fragment", "get", "parent", "fragment", "(", ")", ";", "}", "return", "false", ";", "}" ]
[ "returns", "the", "maximum", "value", "of", "type", "{", "@", "code", "c", "}", ",", "if", "it", "has", "one", "the", "maximum", "value", "is", "the", "unique", "value", "for", "which", "{", "@", "link", "comparable", "#", "compare", "to", "(", "object", ")", "}", "never", "returns", "a", "negative", "value", "for", "any", "input", "of", "type", "{", "@", "code", "c", "}", "the", "default", "implementation", "throws", "{", "@", "code", "no", "such", "element", "exception", "}" ]
[ "public", "c", "max", "value", "(", ")", "{", "throw", "new", "no", "such", "element", "exception", "(", ")", ";", "}" ]
[ "add", "a", "li", "element" ]
[ "li", "li", "(", "string", "cdata", ")", ";" ]
[ "gets", "the", "merge", "constant", "associated", "with", "the", "indicated", "program" ]
[ "int", "get", "program", "index", "(", "program", "pgm", ")", "{", "if", "(", "pgm", "=", "=", "result", "pgm", ")", "{", "return", "result", ";", "}", "else", "if", "(", "pgm", "=", "=", "latest", "pgm", ")", "{", "return", "latest", ";", "}", "else", "if", "(", "pgm", "=", "=", "my", "pgm", ")", "{", "return", "my", ";", "}", "else", "if", "(", "pgm", "=", "=", "original", "pgm", ")", "{", "return", "original", ";", "}", "return", "-", "1", ";", "}" ]
[ "gets", "associations", "which", "refers", "this", "entity" ]
[ "collection", "<", "?", "extends", "d", "b", "s", "entity", "association", ">", "get", "references", "(", "@", "not", "null", "d", "b", "r", "progress", "monitor", "monitor", ")", "throws", "d", "b", "exception", ";" ]
[ "note", ":", "this", "will", "flake", "if", "you", "happen", "to", "be", "running", "a", "server", "on", "port", "9410", "!" ]
[ "@", "test", "public", "void", "provides", "collector", "component", "when", "enabled", "(", ")", "{", "test", "property", "values", "of", "(", "\"", "zipkin", "collector", "scribe", "enabled", ":", "true", "\"", ")", "apply", "to", "(", "context", ")", ";", "refresh", "context", "(", ")", ";", "assert", "that", "(", "context", "get", "bean", "(", "scribe", "collector", "class", ")", ")", "is", "not", "null", "(", ")", ";", "}" ]
[ "return", "the", "default", "headers", "for", "the", "web", "socket", "handshake", "request" ]
[ "public", "http", "headers", "get", "headers", "(", ")", "{", "return", "this", "headers", ";", "}" ]
[ "gets", "the", "eclipse", "dropins", "directory" ]
[ "public", "file", "get", "eclipse", "dropins", "dir", "(", ")", "throws", "file", "not", "found", "exception", "{", "file", "eclipse", "install", "dir", "=", "get", "eclipse", "install", "dir", "(", ")", ";", "file", "dropins", "dir", "=", "new", "file", "(", "eclipse", "install", "dir", ",", "\"", "dropins", "\"", ")", ";", "if", "(", "!", "dropins", "dir", "is", "directory", "(", ")", ")", "{", "throw", "new", "file", "not", "found", "exception", "(", "\"", "eclipse", "dropins", "directory", "does", "not", "exist", "\"", ")", ";", "}", "return", "dropins", "dir", ";", "}" ]
[ "returns", "the", "key", "used", "to", "resolve", "the", "provider", "'", "s", "binding" ]
[ "key", "<", "?", "extends", "provider", "<", "?", "extends", "t", ">", ">", "get", "provider", "key", "(", ")", ";" ]
[ "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", "\"", ")", ";", "}" ]
[ "mark", "entire", "page", "as", "uninitialized" ]
[ "public", "void", "set", "uninitialized", "(", ")", "{", "initialized", "mask", "=", "get", "initialized", "mask", "(", "data", "length", ",", "false", ")", ";", "}" ]
[ "compares", "the", "keys", ",", "values", ",", "and", "timestamps", "of", "two", "{", "@", "link", "producer", "record", "}", "'", "s", "and", "throws", "an", "{", "@", "link", "assertion", "error", "}", "if", "the", "keys", ",", "values", ",", "or", "timestamps", "are", "not", "equal", "to", "each", "other" ]
[ "public", "static", "<", "k", ",", "v", ">", "void", "compare", "key", "value", "timestamp", "(", "final", "producer", "record", "<", "k", ",", "v", ">", "record", ",", "final", "producer", "record", "<", "k", ",", "v", ">", "expected", "record", ")", "throws", "assertion", "error", "{", "objects", "require", "non", "null", "(", "expected", "record", ")", ";", "compare", "key", "value", "timestamp", "(", "record", ",", "expected", "record", "key", "(", ")", ",", "expected", "record", "value", "(", ")", ",", "expected", "record", "timestamp", "(", ")", ")", ";", "}" ]
[ "get", "pet", "{", "pet", "id", "}", ":", "find", "pet", "by", "id", "returns", "a", "single", "pet" ]
[ "default", "response", "entity", "<", "pet", ">", "get", "pet", "by", "id", "(", "@", "api", "param", "(", "value", "=", "\"", "id", "of", "pet", "to", "return", "\"", ",", "required", "=", "true", ")", "@", "path", "variable", "(", "\"", "pet", "id", "\"", ")", "long", "pet", "id", ")", "{", "get", "request", "(", ")", "if", "present", "(", "request", "-", ">", "{", "for", "(", "media", "type", "media", "type", ":", "media", "type", "parse", "media", "types", "(", "request", "get", "header", "(", "\"", "accept", "\"", ")", ")", ")", "{", "if", "(", "media", "type", "is", "compatible", "with", "(", "media", "type", "value", "of", "(", "\"", "application", "/", "json", "\"", ")", ")", ")", "{", "string", "example", "string", "=", "\"", "{", "\\", "\"", "photo", "urls", "\\", "\"", ":", "[", "\\", "\"", "photo", "urls", "\\", "\"", ",", "\\", "\"", "photo", "urls", "\\", "\"", "]", ",", "\\", "\"", "name", "\\", "\"", ":", "\\", "\"", "doggie", "\\", "\"", ",", "\\", "\"", "id", "\\", "\"", ":", "0", ",", "\\", "\"", "category", "\\", "\"", ":", "{", "\\", "\"", "name", "\\", "\"", ":", "\\", "\"", "default", "-", "name", "\\", "\"", ",", "\\", "\"", "id", "\\", "\"", ":", "6", "}", ",", "\\", "\"", "tags", "\\", "\"", ":", "[", "{", "\\", "\"", "name", "\\", "\"", ":", "\\", "\"", "name", "\\", "\"", ",", "\\", "\"", "id", "\\", "\"", ":", "1", "}", ",", "{", "\\", "\"", "name", "\\", "\"", ":", "\\", "\"", "name", "\\", "\"", ",", "\\", "\"", "id", "\\", "\"", ":", "1", "}", "]", ",", "\\", "\"", "status", "\\", "\"", ":", "\\", "\"", "available", "\\", "\"", "}", "\"", ";", "api", "util", "set", "example", "response", "(", "request", ",", "\"", "application", "/", "json", "\"", ",", "example", "string", ")", ";", "break", ";", "}", "if", "(", "media", "type", "is", "compatible", "with", "(", "media", "type", "value", "of", "(", "\"", "application", "/", "xml", "\"", ")", ")", ")", "{", "string", "example", "string", "=", "\"", "<", "pet", ">", "<", "id", ">", "123456789", "<", "/", "id", ">", "<", "name", ">", "doggie", "<", "/", "name", ">", "<", "photo", "urls", ">", "<", "photo", "urls", ">", "aeiou", "<", "/", "photo", "urls", ">", "<", "/", "photo", "urls", ">", "<", "tags", ">", "<", "/", "tags", ">", "<", "status", ">", "aeiou", "<", "/", "status", ">", "<", "/", "pet", ">", "\"", ";", "api", "util", "set", "example", "response", "(", "request", ",", "\"", "application", "/", "xml", "\"", ",", "example", "string", ")", ";", "break", ";", "}", "}", "}", ")", ";", "return", "new", "response", "entity", "<", ">", "(", "http", "status", "not", "implemented", ")", ";", "}" ]
[ "returns", "the", "record", "number", "of", "the", "type", "that", "is", "pointed", "to" ]
[ "public", "record", "number", "get", "underlying", "record", "number", "(", ")", "{", "return", "underlying", "record", "number", ";", "}" ]
[ "the", "id", "of", "the", "type", "this", "may", "be", "0", ",", "which", "indicates", "no", "id", "is", "set", "<", "code", ">", "optional", "uint", "3", "2", "id", "=", "1", ";", "<", "code", ">" ]
[ "public", "builder", "clear", "id", "(", ")", "{", "copy", "on", "write", "(", ")", ";", "instance", "clear", "id", "(", ")", ";", "return", "this", ";", "}" ]
[ "ensures", "initialization", "and", "returns", "the", "parent" ]
[ "public", "execution", "entity", "impl", "get", "parent", "(", ")", "{", "ensure", "parent", "initialized", "(", ")", ";", "return", "parent", ";", "}" ]
[ "<", "code", ">", "repeated", "org", "apache", "dubbo", "metadata", "definition", "protobuf", "model", "phone", "number", "phone", "=", "8", ";", "<", "code", ">" ]
[ "public", "org", "apache", "dubbo", "metadata", "definition", "protobuf", "model", "google", "p", "b", "phone", "number", "builder", "add", "phone", "builder", "(", "int", "index", ")", "{", "return", "get", "phone", "field", "builder", "(", ")", "add", "builder", "(", "index", ",", "org", "apache", "dubbo", "metadata", "definition", "protobuf", "model", "google", "p", "b", "phone", "number", "get", "default", "instance", "(", ")", ")", ";", "}" ]
[ "generates", "a", "default", "external", "name", "for", "an", "external", "function" ]
[ "public", "static", "string", "get", "default", "external", "function", "name", "(", "address", "addr", ")", "{", "return", "default", "external", "entry", "prefix", "+", "default", "function", "prefix", "+", "get", "address", "string", "(", "addr", ")", ";", "}" ]
[ "set", "value", "of", "this", "field", "no", "type", "enforced", "here", "since", "most", "type", "mismatch", "can", "be", "easily", "tested", "and", "exposed", "early" ]
[ "public", "void", "set", "(", "final", "c", "instance", ",", "final", "object", "value", ")", "{", "try", "{", "m", "field", "set", "(", "instance", ",", "value", ")", ";", "}", "catch", "(", "final", "illegal", "access", "exception", "e", ")", "{", "e", "print", "stack", "trace", "(", ")", ";", "/", "*", "should", "never", "happen", "*", "/", "}", "}" ]
[ "returns", "a", "new", "array", "based", "float", "buffer", "with", "the", "specified", "capacity" ]
[ "public", "static", "float", "buffer", "new", "float", "buffer", "(", "int", "capacity", ")", "{", "return", "new", "read", "write", "float", "array", "buffer", "(", "capacity", ")", ";", "}" ]
[ "appends", "the", "string", "representation", "of", "the", "specified", "{", "@", "code", "int", "}", "value", "the", "{", "@", "code", "int", "}", "value", "is", "converted", "to", "a", "string", "without", "memory", "allocation" ]
[ "public", "string", "builder", "append", "(", "int", "value", ")", "{", "return", "append", "(", "value", ",", "0", ")", ";", "}" ]
[ "returns", "an", "immutable", "snapshot", "of", "the", "current", "statistics" ]
[ "public", "stats", "snapshot", "(", ")", "{", "return", "new", "stats", "(", "count", ",", "mean", ",", "sum", "of", "squares", "of", "deltas", ",", "min", ",", "max", ")", ";", "}" ]
[ "returns", "the", "key", "of", "this", "node" ]
[ "public", "byte", "get", "kind", "(", ")", "{", "return", "kind", ";", "}" ]
[ "return", "declared", "http", "methods" ]
[ "public", "set", "<", "http", "method", ">", "get", "allowed", "methods", "(", ")", "{", "return", "this", "partial", "matches", "stream", "(", ")", "flat", "map", "(", "m", "-", ">", "m", "get", "info", "(", ")", "get", "methods", "condition", "(", ")", "get", "methods", "(", ")", "stream", "(", ")", ")", "map", "(", "request", "method", "-", ">", "http", "method", "resolve", "(", "request", "method", "name", "(", ")", ")", ")", "collect", "(", "collectors", "to", "set", "(", ")", ")", ";", "}" ]
[ "guaranteed", "to", "throw", "an", "exception", "and", "leave", "the", "table", "unmodified" ]
[ "public", "final", "v", "put", "(", "r", "row", "key", ",", "c", "column", "key", ",", "v", "value", ")", "{", "throw", "new", "unsupported", "operation", "exception", "(", ")", ";", "}" ]
[ "see", "the", "edsl", "examples", "at", "{", "@", "link", "org", "elasticsearch", "common", "inject", "binder", "}" ]
[ "scoped", "binding", "builder", "to", "(", "key", "<", "?", "extends", "t", ">", "target", "key", ")", ";" ]
[ "create", "a", "deep", "copy", "of", "the", "given", "sort", "definition", ",", "for", "use", "as", "state", "holder", "to", "compare", "a", "modified", "sort", "definition", "against", "default", "implementation", "creates", "a", "mutable", "sort", "definition", "instance", "can", "be", "overridden", "in", "subclasses", ",", "in", "particular", "in", "case", "of", "custom", "extensions", "to", "the", "sort", "definition", "interface", "is", "allowed", "to", "return", "null", ",", "which", "means", "that", "no", "sort", "state", "will", "be", "held", ",", "triggering", "actual", "sorting", "for", "each", "{", "@", "code", "resort", "}", "call" ]
[ "protected", "sort", "definition", "copy", "sort", "definition", "(", "sort", "definition", "sort", ")", "{", "return", "new", "mutable", "sort", "definition", "(", "sort", ")", ";", "}" ]
[ "returns", "the", "first", "selected", "item", ",", "or", "null" ]
[ "public", "@", "null", "t", "get", "selected", "(", ")", "{", "return", "selection", "first", "(", ")", ";", "}" ]
[ "describe", "a", "test", "this", "is", "a", "replacement", "for", "javadocs", "where", "the", "tests", "role", "is", "printed", "in", "the", "log", "output" ]
[ "protected", "void", "describe", "(", "string", "text", ")", "{", "log", "info", "(", "text", ")", ";", "}" ]
[ "reverts", "state", "back", "to", "prior", "edit", "state" ]
[ "public", "void", "revert", "name", "change", "(", "string", "old", "value", ")", "{", "attribute", "item", "figure", "figure", "=", "get", "figure", "(", ")", ";", "figure", "set", "visible", "(", "true", ")", ";", "set", "selected", "(", "edit", "part", "selected", "primary", ")", ";", "figure", "revalidate", "(", ")", ";", "}" ]
[ "remove", "instance", "from", "service" ]
[ "public", "void", "remove", "instance", "(", "string", "namespace", "id", ",", "string", "service", "name", ",", "boolean", "ephemeral", ",", "instance", "ips", ")", "throws", "nacos", "exception", "{", "service", "service", "=", "get", "service", "(", "namespace", "id", ",", "service", "name", ")", ";", "synchronized", "(", "service", ")", "{", "remove", "instance", "(", "namespace", "id", ",", "service", "name", ",", "ephemeral", ",", "service", ",", "ips", ")", ";", "}", "}" ]
[ "groupkey", "-", ">", "subscriber", "status" ]
[ "public", "static", "map", "<", "string", ",", "subscriber", "status", ">", "list", "sub", "status", "(", "string", "ip", ")", "{", "map", "<", "string", ",", "subscriber", "status", ">", "status", "=", "new", "hash", "map", "<", "string", ",", "subscriber", "status", ">", "(", "100", ")", ";", "client", "record", "record", "=", "get", "client", "record", "(", "ip", ")", ";", "if", "(", "record", "=", "=", "null", ")", "{", "return", "status", ";", "}", "for", "(", "map", "entry", "<", "string", ",", "string", ">", "entry", ":", "record", "get", "group", "key", "2md", "5", "map", "(", ")", "entry", "set", "(", ")", ")", "{", "string", "group", "key", "=", "entry", "get", "key", "(", ")", ";", "string", "client", "md", "5", "=", "entry", "get", "value", "(", ")", ";", "long", "last", "polling", "ts", "=", "record", "get", "group", "key", "2polling", "ts", "map", "(", ")", "get", "(", "group", "key", ")", ";", "boolean", "is", "update", "=", "config", "cache", "service", "is", "uptodate", "(", "group", "key", ",", "client", "md", "5", ")", ";", "status", "put", "(", "group", "key", ",", "new", "subscriber", "status", "(", "group", "key", ",", "is", "update", ",", "client", "md", "5", ",", "last", "polling", "ts", ")", ")", ";", "}", "return", "status", ";", "}" ]
[ "configures", "audio", "processors", "to", "apply", "whether", "to", "skip", "silences", "immediately", ",", "returning", "the", "new", "value", "only", "called", "when", "processors", "have", "no", "input", "pending" ]
[ "boolean", "apply", "skip", "silence", "enabled", "(", "boolean", "skip", "silence", "enabled", ")", ";" ]
[ "compares", "the", "specified", "collection", "with", "another", ",", "the", "main", "implementation", "references", "{", "@", "link", "abstract", "set", "}" ]
[ "public", "static", "boolean", "equals", "(", "collection", "<", "?", ">", "one", ",", "collection", "<", "?", ">", "another", ")", "{", "if", "(", "one", "=", "=", "another", ")", "{", "return", "true", ";", "}", "if", "(", "is", "empty", "(", "one", ")", "&", "&", "is", "empty", "(", "another", ")", ")", "{", "return", "true", ";", "}", "if", "(", "size", "(", "one", ")", "!", "=", "size", "(", "another", ")", ")", "{", "return", "false", ";", "}", "try", "{", "return", "one", "contains", "all", "(", "another", ")", ";", "}", "catch", "(", "class", "cast", "exception", "unused", ")", "{", "return", "false", ";", "}", "catch", "(", "null", "pointer", "exception", "unused", ")", "{", "return", "false", ";", "}", "}" ]
[ "test", "for", "blocks", "on", "maintenance", "hosts", "are", "not", "shown", "as", "missing" ]
[ "public", "void", "test", "fsck", "with", "maintenance", "replicas", "(", ")", "throws", "exception", "{", "final", "short", "repl", "factor", "=", "2", ";", "short", "num", "dn", "=", "2", ";", "final", "long", "block", "size", "=", "512", ";", "string", "[", "]", "hosts", "=", "{", "\"", "host", "1", "\"", ",", "\"", "host", "2", "\"", "}", ";", "string", "[", "]", "racks", "=", "{", "\"", "/", "rack", "1", "\"", ",", "\"", "/", "rack", "2", "\"", "}", ";", "conf", "set", "long", "(", "d", "f", "s", "config", "keys", "dfs", "block", "size", "key", ",", "block", "size", ")", ";", "conf", "set", "int", "(", "d", "f", "s", "config", "keys", "dfs", "replication", "key", ",", "repl", "factor", ")", ";", "conf", "set", "int", "(", "d", "f", "s", "config", "keys", "dfs", "namenode", "replication", "min", "key", ",", "repl", "factor", ")", ";", "conf", "set", "int", "(", "d", "f", "s", "config", "keys", "dfs", "namenode", "maintenance", "replication", "min", "key", ",", "repl", "factor", ")", ";", "distributed", "file", "system", "dfs", ";", "file", "builder", "base", "dir", "=", "new", "file", "(", "generic", "test", "utils", "get", "randomized", "temp", "path", "(", ")", ")", ";", "cluster", "=", "new", "mini", "d", "f", "s", "cluster", "builder", "(", "conf", ",", "builder", "base", "dir", ")", "num", "data", "nodes", "(", "num", "dn", ")", "hosts", "(", "hosts", ")", "racks", "(", "racks", ")", "build", "(", ")", ";", "assert", "not", "null", "(", "\"", "failed", "cluster", "creation", "\"", ",", "cluster", ")", ";", "cluster", "wait", "cluster", "up", "(", ")", ";", "dfs", "=", "cluster", "get", "file", "system", "(", ")", ";", "assert", "not", "null", "(", "\"", "failed", "to", "get", "file", "system", "\"", ",", "dfs", ")", ";", "d", "f", "s", "test", "util", "util", "=", "new", "d", "f", "s", "test", "util", "builder", "(", ")", "set", "name", "(", "get", "class", "(", ")", "get", "simple", "name", "(", ")", ")", "set", "num", "files", "(", "1", ")", "build", "(", ")", ";", "/", "/", "create", "files", "final", "string", "test", "file", "=", "new", "string", "(", "\"", "/", "testfile", "\"", ")", ";", "final", "path", "path", "=", "new", "path", "(", "test", "file", ")", ";", "util", "create", "file", "(", "dfs", ",", "path", ",", "1024", ",", "repl", "factor", ",", "1000l", ")", ";", "util", "wait", "replication", "(", "dfs", ",", "path", ",", "repl", "factor", ")", ";", "string", "builder", "sb", "=", "new", "string", "builder", "(", ")", ";", "for", "(", "located", "block", "lb", ":", "util", "get", "all", "blocks", "(", "dfs", ",", "path", ")", ")", "{", "sb", "append", "(", "lb", "get", "block", "(", ")", "get", "local", "block", "(", ")", "get", "block", "name", "(", ")", "+", "\"", "\"", ")", ";", "}", "string", "[", "]", "b", "ids", "=", "sb", "to", "string", "(", ")", "split", "(", "\"", "\"", ")", ";", "/", "/", "make", "sure", "datanode", "that", "has", "replica", "is", "fine", "before", "maintenance", "string", "out", "str", "=", "run", "fsck", "(", "conf", ",", "0", ",", "true", ",", "test", "file", ")", ";", "system", "out", "println", "(", "out", "str", ")", ";", "assert", "true", "(", "out", "str", "contains", "(", "namenode", "fsck", "healthy", "status", ")", ")", ";", "f", "s", "namesystem", "fsn", "=", "cluster", "get", "name", "node", "(", ")", "get", "namesystem", "(", ")", ";", "block", "manager", "bm", "=", "fsn", "get", "block", "manager", "(", ")", ";", "datanode", "manager", "dnm", "=", "bm", "get", "datanode", "manager", "(", ")", ";", "datanode", "descriptor", "dn", "=", "dnm", "get", "datanode", "(", "cluster", "get", "data", "nodes", "(", ")", "get", "(", "0", ")", "get", "datanode", "id", "(", ")", ")", ";", "bm", "get", "datanode", "manager", "(", ")", "get", "datanode", "admin", "manager", "(", ")", "start", "maintenance", "(", "dn", ",", "long", "max", "value", ")", ";", "final", "string", "dn", "name", "=", "dn", "get", "xfer", "addr", "(", ")", ";", "/", "/", "wait", "for", "the", "node", "to", "enter", "maintenance", "state", "generic", "test", "utils", "wait", "for", "(", "new", "supplier", "<", "boolean", ">", "(", ")", "{", "@", "override", "public", "boolean", "get", "(", ")", "{", "datanode", "info", "datanode", "info", "=", "null", ";", "try", "{", "for", "(", "datanode", "info", "info", ":", "dfs", "get", "data", "node", "stats", "(", ")", ")", "{", "if", "(", "dn", "name", "equals", "(", "info", "get", "xfer", "addr", "(", ")", ")", ")", "{", "datanode", "info", "=", "info", ";", "}", "}", "if", "(", "datanode", "info", "!", "=", "null", "&", "&", "datanode", "info", "is", "entering", "maintenance", "(", ")", ")", "{", "/", "/", "verify", "fsck", "returns", "healthy", "status", "string", "fsck", "out", "=", "run", "fsck", "(", "conf", ",", "0", ",", "true", ",", "test", "file", ",", "\"", "-", "maintenance", "\"", ")", ";", "assert", "true", "(", "fsck", "out", "contains", "(", "namenode", "fsck", "healthy", "status", ")", ")", ";", "return", "true", ";", "}", "}", "catch", "(", "exception", "e", ")", "{", "log", "warn", "(", "\"", "unexpected", "exception", ":", "\"", "+", "e", ")", ";", "return", "false", ";", "}", "return", "false", ";", "}", "}", ",", "500", ",", "30000", ")", ";", "/", "/", "start", "3rd", "data", "node", "and", "wait", "for", "node", "to", "reach", "in", "maintenance", "state", "cluster", "start", "data", "nodes", "(", "conf", ",", "1", ",", "true", ",", "null", ",", "new", "string", "[", "]", "{", "\"", "/", "rack", "3", "\"", "}", ",", "new", "string", "[", "]", "{", "\"", "host", "3", "\"", "}", ",", "null", ",", "false", ")", ";", "generic", "test", "utils", "wait", "for", "(", "new", "supplier", "<", "boolean", ">", "(", ")", "{", "@", "override", "public", "boolean", "get", "(", ")", "{", "datanode", "info", "datanode", "info", "=", "null", ";", "try", "{", "for", "(", "datanode", "info", "info", ":", "dfs", "get", "data", "node", "stats", "(", ")", ")", "{", "if", "(", "dn", "name", "equals", "(", "info", "get", "xfer", "addr", "(", ")", ")", ")", "{", "datanode", "info", "=", "info", ";", "}", "}", "if", "(", "datanode", "info", "!", "=", "null", "&", "&", "datanode", "info", "is", "in", "maintenance", "(", ")", ")", "{", "return", "true", ";", "}", "}", "catch", "(", "exception", "e", ")", "{", "log", "warn", "(", "\"", "unexpected", "exception", ":", "\"", "+", "e", ")", ";", "return", "false", ";", "}", "return", "false", ";", "}", "}", ",", "500", ",", "30000", ")", ";", "/", "/", "verify", "fsck", "returns", "healthy", "status", "string", "fsck", "out", "=", "run", "fsck", "(", "conf", ",", "0", ",", "true", ",", "test", "file", ",", "\"", "-", "maintenance", "\"", ")", ";", "assert", "true", "(", "fsck", "out", "contains", "(", "namenode", "fsck", "healthy", "status", ")", ")", ";", "/", "/", "verify", "fsck", "returns", "healthy", "status", "even", "without", "maintenance", "option", "fsck", "out", "=", "run", "fsck", "(", "conf", ",", "0", ",", "true", ",", "test", "file", ")", ";", "assert", "true", "(", "fsck", "out", "contains", "(", "namenode", "fsck", "healthy", "status", ")", ")", ";", "}" ]
[ "returns", "the", "index", "of", "the", "key", "if", "already", "present", ",", "else", "-", "(", "index", "+", "1", ")", "for", "the", "next", "empty", "index", "this", "can", "be", "overridden", "in", "this", "pacakge", "to", "compare", "for", "equality", "differently", "than", "{", "@", "link", "object", "#", "equals", "(", "object", ")", "}" ]
[ "int", "locate", "key", "(", "t", "key", ")", "{", "if", "(", "key", "=", "=", "null", ")", "throw", "new", "illegal", "argument", "exception", "(", "\"", "key", "cannot", "be", "null", "\"", ")", ";", "t", "[", "]", "key", "table", "=", "this", "key", "table", ";", "for", "(", "int", "i", "=", "place", "(", "key", ")", ";", ";", "i", "=", "i", "+", "1", "&", "mask", ")", "{", "t", "other", "=", "key", "table", "[", "i", "]", ";", "if", "(", "other", "=", "=", "null", ")", "return", "-", "(", "i", "+", "1", ")", ";", "/", "/", "empty", "space", "is", "available", "if", "(", "other", "equals", "(", "key", ")", ")", "return", "i", ";", "/", "/", "same", "key", "was", "found", "}", "}" ]
[ "asynchronously", "deletes", "a", "snapshot", "repository", "see", "<", "a", "href", "=", "\"", "https", ":", "www", "elastic", "coguideenelasticsearchreferencecurrentmodules", "-", "snapshots", "html", "\"", ">", "snapshot", "and", "restore", "api", "on", "elastic", "co" ]
[ "public", "cancellable", "delete", "repository", "async", "(", "delete", "repository", "request", "delete", "repository", "request", ",", "request", "options", "options", ",", "action", "listener", "<", "acknowledged", "response", ">", "listener", ")", "{", "return", "rest", "high", "level", "client", "perform", "request", "async", "and", "parse", "entity", "(", "delete", "repository", "request", ",", "snapshot", "request", "converters", ":", ":", "delete", "repository", ",", "options", ",", "acknowledged", "response", ":", ":", "from", "x", "content", ",", "listener", ",", "empty", "set", "(", ")", ")", ";", "}" ]
[ "get", "the", "cluster", "name", "associated", "with", "all", "of", "the", "nodes" ]
[ "public", "string", "get", "cluster", "name", "(", ")", "{", "return", "cluster", "name", ";", "}" ]
[ "test", "the", "property", "'", "password", "'" ]
[ "public", "void", "password", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "password", "}" ]
[ "builds", "the", "object", "in", "random", "order", "and", "parses", "it" ]
[ "public", "void", "test", "random", "order", "(", ")", "throws", "exception", "{", "has", "ctor", "arguments", "expected", "=", "new", "has", "ctor", "arguments", "(", "random", "alpha", "of", "length", "(", "5", ")", ",", "random", "int", "(", ")", ")", ";", "expected", "set", "mineral", "(", "random", "int", "(", ")", ")", ";", "expected", "set", "fruit", "(", "random", "int", "(", ")", ")", ";", "expected", "set", "a", "(", "random", "boolean", "(", ")", "?", "null", ":", "random", "alpha", "of", "length", "(", "5", ")", ")", ";", "expected", "set", "b", "(", "random", "boolean", "(", ")", "?", "null", ":", "random", "alpha", "of", "length", "(", "5", ")", ")", ";", "expected", "set", "c", "(", "random", "boolean", "(", ")", "?", "null", ":", "random", "alpha", "of", "length", "(", "5", ")", ")", ";", "expected", "set", "d", "(", "random", "boolean", "(", ")", ")", ";", "x", "content", "builder", "builder", "=", "x", "content", "factory", "json", "builder", "(", ")", "pretty", "print", "(", ")", ";", "expected", "to", "x", "content", "(", "builder", ",", "to", "x", "content", "empty", "params", ")", ";", "builder", "=", "shuffle", "x", "content", "(", "builder", ")", ";", "builder", "flush", "(", ")", ";", "byte", "[", "]", "bytes", "=", "(", "(", "byte", "array", "output", "stream", ")", "builder", "get", "output", "stream", "(", ")", ")", "to", "byte", "array", "(", ")", ";", "try", "(", "x", "content", "parser", "parser", "=", "create", "parser", "(", "json", "x", "content", "json", "x", "content", ",", "bytes", ")", ")", "{", "has", "ctor", "arguments", "parsed", "=", "random", "from", "(", "has", "ctor", "arguments", "all", "parsers", ")", "apply", "(", "parser", ",", "null", ")", ";", "assert", "equals", "(", "expected", "animal", ",", "parsed", "animal", ")", ";", "assert", "equals", "(", "expected", "vegetable", ",", "parsed", "vegetable", ")", ";", "assert", "equals", "(", "expected", "mineral", ",", "parsed", "mineral", ")", ";", "assert", "equals", "(", "expected", "fruit", ",", "parsed", "fruit", ")", ";", "assert", "equals", "(", "expected", "a", ",", "parsed", "a", ")", ";", "assert", "equals", "(", "expected", "b", ",", "parsed", "b", ")", ";", "assert", "equals", "(", "expected", "c", ",", "parsed", "c", ")", ";", "assert", "equals", "(", "expected", "d", ",", "parsed", "d", ")", ";", "}", "}" ]
[ "asynchronously", "fulfills", "the", "request", "into", "the", "specified", "{", "@", "link", "remote", "views", "}", "object", "with", "the", "given", "{", "@", "code", "view", "id", "}", "this", "is", "used", "for", "loading", "bitmaps", "into", "a", "{", "@", "link", "notification", "}" ]
[ "public", "void", "into", "(", "@", "non", "null", "remote", "views", "remote", "views", ",", "@", "id", "res", "int", "view", "id", ",", "int", "notification", "id", ",", "@", "non", "null", "notification", "notification", ",", "@", "nullable", "string", "notification", "tag", ")", "{", "into", "(", "remote", "views", ",", "view", "id", ",", "notification", "id", ",", "notification", ",", "notification", "tag", ",", "null", ")", ";", "}" ]
[ "test", "the", "property", "'", "class", "name", "'" ]
[ "public", "void", "class", "name", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "class", "name", "}" ]
[ "waits", "until", "the", "list", "view", "is", "populated", "with", "content", ",", "that", "is", "until", "list", "of", "images", "is", "downloaded" ]
[ "private", "void", "wait", "for", "images", "(", ")", "throws", "exception", "{", "final", "atomic", "boolean", "m", "images", "loaded", "=", "new", "atomic", "boolean", "(", ")", ";", "while", "(", "!", "m", "images", "loaded", "get", "(", ")", ")", "{", "thread", "sleep", "(", "wait", "for", "images", "intercheck", "ms", ")", ";", "get", "instrumentation", "(", ")", "run", "on", "main", "sync", "(", "new", "runnable", "(", ")", "{", "@", "override", "public", "void", "run", "(", ")", "{", "m", "images", "loaded", "set", "(", "m", "image", "list", "get", "adapter", "(", ")", "get", "item", "count", "(", ")", ">", "0", ")", ";", "}", "}", ")", ";", "}", "}" ]
[ "handle", "a", "local", "time", "that", "happened", "before", "the", "start", "of", "an", "overlap" ]
[ "long", "before", "overlap", "(", "long", "local", "millis", ",", "overlap", "overlap", ")", ";" ]
[ "a", "callback", "method", "the", "user", "can", "implement", "to", "provide", "asynchronous", "handling", "of", "commit", "request", "failure", "this", "method", "will", "be", "called", "when", "the", "commit", "request", "failed" ]
[ "void", "on", "exception", "(", "throwable", "cause", ")", ";" ]
[ "this", "test", "creates", "some", "directories", "inside", "the", "volume", "roots", ",", "and", "then", "call", "async", "disk", "service", "move", "and", "delete", "all", "volumes", "we", "should", "be", "able", "to", "delete", "all", "filesdirs", "inside", "the", "volumes", "except", "the", "to", "be", "deleted", "directory" ]
[ "public", "void", "test", "m", "r", "async", "disk", "service", "move", "and", "delete", "all", "volumes", "(", ")", "throws", "throwable", "{", "file", "system", "local", "file", "system", "=", "file", "system", "get", "local", "(", "new", "configuration", "(", ")", ")", ";", "string", "[", "]", "vols", "=", "new", "string", "[", "]", "{", "test", "root", "dir", "+", "\"", "/", "0", "\"", ",", "test", "root", "dir", "+", "\"", "/", "1", "\"", "}", ";", "m", "r", "async", "disk", "service", "service", "=", "new", "m", "r", "async", "disk", "service", "(", "local", "file", "system", ",", "vols", ")", ";", "string", "a", "=", "\"", "a", "\"", ";", "string", "b", "=", "\"", "b", "\"", ";", "string", "c", "=", "\"", "b", "/", "c", "\"", ";", "string", "d", "=", "\"", "d", "\"", ";", "file", "fa", "=", "new", "file", "(", "vols", "[", "0", "]", ",", "a", ")", ";", "file", "fb", "=", "new", "file", "(", "vols", "[", "1", "]", ",", "b", ")", ";", "file", "fc", "=", "new", "file", "(", "vols", "[", "1", "]", ",", "c", ")", ";", "file", "fd", "=", "new", "file", "(", "vols", "[", "1", "]", ",", "d", ")", ";", "/", "/", "create", "the", "directories", "fa", "mkdirs", "(", ")", ";", "fb", "mkdirs", "(", ")", ";", "fc", "mkdirs", "(", ")", ";", "fd", "mkdirs", "(", ")", ";", "assert", "true", "(", "fa", "exists", "(", ")", ")", ";", "assert", "true", "(", "fb", "exists", "(", ")", ")", ";", "assert", "true", "(", "fc", "exists", "(", ")", ")", ";", "assert", "true", "(", "fd", "exists", "(", ")", ")", ";", "/", "/", "delete", "all", "of", "them", "service", "cleanup", "all", "volumes", "(", ")", ";", "assert", "false", "(", "fa", "exists", "(", ")", ")", ";", "assert", "false", "(", "fb", "exists", "(", ")", ")", ";", "assert", "false", "(", "fc", "exists", "(", ")", ")", ";", "assert", "false", "(", "fd", "exists", "(", ")", ")", ";", "/", "/", "make", "sure", "everything", "is", "cleaned", "up", "make", "sure", "cleaned", "up", "(", "vols", ",", "service", ")", ";", "}" ]
[ "saves", "the", "changes", "to", "the", "specified", "program", "if", "the", "program", "does", "not", "already", "exist", "in", "the", "current", "project", "then", "it", "will", "be", "saved", "into", "the", "root", "folder", "if", "a", "program", "already", "exists", "with", "the", "specified", "name", ",", "then", "a", "time", "stamp", "will", "be", "appended", "to", "the", "name", "to", "make", "it", "unique" ]
[ "public", "void", "save", "program", "(", "program", "program", ")", "throws", "exception", "{", "save", "program", "(", "program", ",", "null", ")", ";", "}" ]
[ "tells", "the", "system", "that", "spark", "was", "run", "from", "an", "\"", "external", "\"", "web", "application", "server" ]
[ "public", "static", "void", "run", "from", "servlet", "(", ")", "{", "is", "running", "from", "servlet", "set", "(", "true", ")", ";", "}" ]
[ "check", "if", "identity", "is", "allowed", "to", "execute", "show", "schemas", "in", "a", "catalog", "note", ":", "this", "method", "is", "only", "present", "to", "give", "users", "an", "error", "message", "when", "listing", "is", "not", "allowed", "the", "{", "@", "link", "#", "filter", "schemas", "}", "method", "must", "filter", "all", "results", "for", "unauthorized", "users", ",", "since", "there", "are", "multiple", "ways", "to", "list", "schemas" ]
[ "default", "void", "check", "can", "show", "schemas", "(", "identity", "identity", ",", "access", "control", "context", "context", ",", "string", "catalog", "name", ")", "{", "deny", "show", "schemas", "(", ")", ";", "}" ]
[ "check", "if", "the", "replica", "is", "stale", "must", "be", "called", "with", "the", "cache", "lock", "held" ]
[ "boolean", "is", "stale", "(", ")", "{", "if", "(", "slot", "!", "=", "null", ")", "{", "/", "/", "check", "staleness", "by", "looking", "at", "the", "shared", "memory", "area", "we", "use", "to", "/", "/", "communicate", "with", "the", "data", "node", "boolean", "stale", "=", "!", "slot", "is", "valid", "(", ")", ";", "log", "trace", "(", "\"", "{", "}", ":", "checked", "shared", "memory", "segment", "is", "stale", "=", "{", "}", "\"", ",", "this", ",", "stale", ")", ";", "return", "stale", ";", "}", "else", "{", "/", "/", "fall", "back", "to", "old", ",", "time", "-", "based", "staleness", "method", "long", "delta", "ms", "=", "time", "monotonic", "now", "(", ")", "-", "creation", "time", "ms", ";", "long", "stale", "threshold", "ms", "=", "cache", "get", "stale", "threshold", "ms", "(", ")", ";", "if", "(", "delta", "ms", ">", "stale", "threshold", "ms", ")", "{", "log", "trace", "(", "\"", "{", "}", "is", "stale", "because", "it", "'", "s", "{", "}", "ms", "old", "and", "stale", "threadhold", "m", "s", "=", "{", "}", "\"", ",", "this", ",", "delta", "ms", ",", "stale", "threshold", "ms", ")", ";", "return", "true", ";", "}", "else", "{", "log", "trace", "(", "\"", "{", "}", "is", "not", "stale", "because", "it", "'", "s", "only", "{", "}", "ms", "old", "\"", "+", "\"", "and", "stale", "threshold", "ms", "=", "{", "}", "\"", ",", "this", ",", "delta", "ms", ",", "stale", "threshold", "ms", ")", ";", "return", "false", ";", "}", "}", "}" ]
[ "inject", "fake", "stats", "for", "min", "outlier", "detection", "peers", "fast", "nodes" ]
[ "public", "void", "inject", "fast", "nodes", "samples", "(", "data", "node", "peer", "metrics", "peer", "metrics", ")", "{", "for", "(", "int", "node", "index", "=", "0", ";", "node", "index", "<", "min", "outlier", "detection", "peers", ";", "+", "+", "node", "index", ")", "{", "final", "string", "node", "name", "=", "\"", "fast", "node", "-", "\"", "+", "node", "index", ";", "log", "info", "(", "\"", "generating", "stats", "for", "node", "{", "}", "\"", ",", "node", "name", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "2", "*", "peer", "metrics", "get", "min", "outlier", "detection", "samples", "(", ")", ";", "+", "+", "i", ")", "{", "peer", "metrics", "add", "send", "packet", "downstream", "(", "node", "name", ",", "random", "next", "int", "(", "fast", "node", "max", "latency", "ms", ")", ")", ";", "}", "}", "}" ]
[ "write", "string", "to", "a", "file", ",", "formatting", "as", "utf", "-", "8" ]
[ "public", "file", "write", "to", "file", "(", "string", "filename", ",", "string", "contents", ")", "throws", "i", "o", "exception", "{", "return", "write", "to", "file", "(", "filename", ",", "contents", "get", "bytes", "(", "standard", "charsets", "utf", "8", ")", ")", ";", "}" ]
[ "on", "close", "test" ]
[ "public", "void", "on", "close", "test", "(", "global", "session", "global", "session", ")", "throws", "exception", "{", "for", "(", "session", "manager", "session", "manager", ":", "session", "manager", "list", ")", "{", "session", "manager", "on", "begin", "(", "global", "session", ")", ";", "session", "manager", "on", "close", "(", "global", "session", ")", ";", "session", "manager", "on", "end", "(", "global", "session", ")", ";", "}", "}" ]
[ "read", "bean", "definitions", "from", "the", "given", "dom", "document", "and", "register", "them", "with", "the", "registry", "in", "the", "given", "reader", "context" ]
[ "void", "register", "bean", "definitions", "(", "document", "doc", ",", "xml", "reader", "context", "reader", "context", ")", "throws", "bean", "definition", "store", "exception", ";" ]
[ "return", "whether", "the", "request", "failed" ]
[ "public", "boolean", "was", "failure", "(", ")", "{", "return", "(", "this", "failure", "cause", "!", "=", "null", ")", ";", "}" ]
[ "returns", "a", "domain", "file", ",", "using", "the", "title", "parameter", "for", "guidance", "the", "actual", "behavior", "of", "the", "method", "depends", "on", "your", "environment", ",", "which", "can", "be", "gui", "or", "headless", "regardless", "of", "environment", "-", "-", "if", "script", "arguments", "have", "been", "set", ",", "this", "method", "will", "use", "the", "next", "argument", "in", "the", "array", "and", "advance", "the", "array", "index", "so", "the", "next", "call", "to", "an", "ask", "method", "will", "get", "the", "next", "argument", "if", "there", "are", "no", "script", "arguments", "and", "a", "properties", "file", "sharing", "the", "same", "base", "name", "as", "the", "ghidra", "script", "exists", "(", "i", "e", ",", "script", "1", "properties", "for", "script", "1", "java", ")", ",", "then", "this", "method", "will", "then", "look", "there", "for", "the", "string", "value", "to", "return", "the", "method", "will", "look", "in", "the", "properties", "file", "by", "searching", "for", "a", "property", "name", "that", "is", "the", "title", "string", "parameter", "if", "that", "property", "name", "exists", "and", "its", "value", "represents", "a", "valid", "domain", "file", ",", "then", "the", "properties", "value", "will", "be", "used", "in", "the", "following", "way", ":", "in", "the", "gui", "environment", ",", "this", "method", "displays", "a", "popup", "dialog", "listing", "all", "domain", "files", "in", "the", "current", "project", ",", "allowing", "the", "user", "to", "select", "one", "in", "the", "headless", "environment", ",", "if", "a", "properties", "file", "sharing", "the", "same", "base", "name", "as", "the", "ghidra", "script", "exists", "(", "i", "e", ",", "script", "1", "properties", "for", "script", "1", "java", ")", ",", "then", "this", "method", "looks", "there", "for", "the", "name", "of", "the", "domain", "file", "to", "return", "the", "method", "will", "look", "in", "the", "properties", "file", "by", "searching", "for", "a", "property", "name", "equal", "to", "the", "'", "title", "'", "parameter", "if", "that", "property", "name", "exists", "and", "its", "value", "represents", "a", "valid", "domain", "file", "in", "the", "project", ",", "then", "that", "value", "is", "returned", "otherwise", ",", "an", "exception", "is", "thrown", "if", "there", "is", "an", "invalid", "or", "missing", "properties", "value" ]
[ "public", "domain", "file", "ask", "domain", "file", "(", "string", "title", ")", "throws", "cancelled", "exception", "{", "domain", "file", "existing", "value", "=", "load", "ask", "value", "(", "this", ":", ":", "parse", "domain", "file", ",", "title", ")", ";", "if", "(", "is", "running", "headless", "(", ")", ")", "{", "return", "existing", "value", ";", "}", "string", "message", "=", "\"", "\"", ";", "domain", "file", "choice", "=", "do", "ask", "(", "domain", "file", "class", ",", "title", ",", "message", ",", "existing", "value", ",", "last", "value", "-", ">", "{", "data", "tree", "dialog", "dtd", "=", "new", "data", "tree", "dialog", "(", "null", ",", "title", ",", "data", "tree", "dialog", "open", ")", ";", "atomic", "reference", "<", "domain", "file", ">", "ref", "=", "new", "atomic", "reference", "<", ">", "(", ")", ";", "dtd", "add", "ok", "action", "listener", "(", "e", "-", ">", "{", "ref", "set", "(", "dtd", "get", "domain", "file", "(", ")", ")", ";", "dtd", "close", "(", ")", ";", "}", ")", ";", "runnable", "r", "=", "(", ")", "-", ">", "dtd", "show", "component", "(", ")", ";", "swing", "run", "now", "(", "r", ")", ";", "if", "(", "dtd", "was", "cancelled", "(", ")", ")", "{", "throw", "new", "cancelled", "exception", "(", ")", ";", "}", "return", "ref", "get", "(", ")", ";", "}", ")", ";", "return", "choice", ";", "}" ]
[ "how", "often", "this", "timer", "listener", "should", "'", "tick", "'", "defined", "in", "milliseconds" ]
[ "public", "int", "get", "interval", "time", "in", "milliseconds", "(", ")", ";" ]
[ "one", "or", "more", "endpoints", "associated", "with", "the", "service", "<", "code", ">", "repeated", "istio", "networking", "v", "1alpha", "3", "service", "entry", "endpoint", "endpoints", "=", "6", ";", "<", "code", ">" ]
[ "public", "java", "util", "list", "<", "com", "alibaba", "nacos", "istio", "model", "naming", "service", "entry", "endpoint", ">", "get", "endpoints", "list", "(", ")", "{", "if", "(", "endpoints", "builder", "=", "=", "null", ")", "{", "return", "java", "util", "collections", "unmodifiable", "list", "(", "endpoints", ")", ";", "}", "else", "{", "return", "endpoints", "builder", "get", "message", "list", "(", ")", ";", "}", "}" ]
[ "return", "the", "current", "epoch", "time", ",", "used", "to", "find", "absolute", "time", "this", "is", "a", "cached", "version", "of", "{", "@", "link", "system", "#", "current", "time", "millis", "(", ")", "}", "if", "{", "@", "link", "thread", "pool", "#", "estimated", "time", "interval", "setting", "}", "is", "set", "to", "0", "then", "the", "cache", "is", "disabled", "and", "the", "method", "calls", "{", "@", "link", "system", "#", "current", "time", "millis", "(", ")", "}", "whenever", "called", "typically", "used", "for", "testing" ]
[ "long", "absolute", "time", "in", "millis", "(", ")", "{", "if", "(", "0", "<", "interval", ")", "{", "return", "absolute", "millis", ";", "}", "return", "system", "current", "time", "millis", "(", ")", ";", "}" ]
[ "decodes", "the", "provided", "byte", "[", "]", "to", "a", "utf", "-", "8", "char", "[", "]", "this", "is", "done", "while", "avoiding", "conversions", "to", "string", "the", "provided", "byte", "[", "]", "is", "not", "modified", "by", "this", "method", ",", "so", "the", "caller", "needs", "to", "take", "care", "of", "clearing", "the", "value", "if", "it", "is", "sensitive" ]
[ "public", "static", "char", "[", "]", "utf", "8", "bytes", "to", "chars", "(", "byte", "[", "]", "utf", "8", "bytes", ")", "{", "final", "byte", "buffer", "byte", "buffer", "=", "byte", "buffer", "wrap", "(", "utf", "8", "bytes", ")", ";", "final", "char", "buffer", "char", "buffer", "=", "standard", "charsets", "utf", "8", "decode", "(", "byte", "buffer", ")", ";", "final", "char", "[", "]", "chars", ";", "if", "(", "char", "buffer", "has", "array", "(", ")", ")", "{", "/", "/", "there", "is", "no", "guarantee", "that", "the", "char", "buffers", "backing", "array", "is", "the", "right", "size", "/", "/", "so", "we", "need", "to", "make", "a", "copy", "chars", "=", "arrays", "copy", "of", "range", "(", "char", "buffer", "array", "(", ")", ",", "char", "buffer", "position", "(", ")", ",", "char", "buffer", "limit", "(", ")", ")", ";", "arrays", "fill", "(", "char", "buffer", "array", "(", ")", ",", "(", "char", ")", "0", ")", ";", "/", "/", "clear", "sensitive", "data", "}", "else", "{", "final", "int", "length", "=", "char", "buffer", "limit", "(", ")", "-", "char", "buffer", "position", "(", ")", ";", "chars", "=", "new", "char", "[", "length", "]", ";", "char", "buffer", "get", "(", "chars", ")", ";", "/", "/", "if", "the", "buffer", "is", "not", "read", "only", "we", "can", "reset", "and", "fill", "with", "0", "'", "s", "if", "(", "char", "buffer", "is", "read", "only", "(", ")", "=", "=", "false", ")", "{", "char", "buffer", "clear", "(", ")", ";", "/", "/", "reset", "for", "(", "int", "i", "=", "0", ";", "i", "<", "char", "buffer", "limit", "(", ")", ";", "i", "+", "+", ")", "{", "char", "buffer", "put", "(", "(", "char", ")", "0", ")", ";", "}", "}", "}", "return", "chars", ";", "}" ]
[ "must", "be", "called", "when", "values", "in", "one", "or", "more", "parts", "have", "changed" ]
[ "protected", "void", "reset", "all", "parts", "(", ")", "{", "title", "line", "=", "null", ";", "header", "lines", "=", "null", ";", "main", "header", "lines", "=", "null", ";", "main", "lines", "=", "null", ";", "footer", "lines", "=", "null", ";", "total", "main", "width", "=", "0", ";", "}" ]
[ "creates", "labels", "for", "the", "block", "names" ]
[ "private", "void", "build", "labels", "(", ")", "{", "remove", "all", "(", ")", ";", "set", "layout", "(", "null", ")", ";", "container", "parent", "=", "get", "parent", "(", ")", ";", "memory", "block", "[", "]", "blocks", "=", "map", "get", "blocks", "(", ")", ";", "if", "(", "blocks", "=", "=", "null", ")", "{", "return", ";", "}", "for", "(", "memory", "block", "block", ":", "blocks", ")", "{", "j", "label", "label", "=", "new", "g", "d", "label", "(", "block", "get", "name", "(", ")", ")", ";", "label", "set", "font", "(", "font", ")", ";", "label", "set", "horizontal", "alignment", "(", "swing", "constants", "center", ")", ";", "label", "set", "tool", "tip", "text", "(", "block", "get", "name", "(", ")", ")", ";", "rectangle", "rect", "=", "map", "get", "block", "position", "(", "block", ")", ";", "int", "height", "=", "get", "height", "(", ")", ";", "int", "width", "=", "metrics", "string", "width", "(", "block", "get", "name", "(", ")", ")", ";", "if", "(", "rect", "width", "<", "width", ")", "{", "label", "set", "text", "(", "\"", "\"", ")", ";", "}", "int", "label", "width", "=", "math", "min", "(", "rect", "width", ",", "width", ")", ";", "label", "width", "=", "math", "max", "(", "label", "width", ",", "3", ")", ";", "int", "label", "height", "=", "height", "-", "1", ";", "int", "x", "=", "rect", "x", "+", "(", "rect", "width", "-", "1", ")", "/", "2", "-", "label", "width", "/", "2", ";", "int", "y", "=", "0", ";", "label", "set", "bounds", "(", "x", ",", "y", ",", "label", "width", ",", "label", "height", ")", ";", "add", "(", "label", ")", ";", "}", "invalidate", "(", ")", ";", "if", "(", "parent", "!", "=", "null", ")", "{", "parent", "validate", "(", ")", ";", "}", "}" ]
[ "gets", "the", "maximum", "allowed", "message", "size", "acceptable", "to", "send", "the", "remote", "peer" ]
[ "public", "integer", "get", "max", "outbound", "message", "size", "(", ")", "{", "return", "max", "outbound", "message", "size", ";", "}" ]
[ "add", "a", "configuration", "resource", "the", "properties", "of", "this", "resource", "will", "override", "properties", "of", "previously", "added", "resources", ",", "unless", "they", "were", "marked", "<", "a", "href", "=", "\"", "#", "final", "\"", ">", "final", "warning", ":", "the", "contents", "of", "the", "input", "stream", "will", "be", "cached", ",", "by", "this", "method", "so", "use", "this", "sparingly", "because", "it", "does", "increase", "the", "memory", "consumption" ]
[ "public", "void", "add", "resource", "(", "input", "stream", "in", ")", "{", "add", "resource", "object", "(", "new", "resource", "(", "in", ")", ")", ";", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "void", "put", "(", "merged", "context", "configuration", "key", ",", "application", "context", "context", ")", "{", "assert", "not", "null", "(", "key", ",", "\"", "key", "must", "not", "be", "null", "\"", ")", ";", "assert", "not", "null", "(", "context", ",", "\"", "application", "context", "must", "not", "be", "null", "\"", ")", ";", "this", "context", "map", "put", "(", "key", ",", "context", ")", ";", "merged", "context", "configuration", "child", "=", "key", ";", "merged", "context", "configuration", "parent", "=", "child", "get", "parent", "(", ")", ";", "while", "(", "parent", "!", "=", "null", ")", "{", "set", "<", "merged", "context", "configuration", ">", "list", "=", "this", "hierarchy", "map", "compute", "if", "absent", "(", "parent", ",", "k", "-", ">", "new", "hash", "set", "<", ">", "(", ")", ")", ";", "list", "add", "(", "child", ")", ";", "child", "=", "parent", ";", "parent", "=", "child", "get", "parent", "(", ")", ";", "}", "}" ]
[ "returns", "the", "value", "stored", "under", "{", "@", "link", "#", "key", "redirected", "uri", "}", "as", "a", "{", "@", "link", "uri", "}", ",", "or", "{", "code", "null", "}", "if", "not", "set" ]
[ "static", "uri", "get", "redirected", "uri", "(", "content", "metadata", "content", "metadata", ")", "{", "@", "nullable", "string", "redirected", "uri", "=", "content", "metadata", "get", "(", "key", "redirected", "uri", ",", "(", "string", ")", "null", ")", ";", "return", "redirected", "uri", "=", "=", "null", "?", "null", ":", "uri", "parse", "(", "redirected", "uri", ")", ";", "}" ]
[ "set", "whether", "to", "apply", "suffix", "pattern", "matching", "in", "patterns", "request", "condition", "by", "default", "this", "is", "set", "to", "'", "false", "'" ]
[ "public", "void", "set", "suffix", "pattern", "match", "(", "boolean", "suffix", "pattern", "match", ")", "{", "this", "suffix", "pattern", "match", "=", "suffix", "pattern", "match", ";", "}" ]
[ "return", "the", "bytes", "in", "cache" ]
[ "public", "static", "byte", "[", "]", "get", "bytes", "(", "@", "non", "null", "final", "string", "key", ")", "{", "return", "get", "bytes", "(", "key", ",", "get", "default", "cache", "disk", "utils", "(", ")", ")", ";", "}" ]
[ "flips", "the", "sign", "bit", "(", "most", "-", "significant", "-", "bit", ")", "of", "the", "input" ]
[ "public", "static", "long", "flip", "sign", "bit", "(", "long", "in", ")", "{", "return", "in", "^", "long", "min", "value", ";", "}" ]
[ "writes", "the", "contents", "of", "the", "given", "array" ]
[ "public", "void", "write", "(", "long", "[", "]", "data", ")", ";" ]
[ "returns", "whether", "the", "bundle", "is", "finished" ]
[ "public", "boolean", "is", "bundle", "finished", "(", ")", "{", "return", "element", "count", "=", "=", "0", ";", "}" ]
[ "test", "the", "property", "'", "category", "'" ]
[ "public", "void", "category", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "category", "}" ]
[ "evict", "the", "mapping", "for", "this", "key", "from", "this", "cache", "if", "it", "is", "present", "actual", "eviction", "may", "be", "performed", "in", "an", "asynchronous", "or", "deferred", "fashion", ",", "with", "subsequent", "lookups", "possibly", "still", "seeing", "the", "entry", "this", "may", "for", "example", "be", "the", "case", "with", "transactional", "cache", "decorators", "use", "{", "@", "link", "#", "evict", "if", "present", "}", "for", "guaranteed", "immediate", "removal" ]
[ "void", "evict", "(", "object", "key", ")", ";" ]
[ "if", "bs", "diff", "result", "is", "too", "larger", ",", "just", "treat", "it", "as", "newly", "file" ]
[ "public", "static", "boolean", "check", "bs", "diff", "file", "size", "(", "file", "bs", "diff", "file", ",", "file", "new", "file", ")", "{", "if", "(", "!", "bs", "diff", "file", "exists", "(", ")", ")", "{", "throw", "new", "tinker", "patch", "exception", "(", "\"", "can", "not", "find", "the", "bs", "diff", "file", ":", "\"", "+", "bs", "diff", "file", "get", "absolute", "path", "(", ")", ")", ";", "}", "/", "/", "check", "bs", "diff", "file", "file", "size", "double", "ratio", "=", "bs", "diff", "file", "length", "(", ")", "/", "(", "double", ")", "new", "file", "length", "(", ")", ";", "if", "(", "ratio", ">", "typed", "value", "bsdiff", "patch", "max", "ratio", ")", "{", "logger", "e", "(", "\"", "bs", "diff", "patch", "file", ":", "%", "s", ",", "size", ":", "%", "dk", ",", "new", "file", ":", "%", "s", ",", "size", ":", "%", "dk", "patch", "file", "is", "too", "large", ",", "treat", "it", "as", "newly", "file", "to", "save", "patch", "time", "!", "\"", ",", "bs", "diff", "file", "get", "name", "(", ")", ",", "bs", "diff", "file", "length", "(", ")", "/", "1024", ",", "new", "file", "get", "name", "(", ")", ",", "new", "file", "length", "(", ")", "/", "1024", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}" ]
[ "what", "table", "is", "to", "be", "read", "per", "instance", "of", "a", "table", "input", "format", "derivative", "only", "a", "single", "table", "name", "is", "possible" ]
[ "protected", "abstract", "string", "get", "table", "name", "(", ")", ";" ]
[ "parse", "the", "given", "string", "with", "matrix", "variables", "an", "example", "string", "would", "look", "like", "this", "{", "@", "code", "\"", "q", "1", "=", "a", ";", "q", "1", "=", "b", ";", "q", "2", "=", "a", ",", "b", ",", "c", "\"", "}", "the", "resulting", "map", "would", "contain", "keys", "{", "@", "code", "\"", "q", "1", "\"", "}", "and", "{", "@", "code", "\"", "q", "2", "\"", "}", "with", "values", "{", "@", "code", "[", "\"", "a", "\"", ",", "\"", "b", "\"", "]", "}", "and", "{", "@", "code", "[", "\"", "a", "\"", ",", "\"", "b", "\"", ",", "\"", "c", "\"", "]", "}", "respectively" ]
[ "public", "static", "multi", "value", "map", "<", "string", ",", "string", ">", "parse", "matrix", "variables", "(", "string", "matrix", "variables", ")", "{", "multi", "value", "map", "<", "string", ",", "string", ">", "result", "=", "new", "linked", "multi", "value", "map", "<", ">", "(", ")", ";", "if", "(", "!", "string", "utils", "has", "text", "(", "matrix", "variables", ")", ")", "{", "return", "result", ";", "}", "string", "tokenizer", "pairs", "=", "new", "string", "tokenizer", "(", "matrix", "variables", ",", "\"", ";", "\"", ")", ";", "while", "(", "pairs", "has", "more", "tokens", "(", ")", ")", "{", "string", "pair", "=", "pairs", "next", "token", "(", ")", ";", "int", "index", "=", "pair", "index", "of", "(", "'", "=", "'", ")", ";", "if", "(", "index", "!", "=", "-", "1", ")", "{", "string", "name", "=", "pair", "substring", "(", "0", ",", "index", ")", ";", "if", "(", "name", "equals", "ignore", "case", "(", "\"", "jsessionid", "\"", ")", ")", "{", "continue", ";", "}", "string", "raw", "value", "=", "pair", "substring", "(", "index", "+", "1", ")", ";", "for", "(", "string", "value", ":", "string", "utils", "comma", "delimited", "list", "to", "string", "array", "(", "raw", "value", ")", ")", "{", "result", "add", "(", "name", ",", "value", ")", ";", "}", "}", "else", "{", "result", "add", "(", "pair", ",", "\"", "\"", ")", ";", "}", "}", "return", "result", ";", "}" ]
[ "resolve", "the", "target", "class", "to", "convert", "the", "payload", "to", "by", "default", "this", "is", "the", "generic", "type", "declared", "in", "the", "{", "@", "code", "message", "}", "method", "parameter", "but", "that", "can", "be", "overridden", "to", "select", "a", "more", "specific", "target", "type", "after", "also", "taking", "into", "account", "the", "\"", "content", "-", "type", "\"", ",", "e", "g", "return", "{", "@", "code", "string", "}", "if", "target", "type", "is", "{", "@", "code", "object", "}", "and", "{", "@", "code", "\"", "content", "-", "type", ":", "text", "\"", "}" ]
[ "protected", "class", "<", "?", ">", "get", "payload", "type", "(", "method", "parameter", "parameter", ",", "message", "<", "?", ">", "message", ")", "{", "type", "generic", "param", "type", "=", "parameter", "get", "generic", "parameter", "type", "(", ")", ";", "resolvable", "type", "resolvable", "type", "=", "resolvable", "type", "for", "type", "(", "generic", "param", "type", ")", "as", "(", "message", "class", ")", ";", "return", "resolvable", "type", "get", "generic", "(", ")", "to", "class", "(", ")", ";", "}" ]
[ "returns", "the", "multi", "-", "architecture", "binary", "that", "apple", "binary", "created" ]
[ "public", "artifact", "get", "apple", "loadable", "bundle", "binary", "(", ")", "{", "return", "apple", "loadable", "bundle", "binary", ";", "}" ]
[ "calculate", "the", "digest", "based", "on", "the", "given", "params", "besides", "the", "path", "and", "data", ",", "the", "following", "stat", "fields", "are", "included", "in", "the", "digest", "calculation", ":", "-", "long", "czxid", "8", "bytes", "-", "long", "mzxid", "8", "bytes", "-", "long", "pzxid", "8", "bytes", "-", "long", "ctime", "8", "bytes", "-", "long", "mtime", "8", "bytes", "-", "int", "version", "4", "bytes", "-", "int", "cversion", "4", "bytes", "-", "int", "aversion", "4", "bytes", "-", "long", "ephemeral", "owner", "8", "bytes" ]
[ "long", "calculate", "digest", "(", "string", "path", ",", "byte", "[", "]", "data", ",", "stat", "persisted", "stat", ")", "{", "if", "(", "!", "zoo", "keeper", "server", "is", "digest", "enabled", "(", ")", ")", "{", "return", "0", ";", "}", "/", "/", "quota", "nodes", "are", "updated", "locally", ",", "there", "is", "inconsistent", "issue", "/", "/", "when", "we", "tried", "to", "release", "digest", "feature", "at", "the", "beginning", "/", "/", "/", "/", "instead", "of", "taking", "time", "to", "fix", "that", ",", "we", "decided", "to", "disable", "digest", "/", "/", "check", "for", "all", "the", "nodes", "under", "/", "zookeeper", "/", "first", "/", "/", "/", "/", "we", "can", "enable", "this", "after", "fixing", "that", "inconsistent", "problem", "the", "/", "/", "digest", "version", "in", "the", "protocol", "enables", "us", "to", "change", "the", "digest", "/", "/", "calculation", "without", "disrupting", "the", "system", "if", "(", "path", "starts", "with", "(", "zoo", "defs", "zookeeper", "node", "subtree", ")", ")", "{", "return", "0", ";", "}", "/", "/", "\"", "\"", "and", "\"", "/", "\"", "are", "aliases", "to", "each", "other", ",", "in", "data", "tree", "when", "adding", "child", "/", "/", "under", "\"", "/", "\"", ",", "it", "will", "use", "\"", "\"", "as", "the", "path", ",", "but", "when", "set", "data", "or", "change", "/", "/", "acl", "on", "\"", "/", "\"", ",", "it", "will", "use", "\"", "/", "\"", "as", "the", "path", "always", "mapping", "\"", "/", "\"", "to", "\"", "\"", "/", "/", "to", "avoid", "mismatch", "if", "(", "path", "equals", "(", "\"", "/", "\"", ")", ")", "{", "path", "=", "\"", "\"", ";", "}", "/", "/", "total", "=", "8", "*", "6", "+", "4", "*", "3", "=", "60", "bytes", "byte", "[", "]", "b", "=", "new", "byte", "[", "60", "]", ";", "byte", "buffer", "bb", "=", "byte", "buffer", "wrap", "(", "b", ")", ";", "bb", "put", "long", "(", "stat", "get", "czxid", "(", ")", ")", ";", "bb", "put", "long", "(", "stat", "get", "mzxid", "(", ")", ")", ";", "bb", "put", "long", "(", "stat", "get", "pzxid", "(", ")", ")", ";", "bb", "put", "long", "(", "stat", "get", "ctime", "(", ")", ")", ";", "bb", "put", "long", "(", "stat", "get", "mtime", "(", ")", ")", ";", "bb", "put", "int", "(", "stat", "get", "version", "(", ")", ")", ";", "bb", "put", "int", "(", "stat", "get", "cversion", "(", ")", ")", ";", "bb", "put", "int", "(", "stat", "get", "aversion", "(", ")", ")", ";", "bb", "put", "long", "(", "stat", "get", "ephemeral", "owner", "(", ")", ")", ";", "crc32", "crc", "=", "new", "crc32", "(", ")", ";", "crc", "update", "(", "path", "get", "bytes", "(", ")", ")", ";", "if", "(", "data", "!", "=", "null", ")", "{", "crc", "update", "(", "data", ")", ";", "}", "crc", "update", "(", "b", ")", ";", "return", "crc", "get", "value", "(", ")", ";", "}" ]
[ "set", "the", "{", "@", "link", "marshaller", "}", "to", "be", "used", "by", "this", "message", "converter" ]
[ "public", "void", "set", "marshaller", "(", "@", "nullable", "marshaller", "marshaller", ")", "{", "this", "marshaller", "=", "marshaller", ";", "}" ]
[ "add", "a", "custom", "property", "to", "this", "jax", "-", "ws", "binding", "provider" ]
[ "public", "void", "add", "custom", "property", "(", "string", "name", ",", "object", "value", ")", "{", "get", "custom", "properties", "(", ")", "put", "(", "name", ",", "value", ")", ";", "}" ]
[ "returns", "a", "subset", "of", "conjuncts", "matching", "one", "the", "following", "shapes", ":", "-", "st", "distance", "(", ")", "<", "=", "-", "st", "distance", "(", ")", "<", "-", ">", "=", "st", "distance", "(", ")", "-", ">", "st", "distance", "(", ")", "doesn", "'", "t", "check", "or", "guarantee", "anything", "about", "st", "distance", "functions", "arguments", "or", "the", "other", "side", "of", "the", "comparison" ]
[ "public", "static", "list", "<", "call", "expression", ">", "extract", "supported", "spatial", "comparisons", "(", "row", "expression", "filter", "expression", ",", "function", "and", "type", "manager", "function", "and", "type", "manager", ")", "{", "return", "logical", "row", "expressions", "extract", "conjuncts", "(", "filter", "expression", ")", "stream", "(", ")", "filter", "(", "call", "expression", "class", ":", ":", "is", "instance", ")", "map", "(", "call", "expression", "class", ":", ":", "cast", ")", "filter", "(", "call", "-", ">", "new", "function", "resolution", "(", "function", "and", "type", "manager", ")", "is", "comparison", "function", "(", "call", "get", "function", "handle", "(", ")", ")", ")", "filter", "(", "call", "-", ">", "is", "supported", "spatial", "comparison", "(", "call", ",", "function", "and", "type", "manager", ")", ")", "collect", "(", "to", "immutable", "list", "(", ")", ")", ";", "}" ]
[ "sets", "the", "{", "@", "code", "reader", "index", "}", "of", "this", "buffer" ]
[ "void", "reader", "index", "(", "int", "reader", "index", ")", ";" ]
[ "return", "the", "digest", "value" ]
[ "long", "get", "digest", "(", ")", ";" ]
[ "returns", "a", "description", "of", "this", "actions", "owner", "for", "most", "actions", "this", "will", "return", "the", "same", "value", "as", "{", "@", "link", "#", "get", "owner", "(", ")", "}" ]
[ "public", "default", "string", "get", "owner", "description", "(", ")", "{", "return", "get", "owner", "(", ")", ";", "}" ]
[ "configure", "one", "or", "more", "factories", "to", "decorate", "the", "handler", "used", "to", "process", "web", "socket", "messages", "this", "may", "be", "useful", "in", "some", "advanced", "use", "cases", ",", "for", "example", "to", "allow", "spring", "security", "to", "forcibly", "close", "the", "web", "socket", "session", "when", "the", "corresponding", "http", "session", "expires" ]
[ "public", "web", "socket", "transport", "registration", "set", "decorator", "factories", "(", "web", "socket", "handler", "decorator", "factory", "factories", ")", "{", "this", "decorator", "factories", "add", "all", "(", "arrays", "as", "list", "(", "factories", ")", ")", ";", "return", "this", ";", "}" ]
[ "gets", "branch", "id" ]
[ "public", "long", "get", "branch", "id", "(", ")", "{", "return", "branch", "id", ";", "}" ]
[ "returns", "threshold", "value", "of", "number", "of", "pending", "for", "fast", "open", "connect" ]
[ "public", "int", "get", "tcp", "fastopen", "(", ")", "{", "return", "pending", "fast", "open", "requests", "threshold", ";", "}" ]
[ "fills", "the", "cache", "up", "to", "the", "population", "size" ]
[ "private", "void", "populate", "(", "cache", "context", "context", ",", "cache", "<", "integer", ",", "integer", ">", "cache", ")", "{", "if", "(", "context", "population", "size", "(", ")", "=", "=", "0", ")", "{", "return", ";", "}", "int", "maximum", "=", "(", "int", ")", "math", "min", "(", "context", "maximum", "size", "(", ")", ",", "context", "population", "size", "(", ")", ")", ";", "int", "first", "=", "base", "+", "(", "int", ")", "math", "min", "(", "0", ",", "context", "population", "size", "(", ")", ")", ";", "int", "last", "=", "base", "+", "maximum", "-", "1", ";", "int", "middle", "=", "math", "max", "(", "first", ",", "base", "+", "(", "(", "last", "-", "first", ")", "/", "2", ")", ")", ";", "context", "disable", "rejecting", "cache", "writer", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "maximum", ";", "i", "+", "+", ")", "{", "map", "entry", "<", "integer", ",", "integer", ">", "entry", "=", "ints", "get", "(", "i", ")", ";", "/", "/", "reference", "caching", "(", "weak", ",", "soft", ")", "require", "unique", "instances", "for", "identity", "comparison", "integer", "key", "=", "context", "is", "strong", "keys", "(", ")", "?", "entry", "get", "key", "(", ")", ":", "new", "integer", "(", "base", "+", "i", ")", ";", "integer", "value", "=", "context", "is", "strong", "values", "(", ")", "?", "entry", "get", "value", "(", ")", ":", "new", "integer", "(", "-", "key", ")", ";", "if", "(", "key", "=", "=", "first", ")", "{", "context", "first", "key", "=", "key", ";", "}", "if", "(", "key", "=", "=", "middle", ")", "{", "context", "middle", "key", "=", "key", ";", "}", "if", "(", "key", "=", "=", "last", ")", "{", "context", "last", "key", "=", "key", ";", "}", "cache", "put", "(", "key", ",", "value", ")", ";", "context", "original", "put", "(", "key", ",", "value", ")", ";", "context", "ticker", "(", ")", "advance", "(", "context", "advance", "time", "nanos", "(", ")", ",", "time", "unit", "nanoseconds", ")", ";", "}", "context", "enable", "rejecting", "cache", "writer", "(", ")", ";", "if", "(", "context", "writer", "(", ")", "=", "=", "writer", "mockito", ")", "{", "reset", "(", "context", "cache", "writer", "(", ")", ")", ";", "}", "}" ]
[ "special", "binding", "for", "'", "'", "as", "it", "is", "not", "handled", "by", "the", "wildcard", "binding" ]
[ "public", "response", "put", "root", "(", "input", "stream", "is", ",", "@", "context", "uri", "info", "uri", "info", ",", "@", "query", "param", "(", "operation", "param", "name", ")", "operation", "param", "op", ",", "@", "context", "parameters", "params", ",", "@", "context", "http", "servlet", "request", "request", ")", "throws", "i", "o", "exception", ",", "file", "system", "access", "exception", "{", "return", "put", "(", "is", ",", "uri", "info", ",", "\"", "/", "\"", ",", "op", ",", "params", ",", "request", ")", ";", "}" ]
[ "get", "$", "special", "property", "name" ]
[ "public", "long", "get", "$", "special", "property", "name", "(", ")", "{", "return", "$", "special", "property", "name", ";", "}" ]
[ "loads", "properties", "from", "hdfs", "-", "fedbalance", "-", "default", "xml", "into", "configuration", "object" ]
[ "static", "configuration", "get", "default", "conf", "(", ")", "{", "configuration", "config", "=", "new", "configuration", "(", ")", ";", "config", "add", "resource", "(", "fed", "balance", "default", "xml", ")", ";", "config", "add", "resource", "(", "fed", "balance", "site", "xml", ")", ";", "return", "config", ";", "}" ]
[ "returns", "the", "string", "contents", "to", "be", "written", "note", "that", "if", "the", "string", "is", "lazily", "computed", "or", "compressed", ",", "calling", "this", "method", "will", "force", "its", "computation", "or", "decompression", "no", "attempt", "is", "made", "by", "file", "write", "action", "to", "cache", "the", "result", "note", "that", "the", "content", "is", "a", "not", "a", "normal", "java", "string", "when", "bazel", "parses", "build", "files", ",", "it", "misinterprets", "the", "bytes", "as", "latin", "1", ",", "so", "a", "code", "point", "with", "a", "3", "-", "byte", "utf", "-", "8", "encoding", "will", "take", "3", "chars", "internally", "to", "reverse", "this", "process", ",", "you", "must", "encode", "this", "string", "as", "latin", "1", ",", "giving", "you", "back", "the", "correct", "utf", "-", "8", "encoding", "of", "the", "original", "input" ]
[ "public", "string", "get", "file", "contents", "(", ")", "{", "return", "file", "contents", "to", "string", "(", ")", ";", "}" ]
[ "test", "the", "property", "'", "number", "'" ]
[ "public", "void", "number", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "number", "}" ]