Datasets:

Anonymous2023

/

KGSum

like 0

[ "gets", "the", "plugin", "'", "s", "interpreter", "console" ]

[ "interpreter", "console", "get", "console", "(", ")", "{", "return", "console", ";", "}" ]

[ "sets", "the", "repository", "name" ]

[ "public", "create", "snapshot", "request", "builder", "set", "repository", "(", "string", "repository", ")", "{", "request", "repository", "(", "repository", ")", ";", "return", "this", ";", "}" ]

[ "create", "an", "m", "rv", "1", "file", "input", "split" ]

[ "protected", "org", "apache", "hadoop", "mapred", "file", "split", "create", "split", "v", "1", "(", "final", "job", "conf", "conf", ",", "final", "path", "path", ")", "throws", "i", "o", "exception", "{", "file", "system", "fs", "=", "path", "get", "file", "system", "(", "conf", ")", ";", "file", "status", "status", "=", "fs", "get", "file", "status", "(", "path", ")", ";", "return", "new", "org", "apache", "hadoop", "mapred", "file", "split", "(", "path", ",", "0", ",", "status", "get", "len", "(", ")", ",", "new", "string", "[", "]", "{", "\"", "localhost", "\"", "}", ")", ";", "}" ]

[ "gets", "the", "a", "c", "ls", "of", "files", "and", "directories" ]

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

[ "sorts", "the", "elements", "of", "{", "@", "code", "array", "}", "between", "{", "@", "code", "from", "index", "}", "inclusive", "and", "{", "@", "code", "to", "index", "}", "exclusive", "in", "descending", "order", "note", "that", "this", "method", "uses", "the", "total", "order", "imposed", "by", "{", "@", "link", "float", "#", "compare", "}", ",", "which", "treats", "all", "na", "n", "values", "as", "equal", "and", "0", "0", "as", "greater", "than", "-", "0", "0" ]

[ "public", "static", "void", "sort", "descending", "(", "float", "[", "]", "array", ",", "int", "from", "index", ",", "int", "to", "index", ")", "{", "check", "not", "null", "(", "array", ")", ";", "check", "position", "indexes", "(", "from", "index", ",", "to", "index", ",", "array", "length", ")", ";", "arrays", "sort", "(", "array", ",", "from", "index", ",", "to", "index", ")", ";", "reverse", "(", "array", ",", "from", "index", ",", "to", "index", ")", ";", "}" ]

[ "wrap", "the", "exception", "so", "the", "caller", "'", "s", "signature", "shows", "up", "in", "the", "stack", "trace", ",", "taking", "care", "to", "copy", "the", "original", "type", "and", "message", "where", "possible", "so", "async", "and", "sync", "code", "don", "'", "t", "have", "to", "check", "different", "exceptions" ]

[ "private", "static", "exception", "extract", "and", "wrap", "cause", "(", "exception", "exception", ")", "{", "if", "(", "exception", "instanceof", "interrupted", "exception", ")", "{", "throw", "new", "runtime", "exception", "(", "\"", "thread", "waiting", "for", "the", "response", "was", "interrupted", "\"", ",", "exception", ")", ";", "}", "if", "(", "exception", "instanceof", "execution", "exception", ")", "{", "execution", "exception", "execution", "exception", "=", "(", "execution", "exception", ")", "exception", ";", "throwable", "t", "=", "execution", "exception", "get", "cause", "(", ")", "=", "=", "null", "?", "execution", "exception", ":", "execution", "exception", "get", "cause", "(", ")", ";", "if", "(", "t", "instanceof", "error", ")", "{", "throw", "(", "error", ")", "t", ";", "}", "exception", "=", "(", "exception", ")", "t", ";", "}", "if", "(", "exception", "instanceof", "connect", "timeout", "exception", ")", "{", "connect", "timeout", "exception", "e", "=", "new", "connect", "timeout", "exception", "(", "exception", "get", "message", "(", ")", ")", ";", "e", "init", "cause", "(", "exception", ")", ";", "return", "e", ";", "}", "if", "(", "exception", "instanceof", "socket", "timeout", "exception", ")", "{", "socket", "timeout", "exception", "e", "=", "new", "socket", "timeout", "exception", "(", "exception", "get", "message", "(", ")", ")", ";", "e", "init", "cause", "(", "exception", ")", ";", "return", "e", ";", "}", "if", "(", "exception", "instanceof", "connection", "closed", "exception", ")", "{", "connection", "closed", "exception", "e", "=", "new", "connection", "closed", "exception", "(", "exception", "get", "message", "(", ")", ")", ";", "e", "init", "cause", "(", "exception", ")", ";", "return", "e", ";", "}", "if", "(", "exception", "instanceof", "s", "s", "l", "handshake", "exception", ")", "{", "s", "s", "l", "handshake", "exception", "e", "=", "new", "s", "s", "l", "handshake", "exception", "(", "exception", "get", "message", "(", ")", ")", ";", "e", "init", "cause", "(", "exception", ")", ";", "return", "e", ";", "}", "if", "(", "exception", "instanceof", "connect", "exception", ")", "{", "connect", "exception", "e", "=", "new", "connect", "exception", "(", "exception", "get", "message", "(", ")", ")", ";", "e", "init", "cause", "(", "exception", ")", ";", "return", "e", ";", "}", "if", "(", "exception", "instanceof", "i", "o", "exception", ")", "{", "return", "new", "i", "o", "exception", "(", "exception", "get", "message", "(", ")", ",", "exception", ")", ";", "}", "if", "(", "exception", "instanceof", "runtime", "exception", ")", "{", "return", "new", "runtime", "exception", "(", "exception", "get", "message", "(", ")", ",", "exception", ")", ";", "}", "return", "new", "runtime", "exception", "(", "\"", "error", "while", "performing", "request", "\"", ",", "exception", ")", ";", "}" ]

[ "return", "true", "if", "this", "class", "model", "object", "is", "equal", "to", "o" ]

[ "public", "boolean", "equals", "(", "object", "o", ")", "{", "if", "(", "this", "=", "=", "o", ")", "{", "return", "true", ";", "}", "if", "(", "o", "=", "=", "null", "|", "|", "get", "class", "(", ")", "!", "=", "o", "get", "class", "(", ")", ")", "{", "return", "false", ";", "}", "class", "model", "class", "model", "=", "(", "class", "model", ")", "o", ";", "return", "objects", "equals", "(", "this", "property", "class", ",", "class", "model", "property", "class", ")", ";", "}" ]

[ "sets", "the", "{", "@", "link", "data", "spec", "#", "http", "request", "headers", "}", "the", "default", "value", "is", "an", "empty", "map", "note", ":", "{", "@", "code", "range", "}", ",", "{", "@", "code", "accept", "-", "encoding", "}", "and", "{", "@", "code", "user", "-", "agent", "}", "should", "not", "be", "set", "with", "this", "method", ",", "since", "they", "are", "set", "directly", "by", "{", "@", "link", "http", "data", "source", "}", "implementations", "see", "{", "@", "link", "data", "spec", "#", "http", "request", "headers", "}", "for", "more", "details" ]

[ "public", "builder", "set", "http", "request", "headers", "(", "map", "<", "string", ",", "string", ">", "http", "request", "headers", ")", "{", "this", "http", "request", "headers", "=", "http", "request", "headers", ";", "return", "this", ";", "}" ]

[ "search", "for", "pattern", "in", "the", "stream", "-", "in", "-" ]

