Datasets:
Anonymous2023
/
KGSum

Dataset card Data Studio Files Community
docstring_tokens
list
code_tokens
list
[ "model", "tests", "for", "user" ]
[ "public", "void", "test", "user", "(", ")", "{", "/", "/", "todo", ":", "test", "user", "}" ]
[ "get", "prefix", "string" ]
[ "public", "string", "get", "prefix", "string", "(", ")", "{", "return", "prefix", "string", ";", "}" ]
[ "gets", "the", "name", "of", "the", "server", "this", "is", "useful", "for", "debugging" ]
[ "public", "string", "get", "server", "name", "(", ")", "{", "return", "server", "name", ";", "}" ]
[ "clears", "all", "entries", "from", "the", "key", "and", "value", "reference", "queues" ]
[ "void", "clear", "reference", "queues", "(", ")", "{", "if", "(", "map", "uses", "key", "references", "(", ")", ")", "{", "clear", "key", "reference", "queue", "(", ")", ";", "}", "if", "(", "map", "uses", "value", "references", "(", ")", ")", "{", "clear", "value", "reference", "queue", "(", ")", ";", "}", "}" ]
[ "checks", "whether", "the", "given", "crc", "is", "valid", "and", ",", "if", "so", ",", "reads", "it", "if", "the", "crc", "is", "valid", ",", "the", "position", "of", "{", "@", "code", "data", "}", "is", "moved", "to", "the", "byte", "following", "it", "otherwise", ",", "there", "is", "no", "guarantee", "on", "the", "position", "the", "{", "@", "code", "data", "}", "array", "must", "contain", "the", "whole", "frame", "header" ]
[ "private", "static", "boolean", "check", "and", "read", "crc", "(", "parsable", "byte", "array", "data", ",", "int", "frame", "start", "position", ")", "{", "int", "crc", "=", "data", "read", "unsigned", "byte", "(", ")", ";", "int", "frame", "end", "position", "=", "data", "get", "position", "(", ")", ";", "int", "expected", "crc", "=", "util", "crc", "8", "(", "data", "get", "data", "(", ")", ",", "frame", "start", "position", ",", "frame", "end", "position", "-", "1", ",", "/", "*", "initial", "value", "=", "*", "/", "0", ")", ";", "return", "crc", "=", "=", "expected", "crc", ";", "}" ]
[ "assert", "that", "a", "given", "statistic", "has", "an", "expected", "value" ]
[ "private", "static", "<", "e", ">", "object", "assert", "<", "e", ">", "assert", "that", "statistic", "(", "final", "string", "type", ",", "final", "string", "key", ",", "final", "map", "<", "string", ",", "e", ">", "map", ")", "{", "final", "e", "statistic", "=", "lookup", "statistic", "(", "type", ",", "key", ",", "map", ")", ";", "return", "assert", "that", "(", "statistic", ")", "described", "as", "(", "\"", "%", "s", "named", "%", "s", "\"", ",", "type", ",", "key", ")", ";", "}" ]
[ "creates", "a", "mock", "container", "and", "container", "id", "and", "feeds", "to", "the", "component" ]
[ "public", "container", "feed", "container", "to", "comp", "(", "service", "service", ",", "int", "id", ",", "string", "comp", "name", ")", "{", "container", "id", "container", "id", "=", "create", "container", "id", "(", "id", ")", ";", "return", "feed", "container", "to", "comp", "(", "service", ",", "container", "id", ",", "comp", "name", ")", ";", "}" ]
[ "the", "index", "name", "of", "the", "action" ]
[ "public", "string", "get", "index", "(", ")", "{", "return", "this", "index", ";", "}" ]
[ "returns", "the", "boost", "mode", ",", "meaning", "how", "the", "combined", "result", "of", "score", "functions", "will", "influence", "the", "final", "score", "together", "with", "the", "sub", "query", "score" ]
[ "public", "combine", "function", "boost", "mode", "(", ")", "{", "return", "this", "boost", "mode", ";", "}" ]
[ "configure", "a", "limit", "on", "the", "number", "of", "bytes", "that", "can", "be", "buffered", "whenever", "the", "input", "stream", "needs", "to", "be", "aggregated", "this", "can", "be", "a", "result", "of", "decoding", "to", "a", "single", "{", "@", "code", "data", "buffer", "}", ",", "{", "@", "link", "java", "nio", "byte", "buffer", "byte", "buffer", "}", ",", "{", "@", "code", "byte", "[", "]", "}", ",", "{", "@", "link", "org", "springframework", "core", "io", "resource", "resource", "}", ",", "{", "@", "code", "string", "}", ",", "etc", "it", "can", "also", "occur", "when", "splitting", "the", "input", "stream", ",", "e", "g", "delimited", "text", ",", "in", "which", "case", "the", "limit", "applies", "to", "data", "buffered", "between", "delimiters", "by", "default", "this", "is", "not", "set", ",", "in", "which", "case", "individual", "codec", "defaults", "apply", "all", "codecs", "are", "limited", "to", "256k", "by", "default" ]
[ "void", "max", "in", "memory", "size", "(", "int", "byte", "count", ")", ";" ]
[ "process", "an", "edit", "log", "using", "the", "chosen", "processor", "or", "visitor" ]
[ "public", "int", "go", "(", "string", "input", "file", "name", ",", "string", "output", "file", "name", ",", "string", "processor", ",", "flags", "flags", ",", "offline", "edits", "visitor", "visitor", ")", "{", "if", "(", "flags", "get", "print", "to", "screen", "(", ")", ")", "{", "system", "out", "println", "(", "\"", "input", "[", "\"", "+", "input", "file", "name", "+", "\"", "]", "\"", ")", ";", "system", "out", "println", "(", "\"", "output", "[", "\"", "+", "output", "file", "name", "+", "\"", "]", "\"", ")", ";", "}", "boolean", "xml", "input", "=", "string", "utils", "to", "lower", "case", "(", "input", "file", "name", ")", "ends", "with", "(", "\"", "xml", "\"", ")", ";", "if", "(", "xml", "input", "&", "&", "string", "utils", "equals", "ignore", "case", "(", "\"", "xml", "\"", ",", "processor", ")", ")", "{", "system", "err", "println", "(", "\"", "xml", "format", "input", "file", "is", "not", "allowed", "\"", "+", "\"", "to", "be", "processed", "by", "xml", "processor", "\"", ")", ";", "return", "-", "1", ";", "}", "else", "if", "(", "!", "xml", "input", "&", "&", "string", "utils", "equals", "ignore", "case", "(", "\"", "binary", "\"", ",", "processor", ")", ")", "{", "system", "err", "println", "(", "\"", "binary", "format", "input", "file", "is", "not", "allowed", "\"", "+", "\"", "to", "be", "processed", "by", "binary", "processor", "\"", ")", ";", "return", "-", "1", ";", "}", "try", "{", "if", "(", "visitor", "=", "=", "null", ")", "{", "visitor", "=", "offline", "edits", "visitor", "factory", "get", "edits", "visitor", "(", "output", "file", "name", ",", "processor", ",", "flags", "get", "print", "to", "screen", "(", ")", ")", ";", "}", "offline", "edits", "loader", "loader", "=", "offline", "edits", "loader", "factory", "create", "loader", "(", "visitor", ",", "input", "file", "name", ",", "xml", "input", ",", "flags", ")", ";", "loader", "load", "edits", "(", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "system", "err", "println", "(", "\"", "encountered", "exception", "exiting", ":", "\"", "+", "e", "get", "message", "(", ")", ")", ";", "e", "print", "stack", "trace", "(", "system", "err", ")", ";", "return", "-", "1", ";", "}", "return", "0", ";", "}" ]
[ "assert", "a", "boolean", "expression", ",", "throwing", "an", "{", "@", "code", "illegal", "state", "exception", "}", "if", "the", "expression", "evaluates", "to", "{", "@", "code", "false", "}", "call", "{", "@", "link", "#", "is", "true", "}", "if", "you", "wish", "to", "throw", "an", "{", "@", "code", "illegal", "argument", "exception", "}", "on", "an", "assertion", "failure", "<", "pre", "class", "=", "\"", "code", "\"", ">", "assert", "state", "(", "id", "=", "=", "null", ",", "\"", "the", "id", "property", "must", "not", "already", "be", "initialized", "\"", ")", ";" ]
[ "public", "static", "void", "state", "(", "boolean", "expression", ",", "string", "message", ")", "{", "if", "(", "!", "expression", ")", "{", "throw", "new", "illegal", "state", "exception", "(", "message", ")", ";", "}", "}" ]
[ "name", "of", "the", "pet" ]
[ "public", "string", "get", "a", "t", "t", "n", "a", "m", "e", "(", ")", "{", "return", "att", "name", ";", "}" ]
[ "determines", "whether", "this", "data", "stream", "is", "replicated", "from", "elsewhere", ",", "for", "example", "a", "remote", "cluster" ]
[ "public", "boolean", "is", "replicated", "(", ")", "{", "return", "replicated", ";", "}" ]
[ "returns", "all", "requests", "captured", "so", "far", ",", "grouped", "by", "target", "node", "this", "method", "does", "clear", "the", "captured", "request", "list", "if", "you", "do", "not", "want", "the", "captured", "requests", "list", "cleared", ",", "use", "{", "@", "link", "#", "captured", "requests", "by", "target", "node", "(", ")", "}" ]
[ "public", "map", "<", "string", ",", "list", "<", "captured", "request", ">", ">", "get", "captured", "requests", "by", "target", "node", "and", "clear", "(", ")", "{", "list", "<", "captured", "request", ">", "requests", "=", "new", "array", "list", "<", ">", "(", "captured", "requests", "size", "(", ")", ")", ";", "captured", "requests", "drain", "to", "(", "requests", ")", ";", "return", "group", "requests", "by", "target", "node", "(", "requests", ")", ";", "}" ]
[ "get", "namespace", "boolean" ]
[ "public", "boolean", "is", "namespace", "boolean", "(", ")", "{", "return", "namespace", "boolean", ";", "}" ]
[ "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", "\"", ")", ";", "}" ]
[ "get", "number", "item" ]
[ "public", "big", "decimal", "get", "number", "item", "(", ")", "{", "return", "number", "item", ";", "}" ]
[ "extracts", "information", "from", "a", "java", "properties", "file", "to", "create", "an", "{", "@", "link", "extension", "details", "}", "object" ]
[ "public", "static", "extension", "details", "create", "extension", "details", "from", "property", "file", "(", "resource", "file", "resource", "file", ")", "{", "try", "(", "input", "stream", "in", "=", "resource", "file", "get", "input", "stream", "(", ")", ")", "{", "properties", "props", "=", "new", "properties", "(", ")", ";", "props", "load", "(", "in", ")", ";", "return", "create", "extension", "details", "from", "properties", "(", "props", ")", ";", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "msg", "error", "(", "null", ",", "\"", "error", "processing", "extension", "properties", "for", "\"", "+", "resource", "file", "get", "absolute", "path", "(", ")", ",", "e", ")", ";", "return", "null", ";", "}", "}" ]
[ "returns", "{", "@", "code", "true", "}", "if", "the", "layout", "call", "mounted", "the", "component" ]
[ "boolean", "layout", "(", ")", "{", "assert", "main", "thread", "(", ")", ";", "return", "mount", "component", "if", "needed", "(", ")", ";", "}" ]
[ "sets", "the", "address", "of", "the", "{", "@", "link", "blob", "server", "}" ]
[ "public", "void", "set", "blob", "server", "address", "(", "inet", "socket", "address", "blob", "server", "address", ")", "{", "permanent", "blob", "cache", "set", "blob", "server", "address", "(", "blob", "server", "address", ")", ";", "transient", "blob", "cache", "set", "blob", "server", "address", "(", "blob", "server", "address", ")", ";", "}" ]
[ "returns", "the", "value", "associated", "with", "the", "given", "config", "option", "as", "a", "string" ]
[ "public", "string", "get", "string", "(", "config", "option", "<", "string", ">", "config", "option", ")", "{", "return", "get", "optional", "(", "config", "option", ")", "or", "else", "get", "(", "config", "option", ":", ":", "default", "value", ")", ";", "}" ]
[ "make", "sure", "we", "don", "'", "t", "attempt", "to", "recover", "from", "problems", "in", "subrules" ]
[ "public", "void", "sync", "(", "parser", "recognizer", ")", "{", "}" ]
[ "return", "a", "{", "@", "link", "resolvable", "type", "}", "for", "the", "specified", "{", "@", "link", "class", "}", "with", "pre", "-", "declared", "generics" ]
[ "public", "static", "resolvable", "type", "for", "class", "with", "generics", "(", "class", "<", "?", ">", "clazz", ",", "resolvable", "type", "generics", ")", "{", "assert", "not", "null", "(", "clazz", ",", "\"", "class", "must", "not", "be", "null", "\"", ")", ";", "assert", "not", "null", "(", "generics", ",", "\"", "generics", "array", "must", "not", "be", "null", "\"", ")", ";", "type", "variable", "<", "?", ">", "[", "]", "variables", "=", "clazz", "get", "type", "parameters", "(", ")", ";", "assert", "is", "true", "(", "variables", "length", "=", "=", "generics", "length", ",", "\"", "mismatched", "number", "of", "generics", "specified", "\"", ")", ";", "type", "[", "]", "arguments", "=", "new", "type", "[", "generics", "length", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "generics", "length", ";", "i", "+", "+", ")", "{", "resolvable", "type", "generic", "=", "generics", "[", "i", "]", ";", "type", "argument", "=", "(", "generic", "!", "=", "null", "?", "generic", "get", "type", "(", ")", ":", "null", ")", ";", "arguments", "[", "i", "]", "=", "(", "argument", "!", "=", "null", "&", "&", "!", "(", "argument", "instanceof", "type", "variable", ")", "?", "argument", ":", "variables", "[", "i", "]", ")", ";", "}", "parameterized", "type", "synthetic", "type", "=", "new", "synthetic", "parameterized", "type", "(", "clazz", ",", "arguments", ")", ";", "return", "for", "type", "(", "synthetic", "type", ",", "new", "type", "variables", "variable", "resolver", "(", "variables", ",", "generics", ")", ")", ";", "}" ]
[ "format", ",", "if", "needed", ",", "and", "download", "the", "aliasmap" ]
[ "private", "int", "format", "and", "download", "alias", "map", "(", "string", "path", "alias", "map", ",", "remote", "name", "node", "info", "proxy", "info", ")", "throws", "i", "o", "exception", "{", "log", "info", "(", "\"", "bootstrapping", "the", "in", "memory", "alias", "map", "from", "\"", "+", "proxy", "info", "get", "http", "address", "(", ")", ")", ";", "if", "(", "path", "alias", "map", "=", "=", "null", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "in", "memory", "alias", "map", "enabled", "with", "null", "location", "\"", ")", ";", "}", "file", "alias", "map", "file", "=", "new", "file", "(", "path", "alias", "map", ")", ";", "if", "(", "alias", "map", "file", "exists", "(", ")", ")", "{", "alias", "map", "storage", "directory", "alias", "map", "s", "d", "=", "new", "alias", "map", "storage", "directory", "(", "alias", "map", "file", ")", ";", "if", "(", "!", "storage", "confirm", "format", "(", "arrays", "as", "list", "(", "alias", "map", "s", "d", ")", ",", "force", ",", "interactive", ")", ")", "{", "return", "err", "code", "already", "formatted", ";", "}", "else", "{", "if", "(", "!", "file", "util", "fully", "delete", "(", "alias", "map", "file", ")", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "cannot", "remove", "current", "alias", "map", ":", "\"", "+", "alias", "map", "file", ")", ";", "}", "}", "}", "/", "/", "create", "the", "aliasmap", "location", "if", "(", "!", "alias", "map", "file", "mkdirs", "(", ")", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "cannot", "create", "directory", "\"", "+", "alias", "map", "file", ")", ";", "}", "transfer", "fs", "image", "download", "alias", "map", "(", "proxy", "info", "get", "http", "address", "(", ")", ",", "alias", "map", "file", ",", "true", ")", ";", "return", "0", ";", "}" ]
[ "return", "a", "read", "-", "only", "list", "with", "the", "supported", "content", "codings" ]
[ "public", "list", "<", "string", ">", "get", "content", "codings", "(", ")", "{", "return", "collections", "unmodifiable", "list", "(", "this", "content", "codings", ")", ";", "}" ]
[ "returns", "the", "possible", "command", "completions", "for", "a", "command" ]
[ "list", "<", "code", "completion", ">", "get", "command", "completions", "(", "string", "cmd", ",", "boolean", "include", "builtins", ")", "{", "if", "(", "(", "cmd", "length", "(", ")", ">", "0", ")", "&", "&", "(", "cmd", "char", "at", "(", "cmd", "length", "(", ")", "-", "1", ")", "=", "=", "'", "(", "'", ")", ")", "{", "return", "get", "method", "command", "completions", "(", "cmd", ")", ";", "}", "return", "get", "property", "command", "completions", "(", "cmd", ",", "include", "builtins", ")", ";", "}" ]
[ "removes", "{", "@", "code", "node", "}", "from", "this", "tree", ",", "rearranging", "the", "tree", "'", "s", "structure", "as", "necessary" ]
[ "void", "remove", "internal", "(", "node", "<", "k", ",", "v", ">", "node", ",", "boolean", "unlink", ")", "{", "if", "(", "unlink", ")", "{", "node", "prev", "next", "=", "node", "next", ";", "node", "next", "prev", "=", "node", "prev", ";", "node", "next", "=", "node", "prev", "=", "null", ";", "/", "/", "help", "the", "gc", "(", "for", "performance", ")", "}", "node", "<", "k", ",", "v", ">", "left", "=", "node", "left", ";", "node", "<", "k", ",", "v", ">", "right", "=", "node", "right", ";", "node", "<", "k", ",", "v", ">", "original", "parent", "=", "node", "parent", ";", "if", "(", "left", "!", "=", "null", "&", "&", "right", "!", "=", "null", ")", "{", "/", "*", "*", "to", "remove", "a", "node", "with", "both", "left", "and", "right", "subtrees", ",", "move", "an", "*", "adjacent", "node", "from", "one", "of", "those", "subtrees", "into", "this", "node", "'", "s", "place", "*", "*", "removing", "the", "adjacent", "node", "may", "change", "this", "node", "'", "s", "subtrees", "this", "*", "node", "may", "no", "longer", "have", "two", "subtrees", "once", "the", "adjacent", "node", "is", "*", "gone", "!", "*", "/", "node", "<", "k", ",", "v", ">", "adjacent", "=", "(", "left", "height", ">", "right", "height", ")", "?", "left", "last", "(", ")", ":", "right", "first", "(", ")", ";", "remove", "internal", "(", "adjacent", ",", "false", ")", ";", "/", "/", "takes", "care", "of", "rebalance", "and", "size", "-", "-", "int", "left", "height", "=", "0", ";", "left", "=", "node", "left", ";", "if", "(", "left", "!", "=", "null", ")", "{", "left", "height", "=", "left", "height", ";", "adjacent", "left", "=", "left", ";", "left", "parent", "=", "adjacent", ";", "node", "left", "=", "null", ";", "}", "int", "right", "height", "=", "0", ";", "right", "=", "node", "right", ";", "if", "(", "right", "!", "=", "null", ")", "{", "right", "height", "=", "right", "height", ";", "adjacent", "right", "=", "right", ";", "right", "parent", "=", "adjacent", ";", "node", "right", "=", "null", ";", "}", "adjacent", "height", "=", "math", "max", "(", "left", "height", ",", "right", "height", ")", "+", "1", ";", "replace", "in", "parent", "(", "node", ",", "adjacent", ")", ";", "return", ";", "}", "else", "if", "(", "left", "!", "=", "null", ")", "{", "replace", "in", "parent", "(", "node", ",", "left", ")", ";", "node", "left", "=", "null", ";", "}", "else", "if", "(", "right", "!", "=", "null", ")", "{", "replace", "in", "parent", "(", "node", ",", "right", ")", ";", "node", "right", "=", "null", ";", "}", "else", "{", "replace", "in", "parent", "(", "node", ",", "null", ")", ";", "}", "rebalance", "(", "original", "parent", ",", "false", ")", ";", "size", "-", "-", ";", "mod", "count", "+", "+", ";", "}" ]
[ "returns", "true", "if", "the", "task", "is", "not", "assigned", "or", "is", "assigned", "to", "a", "non", "-", "existing", "node" ]
[ "public", "static", "boolean", "needs", "reassignment", "(", "final", "assignment", "assignment", ",", "final", "discovery", "nodes", "nodes", ")", "{", "return", "(", "assignment", "is", "assigned", "(", ")", "=", "=", "false", "|", "|", "nodes", "node", "exists", "(", "assignment", "get", "executor", "node", "(", ")", ")", "=", "=", "false", ")", ";", "}" ]
[ "constructs", "a", "{", "@", "link", "glob", "descriptor", "}", "for", "a", "glob", "lookup", "do", "not", "use", "outside", "{", "@", "code", "glob", "function", "}" ]
[ "static", "glob", "descriptor", "internal", "key", "(", "package", "identifier", "package", "id", ",", "root", "package", "root", ",", "path", "fragment", "subdir", ",", "string", "pattern", ",", "boolean", "exclude", "dirs", ")", "{", "return", "glob", "descriptor", "create", "(", "package", "id", ",", "package", "root", ",", "subdir", ",", "pattern", ",", "exclude", "dirs", ")", ";", "}" ]
[ "append", "text", "and", "one", "line" ]
[ "public", "span", "utils", "append", "line", "(", "@", "non", "null", "final", "char", "sequence", "text", ")", "{", "apply", "(", "m", "type", "char", "sequence", ")", ";", "m", "text", "=", "text", "+", "line", "separator", ";", "return", "this", ";", "}" ]
[ "returns", "a", "{", "@", "link", "byte", "}", "list", "from", "the", "given", "byte", "string" ]
[ "public", "static", "list", "<", "byte", ">", "to", "byte", "array", "(", "string", "byte", "str", ")", "{", "string", "[", "]", "byte", "strs", "=", "byte", "str", "split", "(", "\"", "(", "?", "<", "=", "\\", "\\", "g", "{", "8", "}", ")", "\"", ")", ";", "list", "<", "byte", ">", "bytes", "=", "new", "array", "list", "<", ">", "(", ")", ";", "for", "(", "string", "byte", "str", "2", ":", "byte", "strs", ")", "{", "int", "bint", "=", "integer", "parse", "int", "(", "byte", "str", "2", ",", "2", ")", ";", "byte", "newbyte", "=", "(", "byte", ")", "bint", ";", "bytes", "add", "(", "new", "byte", "(", "newbyte", ")", ")", ";", "}", "return", "bytes", ";", "}" ]
[ "applies", "the", "transformer", "on", "the", "input", "table", ",", "and", "returns", "the", "result", "table" ]
[ "public", "table", "transform", "(", "table", "input", ")", "{", "preconditions", "check", "argument", "(", "input", "!", "=", "null", ",", "\"", "input", "can", "not", "be", "null", "!", "\"", ")", ";", "if", "(", "table", "env", "of", "(", "input", ")", "instanceof", "stream", "table", "environment", ")", "{", "table", "source", "stream", "op", "source", "=", "new", "table", "source", "stream", "op", "(", "input", ")", ";", "if", "(", "this", "params", "contains", "(", "ml", "environment", "id", ")", ")", "{", "source", "set", "m", "l", "environment", "id", "(", "this", "params", "get", "(", "ml", "environment", "id", ")", ")", ";", "}", "return", "transform", "(", "source", ")", "get", "output", "(", ")", ";", "}", "else", "{", "table", "source", "batch", "op", "source", "=", "new", "table", "source", "batch", "op", "(", "input", ")", ";", "if", "(", "this", "params", "contains", "(", "ml", "environment", "id", ")", ")", "{", "source", "set", "m", "l", "environment", "id", "(", "this", "params", "get", "(", "ml", "environment", "id", ")", ")", ";", "}", "return", "transform", "(", "source", ")", "get", "output", "(", ")", ";", "}", "}" ]
[ "model", "tests", "for", "outer", "enum" ]
[ "public", "void", "test", "outer", "enum", "(", ")", "{", "/", "/", "todo", ":", "test", "outer", "enum", "}" ]
[ "parse", "an", "animation", "from", "rawres", "this", "is", "recommended", "over", "putting", "your", "animation", "in", "assets", "because", "it", "uses", "a", "hard", "reference", "to", "r", "the", "resource", "id", "will", "be", "used", "as", "a", "cache", "key", "so", "future", "usages", "won", "'", "t", "parse", "the", "json", "again", "note", ":", "to", "correctly", "load", "dark", "mode", "(", "-", "night", ")", "resources", ",", "make", "sure", "you", "pass", "activity", "as", "a", "context", "(", "instead", "of", "e", "g", "the", "application", "context", ")", "the", "activity", "won", "'", "t", "be", "leaked", "to", "skip", "the", "cache", ",", "add", "null", "as", "a", "third", "parameter" ]
[ "public", "static", "lottie", "result", "<", "lottie", "composition", ">", "from", "raw", "res", "sync", "(", "context", "context", ",", "@", "raw", "res", "int", "raw", "res", ")", "{", "return", "from", "raw", "res", "sync", "(", "context", ",", "raw", "res", ",", "raw", "res", "cache", "key", "(", "context", ",", "raw", "res", ")", ")", ";", "}" ]
[ "returns", "the", "location", "list", "info", "specified", "in", "the", "attribute", "numeric", "attributes", "are", "treated", "as", "offsets", "into", "the", "debug", "loc", "section", "blob", "attributes", "are", "treated", "as", "a", "single", "location", "record", "for", "the", "current", "cu", ",", "using", "the", "blob", "bytes", "as", "the", "dwarf", "expression", "of", "the", "location", "record" ]
[ "public", "list", "<", "d", "w", "a", "r", "f", "location", ">", "get", "as", "location", "(", "int", "attribute", ")", "throws", "i", "o", "exception", "{", "attr", "info", "attr", "info", "=", "find", "attribute", "(", "attribute", ")", ";", "if", "(", "attr", "info", "=", "=", "null", ")", "{", "return", "collections", "empty", "list", ";", "}", "else", "if", "(", "attr", "info", "attr", "instanceof", "d", "w", "a", "r", "f", "numeric", "attribute", ")", "{", "return", "read", "debug", "loc", "list", "(", "(", "(", "d", "w", "a", "r", "f", "numeric", "attribute", ")", "attr", "info", "attr", ")", "get", "unsigned", "value", "(", ")", ")", ";", "}", "else", "if", "(", "attr", "info", "attr", "instanceof", "d", "w", "a", "r", "f", "blob", "attribute", ")", "{", "return", "expr", "bytes", "as", "location", "(", "(", "d", "w", "a", "r", "f", "blob", "attribute", ")", "attr", "info", "attr", ")", ";", "}", "else", "{", "throw", "new", "unsupported", "operation", "exception", "(", "\"", "this", "method", "is", "unsupported", "for", "the", "attribute", "type", "\"", "+", "attr", "info", "form", "+", "\"", "\"", ")", ";", "}", "}" ]
[ "determine", "the", "maximum", "number", "of", "duplicates", "that", "can", "be", "created", "for", "the", "component", "at", "the", "indicated", "index", "the", "duplicates", "would", "follow", "the", "component", "the", "number", "allowed", "depends", "on", "how", "many", "fit", "based", "on", "the", "current", "lockunlock", "state", "of", "the", "editor", "<", "br", ">", "note", ":", "this", "method", "doesn", "'", "t", "care", "whether", "there", "is", "a", "selection", "or", "not" ]
[ "public", "int", "get", "max", "duplicates", "(", "int", "row", "index", ")", "{", "int", "num", "row", "components", "=", "get", "num", "components", "(", ")", ";", "if", "(", "(", "row", "index", "<", "0", ")", "|", "|", "(", "row", "index", ">", "=", "num", "row", "components", ")", ")", "{", "return", "0", ";", "}", "if", "(", "row", "index", "+", "1", "=", "=", "num", "row", "components", ")", "{", "return", "integer", "max", "value", ";", "/", "/", "on", "last", "component", "}", "data", "type", "dt", "=", "get", "component", "(", "row", "index", ")", "get", "data", "type", "(", ")", ";", "int", "max", "dups", "=", "integer", "max", "value", ";", "/", "/", "if", "edit", "model", "is", "showing", "undefined", "bytes", "(", "unaligned", ")", "/", "/", "then", "constrain", "by", "number", "of", "undefined", "bytes", "that", "follow", "if", "(", "is", "showing", "undefined", "bytes", "(", ")", "&", "&", "(", "dt", "!", "=", "data", "type", "default", ")", ")", "{", "int", "num", "bytes", "=", "get", "num", "undefined", "bytes", "at", "(", "row", "index", "+", "1", ")", ";", "max", "dups", "=", "(", "num", "bytes", "/", "dt", "get", "length", "(", ")", ")", ";", "}", "return", "max", "dups", ";", "}" ]
[ "guesses", "class", "fully", "qualified", "names", "for", "the", "given", "short", "name", "this", "method", "should", "be", "called", "before", "{", "@", "link", "#", "create", "file", "content", "(", "string", ")", "}" ]
[ "public", "list", "<", "string", ">", "guess", "qualified", "names", "(", "project", "project", ",", "global", "search", "scope", "search", "scope", ",", "string", "short", "name", ",", "map", "<", "string", ",", "string", ">", "event", "metadata", ")", "{", "return", "arrays", "stream", "(", "psi", "search", "utils", "find", "classes", "by", "short", "name", "(", "project", ",", "search", "scope", ",", "litho", "plugin", "utils", "get", "litho", "component", "spec", "name", "from", "component", "(", "short", "name", ")", ")", ")", "filter", "(", "cls", "-", ">", "{", "if", "(", "litho", "plugin", "utils", "is", "layout", "spec", "(", "cls", ")", ")", "{", "event", "metadata", "put", "(", "event", "logger", "key", "class", ",", "\"", "layout", "spec", "\"", ")", ";", "return", "true", ";", "}", "else", "if", "(", "litho", "plugin", "utils", "is", "mount", "spec", "(", "cls", ")", ")", "{", "event", "metadata", "put", "(", "event", "logger", "key", "class", ",", "\"", "mount", "spec", "\"", ")", ";", "return", "true", ";", "}", "else", "{", "return", "false", ";", "}", "}", ")", "map", "(", "spec", "cls", "-", ">", "{", "final", "string", "component", "f", "q", "n", "=", "litho", "plugin", "utils", "get", "litho", "component", "name", "from", "spec", "(", "spec", "cls", "get", "qualified", "name", "(", ")", ")", ";", "component", "f", "q", "n", "to", "spec", "put", "(", "component", "f", "q", "n", ",", "spec", "cls", ")", ";", "return", "component", "f", "q", "n", ";", "}", ")", "collect", "(", "collectors", "to", "list", "(", ")", ")", ";", "}" ]
[ "returns", "the", "override", "accent", "color", "of", "this", "m", "t", "config", "object" ]
[ "public", "boolean", "is", "override", "accent", "color", "(", ")", "{", "return", "override", "accent", "color", ";", "}" ]
[ "add", "a", "further", "{", "@", "link", "parameter", "name", "discoverer", "}", "delegate", "to", "the", "list", "of", "discoverers", "that", "this", "{", "@", "code", "prioritized", "parameter", "name", "discoverer", "}", "checks" ]
[ "public", "void", "add", "discoverer", "(", "parameter", "name", "discoverer", "pnd", ")", "{", "this", "parameter", "name", "discoverers", "add", "(", "pnd", ")", ";", "}" ]
[ "finds", "pets", "by", "status", "multiple", "status", "values", "can", "be", "provided", "with", "comma", "separated", "strings" ]
[ "public", "void", "find", "pets", "by", "status", "test", "(", ")", "{", "list", "<", "string", ">", "status", "=", "null", ";", "/", "/", "list", "<", "pet", ">", "response", "=", "api", "find", "pets", "by", "status", "(", "status", ")", ";", "/", "/", "todo", ":", "test", "validations", "}" ]
[ "signals", "copy", "block", "to", "exit" ]
[ "public", "void", "set", "exit", "flag", "(", ")", "{", "this", "should", "run", "set", "(", "false", ")", ";", "}" ]
[ "default", "implementation", "that", "returns", "empty", "index" ]
[ "protected", "search", "index", "builder", "make", "search", "index", "(", ")", "{", "return", "new", "search", "index", "builder", "(", ")", "add", "all", "annotations", "(", "this", ")", ";", "}" ]
[ "gets", "the", "node", "from", "the", "optimizer", "dag", "for", "which", "this", "plan", "candidate", "node", "was", "created" ]
[ "public", "optimizer", "node", "get", "original", "optimizer", "node", "(", ")", "{", "return", "this", "template", ";", "}" ]
[ "map", "the", "hdfs", "based", "distributed", "cache", "file", "path", "from", "original", "cluster", "to", "a", "unique", "file", "name", "on", "the", "simulated", "cluster", "<", "br", ">", "unique", "distributed", "file", "names", "on", "simulated", "cluster", "are", "generated", "using", "original", "cluster", "'", "s", "file", "path", ",", "timestamp", "and", "the", "job", "-", "submitter", "for", "private", "distributed", "cache", "file", "<", "br", ">", "this", "implies", "that", "if", "on", "original", "cluster", ",", "a", "single", "hdfs", "file", "considered", "as", "two", "private", "distributed", "cache", "files", "for", "two", "jobs", "of", "different", "users", ",", "then", "the", "corresponding", "simulated", "jobs", "will", "have", "two", "different", "files", "of", "the", "same", "size", "in", "public", "distributed", "cache", ",", "one", "for", "each", "user", "both", "these", "simulated", "jobs", "will", "not", "share", "these", "distributed", "cache", "files", ",", "thus", "leading", "to", "the", "same", "load", "as", "seen", "in", "the", "original", "cluster" ]
[ "private", "string", "map", "dist", "cache", "file", "path", "(", "string", "file", ",", "string", "time", "stamp", ",", "boolean", "is", "public", ",", "string", "user", ")", "{", "string", "id", "=", "file", "+", "time", "stamp", ";", "if", "(", "!", "is", "public", ")", "{", "/", "/", "consider", "job", "-", "submitter", "for", "private", "distributed", "cache", "file", "id", "=", "id", "concat", "(", "user", ")", ";", "}", "return", "new", "path", "(", "dist", "cache", "path", ",", "m", "d", "5", "hash", "digest", "(", "id", ")", "to", "string", "(", ")", ")", "to", "uri", "(", ")", "get", "path", "(", ")", ";", "}" ]
[ "creates", "a", "new", "string", "property", "map", "with", "the", "given", "name" ]
[ "public", "string", "property", "map", "create", "string", "property", "map", "(", "string", "property", "name", ")", "throws", "duplicate", "name", "exception", "{", "lock", "acquire", "(", ")", ";", "try", "{", "if", "(", "property", "map", "cache", "contains", "key", "(", "property", "name", ")", ")", "{", "throw", "new", "duplicate", "name", "exception", "(", ")", ";", "}", "string", "property", "map", "pm", "=", "null", ";", "try", "{", "pm", "=", "new", "string", "property", "map", "d", "b", "(", "db", "handle", ",", "d", "b", "constants", "create", ",", "program", ",", "change", "mgr", ",", "addr", "map", ",", "property", "name", ",", "task", "monitor", "adapter", "dummy", "monitor", ")", ";", "properties", "d", "b", "adapter", "put", "record", "(", "property", "name", ",", "string", "property", "type", ",", "null", ")", ";", "property", "map", "cache", "put", "(", "property", "name", ",", "pm", ")", ";", "}", "catch", "(", "version", "exception", "e", ")", "{", "throw", "new", "assert", "exception", "(", ")", ";", "}", "catch", "(", "cancelled", "exception", "e", ")", "{", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "program", "db", "error", "(", "e", ")", ";", "}", "return", "pm", ";", "}", "finally", "{", "lock", "release", "(", ")", ";", "}", "}" ]
[ "use", "{", "@", "link", "#", "get", "double", "map", "map", "(", ")", "}", "instead" ]
[ "public", "java", "util", "map", "<", "string", ",", "phone", "number", ">", "get", "double", "map", "(", ")", "{", "return", "get", "double", "map", "map", "(", ")", ";", "}" ]
[ "verifies", "content", "of", "the", "response", "when", "domain", "is", "not", "specified" ]
[ "public", "void", "test", "empty", "domain", "(", ")", "{", "socks", "cmd", "response", "socks", "cmd", "response", "=", "new", "socks", "cmd", "response", "(", "socks", "cmd", "status", "success", ",", "socks", "address", "type", "domain", ")", ";", "assert", "null", "(", "socks", "cmd", "response", "host", "(", ")", ")", ";", "assert", "equals", "(", "0", ",", "socks", "cmd", "response", "port", "(", ")", ")", ";", "byte", "buf", "buffer", "=", "unpooled", "buffer", "(", "20", ")", ";", "socks", "cmd", "response", "encode", "as", "byte", "buf", "(", "buffer", ")", ";", "byte", "[", "]", "expected", "=", "{", "0x", "0", "5", ",", "/", "/", "version", "0x", "0", "0", ",", "/", "/", "success", "reply", "0x", "0", "0", ",", "/", "/", "reserved", "0x", "0", "3", ",", "/", "/", "address", "type", "domain", "0x", "0", "1", ",", "/", "/", "length", "of", "domain", "0x", "0", "0", ",", "/", "/", "domain", "value", "0x", "0", "0", ",", "/", "/", "port", "value", "0x", "0", "0", "}", ";", "assert", "byte", "buf", "equals", "(", "expected", ",", "buffer", ")", ";", "}" ]
[ "this", "implementation", "delegates", "to", "{", "@", "code", "get", "connection", "from", "driver", "}", ",", "using", "the", "default", "username", "and", "password", "of", "this", "data", "source" ]
[ "public", "connection", "get", "connection", "(", ")", "throws", "s", "q", "l", "exception", "{", "return", "get", "connection", "from", "driver", "(", "get", "username", "(", ")", ",", "get", "password", "(", ")", ")", ";", "}" ]
[ "<", "code", ">", "required", "string", "number", "=", "1", ";", "<", "code", ">" ]
[ "public", "com", "google", "protobuf", "byte", "string", "get", "number", "bytes", "(", ")", "{", "java", "lang", "object", "ref", "=", "number", ";", "if", "(", "ref", "instanceof", "string", ")", "{", "com", "google", "protobuf", "byte", "string", "b", "=", "com", "google", "protobuf", "byte", "string", "copy", "from", "utf", "8", "(", "(", "java", "lang", "string", ")", "ref", ")", ";", "number", "=", "b", ";", "return", "b", ";", "}", "else", "{", "return", "(", "com", "google", "protobuf", "byte", "string", ")", "ref", ";", "}", "}" ]
[ "releases", "memory", "when", "an", "error", "occurs", "during", "initialization", "(", "e", "g", "syntax", "bug", ")" ]
[ "void", "sandbox", "free", "error", "(", "pointer", "errorbuf", ")", ";" ]
[ "sets", "the", "current", "state", "of", "this", "decoder" ]
[ "protected", "s", "state", "(", "s", "new", "state", ")", "{", "s", "old", "state", "=", "state", ";", "state", "=", "new", "state", ";", "return", "old", "state", ";", "}" ]
[ "persists", "the", "payload", "of", "{", "@", "link", "confidential", "key", "}", "to", "a", "persisted", "storage", "(", "such", "as", "disk", ")", "the", "expectation", "is", "that", "the", "persisted", "form", "is", "secure" ]
[ "protected", "abstract", "void", "store", "(", "confidential", "key", "key", ",", "byte", "[", "]", "payload", ")", "throws", "i", "o", "exception", ";" ]
[ "returns", "a", "zipfian", "sequence", "with", "a", "popularity", "distribution", "of", "items", ",", "skewed", "to", "favor", "recent", "items", "significantly", "more", "than", "older", "items" ]
[ "public", "static", "long", "stream", "skewed", "zipfian", "latest", "(", "int", "items", ",", "int", "events", ")", "{", "return", "generate", "(", "new", "skewed", "latest", "generator", "(", "new", "counter", "generator", "(", "items", ")", ")", ",", "events", ")", ";", "}" ]
[ "get", "prefix", "ns", "number" ]
[ "public", "big", "decimal", "get", "prefix", "ns", "number", "(", ")", "{", "return", "prefix", "ns", "number", ";", "}" ]
[ "sets", "or", "clears", "a", "bit", "at", "the", "given", "index" ]
[ "private", "void", "set", "bit", "(", "int", "index", ",", "boolean", "is", "set", ")", "{", "int", "byte", "index", "=", "index", "/", "8", ";", "int", "new", "byte", "size", "=", "byte", "index", "+", "1", ";", "if", "(", "bytes", "length", "<", "new", "byte", "size", ")", "{", "bytes", "=", "arrays", "copy", "of", "(", "bytes", ",", "new", "byte", "size", ")", ";", "}", "int", "bit", "index", "=", "index", "%", "8", ";", "int", "mask", "=", "1", "<", "<", "bit", "index", ";", "if", "(", "is", "set", ")", "{", "bytes", "[", "byte", "index", "]", "=", "(", "byte", ")", "(", "bytes", "[", "byte", "index", "]", "|", "mask", ")", ";", "}", "else", "{", "bytes", "[", "byte", "index", "]", "=", "(", "byte", ")", "(", "bytes", "[", "byte", "index", "]", "&", "~", "mask", ")", ";", "}", "}" ]
[ "model", "tests", "for", "cat" ]
[ "public", "void", "test", "cat", "(", ")", "{", "/", "/", "todo", ":", "test", "cat", "}" ]
[ "builds", "the", "aggregation", "that", "collect", "required", "data", "to", "compute", "the", "metric" ]
[ "tuple", "<", "list", "<", "aggregation", "builder", ">", ",", "list", "<", "pipeline", "aggregation", "builder", ">", ">", "aggs", "(", "evaluation", "parameters", "parameters", ",", "evaluation", "fields", "fields", ")", ";" ]
[ "extracts", "the", "message", "payload", "portion", "of", "the", "message", "created", "by", "{", "@", "link", "#", "create", "message", "(", "http", "servlet", "request", ",", "string", ",", "string", ")", "}", "when", "{", "@", "link", "#", "is", "include", "payload", "(", ")", "}", "returns", "true" ]
[ "protected", "string", "get", "message", "payload", "(", "http", "servlet", "request", "request", ")", "{", "content", "caching", "request", "wrapper", "wrapper", "=", "web", "utils", "get", "native", "request", "(", "request", ",", "content", "caching", "request", "wrapper", "class", ")", ";", "if", "(", "wrapper", "!", "=", "null", ")", "{", "byte", "[", "]", "buf", "=", "wrapper", "get", "content", "as", "byte", "array", "(", ")", ";", "if", "(", "buf", "length", ">", "0", ")", "{", "int", "length", "=", "math", "min", "(", "buf", "length", ",", "get", "max", "payload", "length", "(", ")", ")", ";", "try", "{", "return", "new", "string", "(", "buf", ",", "0", ",", "length", ",", "wrapper", "get", "character", "encoding", "(", ")", ")", ";", "}", "catch", "(", "unsupported", "encoding", "exception", "ex", ")", "{", "return", "\"", "[", "unknown", "]", "\"", ";", "}", "}", "}", "return", "null", ";", "}" ]
[ "register", "a", "listener", "that", "will", "be", "called", "when", "this", "model", "visibility", "has", "changed", "the", "listener", "will", "contribute", "to", "this", "model", "'", "s", "hash", "code", "state", "per", "the", "{", "@", "link", "com", "airbnb", "epoxy", "epoxy", "attribute", "option", "#", "do", "not", "hash", "}", "rules" ]
[ "public", "generate", "default", "layout", "method", "next", "parent", "layout", "$", "no", "layout", "on", "visibility", "changed", "(", "on", "model", "visibility", "changed", "listener", "<", "generate", "default", "layout", "method", "next", "parent", "layout", "$", "no", "layout", ",", "object", ">", "listener", ")", "{", "on", "mutation", "(", ")", ";", "this", "on", "model", "visibility", "changed", "listener", "epoxy", "generated", "model", "=", "listener", ";", "return", "this", ";", "}" ]
[ "creates", "a", "g", "file", "for", "a", "specific", "owning", "filesystem", "using", "a", "string", "path", "(", "ie", "\"", "dirsubdirfilename", "\"", ")", ",", "with", "the", "path", "starting", "at", "the", "supplied", "{", "@", "code", "parent", "}", "directory", "the", "parents", "of", "this", "g", "file", "are", "created", "fresh", "from", "any", "directory", "names", "in", "the", "path", "string", "it", "is", "better", "to", "use", "the", "{", "@", "link", "#", "from", "filename", "(", "g", "file", "system", ",", "g", "file", ",", "string", ",", "boolean", ",", "long", ",", "fsrl", ")", "}", "method", "to", "create", "g", "file", "instances", "if", "you", "can", "supply", "the", "parent", "value", "as", "that", "will", "allow", "reuse", "of", "the", "parent", "objects", "instead", "of", "duplicates", "of", "them", "being", "created", "for", "each", "file", "with", "the", "same", "parent", "path" ]
[ "public", "static", "g", "file", "impl", "from", "path", "string", "(", "g", "file", "system", "file", "system", ",", "g", "file", "parent", ",", "string", "path", ",", "fsrl", "fsrl", ",", "boolean", "is", "directory", ",", "long", "length", ")", "{", "string", "[", "]", "split", "=", "path", "split", "(", "f", "s", "utilities", "separator", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "split", "length", "-", "1", ";", "+", "+", "i", ")", "{", "if", "(", "split", "[", "i", "]", "length", "(", ")", "=", "=", "0", ")", "{", "continue", ";", "}", "parent", "=", "from", "filename", "(", "file", "system", ",", "parent", ",", "split", "[", "i", "]", ",", "true", ",", "-", "1", ",", "null", ")", ";", "}", "if", "(", "fsrl", "=", "=", "null", ")", "{", "fsrl", "=", "get", "f", "s", "r", "l", "from", "parent", "(", "file", "system", ",", "parent", ",", "split", "[", "split", "length", "-", "1", "]", ")", ";", "}", "return", "new", "g", "file", "impl", "(", "file", "system", ",", "parent", ",", "is", "directory", ",", "length", ",", "fsrl", ")", ";", "}" ]
[ "sets", "the", "maximum", "duration", "for", "which", "video", "renderers", "can", "attempt", "to", "seamlessly", "join", "an", "ongoing", "playback", "the", "default", "value", "is", "{", "@", "link", "#", "default", "allowed", "video", "joining", "time", "ms", "}" ]
[ "public", "default", "renderers", "factory", "set", "allowed", "video", "joining", "time", "ms", "(", "long", "allowed", "video", "joining", "time", "ms", ")", "{", "this", "allowed", "video", "joining", "time", "ms", "=", "allowed", "video", "joining", "time", "ms", ";", "return", "this", ";", "}" ]
[ "hash", "function", "num" ]
[ "public", "int", "get", "k", "(", ")", "{", "return", "k", ";", "}" ]
[ "creates", "the", "same", "random", "sequence", "of", "strings" ]
[ "public", "static", "string", "[", "]", "create", "fixed", "random", "strings", "(", "int", "count", ")", "{", "string", "[", "]", "strings", "=", "new", "string", "[", "count", "]", ";", "random", "length", "random", "=", "new", "random", "(", ")", ";", "length", "random", "set", "seed", "(", "seed", ")", ";", "random", "string", "random", "=", "new", "random", "(", ")", ";", "string", "random", "set", "seed", "(", "seed", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "count", ";", "i", "+", "+", ")", "{", "int", "next", "length", "=", "min", "length", "+", "length", "random", "next", "int", "(", "max", "length", "-", "min", "length", "-", "1", ")", ";", "char", "[", "]", "chars", "=", "new", "char", "[", "next", "length", "]", ";", "for", "(", "int", "j", "=", "0", ";", "j", "<", "next", "length", ";", "j", "+", "+", ")", "{", "chars", "[", "j", "]", "=", "chars", "[", "string", "random", "next", "int", "(", "chars", "length", ")", "]", ";", "}", "strings", "[", "i", "]", "=", "new", "string", "(", "chars", ")", ";", "}", "return", "strings", ";", "}" ]
[ "puts", "the", "given", "int", "value", "in", "the", "int", "array", "at", "the", "given", "index" ]
[ "public", "void", "put", "(", "int", "index", ",", "int", "value", ")", "{", "if", "(", "value", "=", "=", "0", ")", "{", "remove", "(", "index", ")", ";", "return", ";", "}", "if", "(", "index", ">", "=", "ints", "length", ")", "{", "adjust", "array", "(", "math", "max", "(", "index", "+", "1", ",", "ints", "length", "*", "2", ")", ")", ";", "}", "ints", "[", "index", "]", "=", "value", ";", "if", "(", "index", ">", "last", "non", "zero", "index", ")", "{", "last", "non", "zero", "index", "=", "index", ";", "}", "}" ]
[ "see", "{", "@", "link", "mockito", "#", "when", "(", "object", ")", "}" ]
[ "<", "s", ">", "ongoing", "stubbing", "<", "s", ">", "when", "(", "verification", "verification", ")", ";" ]
[ "test", "printable", "characters" ]
[ "public", "void", "test", "printable", "characters", "(", ")", "throws", "exception", "{", "/", "/", "ascii", "expect", "(", "\"", "should", "keep", "ascii", "letter", "\"", ",", "\"", "abcdef", "2", "3", "7", "\"", ",", "\"", "abcdef", "2", "3", "7", "\"", ")", ";", "expect", "(", "\"", "should", "keep", "ascii", "symbol", "\"", ",", "\"", "!", "\\", "\"", "|", "}" ]
[ "checks", "whether", "loading", "the", "given", "target", "results", "in", "the", "specified", "error", "message" ]
[ "protected", "void", "check", "loading", "phase", "error", "(", "string", "target", ",", "string", "expected", "error", "message", ")", "{", "reporter", "remove", "handler", "(", "fail", "fast", "handler", ")", ";", "/", "/", "the", "error", "happens", "during", "the", "loading", "of", "the", "starlark", "file", "so", "check", "error", "doesn", "'", "t", "work", "here", "assert", "throws", "(", "exception", "class", ",", "(", ")", "-", ">", "get", "target", "(", "target", ")", ")", ";", "assert", "contains", "event", "(", "expected", "error", "message", ")", ";", "}" ]
[ "tests", "if", "stream", "xml", "record", "reader", "will", "read", "the", "next", "record", ",", "after", "the", "end", "of", "a", "split", "if", "the", "split", "falls", "before", "the", "end", "of", "end", "-", "tag", "of", "a", "record", "tests", "with", "slowmatch", "=", "true" ]
[ "public", "void", "test", "stream", "xml", "multi", "inner", "slow", "(", ")", "throws", "exception", "{", "if", "(", "has", "perl", ")", "{", "block", "size", "=", "60", ";", "is", "slow", "match", "=", "\"", "true", "\"", ";", "super", "test", "command", "line", "(", ")", ";", "}", "else", "{", "log", "warn", "(", "\"", "no", "perl", ";", "skipping", "test", "\"", ")", ";", "}", "}" ]
[ "build", "an", "adapted", "order", "comparator", "with", "the", "given", "source", "provider" ]
[ "public", "comparator", "<", "object", ">", "with", "source", "provider", "(", "order", "source", "provider", "source", "provider", ")", "{", "return", "(", "o", "1", ",", "o", "2", ")", "-", ">", "do", "compare", "(", "o", "1", ",", "o", "2", ",", "source", "provider", ")", ";", "}" ]
[ "gets", "whether", "the", "number", "of", "vertices", "option", "is", "set", "by", "default", ",", "the", "number", "of", "vertices", "option", "is", "not", "set" ]
[ "public", "boolean", "is", "opt", "num", "vertices", "(", ")", "{", "return", "opt", "num", "vertices", ";", "}" ]
[ "inserts", "the", "given", "line", "number", "at", "the", "appropriate", "position", "in", "the", "line", "number", "table" ]
[ "public", "int", "insert", "line", "number", "(", "line", "number", "info", "line", "number", "info", ")", "{", "return", "insert", "line", "number", "(", "0", ",", "line", "number", "info", ")", ";", "}" ]
[ "returns", "true", "if", "the", "array", "has", "one", "or", "more", "items" ]
[ "public", "boolean", "not", "empty", "(", ")", "{", "return", "size", ">", "0", ";", "}" ]
[ "converts", "a", "list", "of", "{", "@", "code", "a", "b", "d", "}", "strings", "to", "{", "@", "code", "d", "}", "form" ]
[ "private", "static", "list", "<", "string", ">", "get", "base", "names", "(", "list", "<", "string", ">", "list", ")", "{", "return", "list", "stream", "(", ")", "map", "(", "entry", "-", ">", "get", "base", "name", "(", "entry", ")", ")", "collect", "(", "collectors", "to", "list", "(", ")", ")", ";", "}" ]
[ "test", "the", "property", "'", "kind", "'" ]
[ "public", "void", "kind", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "kind", "}" ]
[ "default", "implementation", "that", "returns", "the", "display", "name" ]
[ "public", "string", "get", "search", "name", "(", ")", "{", "return", "get", "display", "name", "(", ")", ";", "}" ]
[ "we", "need", "to", "override", "this", "as", "a", "{", "@", "link", "legacy", "serializer", "snapshot", "transformer", "}", "because", "in", "flink", "1", "6", "x", "and", "below", ",", "this", "serializer", "was", "incorrectly", "returning", "directly", "the", "snapshot", "of", "the", "nested", "map", "serializer", "as", "its", "own", "snapshot", "this", "method", "transforms", "the", "incorrect", "map", "serializer", "snapshot", "to", "be", "a", "proper", "{", "@", "link", "map", "view", "serializer", "snapshot", "}" ]
[ "public", "<", "u", ">", "type", "serializer", "snapshot", "<", "map", "view", "<", "k", ",", "v", ">", ">", "transform", "legacy", "serializer", "snapshot", "(", "type", "serializer", "snapshot", "<", "u", ">", "legacy", "snapshot", ")", "{", "if", "(", "legacy", "snapshot", "instanceof", "map", "view", "serializer", "snapshot", ")", "{", "return", "(", "type", "serializer", "snapshot", "<", "map", "view", "<", "k", ",", "v", ">", ">", ")", "legacy", "snapshot", ";", "}", "else", "if", "(", "legacy", "snapshot", "instanceof", "map", "serializer", "config", "snapshot", ")", "{", "/", "/", "first", ",", "transform", "the", "incorrect", "map", "serializer", "'", "s", "snapshot", "/", "/", "into", "a", "proper", "list", "serializer", "snapshot", "map", "serializer", "snapshot", "<", "k", ",", "v", ">", "transformed", "nested", "map", "serializer", "snapshot", "=", "new", "map", "serializer", "snapshot", "<", ">", "(", ")", ";", "map", "serializer", "config", "snapshot", "<", "k", ",", "v", ">", "snapshot", "=", "(", "map", "serializer", "config", "snapshot", "<", "k", ",", "v", ">", ")", "legacy", "snapshot", ";", "composite", "type", "serializer", "util", "set", "nested", "serializers", "snapshots", "(", "transformed", "nested", "map", "serializer", "snapshot", ",", "snapshot", "get", "nested", "serializers", "and", "configs", "(", ")", "get", "(", "0", ")", "f", "1", ",", "snapshot", "get", "nested", "serializers", "and", "configs", "(", ")", "get", "(", "1", ")", "f", "1", ")", ";", "/", "/", "then", ",", "wrap", "the", "transformed", "map", "serializer", "snapshot", "/", "/", "as", "a", "nested", "snapshot", "in", "the", "final", "resulting", "map", "view", "serializer", "snapshot", "map", "view", "serializer", "snapshot", "<", "k", ",", "v", ">", "transformed", "map", "view", "serializer", "snapshot", "=", "new", "map", "view", "serializer", "snapshot", "<", ">", "(", ")", ";", "composite", "type", "serializer", "util", "set", "nested", "serializers", "snapshots", "(", "transformed", "map", "view", "serializer", "snapshot", ",", "transformed", "nested", "map", "serializer", "snapshot", ")", ";", "return", "transformed", "map", "view", "serializer", "snapshot", ";", "}", "else", "{", "throw", "new", "unsupported", "operation", "exception", "(", "legacy", "snapshot", "get", "class", "(", ")", "get", "canonical", "name", "(", ")", "+", "\"", "is", "not", "supported", "\"", ")", ";", "}", "}" ]
[ "convert", "this", "{", "@", "link", "status", "}", "to", "an", "{", "@", "link", "exception", "}", "use", "{", "@", "link", "#", "from", "throwable", "}", "to", "recover", "this", "{", "@", "link", "status", "}", "instance", "when", "the", "returned", "exception", "is", "in", "the", "causal", "chain" ]
[ "public", "status", "exception", "as", "exception", "(", ")", "{", "return", "new", "status", "exception", "(", "this", ")", ";", "}" ]
[ "returns", "{", "@", "code", "true", "}", "if", "this", "test", "cluster", "can", "use", "a", "mock", "internal", "engine", "defaults", "to", "true" ]
[ "protected", "boolean", "add", "mock", "internal", "engine", "(", ")", "{", "return", "true", ";", "}" ]
[ "parses", "an", "{", "@", "code", "operating", "mode", "}", "from", "a", "string", "the", "string", "must", "name", "an", "operating", "mode", ",", "and", "not", "a", "licensing", "level", "(", "that", "is", ",", "it", "cannot", "parse", "old", "style", "license", "levels", "such", "as", "\"", "dev", "\"", "or", "\"", "silver", "\"", ")" ]
[ "public", "static", "operation", "mode", "parse", "(", "string", "mode", ")", "{", "try", "{", "return", "operation", "mode", "value", "of", "(", "mode", "to", "upper", "case", "(", "locale", "root", ")", ")", ";", "}", "catch", "(", "illegal", "argument", "exception", "e", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "unrecognised", "license", "operating", "mode", "[", "\"", "+", "mode", "+", "\"", "]", ",", "supported", "modes", "are", "[", "\"", "+", "stream", "of", "(", "values", "(", ")", ")", "map", "(", "operation", "mode", ":", ":", "description", ")", "collect", "(", "collectors", "joining", "(", "\"", ",", "\"", ")", ")", "+", "\"", "]", "\"", ")", ";", "}", "}" ]
[ "location", "to", "write", "model", "files", "you", "can", "use", "the", "model", "package", "(", ")", "as", "defined", "when", "the", "class", "is", "instantiated" ]
[ "public", "string", "model", "file", "folder", "(", ")", "{", "return", "output", "folder", ";", "}" ]
[ "gets", "msg", "instance", "by", "code" ]
[ "public", "static", "message", "seata", "codec", "get", "message", "codec", "(", "short", "type", "code", ")", "{", "message", "seata", "codec", "msg", "codec", "=", "null", ";", "switch", "(", "type", "code", ")", "{", "case", "message", "type", "type", "seata", "merge", ":", "msg", "codec", "=", "new", "merged", "warp", "message", "codec", "(", ")", ";", "break", ";", "case", "message", "type", "type", "seata", "merge", "result", ":", "msg", "codec", "=", "new", "merge", "result", "message", "codec", "(", ")", ";", "break", ";", "case", "message", "type", "type", "reg", "clt", ":", "msg", "codec", "=", "new", "register", "t", "m", "request", "codec", "(", ")", ";", "break", ";", "case", "message", "type", "type", "reg", "clt", "result", ":", "msg", "codec", "=", "new", "register", "t", "m", "response", "codec", "(", ")", ";", "break", ";", "case", "message", "type", "type", "reg", "rm", ":", "msg", "codec", "=", "new", "register", "r", "m", "request", "codec", "(", ")", ";", "break", ";", "case", "message", "type", "type", "reg", "rm", "result", ":", "msg", "codec", "=", "new", "register", "r", "m", "response", "codec", "(", ")", ";", "break", ";", "case", "message", "type", "type", "branch", "commit", ":", "msg", "codec", "=", "new", "branch", "commit", "request", "codec", "(", ")", ";", "break", ";", "case", "message", "type", "type", "branch", "rollback", ":", "msg", "codec", "=", "new", "branch", "rollback", "request", "codec", "(", ")", ";", "break", ";", "case", "message", "type", "type", "global", "report", ":", "msg", "codec", "=", "new", "global", "report", "request", "codec", "(", ")", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "msg", "codec", "!", "=", "null", ")", "{", "return", "msg", "codec", ";", "}", "try", "{", "msg", "codec", "=", "get", "merge", "request", "message", "seata", "codec", "(", "type", "code", ")", ";", "}", "catch", "(", "exception", "exx", ")", "{", "}", "if", "(", "msg", "codec", "!", "=", "null", ")", "{", "return", "msg", "codec", ";", "}", "msg", "codec", "=", "get", "merge", "response", "message", "seata", "codec", "(", "type", "code", ")", ";", "return", "msg", "codec", ";", "}" ]
[ "merge", "the", "multiple", "e", "c", "block", "group", "stats" ]
[ "public", "static", "e", "c", "block", "group", "stats", "merge", "(", "collection", "<", "e", "c", "block", "group", "stats", ">", "stats", ")", "{", "long", "low", "redundancy", "block", "groups", "=", "0", ";", "long", "corrupt", "block", "groups", "=", "0", ";", "long", "missing", "block", "groups", "=", "0", ";", "long", "bytes", "in", "future", "block", "groups", "=", "0", ";", "long", "pending", "deletion", "blocks", "=", "0", ";", "long", "highest", "priority", "low", "redundancy", "blocks", "=", "0", ";", "boolean", "has", "highest", "priority", "low", "redundancy", "blocks", "=", "false", ";", "for", "(", "e", "c", "block", "group", "stats", "stat", ":", "stats", ")", "{", "low", "redundancy", "block", "groups", "+", "=", "stat", "get", "low", "redundancy", "block", "groups", "(", ")", ";", "corrupt", "block", "groups", "+", "=", "stat", "get", "corrupt", "block", "groups", "(", ")", ";", "missing", "block", "groups", "+", "=", "stat", "get", "missing", "block", "groups", "(", ")", ";", "bytes", "in", "future", "block", "groups", "+", "=", "stat", "get", "bytes", "in", "future", "block", "groups", "(", ")", ";", "pending", "deletion", "blocks", "+", "=", "stat", "get", "pending", "deletion", "blocks", "(", ")", ";", "if", "(", "stat", "has", "highest", "priority", "low", "redundancy", "blocks", "(", ")", ")", "{", "has", "highest", "priority", "low", "redundancy", "blocks", "=", "true", ";", "highest", "priority", "low", "redundancy", "blocks", "+", "=", "stat", "get", "highest", "priority", "low", "redundancy", "blocks", "(", ")", ";", "}", "}", "if", "(", "has", "highest", "priority", "low", "redundancy", "blocks", ")", "{", "return", "new", "e", "c", "block", "group", "stats", "(", "low", "redundancy", "block", "groups", ",", "corrupt", "block", "groups", ",", "missing", "block", "groups", ",", "bytes", "in", "future", "block", "groups", ",", "pending", "deletion", "blocks", ",", "highest", "priority", "low", "redundancy", "blocks", ")", ";", "}", "return", "new", "e", "c", "block", "group", "stats", "(", "low", "redundancy", "block", "groups", ",", "corrupt", "block", "groups", ",", "missing", "block", "groups", ",", "bytes", "in", "future", "block", "groups", ",", "pending", "deletion", "blocks", ")", ";", "}" ]
[ "returns", "the", "maximum", "value", "indexed", "in", "the", "<", "code", ">", "field", "name", "<", "code", ">", "field", "or", "<", "code", ">", "null", "<", "code", ">", "if", "the", "value", "cannot", "be", "inferred", "from", "the", "indexed", "{", "@", "link", "point", "values", "}" ]
[ "static", "number", "find", "leaf", "max", "value", "(", "leaf", "reader", "reader", ",", "string", "field", "name", ",", "function", "<", "byte", "[", "]", ",", "number", ">", "converter", ")", "throws", "i", "o", "exception", "{", "final", "point", "values", "point", "values", "=", "reader", "get", "point", "values", "(", "field", "name", ")", ";", "if", "(", "point", "values", "=", "=", "null", ")", "{", "return", "null", ";", "}", "final", "bits", "live", "docs", "=", "reader", "get", "live", "docs", "(", ")", ";", "if", "(", "live", "docs", "=", "=", "null", ")", "{", "return", "converter", "apply", "(", "point", "values", "get", "max", "packed", "value", "(", ")", ")", ";", "}", "int", "num", "bytes", "=", "point", "values", "get", "bytes", "per", "dimension", "(", ")", ";", "final", "byte", "[", "]", "max", "value", "=", "point", "values", "get", "max", "packed", "value", "(", ")", ";", "final", "byte", "[", "]", "[", "]", "result", "=", "new", "byte", "[", "1", "]", "[", "]", ";", "point", "values", "intersect", "(", "new", "point", "values", "intersect", "visitor", "(", ")", "{", "@", "override", "public", "void", "visit", "(", "int", "doc", "i", "d", ")", "{", "throw", "new", "unsupported", "operation", "exception", "(", ")", ";", "}", "@", "override", "public", "void", "visit", "(", "int", "doc", "i", "d", ",", "byte", "[", "]", "packed", "value", ")", "{", "if", "(", "live", "docs", "get", "(", "doc", "i", "d", ")", ")", "{", "/", "/", "we", "need", "to", "collect", "all", "values", "in", "this", "leaf", "(", "the", "sort", "is", "ascending", ")", "where", "/", "/", "the", "last", "live", "doc", "is", "guaranteed", "to", "contain", "the", "max", "value", "for", "the", "segment", "if", "(", "result", "[", "0", "]", "=", "=", "null", ")", "{", "result", "[", "0", "]", "=", "new", "byte", "[", "packed", "value", "length", "]", ";", "}", "system", "arraycopy", "(", "packed", "value", ",", "0", ",", "result", "[", "0", "]", ",", "0", ",", "packed", "value", "length", ")", ";", "}", "}", "@", "override", "public", "point", "values", "relation", "compare", "(", "byte", "[", "]", "min", "packed", "value", ",", "byte", "[", "]", "max", "packed", "value", ")", "{", "if", "(", "future", "arrays", "equals", "(", "max", "value", ",", "0", ",", "num", "bytes", ",", "max", "packed", "value", ",", "0", ",", "num", "bytes", ")", ")", "{", "/", "/", "we", "only", "check", "leaves", "that", "contain", "the", "max", "value", "for", "the", "segment", "return", "point", "values", "relation", "cell", "crosses", "query", ";", "}", "else", "{", "return", "point", "values", "relation", "cell", "outside", "query", ";", "}", "}", "}", ")", ";", "return", "result", "[", "0", "]", "!", "=", "null", "?", "converter", "apply", "(", "result", "[", "0", "]", ")", ":", "null", ";", "}" ]
[ "{", "@", "inherit", "doc", "}", "the", "returned", "collection", "is", "immutable" ]
[ "public", "collection", "<", "v", ">", "replace", "values", "(", "@", "nullable", "decl", "k", "key", ",", "iterable", "<", "?", "extends", "v", ">", "values", ")", "{", "iterator", "<", "?", "extends", "v", ">", "iterator", "=", "values", "iterator", "(", ")", ";", "if", "(", "!", "iterator", "has", "next", "(", ")", ")", "{", "return", "remove", "all", "(", "key", ")", ";", "}", "/", "/", "todo", "(", "lowasser", ")", ":", "investigate", "atomic", "failure", "?", "collection", "<", "v", ">", "collection", "=", "get", "or", "create", "collection", "(", "key", ")", ";", "collection", "<", "v", ">", "old", "values", "=", "create", "collection", "(", ")", ";", "old", "values", "add", "all", "(", "collection", ")", ";", "total", "size", "-", "=", "collection", "size", "(", ")", ";", "collection", "clear", "(", ")", ";", "while", "(", "iterator", "has", "next", "(", ")", ")", "{", "if", "(", "collection", "add", "(", "iterator", "next", "(", ")", ")", ")", "{", "total", "size", "+", "+", ";", "}", "}", "return", "unmodifiable", "collection", "subclass", "(", "old", "values", ")", ";", "}" ]
[ "raise", "a", "regular", "error" ]
[ "public", "void", "error", "(", "string", "message", ",", "@", "nullable", "object", "source", ")", "{", "error", "(", "message", ",", "source", ",", "null", ",", "null", ")", ";", "}" ]
[ "subtracts", "another", "3d", "grid", "point", "from", "this", "point" ]
[ "public", "grid", "point", "3", "sub", "(", "grid", "point", "3", "other", ")", "{", "x", "-", "=", "other", "x", ";", "y", "-", "=", "other", "y", ";", "z", "-", "=", "other", "z", ";", "return", "this", ";", "}" ]
[ "returns", "the", "{", "@", "code", "key", "selector", "}", "that", "must", "be", "used", "for", "partitioning", "keyed", "state", "in", "this", "operation" ]
[ "public", "key", "selector", "<", "in", ",", "?", ">", "get", "state", "key", "selector", "(", ")", "{", "return", "state", "key", "selector", ";", "}" ]
[ "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", "\"", ")", ";", "}" ]
[ "send", "an", "input", "record", "with", "the", "given", "value", "on", "the", "topic", "and", "then", "commit", "the", "records", "may", "auto", "advance", "topic", "time" ]
[ "public", "void", "pipe", "input", "(", "final", "v", "value", ")", "{", "pipe", "input", "(", "new", "test", "record", "<", ">", "(", "value", ")", ")", ";", "}" ]
[ "check", "for", "job", "access" ]
[ "void", "check", "access", "(", "job", "job", ",", "http", "servlet", "request", "request", ")", "{", "if", "(", "!", "has", "access", "(", "job", ",", "request", ")", ")", "{", "throw", "new", "web", "application", "exception", "(", "status", "unauthorized", ")", ";", "}", "}", "@", "get", "@", "produces", "(", "{", "media", "type", "application", "json", "+", "\"", ";", "\"", "+", "jetty", "utils", "utf", "8", ",", "media", "type", "application", "xml", "+", "\"", ";", "\"", "+", "jetty", "utils", "utf", "8", "}" ]
[ "given", "a", "requested", "stepping", "behavior", ",", "returns", "a", "predicate", "over", "the", "context", "that", "tells", "the", "debugger", "when", "to", "pause", "(", "debugger", "api", ")", "the", "predicate", "will", "return", "true", "if", "we", "are", "at", "the", "next", "statement", "where", "execution", "should", "pause", ",", "and", "it", "will", "return", "false", "if", "we", "are", "not", "yet", "at", "that", "statement", "no", "guarantee", "is", "made", "about", "the", "predicate", "'", "s", "return", "value", "after", "we", "have", "reached", "the", "desired", "statement", "a", "null", "return", "value", "indicates", "that", "no", "further", "pausing", "should", "occur" ]
[ "public", "static", "debug", "ready", "to", "pause", "step", "control", "(", "starlark", "thread", "th", ",", "debug", "stepping", "stepping", ")", "{", "final", "int", "depth", "=", "th", "get", "call", "stack", "size", "(", ")", ";", "switch", "(", "stepping", ")", "{", "case", "none", ":", "return", "null", ";", "case", "into", ":", "/", "/", "pause", "at", "the", "very", "next", "statement", "return", "thread", "-", ">", "true", ";", "case", "over", ":", "return", "thread", "-", ">", "thread", "get", "call", "stack", "size", "(", ")", "<", "=", "depth", ";", "case", "out", ":", "/", "/", "if", "we", "'", "re", "at", "the", "outermost", "frame", ",", "same", "as", "none", "return", "depth", "=", "=", "0", "?", "null", ":", "thread", "-", ">", "thread", "get", "call", "stack", "size", "(", ")", "<", "depth", ";", "}", "throw", "new", "illegal", "argument", "exception", "(", "\"", "unsupported", "stepping", "type", ":", "\"", "+", "stepping", ")", ";", "}" ]
[ "test", "if", "{", "@", "link", "block", "manager", "#", "compute", "invalidate", "work", "(", "int", ")", "}", "can", "schedule", "invalidate", "work", "correctly", "for", "the", "replicas" ]
[ "public", "void", "test", "compute", "invalidate", "replicas", "(", ")", "throws", "exception", "{", "final", "int", "block", "invalidate", "limit", "=", "bm", "get", "datanode", "manager", "(", ")", "get", "block", "invalidate", "limit", "(", ")", ";", "namesystem", "write", "lock", "(", ")", ";", "try", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "nodes", "length", ";", "i", "+", "+", ")", "{", "for", "(", "int", "j", "=", "0", ";", "j", "<", "3", "*", "block", "invalidate", "limit", "+", "1", ";", "j", "+", "+", ")", "{", "block", "block", "=", "new", "block", "(", "i", "*", "(", "block", "invalidate", "limit", "+", "1", ")", "+", "j", ",", "0", ",", "generation", "stamp", "last", "reserved", "stamp", ")", ";", "bm", "add", "to", "invalidates", "(", "block", ",", "nodes", "[", "i", "]", ")", ";", "}", "}", "verify", "invalidation", "work", "counts", "(", "block", "invalidate", "limit", ")", ";", "}", "finally", "{", "namesystem", "write", "unlock", "(", ")", ";", "}", "}" ]
[ "visit", "a", "parse", "tree", "produced", "by", "the", "{", "@", "code", "value", "expression", "default", "}", "labeled", "alternative", "in", "{", "@", "link", "sql", "base", "parser", "#", "value", "expression", "}" ]
[ "t", "visit", "value", "expression", "default", "(", "sql", "base", "parser", "value", "expression", "default", "context", "ctx", ")", ";" ]
[ "sets", "whether", "the", "parser", "should", "ignore", "internal", "-", "only", "options" ]
[ "public", "builder", "ignore", "internal", "options", "(", "boolean", "ignore", "internal", "options", ")", "{", "this", "ignore", "internal", "options", "=", "ignore", "internal", "options", ";", "return", "this", ";", "}" ]
[ "finds", "a", "{", "@", "link", "rex", "input", "ref", "}", "that", "is", "equivalent", "to", "a", "{", "@", "link", "cor", "ref", "}", ",", "and", "if", "found", ",", "throws", "a", "{", "@", "link", "util", "found", "one", "}" ]
[ "private", "void", "find", "correlation", "equivalent", "(", "cor", "ref", "correlation", ",", "rex", "node", "e", ")", "throws", "util", "found", "one", "{", "switch", "(", "e", "get", "kind", "(", ")", ")", "{", "case", "equals", ":", "final", "rex", "call", "call", "=", "(", "rex", "call", ")", "e", ";", "final", "list", "<", "rex", "node", ">", "operands", "=", "call", "get", "operands", "(", ")", ";", "if", "(", "references", "(", "operands", "get", "(", "0", ")", ",", "correlation", ")", ")", "{", "throw", "new", "util", "found", "one", "(", "operands", "get", "(", "1", ")", ")", ";", "}", "if", "(", "references", "(", "operands", "get", "(", "1", ")", ",", "correlation", ")", ")", "{", "throw", "new", "util", "found", "one", "(", "operands", "get", "(", "0", ")", ")", ";", "}", "break", ";", "case", "and", ":", "for", "(", "rex", "node", "operand", ":", "(", "(", "rex", "call", ")", "e", ")", "get", "operands", "(", ")", ")", "{", "find", "correlation", "equivalent", "(", "correlation", ",", "operand", ")", ";", "}", "}", "}" ]
[ "gets", "the", "modules", "ordered", "by", "\"", "class", "-", "loader", "priority", "\"", "this", "ensures", "that", "core", "modules", "(", "things", "in", "framework", "features", "processors", ",", "etc", ")", "come", "before", "user", "modules", "(", "extensions", ")", "it", "also", "guarantees", "a", "consistent", "module", "order", "from", "run", "to", "run" ]
[ "private", "static", "map", "<", "string", ",", "g", "module", ">", "get", "ordered", "modules", "(", "application", "layout", "layout", ")", "{", "comparator", "<", "g", "module", ">", "comparator", "=", "(", "module", "1", ",", "module", "2", ")", "-", ">", "{", "int", "name", "comparison", "=", "module", "1", "get", "name", "(", ")", "compare", "to", "(", "module", "2", "get", "name", "(", ")", ")", ";", "/", "/", "first", "handle", "modules", "that", "are", "external", "to", "the", "ghidra", "installation", "/", "/", "these", "should", "be", "put", "at", "the", "end", "of", "the", "list", "boolean", "external", "1", "=", "module", "utilities", "is", "external", "module", "(", "module", "1", ",", "layout", ")", ";", "boolean", "external", "2", "=", "module", "utilities", "is", "external", "module", "(", "module", "2", ",", "layout", ")", ";", "if", "(", "external", "1", "&", "&", "external", "2", ")", "{", "return", "name", "comparison", ";", "}", "if", "(", "external", "1", ")", "{", "return", "-", "1", ";", "}", "if", "(", "external", "2", ")", "{", "return", "1", ";", "}", "/", "/", "now", "handle", "modules", "that", "are", "internal", "to", "the", "ghidra", "installation", "/", "/", "we", "will", "primarily", "order", "them", "by", "\"", "type", "\"", "and", "secondarily", "by", "name", "map", "<", "string", ",", "integer", ">", "type", "priority", "map", "=", "new", "hash", "map", "<", ">", "(", ")", ";", "type", "priority", "map", "put", "(", "\"", "framework", "\"", ",", "0", ")", ";", "type", "priority", "map", "put", "(", "\"", "configurations", "\"", ",", "1", ")", ";", "type", "priority", "map", "put", "(", "\"", "features", "\"", ",", "2", ")", ";", "type", "priority", "map", "put", "(", "\"", "processors", "\"", ",", "3", ")", ";", "type", "priority", "map", "put", "(", "\"", "gpl", "\"", ",", "4", ")", ";", "type", "priority", "map", "put", "(", "\"", "extensions", "\"", ",", "5", ")", ";", "type", "priority", "map", "put", "(", "\"", "test", "\"", ",", "6", ")", ";", "string", "type", "1", "=", "module", "1", "get", "module", "root", "(", ")", "get", "parent", "file", "(", ")", "get", "name", "(", ")", ";", "string", "type", "2", "=", "module", "2", "get", "module", "root", "(", ")", "get", "parent", "file", "(", ")", "get", "name", "(", ")", ";", "int", "priority", "1", "=", "type", "priority", "map", "get", "or", "default", "(", "type", "1", ",", "type", "priority", "map", "size", "(", ")", ")", ";", "int", "priority", "2", "=", "type", "priority", "map", "get", "or", "default", "(", "type", "2", ",", "type", "priority", "map", "size", "(", ")", ")", ";", "if", "(", "priority", "1", "!", "=", "priority", "2", ")", "{", "return", "integer", "compare", "(", "priority", "1", ",", "priority", "2", ")", ";", "}", "return", "name", "comparison", ";", "}", ";", "list", "<", "g", "module", ">", "module", "list", "=", "new", "array", "list", "<", ">", "(", "layout", "get", "modules", "(", ")", "values", "(", ")", ")", ";", "collections", "sort", "(", "module", "list", ",", "comparator", ")", ";", "map", "<", "string", ",", "g", "module", ">", "module", "map", "=", "new", "linked", "hash", "map", "<", ">", "(", ")", ";", "for", "(", "g", "module", "module", ":", "module", "list", ")", "{", "module", "map", "put", "(", "module", "get", "name", "(", ")", ",", "module", ")", ";", "}", "return", "module", "map", ";", "}" ]
[ "optional", ":", "if", "specified", ",", "only", "support", "the", "specified", "cipher", "list", "otherwise", "default", "to", "the", "default", "cipher", "list", "supported", "by", "envoy", "<", "code", ">", "repeated", "string", "cipher", "suites", "=", "9", ";", "<", "code", ">" ]
[ "public", "com", "google", "protobuf", "protocol", "string", "list", "get", "cipher", "suites", "list", "(", ")", "{", "return", "cipher", "suites", ";", "}" ]
[ "returns", "the", "actions", "which", "are", "supported", "by", "the", "preparer", "the", "supported", "actions", "must", "be", "a", "bitmask", "combined", "out", "of", "{", "@", "link", "playback", "state", "compat", "#", "action", "prepare", "}", ",", "{", "@", "link", "playback", "state", "compat", "#", "action", "prepare", "from", "media", "id", "}", ",", "{", "@", "link", "playback", "state", "compat", "#", "action", "prepare", "from", "search", "}", ",", "{", "@", "link", "playback", "state", "compat", "#", "action", "prepare", "from", "uri", "}", ",", "{", "@", "link", "playback", "state", "compat", "#", "action", "play", "from", "media", "id", "}", ",", "{", "@", "link", "playback", "state", "compat", "#", "action", "play", "from", "search", "}", "and", "{", "@", "link", "playback", "state", "compat", "#", "action", "play", "from", "uri", "}" ]
[ "long", "get", "supported", "prepare", "actions", "(", ")", ";" ]
[ "seek", "to", "the", "first", "offset", "for", "each", "of", "the", "given", "partitions", "this", "function", "evaluates", "lazily", ",", "seeking", "to", "the", "first", "offset", "in", "all", "partitions", "only", "when", "{", "@", "link", "#", "poll", "(", "duration", ")", "}", "or", "{", "@", "link", "#", "position", "(", "topic", "partition", ")", "}", "are", "called", "if", "no", "partitions", "are", "provided", ",", "seek", "to", "the", "first", "offset", "for", "all", "of", "the", "currently", "assigned", "partitions" ]
[ "public", "void", "seek", "to", "beginning", "(", "collection", "<", "topic", "partition", ">", "partitions", ")", "{", "if", "(", "partitions", "=", "=", "null", ")", "throw", "new", "illegal", "argument", "exception", "(", "\"", "partitions", "collection", "cannot", "be", "null", "\"", ")", ";", "acquire", "and", "ensure", "open", "(", ")", ";", "try", "{", "collection", "<", "topic", "partition", ">", "parts", "=", "partitions", "size", "(", ")", "=", "=", "0", "?", "this", "subscriptions", "assigned", "partitions", "(", ")", ":", "partitions", ";", "subscriptions", "request", "offset", "reset", "(", "parts", ",", "offset", "reset", "strategy", "earliest", ")", ";", "}", "finally", "{", "release", "(", ")", ";", "}", "}" ]