[ "public", "void", "apply", "(", "input", "stream", "in", ",", "long", "max", "bytes", ",", "array", "list", "<", "match", ">", "match", ",", "task", "monitor", "monitor", ")", "throws", "i", "o", "exception", "{", "long", "progress", "=", "monitor", "get", "progress", "(", ")", ";", "int", "max", "size", "=", "get", "max", "sequence", "size", "(", ")", "+", "1", ";", "if", "(", "max", "size", "<", "4096", ")", "{", "max", "size", "=", "4096", ";", "}", "if", "(", "max", "bytes", ">", "0", ")", "{", "max", "bytes", "+", "=", "get", "max", "sequence", "size", "(", ")", "+", "1", ";", "}", "byte", "[", "]", "first", "buf", "=", "new", "byte", "[", "max", "size", "]", ";", "byte", "[", "]", "second", "buf", "=", "new", "byte", "[", "max", "size", "]", ";", "byte", "[", "]", "cur", "buf", ";", "sequence", "search", "state", "cur", "state", ";", "int", "full", "buffers", ";", "/", "/", "number", "of", "buffers", "that", "are", "completely", "full", "int", "ra", "=", "in", "read", "(", "first", "buf", ")", ";", "if", "(", "ra", "=", "=", "first", "buf", "length", ")", "{", "ra", "=", "in", "read", "(", "second", "buf", ")", ";", "if", "(", "ra", "=", "=", "second", "buf", "length", ")", "{", "full", "buffers", "=", "2", ";", "}", "else", "{", "if", "(", "ra", "<", "0", ")", "{", "ra", "=", "0", ";", "}", "full", "buffers", "=", "1", ";", "byte", "[", "]", "tmp", "=", "new", "byte", "[", "ra", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "ra", ";", "+", "+", "i", ")", "{", "tmp", "[", "i", "]", "=", "second", "buf", "[", "i", "]", ";", "}", "second", "buf", "=", "tmp", ";", "}", "}", "else", "if", "(", "ra", "<", "0", ")", "{", "return", ";", "/", "/", "no", "bytes", "at", "all", "were", "read", "}", "else", "{", "byte", "[", "]", "tmp", "=", "new", "byte", "[", "ra", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "ra", ";", "+", "+", "i", ")", "{", "tmp", "[", "i", "]", "=", "first", "buf", "[", "i", "]", ";", "}", "first", "buf", "=", "tmp", ";", "full", "buffers", "=", "0", ";", "second", "buf", "=", "new", "byte", "[", "0", "]", ";", "}", "int", "offset", "=", "0", ";", "int", "buf", "relative", "offset", "=", "0", ";", "int", "sub", "index", ";", "while", "(", "full", "buffers", "=", "=", "2", ")", "{", "cur", "state", "=", "this", ";", "/", "/", "new", "starting", "offset", "-", ">", "root", "state", "sub", "index", "=", "buf", "relative", "offset", ";", "cur", "buf", "=", "first", "buf", ";", "do", "{", "if", "(", "cur", "state", "success", "!", "=", "null", ")", "{", "cur", "state", "export", "success", "(", "match", ",", "offset", ")", ";", "}", "if", "(", "sub", "index", ">", "=", "cur", "buf", "length", ")", "{", "/", "/", "check", "that", "we", "have", "enough", "bytes", "in", "current", "buffer", "cur", "buf", "=", "second", "buf", ";", "/", "/", "if", "not", ",", "switch", "to", "secondary", "buffer", "sub", "index", "=", "0", ";", "}", "cur", "state", "=", "cur", "state", "trans", "[", "0xff", "&", "cur", "buf", "[", "sub", "index", "]", "]", ";", "/", "/", "perform", "state", "transition", "based", "on", "next", "byte", "in", "buffer", "sub", "index", "+", "=", "1", ";", "}", "while", "(", "cur", "state", "!", "=", "null", ")", ";", "offset", "+", "=", "1", ";", "/", "/", "advance", "to", "next", "starting", "offset", "if", "(", "max", "bytes", ">", "0", "&", "&", "offset", ">", "max", "bytes", ")", "{", "break", ";", "}", "buf", "relative", "offset", "+", "=", "1", ";", "if", "(", "buf", "relative", "offset", "=", "=", "first", "buf", "length", ")", "{", "/", "/", "if", "starting", "offset", "no", "longer", "falls", "in", "firstbuf", "byte", "[", "]", "tmp", "=", "first", "buf", ";", "/", "/", "switch", "firstbuf", "with", "secondbuf", "first", "buf", "=", "second", "buf", ";", "second", "buf", "=", "tmp", ";", "ra", "=", "in", "read", "(", "second", "buf", ")", ";", "/", "/", "refill", "secondbuf", "(", "old", "firstbuf", ")", "with", "new", "bytes", "if", "(", "monitor", "!", "=", "null", ")", "{", "if", "(", "monitor", "is", "cancelled", "(", ")", ")", "{", "return", ";", "}", "monitor", "set", "progress", "(", "progress", "+", "offset", ")", ";", "}", "if", "(", "ra", "!", "=", "second", "buf", "length", ")", "{", "full", "buffers", "=", "1", ";", "if", "(", "ra", "<", "0", ")", "{", "ra", "=", "0", ";", "}", "tmp", "=", "new", "byte", "[", "ra", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "ra", ";", "+", "+", "i", ")", "{", "tmp", "[", "i", "]", "=", "second", "buf", "[", "i", "]", ";", "}", "second", "buf", "=", "tmp", ";", "}", "buf", "relative", "offset", "=", "0", ";", "}", "}", "while", "(", "full", "buffers", ">", "=", "0", "&", "&", "(", "max", "bytes", "<", "=", "0", "|", "|", "offset", "<", "max", "bytes", ")", ")", "{", "if", "(", "second", "buf", "length", "=", "=", "0", ")", "{", "full", "buffers", "=", "0", ";", "}", "cur", "state", "=", "this", ";", "sub", "index", "=", "buf", "relative", "offset", ";", "cur", "buf", "=", "first", "buf", ";", "do", "{", "if", "(", "cur", "state", "success", "!", "=", "null", ")", "{", "cur", "state", "export", "success", "(", "match", ",", "offset", ")", ";", "}", "if", "(", "sub", "index", ">", "=", "cur", "buf", "length", ")", "{", "if", "(", "cur", "buf", "=", "=", "second", "buf", ")", "{", "break", ";", "/", "/", "out", "of", "data", ",", "all", "pending", "patterns", "fail", "}", "cur", "buf", "=", "second", "buf", ";", "sub", "index", "=", "0", ";", "if", "(", "cur", "buf", "length", "=", "=", "0", ")", "{", "break", ";", "}", "}", "cur", "state", "=", "cur", "state", "trans", "[", "0xff", "&", "cur", "buf", "[", "sub", "index", "]", "]", ";", "sub", "index", "+", "=", "1", ";", "}", "while", "(", "cur", "state", "!", "=", "null", ")", ";", "offset", "+", "=", "1", ";", "buf", "relative", "offset", "+", "=", "1", ";", "if", "(", "buf", "relative", "offset", "=", "=", "first", "buf", "length", ")", "{", "if", "(", "full", "buffers", "=", "=", "0", ")", "{", "break", ";", "}", "first", "buf", "=", "second", "buf", ";", "full", "buffers", "=", "0", ";", "buf", "relative", "offset", "=", "0", ";", "second", "buf", "=", "new", "byte", "[", "0", "]", ";", "}", "}", "}" ]

[ "zip", "the", "file" ]

[ "public", "static", "boolean", "zip", "file", "(", "final", "file", "src", "file", ",", "final", "file", "zip", "file", ")", "throws", "i", "o", "exception", "{", "return", "zip", "file", "(", "src", "file", ",", "zip", "file", ",", "null", ")", ";", "}" ]

[ "get", "a", "proxy", "connection", "to", "a", "remote", "server" ]

[ "public", "static", "<", "t", ">", "t", "wait", "for", "proxy", "(", "class", "<", "t", ">", "protocol", ",", "long", "client", "version", ",", "inet", "socket", "address", "addr", ",", "configuration", "conf", ")", "throws", "i", "o", "exception", "{", "return", "wait", "for", "protocol", "proxy", "(", "protocol", ",", "client", "version", ",", "addr", ",", "conf", ")", "get", "proxy", "(", ")", ";", "}" ]

[ "if", "this", "parameter", "which", "was", "forced", "by", "the", "associated", "calling", "convention", "to", "be", "passed", "as", "a", "pointer", "instead", "of", "its", "original", "formal", "type" ]

[ "public", "boolean", "is", "forced", "indirect", "(", ")", ";" ]

[ "gets", "the", "bytecode", "offset", "(", "inclusive", ")", "of", "the", "start", "of", "this", "block" ]

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

[ "<", "code", ">", "optional", "org", "apache", "dubbo", "common", "serialize", "protobuf", "model", "p", "b", "request", "type", "c", "dubbo", "p", "b", "request", "type", "=", "3", ";", "<", "code", ">" ]

[ "public", "boolean", "has", "c", "dubbo", "p", "b", "request", "type", "(", ")", "{", "return", "(", "(", "bit", "field", "0", "&", "0x", "0", "0", "0", "0", "0", "0", "0", "2", ")", "=", "=", "0x", "0", "0", "0", "0", "0", "0", "0", "2", ")", ";", "}" ]

[ "runs", "{", "@", "link", "#", "test", "method", "}", "on", "every", "public", "instance", "method", "of", "the", "class", "of", "{", "@", "code", "instance", "}", ",", "including", "those", "inherited", "from", "superclasses", "of", "the", "same", "package" ]

[ "public", "void", "test", "all", "public", "instance", "methods", "(", "object", "instance", ")", "{", "test", "instance", "methods", "(", "instance", ",", "visibility", "public", ")", ";", "}" ]

[ "get", "{", "@", "link", "task", "attempt", "info", "}", "for", "a", "given", "task", "-", "attempt", ",", "without", "regard", "to", "impact", "of", "locality", "(", "e", "g", "not", "needed", "to", "make", "scheduling", "decisions", ")" ]

[ "public", "task", "attempt", "info", "get", "task", "attempt", "info", "(", "task", "type", "task", "type", ",", "int", "task", "number", ",", "int", "task", "attempt", "number", ")", ";" ]

[ "add", "certain", "elements", "from", "the", "given", "array", "at", "a", "certain", "position", "in", "this", "list" ]

[ "public", "boolean", "add", "all", "(", "long", "[", "]", "array", ",", "int", "from", "index", ",", "int", "length", ",", "int", "position", ")", "{", "preconditions", "check", "not", "null", "(", "array", ")", ";", "preconditions", "check", "position", "index", "(", "from", "index", "+", "length", ",", "array", "length", ")", ";", "if", "(", "length", "=", "=", "0", ")", "{", "return", "false", ";", "}", "/", "/", "check", "other", "positions", "later", "to", "allow", "\"", "adding", "\"", "empty", "arrays", "anywhere", "within", "this", "array", "preconditions", "check", "element", "index", "(", "from", "index", ",", "array", "length", ")", ";", "preconditions", "check", "position", "index", "(", "position", ",", "size", ")", ";", "copy", "back", "and", "grow", "(", "position", ",", "length", ")", ";", "system", "arraycopy", "(", "array", ",", "from", "index", ",", "this", "array", ",", "position", ",", "length", ")", ";", "return", "true", ";", "}" ]

[ "check", "if", "identity", "is", "allowed", "to", "drop", "the", "specified", "view", "in", "a", "catalog" ]

[ "default", "void", "check", "can", "drop", "view", "(", "identity", "identity", ",", "access", "control", "context", "context", ",", "catalog", "schema", "table", "name", "view", ")", "{", "deny", "drop", "view", "(", "view", "to", "string", "(", ")", ")", ";", "}" ]

[ "the", "'", "by", "'", "field", "or", "<", "code", ">", "null", "<", "code", ">", "if", "not", "set" ]

[ "public", "string", "get", "by", "field", "name", "(", ")", "{", "return", "by", "field", "name", ";", "}" ]

[ "updates", "the", "binary", "representation", "of", "the", "data", ",", "such", "that", "it", "reflects", "the", "state", "of", "the", "currently", "stored", "fields", "if", "the", "binary", "representation", "is", "already", "up", "to", "date", ",", "nothing", "happens", "otherwise", ",", "this", "function", "triggers", "the", "modified", "fields", "to", "serialize", "themselves", "into", "the", "records", "buffer", "and", "afterwards", "updates", "the", "offset", "table" ]

[ "public", "void", "update", "binary", "represenation", "(", ")", "{", "/", "/", "check", "whether", "the", "binary", "state", "is", "in", "sync", "final", "int", "first", "modified", "=", "this", "first", "modified", "pos", ";", "if", "(", "first", "modified", "=", "=", "integer", "max", "value", ")", "{", "return", ";", "}", "final", "internal", "de", "serializer", "serializer", "=", "this", "serializer", ";", "final", "int", "[", "]", "offsets", "=", "this", "offsets", ";", "final", "int", "num", "fields", "=", "this", "num", "fields", ";", "serializer", "memory", "=", "this", "switch", "buffer", "!", "=", "null", "?", "this", "switch", "buffer", ":", "(", "this", "binary", "len", ">", "0", "?", "new", "byte", "[", "this", "binary", "len", "]", ":", "new", "byte", "[", "num", "fields", "*", "default", "field", "len", "estimate", "+", "1", "]", ")", ";", "serializer", "position", "=", "0", ";", "if", "(", "num", "fields", ">", "0", ")", "{", "int", "offset", "=", "0", ";", "/", "/", "search", "backwards", "to", "find", "the", "latest", "preceding", "non", "-", "null", "field", "if", "(", "first", "modified", ">", "0", ")", "{", "for", "(", "int", "i", "=", "first", "modified", "-", "1", ";", "i", ">", "=", "0", ";", "i", "-", "-", ")", "{", "if", "(", "this", "offsets", "[", "i", "]", "!", "=", "null", "indicator", "offset", ")", "{", "offset", "=", "this", "offsets", "[", "i", "]", "+", "this", "lengths", "[", "i", "]", ";", "break", ";", "}", "}", "}", "/", "/", "we", "assume", "that", "changed", "and", "unchanged", "fields", "are", "interleaved", "and", "serialize", "into", "/", "/", "another", "array", "try", "{", "if", "(", "offset", ">", "0", ")", "{", "/", "/", "copy", "the", "first", "unchanged", "portion", "as", "one", "serializer", "write", "(", "this", "binary", "data", ",", "0", ",", "offset", ")", ";", "}", "/", "/", "copy", "field", "by", "field", "for", "(", "int", "i", "=", "first", "modified", ";", "i", "<", "num", "fields", ";", "i", "+", "+", ")", "{", "final", "int", "co", "=", "offsets", "[", "i", "]", ";", "/", "/", "/", "skip", "null", "fields", "if", "(", "co", "=", "=", "null", "indicator", "offset", ")", "{", "continue", ";", "}", "offsets", "[", "i", "]", "=", "offset", ";", "if", "(", "co", "=", "=", "modified", "indicator", "offset", ")", "{", "final", "value", "write", "field", "=", "this", "write", "fields", "[", "i", "]", ";", "if", "(", "write", "field", "=", "=", "reserve", "space", ")", "{", "/", "/", "reserve", "space", "is", "a", "placeholder", "indicating", "lengths", "[", "i", "]", "bytes", "should", "be", "/", "/", "reserved", "final", "int", "length", "=", "this", "lengths", "[", "i", "]", ";", "if", "(", "serializer", "position", ">", "=", "serializer", "memory", "length", "-", "length", "-", "1", ")", "{", "serializer", "resize", "(", "length", ")", ";", "}", "serializer", "position", "+", "=", "length", ";", "}", "else", "{", "/", "/", "serialize", "modified", "fields", "this", "write", "fields", "[", "i", "]", "write", "(", "serializer", ")", ";", "}", "}", "else", "{", "/", "/", "bin", "-", "copy", "unmodified", "fields", "serializer", "write", "(", "this", "binary", "data", ",", "co", ",", "this", "lengths", "[", "i", "]", ")", ";", "}", "this", "lengths", "[", "i", "]", "=", "serializer", "position", "-", "offset", ";", "offset", "=", "serializer", "position", ";", "}", "}", "catch", "(", "exception", "e", ")", "{", "throw", "new", "runtime", "exception", "(", "\"", "error", "in", "data", "type", "serialization", ":", "\"", "+", "e", "get", "message", "(", ")", ",", "e", ")", ";", "}", "}", "serialize", "header", "(", "serializer", ",", "offsets", ",", "num", "fields", ")", ";", "/", "/", "set", "the", "fields", "this", "switch", "buffer", "=", "this", "binary", "data", ";", "this", "binary", "data", "=", "serializer", "memory", ";", "this", "binary", "len", "=", "serializer", "position", ";", "this", "first", "modified", "pos", "=", "integer", "max", "value", ";", "}" ]

[ "whether", "the", "symbol", "can", "be", "merged", "into", "another", "resource", "table", "without", "there", "being", "an", "existing", "definition", "to", "override", "used", "for", "overlays", "and", "set", "to", "true", "when", "&", "lt", ";", "add", "-", "resource", "&", "gt", ";", "is", "specified", "<", "code", ">", "optional", "bool", "allow", "new", "=", "4", ";", "<", "code", ">" ]

[ "public", "boolean", "has", "allow", "new", "(", ")", "{", "return", "(", "(", "bit", "field", "0", "&", "0x", "0", "0", "0", "0", "0", "0", "0", "8", ")", "=", "=", "0x", "0", "0", "0", "0", "0", "0", "0", "8", ")", ";", "}" ]

[ "convert", "the", "given", "object", "to", "string", "with", "each", "line", "indented", "by", "4", "spaces", "(", "except", "the", "first", "line", ")" ]

[ "private", "static", "string", "to", "indented", "string", "(", "object", "o", ")", "{", "if", "(", "o", "=", "=", "null", ")", "{", "return", "\"", "null", "\"", ";", "}", "return", "o", "to", "string", "(", ")", "replace", "(", "\"", "\\", "n", "\"", ",", "\"", "\\", "n", "\"", ")", ";", "}" ]

[ "returns", "a", "{", "@", "link", "decoder", "}", "that", "decodes", "using", "the", "<", "a", "href", "=", "\"", "#", "url", "\"", ">", "url", "and", "filename", "safe", "type", "base", "6", "4", "encoding", "scheme" ]

[ "public", "static", "decoder", "get", "url", "decoder", "(", ")", "{", "return", "decoder", "rfc4648", "urlsafe", ";", "}" ]

[ "c", ":", "=", "alpha", "a", "b", "+", "beta", "c" ]

[ "public", "static", "void", "gemm", "(", "double", "alpha", ",", "dense", "matrix", "mat", "a", ",", "boolean", "trans", "a", ",", "dense", "matrix", "mat", "b", ",", "boolean", "trans", "b", ",", "double", "beta", ",", "dense", "matrix", "mat", "c", ")", "{", "if", "(", "trans", "a", ")", "{", "preconditions", "check", "argument", "(", "mat", "a", "num", "cols", "(", ")", "=", "=", "mat", "c", "num", "rows", "(", ")", ",", "\"", "the", "columns", "of", "a", "does", "not", "match", "the", "rows", "of", "c", "\"", ")", ";", "}", "else", "{", "preconditions", "check", "argument", "(", "mat", "a", "num", "rows", "(", ")", "=", "=", "mat", "c", "num", "rows", "(", ")", ",", "\"", "the", "rows", "of", "a", "does", "not", "match", "the", "rows", "of", "c", "\"", ")", ";", "}", "if", "(", "trans", "b", ")", "{", "preconditions", "check", "argument", "(", "mat", "b", "num", "rows", "(", ")", "=", "=", "mat", "c", "num", "cols", "(", ")", ",", "\"", "the", "rows", "of", "b", "does", "not", "match", "the", "columns", "of", "c", "\"", ")", ";", "}", "else", "{", "preconditions", "check", "argument", "(", "mat", "b", "num", "cols", "(", ")", "=", "=", "mat", "c", "num", "cols", "(", ")", ",", "\"", "the", "columns", "of", "b", "does", "not", "match", "the", "columns", "of", "c", "\"", ")", ";", "}", "final", "int", "m", "=", "mat", "c", "num", "rows", "(", ")", ";", "final", "int", "n", "=", "mat", "c", "num", "cols", "(", ")", ";", "final", "int", "k", "=", "trans", "a", "?", "mat", "a", "num", "rows", "(", ")", ":", "mat", "a", "num", "cols", "(", ")", ";", "final", "int", "lda", "=", "mat", "a", "num", "rows", "(", ")", ";", "final", "int", "ldb", "=", "mat", "b", "num", "rows", "(", ")", ";", "final", "int", "ldc", "=", "mat", "c", "num", "rows", "(", ")", ";", "final", "string", "ta", "=", "trans", "a", "?", "\"", "t", "\"", ":", "\"", "n", "\"", ";", "final", "string", "tb", "=", "trans", "b", "?", "\"", "t", "\"", ":", "\"", "n", "\"", ";", "native", "blas", "dgemm", "(", "ta", ",", "tb", ",", "m", ",", "n", ",", "k", ",", "alpha", ",", "mat", "a", "get", "data", "(", ")", ",", "lda", ",", "mat", "b", "get", "data", "(", ")", ",", "ldb", ",", "beta", ",", "mat", "c", "get", "data", "(", ")", ",", "ldc", ")", ";", "}" ]

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

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

[ "return", "the", "configured", "{", "@", "code", "gson", "}", "instance", "for", "this", "converter" ]

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

[ "gets", "the", "instruction", "prefix", "required", ",", "if", "any", ",", "to", "use", "in", "an", "expanded", "version", "of", "this", "instance", "will", "not", "generate", "moves", "for", "registers", "marked", "compatible", "to", "the", "format", "by", "the", "given", "bit", "set" ]

[ "public", "dalv", "insn", "expanded", "prefix", "(", "bit", "set", "compat", "regs", ")", "{", "register", "spec", "list", "regs", "=", "registers", ";", "boolean", "first", "bit", "=", "compat", "regs", "get", "(", "0", ")", ";", "if", "(", "has", "result", "(", ")", ")", "compat", "regs", "set", "(", "0", ")", ";", "regs", "=", "regs", "subset", "(", "compat", "regs", ")", ";", "if", "(", "has", "result", "(", ")", ")", "compat", "regs", "set", "(", "0", ",", "first", "bit", ")", ";", "if", "(", "regs", "size", "(", ")", "=", "=", "0", ")", "return", "null", ";", "return", "new", "high", "register", "prefix", "(", "position", ",", "regs", ")", ";", "}" ]

[ "add", "a", "custom", "formatter", ",", "applying", "it", "to", "the", "specified", "field", "types", "only", ",", "if", "any", ",", "or", "otherwise", "to", "all", "fields", "matching", "the", "{", "@", "link", "formatter", "}", "-", "declared", "type", "registers", "a", "corresponding", "{", "@", "link", "property", "editor", "}", "adapter", "underneath", "the", "covers" ]

[ "public", "void", "add", "custom", "formatter", "(", "formatter", "<", "?", ">", "formatter", ",", "class", "<", "?", ">", "field", "types", ")", "{", "formatter", "property", "editor", "adapter", "adapter", "=", "new", "formatter", "property", "editor", "adapter", "(", "formatter", ")", ";", "if", "(", "object", "utils", "is", "empty", "(", "field", "types", ")", ")", "{", "get", "property", "editor", "registry", "(", ")", "register", "custom", "editor", "(", "adapter", "get", "field", "type", "(", ")", ",", "adapter", ")", ";", "}", "else", "{", "for", "(", "class", "<", "?", ">", "field", "type", ":", "field", "types", ")", "{", "get", "property", "editor", "registry", "(", ")", "register", "custom", "editor", "(", "field", "type", ",", "adapter", ")", ";", "}", "}", "}" ]

[ "check", "whether", "the", "given", "method", "corresponds", "to", "the", "container", "'", "s", "currently", "invoked", "factory", "method", "compares", "method", "name", "and", "parameter", "types", "only", "in", "order", "to", "work", "around", "a", "potential", "problem", "with", "covariant", "return", "types", "(", "currently", "only", "known", "to", "happen", "on", "groovy", "classes", ")" ]

[ "private", "boolean", "is", "currently", "invoked", "factory", "method", "(", "method", "method", ")", "{", "method", "currently", "invoked", "=", "simple", "instantiation", "strategy", "get", "currently", "invoked", "factory", "method", "(", ")", ";", "return", "(", "currently", "invoked", "!", "=", "null", "&", "&", "method", "get", "name", "(", ")", "equals", "(", "currently", "invoked", "get", "name", "(", ")", ")", "&", "&", "arrays", "equals", "(", "method", "get", "parameter", "types", "(", ")", ",", "currently", "invoked", "get", "parameter", "types", "(", ")", ")", ")", ";", "}" ]

[ "get", "enum", "string", "required" ]

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

[ "find", "the", "fields", "constant", "that", "matches", "field", "id", ",", "throwing", "an", "exception", "if", "it", "is", "not", "found" ]

[ "public", "static", "fields", "find", "by", "thrift", "id", "or", "throw", "(", "int", "field", "id", ")", "{", "fields", "fields", "=", "find", "by", "thrift", "id", "(", "field", "id", ")", ";", "if", "(", "fields", "=", "=", "null", ")", "throw", "new", "illegal", "argument", "exception", "(", "\"", "field", "\"", "+", "field", "id", "+", "\"", "doesn", "'", "t", "exist", "!", "\"", ")", ";", "return", "fields", ";", "}" ]

[ "add", "a", "complete", "small", "(", "small", "print", ")", "element", "shortcut", "of", ":", "small", "(", ")", "$", "id", "(", "id", ")", "$", "class", "(", "class", ")", "(", "cdata", ")", "(", ")", ";" ]

[ "font", "size", "small", "(", "string", "selector", ",", "string", "cdata", ")", ";" ]

[ "returns", "a", "new", "status", "with", "the", "same", "code", "and", "description", "if", "include", "cause", "with", "status", "is", "true", ",", "cause", "is", "also", "included", "for", "in", "process", "transport", "to", "behave", "in", "the", "same", "way", "as", "the", "other", "transports", ",", "when", "exchanging", "statuses", "between", "client", "and", "server", "and", "vice", "versa", ",", "the", "cause", "should", "be", "excluded", "from", "the", "status", "for", "easier", "debugging", ",", "the", "status", "may", "be", "optionally", "included" ]

[ "private", "static", "status", "clean", "status", "(", "status", "status", ",", "boolean", "include", "cause", "with", "status", ")", "{", "if", "(", "status", "=", "=", "null", ")", "{", "return", "null", ";", "}", "status", "client", "status", "=", "status", "from", "code", "value", "(", "status", "get", "code", "(", ")", "value", "(", ")", ")", "with", "description", "(", "status", "get", "description", "(", ")", ")", ";", "if", "(", "include", "cause", "with", "status", ")", "{", "client", "status", "=", "client", "status", "with", "cause", "(", "status", "get", "cause", "(", ")", ")", ";", "}", "return", "client", "status", ";", "}" ]

[ "clear", "the", "local", "metadata", "reader", "cache", ",", "if", "any", ",", "removing", "all", "cached", "class", "metadata" ]

[ "public", "void", "clear", "cache", "(", ")", "{", "if", "(", "this", "metadata", "reader", "cache", "instanceof", "local", "resource", "cache", ")", "{", "synchronized", "(", "this", "metadata", "reader", "cache", ")", "{", "this", "metadata", "reader", "cache", "clear", "(", ")", ";", "}", "}", "else", "if", "(", "this", "metadata", "reader", "cache", "!", "=", "null", ")", "{", "/", "/", "shared", "resource", "cache", "-", ">", "reset", "to", "local", "cache", "set", "cache", "limit", "(", "default", "cache", "limit", ")", ";", "}", "}" ]

[ "sets", "whether", "this", "aspect", "should", ",", "when", "it", "would", "be", "applied", "to", "an", "output", "file", ",", "instead", "apply", "to", "the", "generating", "rule", "of", "that", "output", "file", "default", "is", "<", "code", ">", "false", "<", "code", ">", "currently", "only", "supported", "for", "aspects", "which", "do", "not", "have", "a", "\"", "required", "providers", "\"", "list" ]

[ "public", "builder", "apply", "to", "generating", "rules", "(", "boolean", "apply", "to", "generating", "rules", ")", "{", "this", "apply", "to", "generating", "rules", "=", "apply", "to", "generating", "rules", ";", "return", "this", ";", "}" ]

[ "matches", "only", "if", "window", "node", "get", "hash", "variable", "(", ")", "is", "a", "non", "-", "empty", "option", "containing", "hash", "variable" ]

[ "public", "builder", "hash", "symbol", "(", "string", "hash", "symbol", ")", "{", "require", "non", "null", "(", "hash", "symbol", ",", "\"", "hash", "symbol", "is", "null", "\"", ")", ";", "this", "hash", "symbol", "=", "optional", "of", "(", "optional", "of", "(", "new", "symbol", "alias", "(", "hash", "symbol", ")", ")", ")", ";", "return", "this", ";", "}" ]

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

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

[ "returns", "the", "java", "class", "that", "implements", "the", "open", "a", "p", "i", "schema", "for", "the", "specified", "discriminator", "value" ]

[ "private", "static", "class", "get", "class", "by", "discriminator", "(", "map", "class", "by", "discriminator", "value", ",", "string", "discriminator", "value", ")", "{", "class", "clazz", "=", "(", "class", ")", "class", "by", "discriminator", "value", "get", "(", "discriminator", "value", ")", ";", "if", "(", "null", "=", "=", "clazz", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "cannot", "determine", "model", "class", "of", "name", ":", "<", "\"", "+", "discriminator", "value", "+", "\"", ">", "\"", ")", ";", "}", "return", "clazz", ";", "}" ]

[ "returns", "{", "@", "code", "true", "}", "if", "the", "given", "{", "@", "link", "transition", "factory", "}", "is", "an", "instance", "of", "the", "no", "transition" ]

[ "public", "static", "<", "t", ">", "boolean", "is", "instance", "(", "transition", "factory", "<", "t", ">", "instance", ")", "{", "return", "instance", "instanceof", "factory", ";", "}" ]

[ "test", "serialization", "of", "outer", "number", "types" ]

[ "public", "void", "fake", "outer", "number", "serialize", "test", "(", ")", "throws", "api", "exception", "{", "big", "decimal", "body", "=", "null", ";", "big", "decimal", "response", "=", "api", "fake", "outer", "number", "serialize", "(", "body", ")", ";", "/", "/", "todo", ":", "test", "validations", "}" ]

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

[ "converts", "\"", "abc", "\"", "to", "\"", "abc", "\"" ]

[ "public", "static", "string", "capitalize", "(", "string", "s", ")", "{", "if", "(", "s", "=", "=", "null", "|", "|", "s", "length", "(", ")", "=", "=", "0", ")", "return", "s", ";", "return", "character", "to", "upper", "case", "(", "s", "char", "at", "(", "0", ")", ")", "+", "s", "substring", "(", "1", ")", ";", "}" ]

[ "returns", "the", "copyright", "string", "defined", "in", "this", "directory" ]

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

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

[ "detail", "level", "parameter", "adjustments", "may", "only", "be", "done", "when", "both", "source", "and", "result", "functions", "initially", "had", "the", "same", "number", "of", "auto", "-", "params", "and", "the", "same", "total", "number", "of", "parameters", "(", "only", "complete", "signature", "replacement", "is", "supported", "otherwise", ")", "this", "method", "is", "intended", "to", "adjust", "the", "result", "ordinal", "based", "upon", "adjustments", "which", "may", "have", "already", "been", "performed", "on", "the", "result", "function", "causing", "its", "number", "of", "auto", "-", "params", "to", "change", "from", "when", "the", "conflicts", "were", "initially", "determined" ]

[ "private", "int", "get", "adjusted", "result", "ordinal", "(", "function", "result", "func", ",", "function", "src", "func", ",", "int", "ordinal", ")", "{", "return", "result", "func", "get", "auto", "parameter", "count", "(", ")", "-", "src", "func", "get", "auto", "parameter", "count", "(", ")", "+", "ordinal", ";", "}" ]

[ "sets", "message", "type" ]

[ "public", "void", "set", "message", "type", "(", "byte", "message", "type", ")", "{", "this", "message", "type", "=", "message", "type", ";", "}" ]

[ "the", "maximum", "uptime", "of", "a", "node", "in", "the", "cluster" ]

[ "public", "time", "value", "get", "max", "up", "time", "(", ")", "{", "return", "new", "time", "value", "(", "max", "uptime", ")", ";", "}" ]

[ "whether", "to", "use", "a", "{", "@", "link", "hystrix", "circuit", "breaker", "}", "or", "not", "if", "false", "no", "circuit", "-", "breaker", "logic", "will", "be", "used", "and", "all", "requests", "permitted", "this", "is", "similar", "in", "effect", "to", "{", "@", "link", "#", "circuit", "breaker", "force", "closed", "(", ")", "}", "except", "that", "continues", "tracking", "metrics", "and", "knowing", "whether", "it", "should", "be", "openclosed", ",", "this", "property", "results", "in", "not", "even", "instantiating", "a", "circuit", "-", "breaker" ]

[ "public", "hystrix", "property", "<", "boolean", ">", "circuit", "breaker", "enabled", "(", ")", "{", "return", "circuit", "breaker", "enabled", ";", "}" ]

[ "returns", "the", "{", "@", "code", "big", "integer", "}", "value", "that", "is", "equal", "to", "{", "@", "code", "x", "}", "rounded", "with", "the", "specified", "rounding", "mode", ",", "if", "possible" ]

[ "public", "static", "big", "integer", "round", "to", "big", "integer", "(", "double", "x", ",", "rounding", "mode", "mode", ")", "{", "x", "=", "round", "intermediate", "(", "x", ",", "mode", ")", ";", "if", "(", "min", "long", "as", "double", "-", "x", "<", "1", "0", "&", "x", "<", "max", "long", "as", "double", "plus", "one", ")", "{", "return", "big", "integer", "value", "of", "(", "(", "long", ")", "x", ")", ";", "}", "int", "exponent", "=", "get", "exponent", "(", "x", ")", ";", "long", "significand", "=", "get", "significand", "(", "x", ")", ";", "big", "integer", "result", "=", "big", "integer", "value", "of", "(", "significand", ")", "shift", "left", "(", "exponent", "-", "significand", "bits", ")", ";", "return", "(", "x", "<", "0", ")", "?", "result", "negate", "(", ")", ":", "result", ";", "}" ]

[ "return", "true", "if", "the", "method", "includes", "the", "{", "@", "code", "abstract", "}", "modifier" ]

[ "public", "boolean", "is", "abstract", "(", ")", "{", "return", "modifier", "is", "abstract", "(", "method", "get", "modifiers", "(", ")", ")", ";", "}" ]

[ "make", "the", "pre", "0", "21", "counters", "string" ]

[ "public", "static", "<", "c", "extends", "counter", ",", "g", "extends", "counter", "group", "base", "<", "c", ">", ",", "t", "extends", "abstract", "counters", "<", "c", ",", "g", ">", ">", "string", "to", "escaped", "compact", "string", "(", "t", "counters", ")", "{", "string", "builder", "builder", "=", "new", "string", "builder", "(", ")", ";", "synchronized", "(", "counters", ")", "{", "for", "(", "g", "group", ":", "counters", ")", "{", "builder", "append", "(", "to", "escaped", "compact", "string", "(", "group", ")", ")", ";", "}", "}", "return", "builder", "to", "string", "(", ")", ";", "}", "/", "/", "escapes", "all", "the", "delimiters", "for", "counters", "i", "e", "{", ",", "[", ",", "(", ",", ")", ",", "]", ",", "}" ]

[ "creates", "a", "new", "tuple", "descriptor", "containing", "only", "the", "visible", "fields" ]

[ "public", "relation", "type", "with", "only", "visible", "fields", "(", ")", "{", "return", "new", "relation", "type", "(", "visible", "fields", ")", ";", "}" ]

[ "creates", "the", "uam", "instance", "pull", "out", "to", "make", "unit", "test", "easy" ]

[ "protected", "unmanaged", "application", "manager", "create", "u", "a", "m", "(", "configuration", "conf", ",", "application", "id", "app", "id", ",", "string", "queue", "name", ",", "string", "submitter", ",", "string", "app", "name", "suffix", ",", "boolean", "keep", "containers", "across", "application", "attempts", ",", "string", "rm", "name", ")", "{", "return", "new", "unmanaged", "application", "manager", "(", "conf", ",", "app", "id", ",", "queue", "name", ",", "submitter", ",", "app", "name", "suffix", ",", "keep", "containers", "across", "application", "attempts", ",", "rm", "name", ")", ";", "}" ]

[ "whether", "the", "collector", "requires", "an", "extra", "query", "to", "identify", "the", "changes" ]

[ "boolean", "query", "for", "changes", "(", ")", ";" ]

[ "returns", "true", "if", "this", "filter", "matches", "the", "given", "access", "control", "entry" ]

[ "public", "boolean", "matches", "(", "access", "control", "entry", "other", ")", "{", "if", "(", "(", "principal", "(", ")", "!", "=", "null", ")", "&", "&", "(", "!", "data", "principal", "(", ")", "equals", "(", "other", "principal", "(", ")", ")", ")", ")", "return", "false", ";", "if", "(", "(", "host", "(", ")", "!", "=", "null", ")", "&", "&", "(", "!", "host", "(", ")", "equals", "(", "other", "host", "(", ")", ")", ")", ")", "return", "false", ";", "if", "(", "(", "operation", "(", ")", "!", "=", "acl", "operation", "any", ")", "&", "&", "(", "!", "operation", "(", ")", "equals", "(", "other", "operation", "(", ")", ")", ")", ")", "return", "false", ";", "return", "(", "permission", "type", "(", ")", "=", "=", "acl", "permission", "type", "any", ")", "|", "|", "(", "permission", "type", "(", ")", "equals", "(", "other", "permission", "type", "(", ")", ")", ")", ";", "}" ]

[ "configure", "the", "reply", "destination", "type", "by", "default", ",", "the", "configured", "{", "@", "code", "pub", "sub", "domain", "}", "value", "is", "used", "(", "see", "{", "@", "link", "#", "is", "pub", "sub", "domain", "(", ")", "}", "this", "setting", "primarily", "indicates", "what", "type", "of", "destination", "to", "resolve", "if", "dynamic", "destinations", "are", "enabled" ]

[ "public", "void", "set", "reply", "pub", "sub", "domain", "(", "boolean", "reply", "pub", "sub", "domain", ")", "{", "this", "reply", "pub", "sub", "domain", "=", "reply", "pub", "sub", "domain", ";", "}" ]

[ "put", "existing", "single", "sign", "on", "session", "principal" ]

[ "public", "static", "void", "put", "existing", "single", "sign", "on", "session", "principal", "(", "final", "request", "context", "context", ",", "final", "principal", "value", ")", "{", "context", "get", "flash", "scope", "(", ")", "put", "(", "\"", "existing", "single", "sign", "on", "session", "principal", "\"", ",", "value", ")", ";", "}" ]

[ "writes", "the", "values", "of", "the", "snapshot", "to", "the", "given", "stream" ]

[ "public", "void", "dump", "(", "output", "stream", "output", ")", "{", "try", "(", "print", "writer", "out", "=", "new", "print", "writer", "(", "new", "output", "stream", "writer", "(", "output", ",", "utf", "8", ")", ")", ")", "{", "for", "(", "long", "value", ":", "values", ")", "{", "out", "printf", "(", "\"", "%", "d", "%", "n", "\"", ",", "value", ")", ";", "}", "}", "}" ]

[ "read", "timeout", "(", "in", "milliseconds", ")" ]

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

[ "get", "date", "time" ]

[ "public", "offset", "date", "time", "get", "date", "time", "(", ")", "{", "return", "date", "time", ";", "}" ]

[ "finds", "the", "node", "that", "represents", "the", "given", "category", "<", "p", ">", "children", "<", "b", ">", "will", "not", "<", "b", ">", "be", "loaded", "when", "searching", "for", "the", "node", "this", "allows", "clients", "to", "search", "for", "data", "types", "of", "interest", ",", "only", "updating", "the", "tree", "when", "the", "nodes", "are", "loaded" ]

[ "public", "category", "node", "find", "category", "node", "(", "category", "local", "category", ")", "{", "return", "find", "category", "node", "(", "local", "category", ",", "false", ")", ";", "}" ]

[ "sets", "the", "enabled", "agent", "protocols" ]

[ "public", "void", "set", "agent", "protocols", "(", "set", "<", "string", ">", "protocols", ")", "{", "set", "<", "string", ">", "disabled", "=", "new", "tree", "set", "<", ">", "(", ")", ";", "set", "<", "string", ">", "enabled", "=", "new", "tree", "set", "<", ">", "(", ")", ";", "for", "(", "agent", "protocol", "p", ":", "agent", "protocol", "all", "(", ")", ")", "{", "string", "name", "=", "p", "get", "name", "(", ")", ";", "if", "(", "name", "!", "=", "null", "&", "&", "!", "p", "is", "required", "(", ")", ")", "{", "/", "/", "we", "want", "to", "record", "the", "protocols", "where", "the", "admin", "has", "made", "a", "conscious", "decision", "/", "/", "thus", ",", "if", "a", "protocol", "is", "opt", "-", "in", ",", "we", "record", "the", "admin", "enabling", "it", "/", "/", "if", "a", "protocol", "is", "opt", "-", "out", ",", "we", "record", "the", "admin", "disabling", "it", "/", "/", "we", "should", "not", "transition", "rapidly", "from", "opt", "-", "in", "-", ">", "opt", "-", "out", "-", ">", "opt", "-", "in", "/", "/", "the", "scenario", "we", "want", "to", "have", "work", "is", ":", "/", "/", "1", "we", "introduce", "a", "new", "protocol", ",", "it", "starts", "off", "as", "opt", "-", "in", "some", "admins", "decide", "to", "test", "and", "opt", "-", "in", "/", "/", "2", "we", "decide", "that", "the", "protocol", "is", "ready", "for", "general", "use", "it", "gets", "marked", "as", "opt", "-", "out", "any", "admins", "/", "/", "that", "took", "part", "in", "early", "testing", "now", "have", "their", "config", "switched", "to", "not", "mention", "the", "new", "protocol", "/", "/", "at", "all", "when", "they", "save", "their", "config", "as", "the", "protocol", "is", "now", "opt", "-", "out", "any", "admins", "that", "want", "to", "/", "/", "disable", "it", "can", "do", "so", "and", "will", "have", "their", "preference", "recorded", "/", "/", "3", "we", "decide", "that", "the", "protocol", "needs", "to", "be", "retired", "it", "gets", "switched", "back", "to", "opt", "-", "in", "at", "this", "point", "/", "/", "the", "initial", "opt", "-", "in", "admins", ",", "assuming", "they", "visited", "an", "upgrade", "to", "a", "master", "with", "step", "2", ",", "will", "/", "/", "have", "the", "protocol", "disabled", "for", "them", "this", "is", "what", "we", "want", "if", "they", "didn", "'", "t", "upgrade", "to", "a", "master", "/", "/", "with", "step", "2", ",", "well", "there", "is", "not", "much", "we", "can", "do", "to", "differentiate", "them", "from", "somebody", "who", "is", "upgrading", "/", "/", "from", "a", "previous", "step", "3", "master", "and", "had", "needed", "to", "keep", "the", "protocol", "turned", "on", "/", "/", "/", "/", "what", "we", "should", "never", "do", "is", "flip", "-", "flop", ":", "opt", "-", "in", "-", ">", "opt", "-", "out", "-", ">", "opt", "-", "in", "-", ">", "opt", "-", "out", "as", "that", "will", "basically", "/", "/", "clear", "any", "preference", "that", "an", "admin", "has", "set", ",", "but", "this", "should", "be", "ok", "as", "we", "only", "ever", "will", "be", "/", "/", "adding", "new", "protocols", "and", "retiring", "old", "ones", "if", "(", "p", "is", "opt", "in", "(", ")", ")", "{", "if", "(", "protocols", "contains", "(", "name", ")", ")", "{", "enabled", "add", "(", "name", ")", ";", "}", "}", "else", "{", "if", "(", "!", "protocols", "contains", "(", "name", ")", ")", "{", "disabled", "add", "(", "name", ")", ";", "}", "}", "}", "}", "disabled", "agent", "protocols", "=", "disabled", "is", "empty", "(", ")", "?", "null", ":", "new", "array", "list", "<", ">", "(", "disabled", ")", ";", "enabled", "agent", "protocols", "=", "enabled", "is", "empty", "(", ")", "?", "null", ":", "new", "array", "list", "<", ">", "(", "enabled", ")", ";", "agent", "protocols", "=", "null", ";", "}" ]

[ "unsafely", "extracts", "the", "weak", "value", "reference", "inside", "of", "the", "given", "{", "@", "code", "entry", "}" ]

[ "weak", "value", "reference", "<", "k", ",", "v", ",", "e", ">", "get", "weak", "value", "reference", "for", "testing", "(", "internal", "entry", "<", "k", ",", "v", ",", "?", ">", "entry", ")", "{", "throw", "new", "assertion", "error", "(", ")", ";", "}" ]

[ "enter", "a", "parse", "tree", "produced", "by", "{", "@", "link", "eql", "base", "parser", "#", "identifier", "}" ]

[ "void", "enter", "identifier", "(", "eql", "base", "parser", "identifier", "context", "ctx", ")", ";" ]

[ "returns", "the", "names", "of", "all", "{", "@", "link", "output", "formatter", "}", "s", "in", "the", "input" ]

[ "public", "static", "string", "formatter", "names", "(", "iterable", "<", "output", "formatter", ">", "formatters", ")", "{", "return", "streams", "stream", "(", "formatters", ")", "map", "(", "output", "formatter", ":", ":", "get", "name", ")", "collect", "(", "joining", "(", "\"", ",", "\"", ")", ")", ";", "}" ]

[ "set", "the", "jndi", "environment", "to", "use", "for", "jndi", "lookups", "creates", "a", "jndi", "template", "with", "the", "given", "environment", "settings" ]

[ "public", "void", "set", "jndi", "environment", "(", "@", "nullable", "properties", "jndi", "environment", ")", "{", "this", "jndi", "template", "=", "new", "jndi", "template", "(", "jndi", "environment", ")", ";", "}" ]

[ "set", "the", "position", "of", "the", "body", "'", "s", "origin", "and", "rotation", "this", "breaks", "any", "contacts", "and", "wakes", "the", "other", "bodies", "manipulating", "a", "body", "'", "s", "transform", "may", "cause", "non", "-", "physical", "behavior" ]

[ "public", "void", "set", "transform", "(", "vector", "2", "position", ",", "float", "angle", ")", "{", "jni", "set", "transform", "(", "addr", ",", "position", "x", ",", "position", "y", ",", "angle", ")", ";", "}" ]

[ "pet", "status", "in", "the", "store" ]

[ "public", "status", "enum", "get", "status", "(", ")", "{", "return", "status", ";", "}" ]

[ "wraps", "a", "given", "f", "s", "data", "input", "stream", "with", "a", "crypto", "input", "stream", "the", "size", "of", "the", "data", "buffer", "required", "for", "the", "stream", "is", "specified", "by", "the", "\"", "mapreduce", "job", "encrypted", "-", "intermediate", "-", "data", "buffer", "kb", "\"", "job", "configuration", "variable" ]

[ "public", "static", "f", "s", "data", "input", "stream", "wrap", "if", "necessary", "(", "configuration", "conf", ",", "f", "s", "data", "input", "stream", "in", ")", "throws", "i", "o", "exception", "{", "if", "(", "is", "encrypted", "spill", "enabled", "(", "conf", ")", ")", "{", "crypto", "codec", "crypto", "codec", "=", "crypto", "codec", "get", "instance", "(", "conf", ")", ";", "int", "buffer", "size", "=", "get", "buffer", "size", "(", "conf", ")", ";", "/", "/", "not", "going", "to", "be", "used", "but", "still", "has", "to", "be", "read", "/", "/", "since", "the", "o", "/", "p", "stream", "always", "writes", "it", "i", "o", "utils", "read", "fully", "(", "in", ",", "new", "byte", "[", "8", "]", ",", "0", ",", "8", ")", ";", "byte", "[", "]", "iv", "=", "new", "byte", "[", "crypto", "codec", "get", "cipher", "suite", "(", ")", "get", "algorithm", "block", "size", "(", ")", "]", ";", "i", "o", "utils", "read", "fully", "(", "in", ",", "iv", ",", "0", ",", "crypto", "codec", "get", "cipher", "suite", "(", ")", "get", "algorithm", "block", "size", "(", ")", ")", ";", "if", "(", "log", "is", "debug", "enabled", "(", ")", ")", "{", "log", "debug", "(", "\"", "iv", "read", "from", "stream", "[", "\"", "+", "base", "6", "4", "encode", "base", "6", "4", "u", "r", "l", "safe", "string", "(", "iv", ")", "+", "\"", "]", "\"", ")", ";", "}", "return", "new", "crypto", "f", "s", "data", "input", "stream", "(", "in", ",", "crypto", "codec", ",", "buffer", "size", ",", "get", "encryption", "key", "(", ")", ",", "iv", ")", ";", "}", "else", "{", "return", "in", ";", "}", "}" ]

[ "returns", "the", "address", "for", "the", "given", "section", "and", "offset", "if", "the", "{", "@", "link", "pdb", "applicator", "options", "}", "address", "remap", "option", "is", "turned", "on", "is", "turned", "on", ",", "it", "will", "attempt", "to", "map", "the", "address", "to", "a", "new", "address", "in", "the", "current", "program" ]

[ "address", "get", "raw", "address", "(", "address", "ms", "symbol", "symbol", ")", "{", "return", "get", "raw", "address", "(", "symbol", "get", "segment", "(", ")", ",", "symbol", "get", "offset", "(", ")", ")", ";", "}" ]

[ "this", "test", "validates", "that", "an", "index", "which", "is", "out", "of", "bounds", "throws", "an", "index", "out", "of", "bounds", "exception" ]

[ "public", "void", "test", "out", "of", "tuple", "bounds", "grouping", "2", "(", ")", "{", "final", "execution", "environment", "env", "=", "execution", "environment", "get", "execution", "environment", "(", ")", ";", "unsorted", "grouping", "<", "tuple", "5", "<", "integer", ",", "long", ",", "string", ",", "long", ",", "integer", ">", ">", "group", "ds", "=", "env", "from", "collection", "(", "empty", "tuple", "data", ",", "tuple", "type", "info", ")", "group", "by", "(", "0", ")", ";", "/", "/", "should", "not", "work", ",", "key", "out", "of", "tuple", "bounds", "group", "ds", "max", "by", "(", "-", "1", ")", ";", "}" ]

[ "return", "the", "current", "user", "'", "s", "home", "directory", "in", "this", "file", "system", "the", "default", "implementation", "returns", "\"", "user", "$", "user", "\"" ]

[ "public", "path", "get", "home", "directory", "(", ")", "{", "return", "default", "f", "s", "get", "home", "directory", "(", ")", ";", "}" ]

[ "test", "json", "serialization", "of", "form", "data", "<", "b", ">", "200", "<", "b", ">", "-", "successful", "operation" ]

[ "public", "mono", "<", "void", ">", "test", "json", "form", "data", "(", "string", "param", ",", "string", "param", "2", ")", "throws", "web", "client", "response", "exception", "{", "object", "post", "body", "=", "null", ";", "/", "/", "verify", "the", "required", "parameter", "'", "param", "'", "is", "set", "if", "(", "param", "=", "=", "null", ")", "{", "throw", "new", "web", "client", "response", "exception", "(", "\"", "missing", "the", "required", "parameter", "'", "param", "'", "when", "calling", "test", "json", "form", "data", "\"", ",", "http", "status", "bad", "request", "value", "(", ")", ",", "http", "status", "bad", "request", "get", "reason", "phrase", "(", ")", ",", "null", ",", "null", ",", "null", ")", ";", "}", "/", "/", "verify", "the", "required", "parameter", "'", "param", "2", "'", "is", "set", "if", "(", "param", "2", "=", "=", "null", ")", "{", "throw", "new", "web", "client", "response", "exception", "(", "\"", "missing", "the", "required", "parameter", "'", "param", "2", "'", "when", "calling", "test", "json", "form", "data", "\"", ",", "http", "status", "bad", "request", "value", "(", ")", ",", "http", "status", "bad", "request", "get", "reason", "phrase", "(", ")", ",", "null", ",", "null", ",", "null", ")", ";", "}", "/", "/", "create", "path", "and", "map", "variables", "final", "map", "<", "string", ",", "object", ">", "path", "params", "=", "new", "hash", "map", "<", "string", ",", "object", ">", "(", ")", ";", "final", "multi", "value", "map", "<", "string", ",", "string", ">", "query", "params", "=", "new", "linked", "multi", "value", "map", "<", "string", ",", "string", ">", "(", ")", ";", "final", "http", "headers", "header", "params", "=", "new", "http", "headers", "(", ")", ";", "final", "multi", "value", "map", "<", "string", ",", "string", ">", "cookie", "params", "=", "new", "linked", "multi", "value", "map", "<", "string", ",", "string", ">", "(", ")", ";", "final", "multi", "value", "map", "<", "string", ",", "object", ">", "form", "params", "=", "new", "linked", "multi", "value", "map", "<", "string", ",", "object", ">", "(", ")", ";", "if", "(", "param", "!", "=", "null", ")", "form", "params", "add", "(", "\"", "param", "\"", ",", "param", ")", ";", "if", "(", "param", "2", "!", "=", "null", ")", "form", "params", "add", "(", "\"", "param", "2", "\"", ",", "param", "2", ")", ";", "final", "string", "[", "]", "local", "var", "accepts", "=", "{", "}", ";", "final", "list", "<", "media", "type", ">", "local", "var", "accept", "=", "api", "client", "select", "header", "accept", "(", "local", "var", "accepts", ")", ";", "final", "string", "[", "]", "local", "var", "content", "types", "=", "{", "\"", "application", "/", "x", "-", "www", "-", "form", "-", "urlencoded", "\"", "}", ";", "final", "media", "type", "local", "var", "content", "type", "=", "api", "client", "select", "header", "content", "type", "(", "local", "var", "content", "types", ")", ";", "string", "[", "]", "local", "var", "auth", "names", "=", "new", "string", "[", "]", "{", "}", ";", "parameterized", "type", "reference", "<", "void", ">", "local", "var", "return", "type", "=", "new", "parameterized", "type", "reference", "<", "void", ">", "(", ")", "{", "}", ";", "return", "api", "client", "invoke", "a", "p", "i", "(", "\"", "/", "fake", "/", "json", "form", "data", "\"", ",", "http", "method", "get", ",", "path", "params", ",", "query", "params", ",", "post", "body", ",", "header", "params", ",", "cookie", "params", ",", "form", "params", ",", "local", "var", "accept", ",", "local", "var", "content", "type", ",", "local", "var", "auth", "names", ",", "local", "var", "return", "type", ")", ";", "}" ]

[ "returns", "headers", "of", "this", "frame" ]

[ "stomp", "headers", "headers", "(", ")", ";" ]

[ "this", "method", "will", "be", "removed", "in", "a", "certain", "version", "after", "april", "5", ",", "2020", ",", "so", "please", "do", "not", "use", "this", "method" ]

[ "public", "void", "create", "topic", "(", "string", "key", ",", "string", "new", "topic", ",", "int", "queue", "num", ",", "int", "topic", "sys", "flag", ")", "throws", "m", "q", "client", "exception", "{", "this", "default", "m", "q", "pull", "consumer", "impl", "create", "topic", "(", "key", ",", "with", "namespace", "(", "new", "topic", ")", ",", "queue", "num", ",", "topic", "sys", "flag", ")", ";", "}" ]

[ "return", "number", "of", "low", "redundancy", "blocks", "but", "not", "missing", "blocks" ]

[ "public", "int", "get", "under", "replicated", "not", "missing", "blocks", "(", ")", "{", "return", "needed", "reconstruction", "get", "low", "redundancy", "block", "count", "(", ")", ";", "}" ]

[ "place", "an", "order", "for", "a", "pet" ]

[ "public", "void", "place", "order", "(", "order", "body", ",", "handler", "<", "async", "result", "<", "order", ">", ">", "result", "handler", ")", "{", "delegate", "place", "order", "(", "body", ",", "result", "handler", ")", ";", "}" ]

[ "return", "the", "response", "body", "as", "a", "byte", "array" ]

[ "public", "byte", "[", "]", "get", "response", "body", "(", ")", "{", "return", "this", "response", "body", ";", "}" ]

[ "determine", "if", "an", "upward", "scrolling", "is", "required" ]

[ "private", "boolean", "is", "up", "scroll", "required", "(", ")", "{", "return", "elements", "length", ">", "tabs", "that", "fit", "in", "composite", "&", "&", "top", "visible", "index", "!", "=", "0", ";", "}" ]

[ "check", "whether", "the", "given", "value", "from", "the", "current", "view", "'", "s", "model", "is", "eligible", "for", "marshalling", "through", "the", "configured", "{", "@", "link", "marshaller", "}", "the", "default", "implementation", "calls", "{", "@", "link", "marshaller", "#", "supports", "(", "class", ")", "}", ",", "unwrapping", "a", "given", "{", "@", "link", "j", "a", "x", "b", "element", "}", "first", "if", "applicable" ]

[ "protected", "boolean", "is", "eligible", "for", "marshalling", "(", "string", "model", "key", ",", "object", "value", ")", "{", "assert", "state", "(", "this", "marshaller", "!", "=", "null", ",", "\"", "no", "marshaller", "set", "\"", ")", ";", "class", "<", "?", ">", "class", "to", "check", "=", "value", "get", "class", "(", ")", ";", "if", "(", "value", "instanceof", "j", "a", "x", "b", "element", ")", "{", "class", "to", "check", "=", "(", "(", "j", "a", "x", "b", "element", "<", "?", ">", ")", "value", ")", "get", "declared", "type", "(", ")", ";", "}", "return", "this", "marshaller", "supports", "(", "class", "to", "check", ")", ";", "}" ]

[ "push", "a", "setting", "that", "permits", "up", "to", "2", "concurrent", "streams", ",", "then", "make", "3", "concurrent", "requests", "and", "confirm", "that", "the", "third", "concurrent", "request", "prepared", "a", "new", "connection" ]

[ "public", "void", "settings", "limits", "max", "concurrent", "streams", "(", "protocol", "protocol", ",", "mock", "web", "server", "mock", "web", "server", ")", "throws", "exception", "{", "set", "up", "(", "protocol", ",", "mock", "web", "server", ")", ";", "settings", "settings", "=", "new", "settings", "(", ")", ";", "settings", "set", "(", "settings", "max", "concurrent", "streams", ",", "2", ")", ";", "/", "/", "read", "&", "write", "a", "full", "request", "to", "confirm", "settings", "are", "accepted", "server", "enqueue", "(", "new", "mock", "response", "(", ")", "with", "settings", "(", "settings", ")", ")", ";", "call", "call", "=", "client", "new", "call", "(", "new", "request", "builder", "(", ")", "url", "(", "server", "url", "(", "\"", "/", "\"", ")", ")", "build", "(", ")", ")", ";", "response", "response", "=", "call", "execute", "(", ")", ";", "assert", "that", "(", "response", "body", "(", ")", "string", "(", ")", ")", "is", "equal", "to", "(", "\"", "\"", ")", ";", "server", "enqueue", "(", "new", "mock", "response", "(", ")", "set", "body", "(", "\"", "abc", "\"", ")", ")", ";", "server", "enqueue", "(", "new", "mock", "response", "(", ")", "set", "body", "(", "\"", "def", "\"", ")", ")", ";", "server", "enqueue", "(", "new", "mock", "response", "(", ")", "set", "body", "(", "\"", "ghi", "\"", ")", ")", ";", "call", "call", "1", "=", "client", "new", "call", "(", "new", "request", "builder", "(", ")", "url", "(", "server", "url", "(", "\"", "/", "\"", ")", ")", "build", "(", ")", ")", ";", "response", "response", "1", "=", "call", "1", "execute", "(", ")", ";", "call", "call", "2", "=", "client", "new", "call", "(", "new", "request", "builder", "(", ")", "url", "(", "server", "url", "(", "\"", "/", "\"", ")", ")", "build", "(", ")", ")", ";", "response", "response", "2", "=", "call", "2", "execute", "(", ")", ";", "call", "call", "3", "=", "client", "new", "call", "(", "new", "request", "builder", "(", ")", "url", "(", "server", "url", "(", "\"", "/", "\"", ")", ")", "build", "(", ")", ")", ";", "response", "response", "3", "=", "call", "3", "execute", "(", ")", ";", "assert", "that", "(", "response", "1", "body", "(", ")", "string", "(", ")", ")", "is", "equal", "to", "(", "\"", "abc", "\"", ")", ";", "assert", "that", "(", "response", "2", "body", "(", ")", "string", "(", ")", ")", "is", "equal", "to", "(", "\"", "def", "\"", ")", ";", "assert", "that", "(", "response", "3", "body", "(", ")", "string", "(", ")", ")", "is", "equal", "to", "(", "\"", "ghi", "\"", ")", ";", "/", "/", "settings", "connection", "assert", "that", "(", "server", "take", "request", "(", ")", "get", "sequence", "number", "(", ")", ")", "is", "equal", "to", "(", "0", ")", ";", "/", "/", "reuse", "settings", "connection", "assert", "that", "(", "server", "take", "request", "(", ")", "get", "sequence", "number", "(", ")", ")", "is", "equal", "to", "(", "1", ")", ";", "/", "/", "reuse", "settings", "connection", "assert", "that", "(", "server", "take", "request", "(", ")", "get", "sequence", "number", "(", ")", ")", "is", "equal", "to", "(", "2", ")", ";", "/", "/", "new", "connection", "!", "assert", "that", "(", "server", "take", "request", "(", ")", "get", "sequence", "number", "(", ")", ")", "is", "equal", "to", "(", "0", ")", ";", "}" ]

[ "estimation", "of", "the", "term", "vectors", "memory", "usage", "by", "a", "segment" ]

[ "public", "long", "get", "term", "vectors", "memory", "in", "bytes", "(", ")", "{", "return", "this", "term", "vectors", "memory", "in", "bytes", ";", "}" ]

[ "returns", "the", "current", "critical", "path", "for", "the", "action", "critical", "path", "is", "defined", "as", ":", "action", "execution", "time", "+", "max", "(", "child", "critical", "path", ")" ]

[ "duration", "get", "aggregated", "elapsed", "time", "(", ")", "{", "return", "duration", "of", "nanos", "(", "get", "aggregated", "elapsed", "time", "nanos", "(", ")", ")", ";", "}" ]

[ "invoked", "by", "the", "{", "@", "link", "hystrix", "network", "auditor", "agent", "}", "when", "network", "events", "occur", "an", "event", "may", "be", "the", "opening", "of", "a", "socket", ",", "channel", "or", "readingwriting", "bytes", "it", "is", "not", "guaranteed", "to", "be", "a", "one", "-", "to", "-", "one", "relationship", "with", "a", "requestresponse", "no", "arguments", "are", "returned", "as", "it", "is", "left", "to", "the", "implementation", "to", "decide", "whether", "the", "current", "thread", "stacktrace", "should", "be", "captured", "or", "not", "typical", "implementations", "will", "want", "to", "filter", "to", "non", "-", "hystrix", "isolated", "network", "traffic", "with", "code", "such", "as", "this", ":", "{", "@", "code", "if", "(", "hystrix", "get", "current", "thread", "executing", "command", "(", ")", "=", "=", "null", ")", "{", "this", "event", "is", "not", "inside", "a", "hystrix", "context", "(", "according", "to", "thread", "local", "variables", ")", "stack", "trace", "element", "[", "]", "stack", "=", "thread", "current", "thread", "(", ")", "get", "stack", "trace", "(", ")", ";", "increment", "counters", ",", "fire", "alerts", ",", "log", "stack", "traces", "etc", "}", "}" ]

[ "public", "void", "handle", "network", "event", "(", ")", ";" ]

[ "return", "the", "value", "associated", "to", "the", "specified", "keyed", "object" ]

[ "public", "object", "get", "value", "(", "keyed", "object", "o", ")", "/", "/", "throws", "no", "value", "exception", "{", "/", "/", "return", "values", "[", "owning", "set", "(", ")", "index", "(", "o", ")", "]", ";", "return", "values", "get", "(", "o", "key", "(", ")", ")", ";", "}", "/", "/" ]

[ "return", "whether", "the", "activity", "is", "alive" ]

[ "public", "static", "boolean", "is", "activity", "alive", "(", "final", "context", "context", ")", "{", "return", "is", "activity", "alive", "(", "get", "activity", "by", "context", "(", "context", ")", ")", ";", "}" ]

[ "configure", "this", "{", "@", "link", "result", "builder", "}", "to", "use", "the", "given", "{", "@", "code", "clock", "}", "instead", "of", "the", "default", "clock", "if", "not", "specified", ",", "the", "default", "clock", "is", "{", "@", "link", "clock", "#", "default", "clock", "(", ")", "}" ]

[ "public", "result", "builder", "using", "clock", "(", "clock", "clock", ")", "{", "this", "clock", "=", "clock", ";", "return", "this", ";", "}" ]

[ "serialize", "the", "java", "object", "to", "byte", "array", "with", "the", "given", "type" ]

[ "public", "static", "byte", "[", "]", "serialize", "from", "object", "(", "object", "value", ",", "int", "type", "idx", ",", "charset", "string", "charset", ")", "{", "switch", "(", "type", "idx", ")", "{", "case", "0", ":", "/", "/", "byte", "[", "]", "return", "(", "byte", "[", "]", ")", "value", ";", "case", "1", ":", "/", "/", "external", "string", "return", "value", "=", "=", "null", "?", "empty", "bytes", ":", "(", "(", "string", ")", "value", ")", "get", "bytes", "(", "string", "charset", ")", ";", "case", "2", ":", "/", "/", "byte", "return", "value", "=", "=", "null", "?", "empty", "bytes", ":", "new", "byte", "[", "]", "{", "(", "byte", ")", "value", "}", ";", "case", "3", ":", "return", "bytes", "to", "bytes", "(", "(", "short", ")", "value", ")", ";", "case", "4", ":", "return", "bytes", "to", "bytes", "(", "(", "int", ")", "value", ")", ";", "case", "5", ":", "return", "bytes", "to", "bytes", "(", "(", "long", ")", "value", ")", ";", "case", "6", ":", "return", "bytes", "to", "bytes", "(", "(", "float", ")", "value", ")", ";", "case", "7", ":", "return", "bytes", "to", "bytes", "(", "(", "double", ")", "value", ")", ";", "case", "8", ":", "return", "bytes", "to", "bytes", "(", "(", "boolean", ")", "value", ")", ";", "case", "9", ":", "/", "/", "sql", "timestamp", "encoded", "to", "long", "return", "bytes", "to", "bytes", "(", "(", "(", "timestamp", ")", "value", ")", "get", "time", "(", ")", ")", ";", "case", "10", ":", "/", "/", "sql", "date", "encoded", "as", "long", "return", "bytes", "to", "bytes", "(", "(", "(", "date", ")", "value", ")", "get", "time", "(", ")", ")", ";", "case", "11", ":", "/", "/", "sql", "time", "encoded", "as", "long", "return", "bytes", "to", "bytes", "(", "(", "(", "time", ")", "value", ")", "get", "time", "(", ")", ")", ";", "case", "12", ":", "return", "bytes", "to", "bytes", "(", "(", "big", "decimal", ")", "value", ")", ";", "case", "13", ":", "return", "(", "(", "big", "integer", ")", "value", ")", "to", "byte", "array", "(", ")", ";", "default", ":", "throw", "new", "illegal", "argument", "exception", "(", "\"", "unsupported", "type", "index", ":", "\"", "+", "type", "idx", ")", ";", "}", "}" ]

[ "checks", "if", "the", "executor", "has", "been", "shut", "down", "and", "increments", "the", "running", "task", "count" ]

[ "private", "void", "start", "task", "(", ")", "{", "synchronized", "(", "lock", ")", "{", "if", "(", "shutdown", ")", "{", "throw", "new", "rejected", "execution", "exception", "(", "\"", "executor", "already", "shutdown", "\"", ")", ";", "}", "running", "tasks", "+", "+", ";", "}", "}" ]

[ "wrap", "the", "supplied", "{", "@", "link", "statement", "}", "with", "a", "{", "@", "code", "profile", "value", "checker", "}", "statement" ]

[ "private", "statement", "with", "profile", "value", "check", "(", "statement", "next", ",", "class", "<", "?", ">", "test", "class", ")", "{", "return", "new", "profile", "value", "checker", "(", "next", ",", "test", "class", ",", "null", ")", ";", "}" ]

[ "create", "a", "lsda", "header", "from", "the", "bytes", "at", "<", "code", ">", "addr", "<", "code", ">", "<", "br", ">", "note", ":", "this", "method", "must", "get", "called", "before", "any", "of", "the", "\"", "get", "\"", "methods" ]

[ "public", "void", "create", "(", "address", "addr", ")", "throws", "memory", "access", "exception", "{", "/", "*", "use", "current", "program", "location", "if", "'", "addr", "'", "is", "null", "*", "/", "if", "(", "addr", "=", "=", "null", "|", "|", "monitor", "is", "cancelled", "(", ")", ")", "{", "return", ";", "}", "monitor", "set", "message", "(", "\"", "creating", "gcc", "exception", "table", "header", "\"", ")", ";", "address", "base", "addr", "=", "addr", ";", "addr", "=", "create", "l", "p", "start", "encoding", "(", "addr", ")", ";", "addr", "=", "create", "l", "p", "start", "pointer", "(", "addr", ")", ";", "addr", "=", "create", "t", "type", "encoding", "(", "addr", ")", ";", "addr", "=", "create", "t", "type", "offset", "(", "addr", ")", ";", "address", "call", "site", "table", "start", "=", "addr", ";", "addr", "=", "create", "call", "site", "table", "encoding", "(", "addr", ")", ";", "addr", "=", "create", "call", "site", "table", "length", "(", "addr", ")", ";", "header", "size", "=", "addr", "subtract", "(", "base", "addr", ")", ";", "call", "site", "table", "header", "size", "=", "addr", "subtract", "(", "call", "site", "table", "start", ")", ";", "address", "extent", "=", "addr", "add", "(", "get", "call", "site", "table", "length", "(", ")", "-", "1", ")", ";", "if", "(", "ttype", "encoding", "!", "=", "omitted", "encoding", "type", ")", "{", "ttype", "addr", "=", "base", "addr", "add", "(", "ttype", "offset", ")", ";", "extent", "=", "ttype", "addr", ";", "}", "table", "bounds", "=", "new", "address", "range", "impl", "(", "base", "addr", ",", "extent", ")", ";", "string", "table", "label", "=", "\"", "lsda", "exception", "table", "\"", "+", "base", "addr", ";", "try", "{", "symbol", "sym", "=", "program", "get", "symbol", "table", "(", ")", "get", "primary", "symbol", "(", "base", "addr", ")", ";", "if", "(", "sym", "=", "=", "null", ")", "{", "sym", "=", "program", "get", "symbol", "table", "(", ")", "create", "label", "(", "base", "addr", ",", "table", "label", ",", "source", "type", "analysis", ")", ";", "}", "else", "{", "sym", "set", "name", "(", "table", "label", ",", "source", "type", "analysis", ")", ";", "}", "}", "catch", "(", "exception", "e", ")", "{", "/", "/", "ignored", "}", "set", "comment", "cmd", "comment", "cmd", "=", "new", "set", "comment", "cmd", "(", "base", "addr", ",", "code", "unit", "plate", "comment", ",", "\"", "(", "lsda", ")", "exception", "table", "\"", ")", ";", "comment", "cmd", "apply", "to", "(", "program", ")", ";", "next", "address", "=", "addr", ";", "}" ]

[ "diagnostics", "method", "to", "dump", "a", "registry", "robustly", "any", "exception", "raised", "is", "swallowed" ]

[ "protected", "string", "dump", "registry", "robustly", "(", "boolean", "verbose", ")", "{", "try", "{", "z", "k", "path", "dumper", "path", "dumper", "=", "dump", "path", "(", "verbose", ")", ";", "return", "path", "dumper", "to", "string", "(", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "/", "/", "ignore", "log", "debug", "(", "\"", "ignoring", "exception", ":", "{", "}", "\"", ",", "e", ")", ";", "}", "return", "\"", "\"", ";", "}" ]

[ "remove", "multiple", "node", "labels", "from", "repository" ]

[ "public", "void", "remove", "from", "cluster", "node", "labels", "(", "collection", "<", "string", ">", "labels", "to", "remove", ")", "throws", "i", "o", "exception", "{", "if", "(", "!", "node", "labels", "enabled", ")", "{", "log", "error", "(", "node", "labels", "not", "enabled", "err", ")", ";", "throw", "new", "i", "o", "exception", "(", "node", "labels", "not", "enabled", "err", ")", ";", "}", "labels", "to", "remove", "=", "normalize", "labels", "(", "labels", "to", "remove", ")", ";", "check", "remove", "from", "cluster", "node", "labels", "(", "labels", "to", "remove", ")", ";", "internal", "remove", "from", "cluster", "node", "labels", "(", "labels", "to", "remove", ")", ";", "}" ]

[ "tests", "that", "evicted", "{", "@", "link", "archived", "execution", "graph", "}", "are", "loaded", "from", "disk", "again" ]

[ "public", "void", "test", "cache", "loading", "(", ")", "throws", "i", "o", "exception", "{", "final", "file", "root", "dir", "=", "temporary", "folder", "new", "folder", "(", ")", ";", "try", "(", "final", "file", "archived", "execution", "graph", "store", "execution", "graph", "store", "=", "new", "file", "archived", "execution", "graph", "store", "(", "root", "dir", ",", "time", "hours", "(", "1l", ")", ",", "integer", "max", "value", ",", "100l", "<", "<", "10", ",", "testing", "utils", "default", "scheduled", "executor", "(", ")", ",", "ticker", "system", "ticker", "(", ")", ")", ")", "{", "final", "loading", "cache", "<", "job", "i", "d", ",", "archived", "execution", "graph", ">", "execution", "graph", "cache", "=", "execution", "graph", "store", "get", "archived", "execution", "graph", "cache", "(", ")", ";", "collection", "<", "archived", "execution", "graph", ">", "execution", "graphs", "=", "new", "array", "list", "<", ">", "(", "64", ")", ";", "boolean", "continue", "inserting", "=", "true", ";", "/", "/", "insert", "execution", "graphs", "until", "the", "first", "one", "got", "evicted", "while", "(", "continue", "inserting", ")", "{", "/", "/", "has", "roughly", "a", "size", "of", "1", "4", "kb", "final", "archived", "execution", "graph", "execution", "graph", "=", "new", "archived", "execution", "graph", "builder", "(", ")", "set", "state", "(", "job", "status", "finished", ")", "build", "(", ")", ";", "execution", "graph", "store", "put", "(", "execution", "graph", ")", ";", "execution", "graphs", "add", "(", "execution", "graph", ")", ";", "continue", "inserting", "=", "execution", "graph", "cache", "size", "(", ")", "=", "=", "execution", "graphs", "size", "(", ")", ";", "}", "final", "file", "storage", "directory", "=", "execution", "graph", "store", "get", "storage", "dir", "(", ")", ";", "assert", "that", "(", "storage", "directory", "list", "files", "(", ")", "length", ",", "matchers", "equal", "to", "(", "execution", "graphs", "size", "(", ")", ")", ")", ";", "for", "(", "archived", "execution", "graph", "execution", "graph", ":", "execution", "graphs", ")", "{", "assert", "that", "(", "execution", "graph", "store", "get", "(", "execution", "graph", "get", "job", "i", "d", "(", ")", ")", ",", "matches", "partially", "with", "(", "execution", "graph", ")", ")", ";", "}", "}", "}" ]

[ "registers", "a", "uninstantiated", "temporary", "system", "function" ]

[ "public", "void", "register", "temporary", "system", "function", "(", "string", "name", ",", "string", "fully", "qualified", "name", ",", "function", "language", "language", ",", "boolean", "ignore", "if", "exists", ")", "{", "register", "temporary", "system", "function", "(", "name", ",", "new", "catalog", "function", "impl", "(", "fully", "qualified", "name", ",", "language", ")", ",", "ignore", "if", "exists", ")", ";", "}" ]

[ "makes", "an", "instance", "for", "the", "given", "{", "@", "code", "int", "}", "value", "this", "may", "(", "but", "does", "not", "necessarily", ")", "return", "an", "already", "-", "allocated", "instance" ]

[ "public", "static", "cst", "short", "make", "(", "int", "value", ")", "{", "short", "cast", "=", "(", "short", ")", "value", ";", "if", "(", "cast", "!", "=", "value", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "bogus", "short", "value", ":", "\"", "+", "value", ")", ";", "}", "return", "make", "(", "cast", ")", ";", "}" ]

[ "writes", "remaining", "content", "in", "the", "cache", "into", "the", "db" ]

[ "public", "static", "void", "flush", "cache", "(", ")", "{", "logger", "info", "(", "\"", "#", "flush", "cache", "\"", ")", ";", "optional", "of", "nullable", "(", "cache", ")", "map", "(", "lru", "cache", ":", ":", "get", "cache", "data", "in", "list", "form", ")", "or", "else", "(", "list", "of", "(", ")", ")", "for", "each", "(", "db", "manager", ":", ":", "update", "db", ")", ";", "}" ]

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

[ "@", "override", "public", "void", "visit", "error", "node", "(", "error", "node", "node", ")", "{", "}" ]

[ "test", "the", "property", "'", "photo", "urls", "'" ]

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

[ "get", "the", "next", "random", "number" ]

[ "public", "int", "next", "int", "(", ")", ";" ]