Datasets:
Anonymous2023
/
KGSum

Dataset card Data Studio Files Community
docstring_tokens
list
code_tokens
list
[ "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", "\"", ")", ";", "}" ]
[ "add", "a", "new", "pet", "to", "the", "store" ]
[ "public", "void", "add", "pet", "test", "(", ")", "throws", "api", "exception", "{", "pet", "pet", "=", "null", ";", "api", "add", "pet", "(", "pet", ")", ";", "/", "/", "todo", ":", "test", "validations", "}" ]
[ "configure", "a", "{", "@", "link", "message", "header", "initializer", "}", "to", "apply", "to", "the", "headers", "of", "all", "messages", "created", "through", "the", "{", "@", "code", "simp", "messaging", "template", "}", "by", "default", ",", "this", "property", "is", "not", "set" ]
[ "public", "void", "set", "header", "initializer", "(", "@", "nullable", "message", "header", "initializer", "header", "initializer", ")", "{", "this", "header", "initializer", "=", "header", "initializer", ";", "}" ]
[ "test", "to", "verify", "the", "check", "for", "whether", "a", "process", "tree", "is", "over", "limit", "or", "not" ]
[ "public", "void", "test", "process", "tree", "limits", "(", ")", "throws", "i", "o", "exception", "{", "/", "/", "set", "up", "a", "dummy", "proc", "file", "system", "file", "procfs", "root", "dir", "=", "new", "file", "(", "local", "dir", ",", "\"", "proc", "\"", ")", ";", "string", "[", "]", "pids", "=", "{", "\"", "100", "\"", ",", "\"", "200", "\"", ",", "\"", "300", "\"", ",", "\"", "400", "\"", ",", "\"", "500", "\"", ",", "\"", "600", "\"", ",", "\"", "700", "\"", "}", ";", "try", "{", "test", "procfs", "based", "process", "tree", "setup", "procfs", "root", "dir", "(", "procfs", "root", "dir", ")", ";", "/", "/", "create", "pid", "dirs", "test", "procfs", "based", "process", "tree", "setup", "pid", "dirs", "(", "procfs", "root", "dir", ",", "pids", ")", ";", "/", "/", "create", "process", "infos", "test", "procfs", "based", "process", "tree", "process", "stat", "info", "[", "]", "procs", "=", "new", "test", "procfs", "based", "process", "tree", "process", "stat", "info", "[", "7", "]", ";", "/", "/", "assume", "pids", "100", ",", "500", "are", "in", "1", "tree", "/", "/", "200", ",", "300", ",", "400", "are", "in", "another", "/", "/", "600", ",", "700", "are", "in", "a", "third", "procs", "[", "0", "]", "=", "new", "test", "procfs", "based", "process", "tree", "process", "stat", "info", "(", "new", "string", "[", "]", "{", "\"", "100", "\"", ",", "\"", "proc", "1", "\"", ",", "\"", "1", "\"", ",", "\"", "100", "\"", ",", "\"", "100", "\"", ",", "\"", "100000", "\"", "}", ")", ";", "procs", "[", "1", "]", "=", "new", "test", "procfs", "based", "process", "tree", "process", "stat", "info", "(", "new", "string", "[", "]", "{", "\"", "200", "\"", ",", "\"", "proc", "2", "\"", ",", "\"", "1", "\"", ",", "\"", "200", "\"", ",", "\"", "200", "\"", ",", "\"", "200000", "\"", "}", ")", ";", "procs", "[", "2", "]", "=", "new", "test", "procfs", "based", "process", "tree", "process", "stat", "info", "(", "new", "string", "[", "]", "{", "\"", "300", "\"", ",", "\"", "proc", "3", "\"", ",", "\"", "200", "\"", ",", "\"", "200", "\"", ",", "\"", "200", "\"", ",", "\"", "300000", "\"", "}", ")", ";", "procs", "[", "3", "]", "=", "new", "test", "procfs", "based", "process", "tree", "process", "stat", "info", "(", "new", "string", "[", "]", "{", "\"", "400", "\"", ",", "\"", "proc", "4", "\"", ",", "\"", "200", "\"", ",", "\"", "200", "\"", ",", "\"", "200", "\"", ",", "\"", "400000", "\"", "}", ")", ";", "procs", "[", "4", "]", "=", "new", "test", "procfs", "based", "process", "tree", "process", "stat", "info", "(", "new", "string", "[", "]", "{", "\"", "500", "\"", ",", "\"", "proc", "5", "\"", ",", "\"", "100", "\"", ",", "\"", "100", "\"", ",", "\"", "100", "\"", ",", "\"", "1500000", "\"", "}", ")", ";", "procs", "[", "5", "]", "=", "new", "test", "procfs", "based", "process", "tree", "process", "stat", "info", "(", "new", "string", "[", "]", "{", "\"", "600", "\"", ",", "\"", "proc", "6", "\"", ",", "\"", "1", "\"", ",", "\"", "600", "\"", ",", "\"", "600", "\"", ",", "\"", "100000", "\"", "}", ")", ";", "procs", "[", "6", "]", "=", "new", "test", "procfs", "based", "process", "tree", "process", "stat", "info", "(", "new", "string", "[", "]", "{", "\"", "700", "\"", ",", "\"", "proc", "7", "\"", ",", "\"", "600", "\"", ",", "\"", "600", "\"", ",", "\"", "600", "\"", ",", "\"", "100000", "\"", "}", ")", ";", "/", "/", "write", "stat", "files", "test", "procfs", "based", "process", "tree", "write", "stat", "files", "(", "procfs", "root", "dir", ",", "pids", ",", "procs", ",", "null", ")", ";", "/", "/", "vmem", "limit", "long", "limit", "=", "700000", ";", "containers", "monitor", "impl", "test", "=", "new", "containers", "monitor", "impl", "(", "null", ",", "null", ",", "null", ")", ";", "/", "/", "create", "process", "trees", "/", "/", "tree", "rooted", "at", "100", "is", "over", "limit", "immediately", ",", "as", "it", "is", "/", "/", "twice", "over", "the", "mem", "limit", "procfs", "based", "process", "tree", "p", "tree", "=", "new", "procfs", "based", "process", "tree", "(", "\"", "100", "\"", ",", "procfs", "root", "dir", "get", "absolute", "path", "(", ")", ")", ";", "p", "tree", "update", "process", "tree", "(", ")", ";", "assert", "true", "(", "\"", "tree", "rooted", "at", "100", "should", "be", "over", "limit", "\"", "+", "\"", "after", "first", "iteration", "\"", ",", "test", "is", "process", "tree", "over", "limit", "(", "p", "tree", ",", "\"", "dummy", "id", "\"", ",", "limit", ")", ")", ";", "/", "/", "the", "tree", "rooted", "at", "200", "is", "initially", "below", "limit", "p", "tree", "=", "new", "procfs", "based", "process", "tree", "(", "\"", "200", "\"", ",", "procfs", "root", "dir", "get", "absolute", "path", "(", ")", ")", ";", "p", "tree", "update", "process", "tree", "(", ")", ";", "assert", "false", "(", "\"", "tree", "rooted", "at", "200", "shouldn", "'", "t", "be", "over", "limit", "\"", "+", "\"", "after", "one", "iteration", "\"", ",", "test", "is", "process", "tree", "over", "limit", "(", "p", "tree", ",", "\"", "dummy", "id", "\"", ",", "limit", ")", ")", ";", "/", "/", "second", "iteration", "-", "now", "the", "tree", "has", "been", "over", "limit", "twice", ",", "/", "/", "hence", "it", "should", "be", "declared", "over", "limit", "p", "tree", "update", "process", "tree", "(", ")", ";", "assert", "true", "(", "\"", "tree", "rooted", "at", "200", "should", "be", "over", "limit", "after", "2", "iterations", "\"", ",", "test", "is", "process", "tree", "over", "limit", "(", "p", "tree", ",", "\"", "dummy", "id", "\"", ",", "limit", ")", ")", ";", "/", "/", "the", "tree", "rooted", "at", "600", "is", "never", "over", "limit", "p", "tree", "=", "new", "procfs", "based", "process", "tree", "(", "\"", "600", "\"", ",", "procfs", "root", "dir", "get", "absolute", "path", "(", ")", ")", ";", "p", "tree", "update", "process", "tree", "(", ")", ";", "assert", "false", "(", "\"", "tree", "rooted", "at", "600", "should", "never", "be", "over", "limit", "\"", ",", "test", "is", "process", "tree", "over", "limit", "(", "p", "tree", ",", "\"", "dummy", "id", "\"", ",", "limit", ")", ")", ";", "/", "/", "another", "iteration", "does", "not", "make", "any", "difference", "p", "tree", "update", "process", "tree", "(", ")", ";", "assert", "false", "(", "\"", "tree", "rooted", "at", "600", "should", "never", "be", "over", "limit", "\"", ",", "test", "is", "process", "tree", "over", "limit", "(", "p", "tree", ",", "\"", "dummy", "id", "\"", ",", "limit", ")", ")", ";", "}", "finally", "{", "file", "util", "fully", "delete", "(", "procfs", "root", "dir", ")", ";", "}", "}" ]
[ "see", "{", "@", "link", "script", "template", "configurer", "#", "set", "resource", "loader", "path", "(", "string", ")", "}", "documentation" ]
[ "public", "void", "set", "resource", "loader", "path", "(", "string", "resource", "loader", "path", ")", "{", "string", "[", "]", "paths", "=", "string", "utils", "comma", "delimited", "list", "to", "string", "array", "(", "resource", "loader", "path", ")", ";", "this", "resource", "loader", "paths", "=", "new", "string", "[", "paths", "length", "+", "1", "]", ";", "this", "resource", "loader", "paths", "[", "0", "]", "=", "\"", "\"", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "paths", "length", ";", "i", "+", "+", ")", "{", "string", "path", "=", "paths", "[", "i", "]", ";", "if", "(", "!", "path", "ends", "with", "(", "\"", "/", "\"", ")", "&", "&", "!", "path", "ends", "with", "(", "\"", ":", "\"", ")", ")", "{", "path", "=", "path", "+", "\"", "/", "\"", ";", "}", "this", "resource", "loader", "paths", "[", "i", "+", "1", "]", "=", "path", ";", "}", "}" ]
[ "commits", "the", "current", "value", "of", "the", "cell", "editor", "by", "getting", "a", "{", "@", "link", "command", "}", "from", "the", "source", "edit", "part", "and", "executing", "it", "via", "the", "{", "@", "link", "command", "stack", "}", "finally", ",", "{", "@", "link", "#", "bring", "down", "(", ")", "}", "is", "called", "to", "perform", "and", "necessary", "cleanup" ]
[ "protected", "void", "commit", "(", ")", "{", "if", "(", "committing", ")", "return", ";", "committing", "=", "true", ";", "try", "{", "/", "/", "we", "set", "the", "cell", "editor", "control", "to", "invisible", "to", "remove", "any", "/", "/", "possible", "flicker", "get", "cell", "editor", "(", ")", "get", "control", "(", ")", "set", "visible", "(", "false", ")", ";", "if", "(", "is", "dirty", "(", ")", ")", "{", "command", "stack", "stack", "=", "get", "edit", "part", "(", ")", "get", "viewer", "(", ")", "get", "edit", "domain", "(", ")", "get", "command", "stack", "(", ")", ";", "edit", "policy", "edit", "policy", "=", "get", "edit", "part", "(", ")", "get", "edit", "policy", "(", "edit", "policy", "direct", "edit", "role", ")", ";", "command", "command", ";", "if", "(", "edit", "policy", "!", "=", "null", ")", "{", "command", "=", "edit", "policy", "get", "command", "(", "get", "direct", "edit", "request", "(", ")", ")", ";", "}", "else", "{", "command", "=", "get", "edit", "part", "(", ")", "get", "command", "(", "get", "direct", "edit", "request", "(", ")", ")", ";", "}", "if", "(", "command", "!", "=", "null", "&", "&", "command", "can", "execute", "(", ")", ")", "{", "stack", "execute", "(", "command", ")", ";", "}", "}", "}", "finally", "{", "bring", "down", "(", ")", ";", "committing", "=", "false", ";", "}", "}" ]
[ "set", "the", "value", "of", "the", "'", "{", "@", "code", "enctype", "}", "'", "attribute", "may", "be", "a", "runtime", "expression" ]
[ "public", "void", "set", "enctype", "(", "string", "enctype", ")", "{", "this", "enctype", "=", "enctype", ";", "}" ]
[ "sets", "the", "configuration", "key", "for", "the", "configured", "target" ]
[ "public", "builder", "set", "configuration", "key", "(", "@", "nullable", "build", "configuration", "value", "key", "configuration", "key", ")", "{", "this", "configuration", "key", "=", "configuration", "key", ";", "return", "this", ";", "}" ]
[ "delete", "a", "snapshot", "that", "is", "taken", "before", "a", "directory", "deletion", ",", "directory", "diff", "list", "should", "be", "combined", "correctly" ]
[ "public", "void", "test", "delete", "snapshot", "1", "(", ")", "throws", "exception", "{", "final", "path", "root", "=", "new", "path", "(", "\"", "/", "\"", ")", ";", "path", "dir", "=", "new", "path", "(", "\"", "/", "dir", "1", "\"", ")", ";", "path", "file", "1", "=", "new", "path", "(", "dir", ",", "\"", "file", "1", "\"", ")", ";", "d", "f", "s", "test", "util", "create", "file", "(", "hdfs", ",", "file", "1", ",", "blocksize", ",", "replication", ",", "seed", ")", ";", "hdfs", "allow", "snapshot", "(", "root", ")", ";", "hdfs", "create", "snapshot", "(", "root", ",", "\"", "s", "1", "\"", ")", ";", "path", "file", "2", "=", "new", "path", "(", "dir", ",", "\"", "file", "2", "\"", ")", ";", "d", "f", "s", "test", "util", "create", "file", "(", "hdfs", ",", "file", "2", ",", "blocksize", ",", "replication", ",", "seed", ")", ";", "hdfs", "create", "snapshot", "(", "root", ",", "\"", "s", "2", "\"", ")", ";", "/", "/", "delete", "file", "hdfs", "delete", "(", "file", "1", ",", "true", ")", ";", "hdfs", "delete", "(", "file", "2", ",", "true", ")", ";", "/", "/", "delete", "directory", "assert", "true", "(", "hdfs", "delete", "(", "dir", ",", "false", ")", ")", ";", "/", "/", "delete", "second", "snapshot", "hdfs", "delete", "snapshot", "(", "root", ",", "\"", "s", "2", "\"", ")", ";", "name", "node", "adapter", "enter", "safe", "mode", "(", "cluster", "get", "name", "node", "(", ")", ",", "false", ")", ";", "name", "node", "adapter", "save", "namespace", "(", "cluster", "get", "name", "node", "(", ")", ")", ";", "/", "/", "restart", "nn", "cluster", "restart", "name", "nodes", "(", ")", ";", "}" ]
[ "{", "@", "link", "hystrix", "thread", "pool", "properties", "}", "of", "the", "{", "@", "link", "hystrix", "thread", "pool", "}", "these", "metrics", "represent" ]
[ "public", "hystrix", "thread", "pool", "properties", "get", "properties", "(", ")", "{", "return", "properties", ";", "}" ]
[ "get", "the", "number", "of", "occurrences", "of", "this", "sequence" ]
[ "public", "int", "get", "num", "occurrences", "(", ")", "{", "return", "num", "occurrences", ";", "}" ]
[ "get", "an", "xattr", "name", "and", "value", "for", "a", "file", "or", "directory", "the", "name", "must", "be", "prefixed", "with", "the", "namespace", "followed", "by", "\"", "\"", "for", "example", ",", "\"", "user", "attr", "\"", "refer", "to", "the", "hdfs", "extended", "attributes", "user", "documentation", "for", "details" ]
[ "public", "byte", "[", "]", "get", "x", "attr", "(", "path", "path", ",", "string", "name", ")", "throws", "i", "o", "exception", "{", "throw", "new", "unsupported", "operation", "exception", "(", "get", "class", "(", ")", "get", "simple", "name", "(", ")", "+", "\"", "doesn", "'", "t", "support", "get", "x", "attr", "\"", ")", ";", "}" ]
[ "convert", "the", "given", "object", "to", "string", "with", "each", "line", "indented", "by", "4", "spaces", "(", "except", "the", "first", "line", ")" ]
[ "private", "string", "to", "indented", "string", "(", "object", "o", ")", "{", "if", "(", "o", "=", "=", "null", ")", "{", "return", "\"", "null", "\"", ";", "}", "return", "o", "to", "string", "(", ")", "replace", "(", "\"", "\\", "n", "\"", ",", "\"", "\\", "n", "\"", ")", ";", "}" ]
[ "return", "the", "current", "secure", "settings", ",", "or", "{", "@", "code", "null", "}", "if", "none", "have", "been", "set" ]
[ "public", "secure", "settings", "get", "secure", "settings", "(", ")", "{", "return", "secure", "settings", "get", "(", ")", ";", "}" ]
[ "load", "the", "block", "mmap", "and", "mlock", "the", "block", ",", "and", "then", "verify", "its", "checksum" ]
[ "mappable", "block", "load", "(", "long", "length", ",", "file", "input", "stream", "block", "in", ",", "file", "input", "stream", "meta", "in", ",", "string", "block", "file", "name", ",", "extended", "block", "id", "key", ")", "throws", "i", "o", "exception", "{", "memory", "mapped", "block", "mappable", "block", "=", "null", ";", "mapped", "byte", "buffer", "mmap", "=", "null", ";", "file", "channel", "block", "channel", "=", "null", ";", "try", "{", "block", "channel", "=", "block", "in", "get", "channel", "(", ")", ";", "if", "(", "block", "channel", "=", "=", "null", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "block", "input", "stream", "has", "no", "file", "channel", "\"", ")", ";", "}", "mmap", "=", "block", "channel", "map", "(", "file", "channel", "map", "mode", "read", "only", ",", "0", ",", "length", ")", ";", "native", "i", "o", "posix", "get", "cache", "manipulator", "(", ")", "mlock", "(", "block", "file", "name", ",", "mmap", ",", "length", ")", ";", "verify", "checksum", "(", "length", ",", "meta", "in", ",", "block", "channel", ",", "block", "file", "name", ")", ";", "mappable", "block", "=", "new", "memory", "mapped", "block", "(", "mmap", ",", "length", ")", ";", "}", "finally", "{", "i", "o", "utils", "close", "quietly", "(", "block", "channel", ")", ";", "if", "(", "mappable", "block", "=", "=", "null", ")", "{", "if", "(", "mmap", "!", "=", "null", ")", "{", "native", "i", "o", "posix", "munmap", "(", "mmap", ")", ";", "/", "/", "unmapping", "also", "unlocks", "}", "}", "}", "return", "mappable", "block", ";", "}" ]
[ "called", "when", "the", "view", "is", "detached", "from", "window", "perform", "house", "keeping", "task", ",", "such", "as", "stopping", "runnable", "thread", "that", "would", "otherwise", "keep", "a", "reference", "on", "the", "context", ",", "thus", "preventing", "the", "activity", "to", "be", "recycled" ]
[ "void", "on", "detached", "(", ")", ";" ]
[ "set", "the", "capacity", "scheduler", "context" ]
[ "public", "void", "set", "capacity", "scheduler", "context", "(", "capacity", "scheduler", "context", "capacity", "scheduler", "context", ")", "{", "this", "cs", "context", "=", "capacity", "scheduler", "context", ";", "}" ]
[ "sets", "the", "<", "code", ">", "outer", "enum", "<", "code", ">", "property" ]
[ "public", "enum", "test", "outer", "enum", "(", "outer", "enum", "outer", "enum", ")", "{", "this", "outer", "enum", "=", "outer", "enum", ";", "return", "this", ";", "}" ]
[ "select", "the", "root", "data", "folder", "(", "not", "root", "node", "in", "the", "tree", "which", "shows", "the", "project", "name", ")" ]
[ "public", "void", "select", "root", "data", "folder", "(", ")", "{", "tree", "set", "selection", "path", "(", "root", "get", "tree", "path", "(", ")", ")", ";", "}" ]
[ "gets", "the", "original", "field", "name", "within", "the", "parent", "data", "type", "for", "a", "given", "row", "in", "the", "editor" ]
[ "private", "boolean", "is", "original", "field", "name", "(", "string", "test", "name", ",", "int", "row", "index", ")", "{", "stack", "frame", "data", "type", "data", "type", "=", "(", "stack", "frame", "data", "type", ")", "get", "original", "composite", "(", ")", ";", "string", "field", "name", "=", "get", "field", "name", "at", "row", "(", "row", "index", ",", "data", "type", ")", ";", "return", "system", "utilities", "is", "equal", "(", "field", "name", ",", "test", "name", ")", ";", "}" ]
[ "returns", "the", "list", "of", "subfields", "in", "this", "field" ]
[ "public", "list", "<", "field", ">", "get", "subfields", "(", ")", "{", "return", "collections", "unmodifiable", "list", "(", "sub", "fields", ")", ";", "}" ]
[ "tests", "that", "after", "calling", "{", "@", "link", "rest", "server", "endpoint", "#", "close", "async", "(", ")", "}", ",", "the", "handlers", "are", "closed", "first", ",", "and", "we", "wait", "for", "in", "-", "flight", "requests", "to", "finish", "as", "long", "as", "not", "all", "handlers", "are", "closed", ",", "http", "requests", "should", "be", "served" ]
[ "public", "void", "test", "should", "wait", "for", "handlers", "when", "closing", "(", ")", "throws", "exception", "{", "test", "handler", "close", "future", "=", "new", "completable", "future", "<", ">", "(", ")", ";", "final", "blocker", "sync", "sync", "=", "new", "blocker", "sync", "(", ")", ";", "test", "handler", "handler", "body", "=", "id", "-", ">", "{", "/", "/", "intentionally", "schedule", "the", "work", "on", "a", "different", "thread", "this", "is", "to", "simulate", "/", "/", "handlers", "where", "the", "completable", "future", "is", "finished", "by", "the", "rpc", "framework", "return", "completable", "future", "supply", "async", "(", "(", ")", "-", ">", "{", "try", "{", "sync", "block", "(", ")", ";", "}", "catch", "(", "interrupted", "exception", "e", ")", "{", "thread", "current", "thread", "(", ")", "interrupt", "(", ")", ";", "}", "return", "new", "test", "response", "(", "id", ")", ";", "}", ")", ";", "}", ";", "/", "/", "initiate", "closing", "rest", "server", "endpoint", "but", "the", "test", "handler", "should", "block", "final", "completable", "future", "<", "void", ">", "close", "rest", "server", "endpoint", "future", "=", "server", "endpoint", "close", "async", "(", ")", ";", "assert", "that", "(", "close", "rest", "server", "endpoint", "future", "is", "done", "(", ")", ",", "is", "(", "false", ")", ")", ";", "/", "/", "create", "an", "in", "-", "flight", "request", "final", "completable", "future", "<", "test", "response", ">", "request", "=", "send", "request", "to", "test", "handler", "(", "new", "test", "request", "(", "1", ")", ")", ";", "sync", "await", "blocker", "(", ")", ";", "/", "/", "allow", "handler", "to", "close", "but", "there", "is", "still", "one", "in", "-", "flight", "request", "which", "should", "prevent", "/", "/", "the", "rest", "server", "endpoint", "from", "closing", "test", "handler", "close", "future", "complete", "(", "null", ")", ";", "assert", "that", "(", "close", "rest", "server", "endpoint", "future", "is", "done", "(", ")", ",", "is", "(", "false", ")", ")", ";", "/", "/", "finish", "the", "in", "-", "flight", "request", "sync", "release", "blocker", "(", ")", ";", "request", "get", "(", "timeout", "get", "size", "(", ")", ",", "timeout", "get", "unit", "(", ")", ")", ";", "close", "rest", "server", "endpoint", "future", "get", "(", "timeout", "get", "size", "(", ")", ",", "timeout", "get", "unit", "(", ")", ")", ";", "}" ]
[ "append", "one", "image" ]
[ "public", "span", "utils", "append", "image", "(", "@", "non", "null", "final", "bitmap", "bitmap", ")", "{", "return", "append", "image", "(", "bitmap", ",", "align", "bottom", ")", ";", "}" ]
[ "return", "{", "@", "link", "byte", "buf", "#", "to", "string", "(", ")", "}", "without", "checking", "the", "reference", "count", "first", "this", "is", "useful", "to", "implement", "{", "@", "link", "#", "to", "string", "(", ")", "}" ]
[ "protected", "final", "string", "content", "to", "string", "(", ")", "{", "return", "data", "to", "string", "(", ")", ";", "}" ]
[ "returns", "the", "{", "@", "link", "method", "}", "instance", "for", "{", "@", "link", "#", "test", "add", "null", "supported", "(", ")", "}", "so", "that", "tests", "of", "{", "@", "link", "java", "util", "collections", "#", "checked", "collection", "(", "java", "util", "collection", ",", "class", ")", "}", "can", "suppress", "it", "with", "{", "@", "code", "feature", "specific", "test", "suite", "builder", "suppressing", "(", ")", "}", "until", "<", "a", "href", "=", "\"", "http", ":", "bugs", "sun", "combugdatabaseview", "bug", "do", "?", "bug", "id", "=", "6409434", "\"", ">", "sun", "bug", "6409434", "is", "fixed", "it", "'", "s", "unclear", "whether", "nulls", "were", "to", "be", "permitted", "or", "forbidden", ",", "but", "presumably", "the", "eventual", "fix", "will", "be", "to", "permit", "them", ",", "as", "it", "seems", "more", "likely", "that", "code", "would", "depend", "on", "that", "behavior", "than", "on", "the", "other", "thus", ",", "we", "say", "the", "bug", "is", "in", "add", "(", ")", ",", "which", "fails", "to", "support", "null" ]
[ "public", "static", "method", "get", "add", "null", "supported", "method", "(", ")", "{", "return", "helpers", "get", "method", "(", "collection", "add", "tester", "class", ",", "\"", "test", "add", "null", "supported", "\"", ")", ";", "}" ]
[ "return", "a", "{", "@", "link", "string", "}", "that", "is", "the", "json", "representation", "of", "the", "provided", "{", "@", "link", "to", "x", "content", "}", "wraps", "the", "output", "into", "an", "anonymous", "object", "if", "needed", "allows", "to", "configure", "the", "params", "the", "content", "is", "not", "pretty", "-", "printed", "nor", "human", "readable" ]
[ "public", "static", "string", "to", "string", "(", "to", "x", "content", "to", "x", "content", ",", "to", "x", "content", "params", "params", ")", "{", "return", "to", "string", "(", "to", "x", "content", ",", "params", ",", "false", ",", "false", ")", ";", "}" ]
[ "gets", "the", "unwind", "model", "for", "the", "function", "info" ]
[ "public", "e", "h", "unwind", "model", "get", "unwind", "model", "(", ")", "throws", "invalid", "data", "type", "exception", "{", "check", "validity", "(", ")", ";", "if", "(", "unwind", "model", "=", "=", "null", ")", "{", "unwind", "model", "=", "new", "e", "h", "unwind", "model", "(", "get", "program", "(", ")", ",", "get", "unwind", "count", "(", ")", ",", "get", "unwind", "map", "address", "(", ")", ",", "validation", "options", ")", ";", "}", "return", "unwind", "model", ";", "}" ]
[ "returns", "an", "options", "object", "at", "its", "default", "values", "the", "returned", "object", "may", "be", "freely", "modified", "by", "the", "caller", ",", "by", "assigning", "its", "fields" ]
[ "public", "static", "<", "o", "extends", "options", "base", ">", "o", "get", "defaults", "(", "class", "<", "o", ">", "options", "class", ")", "{", "try", "{", "return", "parse", "(", "options", "class", ",", "new", "string", "[", "0", "]", ")", "get", "options", "(", ")", ";", "}", "catch", "(", "options", "parsing", "exception", "e", ")", "{", "string", "message", "=", "\"", "error", "while", "parsing", "defaults", ":", "\"", "+", "e", "get", "message", "(", ")", ";", "throw", "new", "assertion", "error", "(", "message", ")", ";", "}", "}" ]
[ "removes", "the", "external", "location", "at", "the", "given", "external", "address" ]
[ "public", "boolean", "remove", "external", "location", "(", "address", "external", "addr", ")", "{", "lock", "acquire", "(", ")", ";", "try", "{", "external", "location", "d", "b", "loc", "=", "(", "external", "location", "d", "b", ")", "get", "ext", "location", "(", "external", "addr", ")", ";", "if", "(", "loc", "!", "=", "null", ")", "{", "loc", "get", "symbol", "(", ")", "delete", "(", ")", ";", "return", "true", ";", "}", "}", "finally", "{", "lock", "release", "(", ")", ";", "}", "return", "false", ";", "}" ]
[ "execute", "the", "task" ]
[ "protected", "t", "execute", "(", "@", "nullable", "reference", "<", "k", ",", "v", ">", "ref", ",", "@", "nullable", "entry", "<", "k", ",", "v", ">", "entry", ",", "@", "nullable", "entries", "<", "v", ">", "entries", ")", "{", "return", "execute", "(", "ref", ",", "entry", ")", ";", "}" ]
[ "note", "the", "change", "will", "be", "taken", "as", "best", "effort", ",", "meaning", "that", "all", "already", "scheduled", "traffics", "will", "not", "be", "changed", ",", "but", "only", "applied", "to", "new", "traffics", "so", "the", "expected", "usage", "of", "this", "method", "is", "to", "be", "used", "not", "too", "often", ",", "accordingly", "to", "the", "traffic", "shaping", "configuration" ]
[ "public", "void", "set", "max", "time", "wait", "(", "long", "max", "time", ")", "{", "if", "(", "max", "time", "<", "=", "0", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "max", "time", "must", "be", "positive", "\"", ")", ";", "}", "this", "max", "time", "=", "max", "time", ";", "}" ]
[ "@", "inherit", "doc" ]
[ "public", "boolean", "has", "next", "(", ")", "{", "return", "idx", ">", "=", "0", ";", "}" ]
[ "customize", "request", "specification" ]
[ "public", "delete", "pet", "oper", "req", "spec", "(", "consumer", "<", "request", "spec", "builder", ">", "req", "spec", "customizer", ")", "{", "req", "spec", "customizer", "accept", "(", "req", "spec", ")", ";", "return", "this", ";", "}" ]
[ "this", "function", "originally", "did", "not", "return", "anything", "it", "returns", "a", "vertex", "for", "the", "purpose", "of", "keeping", "track", "of", "which", "vertex", "we", "left", "off", "on", "so", "if", "we", "backtrack", ",", "we", "can", "copy", "the", "portion", "of", "the", "previous", "path", "that", "is", "contained", "in", "the", "path", "we", "are", "currently", "construction", "i", "tried", "to", "do", "this", "without", "passing", "v", "as", "a", "parameter", "and", "it", "did", "not", "work", "something", "funny", "happened", "i", "suppose", "with", "java", "and", "pointers", "this", "function", "simply", "adds", "to", "single", "path", "until", "there", "are", "no", "more", "white", "children", "which", "means", "we", "'", "ve", "either", "reached", "a", "sink", ",", "or", "the", "only", "vertices", "left", "are", "repeated", "meaning", "we", "have", "a", "loop" ]
[ "public", "vertex", "add", "to", "paths", "(", "vertex", "v", ",", "vector", "single", "path", ")", "{", "int", "i", "=", "single", "path", "size", "(", ")", ";", "this", "set", "color", "(", "v", ",", "gray", ")", ";", "if", "(", "!", "single", "path", "contains", "(", "v", ")", ")", "{", "single", "path", "add", "(", "i", "+", "+", ",", "v", ")", ";", "}", "while", "(", "this", "has", "white", "child", "(", "v", ")", ")", "{", "v", "=", "this", "go", "to", "next", "white", "child", "(", "v", ")", ";", "this", "set", "color", "(", "v", ",", "gray", ")", ";", "single", "path", "add", "(", "i", "+", "+", ",", "v", ")", ";", "}", "return", "v", ";", "}" ]
[ "returns", "a", "hash", "code", ",", "having", "the", "same", "bit", "length", "as", "each", "of", "the", "input", "hash", "codes", ",", "that", "combines", "the", "information", "of", "these", "hash", "codes", "in", "an", "ordered", "fashion", "that", "is", ",", "whenever", "two", "equal", "hash", "codes", "are", "produced", "by", "two", "calls", "to", "this", "method", ",", "it", "is", "as", "likely", "as", "possible", "that", "each", "was", "computed", "from", "the", "same", "input", "hash", "codes", "in", "the", "same", "order" ]
[ "public", "static", "hash", "code", "combine", "ordered", "(", "iterable", "<", "hash", "code", ">", "hash", "codes", ")", "{", "iterator", "<", "hash", "code", ">", "iterator", "=", "hash", "codes", "iterator", "(", ")", ";", "check", "argument", "(", "iterator", "has", "next", "(", ")", ",", "\"", "must", "be", "at", "least", "1", "hash", "code", "to", "combine", "\"", ")", ";", "int", "bits", "=", "iterator", "next", "(", ")", "bits", "(", ")", ";", "byte", "[", "]", "result", "bytes", "=", "new", "byte", "[", "bits", "/", "8", "]", ";", "for", "(", "hash", "code", "hash", "code", ":", "hash", "codes", ")", "{", "byte", "[", "]", "next", "bytes", "=", "hash", "code", "as", "bytes", "(", ")", ";", "check", "argument", "(", "next", "bytes", "length", "=", "=", "result", "bytes", "length", ",", "\"", "all", "hashcodes", "must", "have", "the", "same", "bit", "length", "\"", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "next", "bytes", "length", ";", "i", "+", "+", ")", "{", "result", "bytes", "[", "i", "]", "=", "(", "byte", ")", "(", "result", "bytes", "[", "i", "]", "*", "37", "^", "next", "bytes", "[", "i", "]", ")", ";", "}", "}", "return", "hash", "code", "from", "bytes", "no", "copy", "(", "result", "bytes", ")", ";", "}" ]
[ "indicate", "that", "s3a", "copied", "some", "files", "within", "the", "store" ]
[ "public", "void", "files", "copied", "(", "int", "files", ",", "long", "size", ")", "{", "increment", "counter", "(", "files", "copied", ",", "files", ")", ";", "increment", "counter", "(", "files", "copied", "bytes", ",", "size", ")", ";", "}" ]
[ "gets", "get", "temporary", "state" ]
[ "public", "state", "get", "temporary", "state", "(", ")", "{", "return", "temporary", "state", ";", "}" ]
[ "returns", "a", "buffered", "reader", "for", "reading", "this", "file", "as", "characters", "@", "throw", "gdx", "runtime", "exception", "if", "the", "file", "handle", "represents", "a", "directory", ",", "doesn", "'", "t", "exist", ",", "or", "could", "not", "be", "read" ]
[ "public", "buffered", "reader", "reader", "(", "int", "buffer", "size", ")", "{", "return", "new", "buffered", "reader", "(", "reader", "(", ")", ",", "buffer", "size", ")", ";", "}" ]
[ "check", "that", "file", "status", "are", "not", "equal", "if", "their", "paths", "are", "not", "equal" ]
[ "public", "void", "test", "not", "equals", "(", ")", "{", "path", "path", "1", "=", "new", "path", "(", "\"", "path", "1", "\"", ")", ";", "path", "path", "2", "=", "new", "path", "(", "\"", "path", "2", "\"", ")", ";", "file", "status", "file", "status", "1", "=", "new", "file", "status", "(", "1", ",", "true", ",", "1", ",", "1", ",", "1", ",", "1", ",", "fs", "permission", "value", "of", "(", "\"", "-", "rw", "-", "rw", "-", "rw", "-", "\"", ")", ",", "\"", "one", "\"", ",", "\"", "one", "\"", ",", "null", ",", "path", "1", ")", ";", "file", "status", "file", "status", "2", "=", "new", "file", "status", "(", "1", ",", "true", ",", "1", ",", "1", ",", "1", ",", "1", ",", "fs", "permission", "value", "of", "(", "\"", "-", "rw", "-", "rw", "-", "rw", "-", "\"", ")", ",", "\"", "one", "\"", ",", "\"", "one", "\"", ",", "null", ",", "path", "2", ")", ";", "assert", "false", "(", "file", "status", "1", "equals", "(", "file", "status", "2", ")", ")", ";", "assert", "false", "(", "file", "status", "2", "equals", "(", "file", "status", "1", ")", ")", ";", "}" ]
[ "returns", "the", "name", "of", "the", "variable", "for", "this", "location" ]
[ "public", "string", "get", "name", "(", ")", "{", "return", "name", ";", "}" ]
[ "returns", "an", "immutable", "sorted", "map", "containing", "the", "given", "entries", ",", "sorted", "by", "the", "natural", "ordering", "of", "their", "keys" ]
[ "public", "static", "<", "k", "extends", "comparable", "<", "?", "super", "k", ">", ",", "v", ">", "immutable", "sorted", "map", "<", "k", ",", "v", ">", "of", "(", "k", "k", "1", ",", "v", "v", "1", ",", "k", "k", "2", ",", "v", "v", "2", ",", "k", "k", "3", ",", "v", "v", "3", ",", "k", "k", "4", ",", "v", "v", "4", ")", "{", "return", "of", "entries", "(", "entry", "of", "(", "k", "1", ",", "v", "1", ")", ",", "entry", "of", "(", "k", "2", ",", "v", "2", ")", ",", "entry", "of", "(", "k", "3", ",", "v", "3", ")", ",", "entry", "of", "(", "k", "4", ",", "v", "4", ")", ")", ";", "}" ]
[ "variant", "of", "{", "@", "link", "#", "data", "(", "object", ",", "class", ")", "}", "for", "when", "the", "type", "hint", "has", "to", "have", "a", "generic", "type", "see", "{", "@", "link", "parameterized", "type", "reference", "}" ]
[ "retrieve", "spec", "data", "(", "object", "producer", ",", "parameterized", "type", "reference", "<", "?", ">", "element", "type", "ref", ")", ";" ]
[ "returns", "whether", "the", "specified", "{", "@", "code", "timeline", "}", "can", "be", "shown", "on", "a", "multi", "-", "window", "time", "bar" ]
[ "private", "static", "boolean", "can", "show", "multi", "window", "time", "bar", "(", "timeline", "timeline", ",", "timeline", "window", "window", ")", "{", "if", "(", "timeline", "get", "window", "count", "(", ")", ">", "max", "windows", "for", "multi", "window", "time", "bar", ")", "{", "return", "false", ";", "}", "int", "window", "count", "=", "timeline", "get", "window", "count", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "window", "count", ";", "i", "+", "+", ")", "{", "if", "(", "timeline", "get", "window", "(", "i", ",", "window", ")", "duration", "us", "=", "=", "c", "time", "unset", ")", "{", "return", "false", ";", "}", "}", "return", "true", ";", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "long", "plus", "millis", "0", "(", "final", "long", "time", ",", "final", "long", "millis", ")", "{", "return", "time", "+", "millis", ";", "}" ]
[ "returns", "an", "{", "@", "link", "engine", "factory", "}", "for", "the", "source", "only", "snapshots" ]
[ "public", "static", "engine", "factory", "get", "engine", "factory", "(", ")", "{", "return", "config", "-", ">", "new", "read", "only", "engine", "(", "config", ",", "null", ",", "new", "translog", "stats", "(", "0", ",", "0", ",", "0", ",", "0", ",", "0", ")", ",", "true", ",", "reader", "-", ">", "{", "try", "{", "return", "seq", "id", "generating", "filter", "reader", "wrap", "(", "reader", ",", "config", "get", "primary", "term", "supplier", "(", ")", "get", "as", "long", "(", ")", ")", ";", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "throw", "new", "unchecked", "i", "o", "exception", "(", "e", ")", ";", "}", "}", ",", "true", ")", ";", "}" ]
[ "the", "channel", "asks", "the", "load", "-", "balancer", "to", "shutdown", "no", "more", "methods", "on", "this", "class", "will", "be", "called", "after", "this", "method", "the", "implementation", "should", "shutdown", "all", "subchannels", "and", "oob", "channels", ",", "and", "do", "any", "other", "cleanup", "as", "necessary" ]
[ "public", "abstract", "void", "shutdown", "(", ")", ";" ]
[ "returns", "{", "@", "code", "true", "}", "if", "this", "map", "contains", "no", "key", "-", "value", "mappings" ]
[ "public", "boolean", "is", "empty", "(", ")", "{", "return", "map", "is", "empty", "(", ")", ";", "}" ]
[ "test", "the", "property", "'", "my", "string", "'" ]
[ "public", "void", "my", "string", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "my", "string", "}" ]
[ "sets", "the", "log", "file", "symlink", "filename", "if", "unset", ",", "the", "value", "of", "\"", "symlink", "\"", "from", "the", "jvm", "logging", "configuration", "for", "{", "@", "link", "simple", "log", "handler", "}", "will", "be", "used", ";", "and", "if", "that", "'", "s", "unset", ",", "the", "prefix", "will", "be", "used" ]
[ "public", "builder", "set", "symlink", "name", "(", "string", "symlink", "name", ")", "{", "this", "symlink", "name", "=", "symlink", "name", ";", "return", "this", ";", "}" ]
[ "flag", "this", "contact", "for", "filtering", "filtering", "will", "occur", "the", "next", "time", "step" ]
[ "public", "void", "flag", "for", "filtering", "(", ")", "{", "m", "flags", "|", "=", "filter", "flag", ";", "}" ]
[ "get", "existing", "circuit", "breaking", "rules", "note", ":", "do", "not", "modify", "the", "rules", "from", "the", "returned", "list", "directly", "the", "behavior", "is", "undefined" ]
[ "public", "static", "list", "<", "degrade", "rule", ">", "get", "rules", "(", ")", "{", "list", "<", "degrade", "rule", ">", "rules", "=", "new", "array", "list", "<", ">", "(", ")", ";", "for", "(", "map", "entry", "<", "string", ",", "set", "<", "degrade", "rule", ">", ">", "entry", ":", "rule", "map", "entry", "set", "(", ")", ")", "{", "rules", "add", "all", "(", "entry", "get", "value", "(", ")", ")", ";", "}", "return", "rules", ";", "}" ]
[ "fluent", "-", "interface", "to", "change", "the", "retry", "handler" ]
[ "public", "retriable", "command", "set", "retry", "policy", "(", "retry", "policy", "retry", "handler", ")", "{", "this", "retry", "policy", "=", "retry", "handler", ";", "return", "this", ";", "}" ]
[ "read", "fixed", "length", "string", "from", "byte", "buffers" ]
[ "public", "string", "read", "string", "fix", "(", "final", "int", "length", ")", "{", "byte", "[", "]", "result", "=", "new", "byte", "[", "length", "]", ";", "byte", "buf", "read", "bytes", "(", "result", ")", ";", "return", "new", "string", "(", "result", ")", ";", "}" ]
[ "object", "argument", "that", "is", "equal", "to", "the", "given", "value", "see", "examples", "in", "javadoc", "for", "{", "@", "link", "argument", "matchers", "}", "class" ]
[ "public", "static", "<", "t", ">", "t", "eq", "(", "t", "value", ")", "{", "report", "matcher", "(", "new", "equals", "(", "value", ")", ")", ";", "if", "(", "value", "=", "=", "null", ")", "return", "null", ";", "return", "(", "t", ")", "primitives", "default", "value", "(", "value", "get", "class", "(", ")", ")", ";", "}" ]
[ "check", "whether", "this", "operation", "has", "been", "compiled", "already", ";", "lazily", "compile", "it", "if", "not", "already", "compiled", "automatically", "called", "by", "{", "@", "code", "validate", "parameters", "}" ]
[ "protected", "void", "check", "compiled", "(", ")", "{", "if", "(", "!", "is", "compiled", "(", ")", ")", "{", "logger", "debug", "(", "\"", "jdbc", "insert", "not", "compiled", "before", "execution", "-", "invoking", "compile", "\"", ")", ";", "compile", "(", ")", ";", "}", "}" ]
[ "returns", "the", "sentinel", "master", "id" ]
[ "public", "string", "get", "redis", "sentinel", "master", "id", "(", ")", "{", "return", "redis", "sentinel", "master", "id", ";", "}" ]
[ "pops", "an", "abstract", "type", "from", "the", "output", "frame", "stack", "and", "returns", "its", "value" ]
[ "private", "int", "pop", "(", ")", "{", "if", "(", "output", "stack", "top", ">", "0", ")", "{", "return", "output", "stack", "[", "-", "-", "output", "stack", "top", "]", ";", "}", "else", "{", "/", "/", "if", "the", "output", "frame", "stack", "is", "empty", ",", "pop", "from", "the", "input", "stack", "return", "stack", "kind", "|", "-", "(", "-", "-", "output", "stack", "start", ")", ";", "}", "}" ]
[ "test", "json", "serialization", "of", "form", "data" ]
[ "public", "void", "test", "json", "form", "data", "test", "(", ")", "throws", "i", "o", "exception", "{", "string", "param", "=", "null", ";", "string", "param", "2", "=", "null", ";", "api", "test", "json", "form", "data", "(", "param", ",", "param", "2", ")", ";", "/", "/", "todo", ":", "test", "validations", "}" ]
[ "get", "sc", "a", "e", "t", "h", "flow", "points" ]
[ "public", "string", "get", "sc", "a", "e", "t", "h", "flow", "points", "(", ")", "{", "return", "sc", "a", "e", "t", "h", "flow", "points", ";", "}" ]
[ "creates", "a", "64", "-", "bit", "{", "@", "code", "hash", "code", "}", "representation", "of", "the", "given", "long", "value", "the", "underlying", "bytes", "are", "interpreted", "in", "little", "endian", "order" ]
[ "public", "static", "hash", "code", "from", "long", "(", "long", "hash", ")", "{", "return", "new", "long", "hash", "code", "(", "hash", ")", ";", "}" ]
[ "tests", "that", "features", "=", "[", "-", "thin", "lto", "]", "in", "the", "build", "rule", "overrides", "-", "-", "features", "=", "autofdo", "implicit", "thinlto", "and", "prevents", "enabling", "thin", "l", "t", "o", "for", "afdo", "with", "llvm" ]
[ "public", "void", "test", "auto", "fdo", "implicit", "thin", "lto", "disabled", "rule", "(", ")", "throws", "exception", "{", "scratch", "file", "(", "\"", "pkg", "/", "build", "\"", ",", "\"", "\"", ",", "\"", "cc", "binary", "(", "name", "=", "'", "bin", "'", ",", "\"", ",", "\"", "srcs", "=", "[", "'", "binfile", "cc", "'", ",", "]", ",", "\"", ",", "\"", "features", "=", "[", "'", "-", "thin", "lto", "'", "]", ",", "\"", ",", "\"", "malloc", "=", "'", "/", "/", "base", ":", "system", "malloc", "'", ")", "\"", ")", ";", "scratch", "file", "(", "\"", "pkg", "/", "binfile", "cc", "\"", ",", "\"", "int", "main", "(", ")", "{", "}", "\"", ")", ";", "scratch", "file", "(", "\"", "pkg", "/", "profile", "afdo", "\"", ",", "\"", "\"", ")", ";", "setup", "auto", "fdo", "thin", "lto", "crosstool", "(", ")", ";", "use", "configuration", "(", "\"", "-", "-", "fdo", "optimize", "=", "pkg", "/", "profile", "afdo", "\"", ",", "\"", "-", "-", "compilation", "mode", "=", "opt", "\"", ",", "\"", "-", "-", "features", "=", "autofdo", "implicit", "thinlto", "\"", ")", ";", "artifact", "bin", "artifact", "=", "get", "files", "to", "build", "(", "get", "configured", "target", "(", "\"", "/", "/", "pkg", ":", "bin", "\"", ")", ")", "get", "singleton", "(", ")", ";", "cpp", "link", "action", "link", "action", "=", "(", "cpp", "link", "action", ")", "get", "generating", "action", "(", "bin", "artifact", ")", ";", "assert", "that", "(", "link", "action", "get", "outputs", "(", ")", ")", "contains", "exactly", "(", "bin", "artifact", ")", ";", "lto", "backend", "action", "backend", "action", "=", "(", "lto", "backend", "action", ")", "get", "predecessor", "by", "input", "name", "(", "link", "action", ",", "\"", "pkg", "/", "bin", "lto", "/", "pkg", "/", "objs", "/", "bin", "/", "binfile", "o", "\"", ")", ";", "/", "/", "we", "should", "not", "have", "a", "thin", "l", "t", "o", "backend", "action", "assert", "that", "(", "backend", "action", ")", "is", "null", "(", ")", ";", "}" ]
[ "schedule", "client", "beat", "check", "task", "without", "a", "delay" ]
[ "public", "static", "scheduled", "future", "<", "?", ">", "schedule", "now", "(", "runnable", "task", ")", "{", "return", "global", "executor", "schedule", "naming", "health", "(", "task", ",", "0", ",", "time", "unit", "milliseconds", ")", ";", "}" ]
[ "set", "bit", "from", "segments" ]
[ "public", "static", "void", "bit", "set", "(", "memory", "segment", "[", "]", "segments", ",", "int", "base", "offset", ",", "int", "index", ")", "{", "if", "(", "segments", "length", "=", "=", "1", ")", "{", "int", "offset", "=", "base", "offset", "+", "byte", "index", "(", "index", ")", ";", "memory", "segment", "segment", "=", "segments", "[", "0", "]", ";", "byte", "current", "=", "segment", "get", "(", "offset", ")", ";", "current", "|", "=", "(", "1", "<", "<", "(", "index", "&", "bit", "byte", "index", "mask", ")", ")", ";", "segment", "put", "(", "offset", ",", "current", ")", ";", "}", "else", "{", "bit", "set", "multi", "segments", "(", "segments", ",", "base", "offset", ",", "index", ")", ";", "}", "}" ]
[ "get", "just", "symbol" ]
[ "public", "just", "symbol", "enum", "get", "just", "symbol", "(", ")", "{", "return", "just", "symbol", ";", "}" ]
[ "send", "some", "basic", "index", ",", "count", "and", "delete", "requests", ",", "in", "order", "to", "check", "that", "the", "installation", "is", "minimally", "functional" ]
[ "public", "void", "test", "0", "5", "0", "basic", "api", "tests", "(", ")", "throws", "exception", "{", "wait", "for", "elasticsearch", "(", "installation", ")", ";", "assert", "true", "(", "exists", "in", "container", "(", "installation", "logs", "resolve", "(", "\"", "gc", "log", "\"", ")", ")", ")", ";", "server", "utils", "run", "elasticsearch", "tests", "(", ")", ";", "}" ]
[ "take", "a", "{", "@", "code", "string", "}", "that", "is", "a", "delimited", "list", "and", "convert", "it", "into", "a", "{", "@", "code", "string", "}", "array", "a", "single", "{", "@", "code", "delimiter", "}", "may", "consist", "of", "more", "than", "one", "character", ",", "but", "it", "will", "still", "be", "considered", "as", "a", "single", "delimiter", "string", ",", "rather", "than", "as", "bunch", "of", "potential", "delimiter", "characters", ",", "in", "contrast", "to", "{", "@", "link", "#", "tokenize", "to", "string", "array", "}" ]
[ "public", "static", "string", "[", "]", "delimited", "list", "to", "string", "array", "(", "@", "nullable", "string", "str", ",", "@", "nullable", "string", "delimiter", ",", "@", "nullable", "string", "chars", "to", "delete", ")", "{", "if", "(", "str", "=", "=", "null", ")", "{", "return", "empty", "string", "array", ";", "}", "if", "(", "delimiter", "=", "=", "null", ")", "{", "return", "new", "string", "[", "]", "{", "str", "}", ";", "}", "list", "<", "string", ">", "result", "=", "new", "array", "list", "<", ">", "(", ")", ";", "if", "(", "delimiter", "is", "empty", "(", ")", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "str", "length", "(", ")", ";", "i", "+", "+", ")", "{", "result", "add", "(", "delete", "any", "(", "str", "substring", "(", "i", ",", "i", "+", "1", ")", ",", "chars", "to", "delete", ")", ")", ";", "}", "}", "else", "{", "int", "pos", "=", "0", ";", "int", "del", "pos", ";", "while", "(", "(", "del", "pos", "=", "str", "index", "of", "(", "delimiter", ",", "pos", ")", ")", "!", "=", "-", "1", ")", "{", "result", "add", "(", "delete", "any", "(", "str", "substring", "(", "pos", ",", "del", "pos", ")", ",", "chars", "to", "delete", ")", ")", ";", "pos", "=", "del", "pos", "+", "delimiter", "length", "(", ")", ";", "}", "if", "(", "str", "length", "(", ")", ">", "0", "&", "&", "pos", "<", "=", "str", "length", "(", ")", ")", "{", "/", "/", "add", "rest", "of", "string", ",", "but", "not", "in", "case", "of", "empty", "input", "result", "add", "(", "delete", "any", "(", "str", "substring", "(", "pos", ")", ",", "chars", "to", "delete", ")", ")", ";", "}", "}", "return", "to", "string", "array", "(", "result", ")", ";", "}" ]
[ "this", "is", "called", "when", "the", "server", "is", "shut", "down", "as", "a", "result", "of", "a", "\"", "clean", "-", "-", "expunge", "\"", "in", "this", "case", ",", "no", "files", "should", "be", "deleted", "on", "shutdown", "hooks", ",", "since", "clean", "also", "deletes", "the", "lock", "file", ",", "and", "there", "is", "a", "small", "possibility", "of", "the", "following", "sequence", "of", "events", ":", "client", "1", "runs", "\"", "blaze", "clean", "-", "-", "expunge", "\"", "client", "2", "runs", "a", "command", "and", "waits", "for", "client", "1", "to", "finish", "the", "clean", "command", "deletes", "everything", "including", "the", "lock", "file", "client", "2", "starts", "running", "and", "since", "the", "output", "base", "is", "empty", ",", "starts", "up", "a", "new", "server", ",", "which", "creates", "its", "own", "socket", "and", "pid", "files", "the", "server", "used", "by", "client", "runs", "its", "shutdown", "hooks", ",", "deleting", "the", "pid", "files", "created", "by", "the", "new", "server", "it", "also", "disables", "the", "\"", "die", "when", "the", "pid", "file", "changes", "\"", "handler", "so", "that", "it", "doesn", "'", "t", "kill", "the", "server", "while", "the", "\"", "clean", "-", "-", "expunge", "\"", "command", "is", "running" ]
[ "public", "void", "prepare", "for", "abrupt", "shutdown", "(", ")", "{", "shutdown", "hooks", "disable", "(", ")", ";", "pid", "file", "watcher", "signal", "shutdown", "(", ")", ";", "}" ]
[ "returns", "the", "{", "@", "link", "#", "sum", "}", "as", "an", "{", "@", "code", "int", "}", "after", "a", "narrowing", "primitive", "conversion" ]
[ "public", "int", "int", "value", "(", ")", "{", "return", "(", "int", ")", "sum", "(", ")", ";", "}" ]
[ "request", "an", "incremental", "update", "for", "the", "specified", "collection", "the", "source", "may", "choose", "to", "honor", "this", "request", "or", "ignore", "and", "and", "provide", "a", "full", "-", "state", "update", "in", "the", "corresponding", "`", "resource", "`", "response", "<", "code", ">", "bool", "incremental", "=", "6", ";", "<", "code", ">" ]
[ "boolean", "get", "incremental", "(", ")", ";" ]
[ "returns", "the", "byte", "value", "representation", "of", "this", "{", "@", "link", "row", "kind", "}", "the", "byte", "value", "is", "used", "for", "serialization", "and", "deserialization", "\"", "0", "\"", "represents", "{", "@", "link", "#", "insert", "}", "\"", "1", "\"", "represents", "{", "@", "link", "#", "update", "before", "}", "\"", "2", "\"", "represents", "{", "@", "link", "#", "update", "after", "}", "\"", "3", "\"", "represents", "{", "@", "link", "#", "delete", "}" ]
[ "public", "byte", "to", "byte", "value", "(", ")", "{", "return", "value", ";", "}" ]
[ "returns", "the", "name", "of", "the", "key", "class" ]
[ "public", "string", "get", "key", "class", "name", "(", ")", "{", "return", "key", "class", "name", ";", "}" ]
[ "to", "test", "enum", "parameters", "to", "test", "enum", "parameters" ]
[ "public", "void", "test", "enum", "parameters", "(", "list", "<", "string", ">", "enum", "header", "string", "array", ",", "string", "enum", "header", "string", ",", "list", "<", "string", ">", "enum", "query", "string", "array", ",", "string", "enum", "query", "string", ",", "integer", "enum", "query", "integer", ",", "double", "enum", "query", "double", ",", "list", "<", "string", ">", "enum", "form", "string", "array", ",", "string", "enum", "form", "string", ")", "throws", "api", "exception", "{", "test", "enum", "parameters", "with", "http", "info", "(", "enum", "header", "string", "array", ",", "enum", "header", "string", ",", "enum", "query", "string", "array", ",", "enum", "query", "string", ",", "enum", "query", "integer", ",", "enum", "query", "double", ",", "enum", "form", "string", "array", ",", "enum", "form", "string", ")", ";", "}" ]
[ "set", "the", "estimated", "compression", "ratio", "for", "the", "memory", "records", "builder" ]
[ "public", "void", "set", "estimated", "compression", "ratio", "(", "float", "estimated", "compression", "ratio", ")", "{", "this", "estimated", "compression", "ratio", "=", "estimated", "compression", "ratio", ";", "}" ]
[ "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", "}" ]
[ "for", "testing", "only", "!", "!", "!" ]
[ "public", "static", "path", "get", "bindir", "from", "script", "file", "(", "resource", "file", "source", "file", ")", "{", "resource", "file", "tmp", "source", "dir", "=", "source", "file", "get", "parent", "file", "(", ")", ";", "string", "tmp", "symbolic", "name", "=", "ghidra", "source", "bundle", "source", "dir", "hash", "(", "tmp", "source", "dir", ")", ";", "return", "ghidra", "source", "bundle", "get", "compiled", "bundles", "dir", "(", ")", "resolve", "(", "tmp", "symbolic", "name", ")", ";", "}" ]
[ "returns", "the", "value", "pointer", "used", "by", "the", "snapshot", "of", "the", "given", "version" ]
[ "long", "get", "value", "for", "snapshot", "(", "long", "node", ",", "int", "snapshot", "version", ")", "{", "long", "snapshot", "value", "pointer", "=", "nil", "value", "pointer", ";", "value", "version", "iterator", "version", "iterator", "=", "new", "value", "version", "iterator", "(", "node", ")", ";", "long", "value", "pointer", ";", "while", "(", "version", "iterator", "has", "next", "(", ")", ")", "{", "value", "pointer", "=", "version", "iterator", "get", "value", "pointer", "(", ")", ";", "int", "version", "=", "version", "iterator", "next", "(", ")", ";", "/", "/", "the", "first", "value", "whose", "version", "is", "less", "than", "snapshot", "version", "if", "(", "version", "<", "snapshot", "version", ")", "{", "snapshot", "value", "pointer", "=", "value", "pointer", ";", "break", ";", "}", "}", "return", "snapshot", "value", "pointer", ";", "}" ]
[ "create", "a", "new", "instance", "of", "this", "connection", "manager" ]
[ "public", "static", "pg", "s", "q", "l", "connection", "manager", "get", "instance", "(", ")", "throws", "database", "service", "exception", "{", "if", "(", "instance", "=", "=", "null", ")", "{", "if", "(", "logger", "is", "debug", "enabled", "(", ")", ")", "{", "logger", "debug", "(", "\"", ":", ":", "creating", "new", "pg", "s", "q", "l", "connection", "manager", ":", ":", "\"", ")", ";", "}", "instance", "=", "new", "pg", "s", "q", "l", "connection", "manager", "(", ")", ";", "}", "return", "instance", ";", "}" ]
[ "get", "namespace", "string" ]
[ "public", "string", "get", "namespace", "string", "(", ")", "{", "return", "namespace", "string", ";", "}" ]
[ "adds", "a", "keyvalue", "pair", "to", "the", "hashtable", "if", "the", "key", "is", "already", "in", "the", "table", ",", "the", "old", "value", "is", "replaced", "with", "the", "new", "value", "if", "the", "hashtable", "is", "already", "full", ",", "the", "hashtable", "will", "attempt", "to", "approximately", "double", "in", "size", "(", "it", "will", "use", "a", "prime", "number", ")", ",", "and", "all", "the", "current", "entries", "will", "be", "rehashed" ]
[ "public", "void", "put", "(", "int", "key", ",", "int", "value", ")", "{", "int", "index", "=", "indexer", "put", "(", "key", ")", ";", "/", "/", "make", "sure", "there", "is", "room", "if", "(", "index", ">", "=", "capacity", ")", "{", "grow", "(", ")", ";", "}", "values", "[", "index", "]", "=", "value", ";", "}" ]
[ "clears", "all", "state", "from", "metrics", "if", "new", "requests", "come", "in", "instances", "will", "be", "recreated", "and", "metrics", "started", "from", "scratch" ]
[ "/", "*", "package", "*", "/", "static", "void", "reset", "(", ")", "{", "metrics", "clear", "(", ")", ";", "}" ]
[ "build", "the", "{", "@", "code", "mock", "server", "web", "exchange", "}", "instance" ]
[ "public", "mock", "server", "web", "exchange", "build", "(", ")", "{", "return", "new", "mock", "server", "web", "exchange", "(", "this", "request", ",", "this", "session", "manager", "!", "=", "null", "?", "this", "session", "manager", ":", "new", "default", "web", "session", "manager", "(", ")", ")", ";", "}" ]
[ "currently", "not", "exposed", "bulk", "adds", "methods", "to", "this", "builder" ]
[ "private", "builder", "add", "all", "methods", "(", "collection", "<", "method", "descriptor", "<", "?", ",", "?", ">", ">", "methods", ")", "{", "this", "methods", "add", "all", "(", "methods", ")", ";", "return", "this", ";", "}" ]
[ "the", "interface", "used", "by", "clients", "to", "release", "a", "resource", "with", "the", "<", "code", ">", "shared", "cache", "manager", "<", "code", ">", "this", "method", "is", "called", "once", "an", "application", "is", "no", "longer", "using", "a", "claimed", "resource", "in", "the", "shared", "cache", "the", "client", "uses", "a", "checksum", "to", "identify", "the", "resource", "and", "an", "{", "@", "link", "application", "id", "}", "to", "identify", "which", "application", "is", "releasing", "the", "resource", "note", ":", "this", "method", "is", "an", "optimization", "and", "the", "client", "is", "not", "required", "to", "call", "it", "for", "correctness", "currently", "the", "<", "code", ">", "shared", "cache", "manager", "<", "code", ">", "sends", "an", "empty", "response" ]
[ "public", "release", "shared", "cache", "resource", "response", "release", "(", "release", "shared", "cache", "resource", "request", "request", ")", "throws", "yarn", "exception", ",", "i", "o", "exception", ";" ]
[ "signals", "to", "the", "renderer", "that", "the", "current", "{", "@", "link", "sample", "stream", "}", "will", "be", "the", "final", "one", "supplied", "before", "it", "is", "next", "disabled", "or", "reset", "this", "method", "may", "be", "called", "when", "the", "renderer", "is", "in", "the", "following", "states", ":", "{", "@", "link", "#", "state", "enabled", "}", ",", "{", "@", "link", "#", "state", "started", "}" ]
[ "void", "set", "current", "stream", "final", "(", ")", ";" ]
[ "returns", "an", "initialized", "test", "harness", "for", "{", "@", "link", "keyed", "broadcast", "process", "function", "}" ]
[ "public", "static", "<", "k", ",", "in1", ",", "in2", ",", "out", ">", "keyed", "broadcast", "operator", "test", "harness", "<", "k", ",", "in1", ",", "in2", ",", "out", ">", "for", "keyed", "broadcast", "process", "function", "(", "final", "keyed", "broadcast", "process", "function", "<", "k", ",", "in1", ",", "in2", ",", "out", ">", "function", ",", "final", "key", "selector", "<", "in1", ",", "k", ">", "key", "selector", ",", "final", "type", "information", "<", "k", ">", "key", "type", ",", "final", "map", "state", "descriptor", "<", "?", ",", "?", ">", "descriptors", ")", "throws", "exception", "{", "keyed", "broadcast", "operator", "test", "harness", "<", "k", ",", "in1", ",", "in2", ",", "out", ">", "test", "harness", "=", "new", "keyed", "broadcast", "operator", "test", "harness", "<", ">", "(", "new", "co", "broadcast", "with", "keyed", "operator", "<", ">", "(", "preconditions", "check", "not", "null", "(", "function", ")", ",", "arrays", "as", "list", "(", "descriptors", ")", ")", ",", "key", "selector", ",", "key", "type", ",", "1", ",", "1", ",", "0", ")", ";", "test", "harness", "open", "(", ")", ";", "return", "test", "harness", ";", "}" ]
[ "only", "select", "historic", "process", "instances", "which", "have", "a", "local", "string", "variable", "with", "the", "given", "value", ",", "case", "insensitive" ]
[ "historic", "process", "instance", "query", "variable", "value", "equals", "ignore", "case", "(", "string", "name", ",", "string", "value", ")", ";" ]
[ "particulary", ",", "thrift", "can", "mistake", "malformed", "content", "as", "a", "huge", "list", "let", "'", "s", "not", "blow", "up" ]
[ "@", "test", "public", "void", "nice", "error", "on", "malformed", "input", "spans", "json", "v2", "(", ")", "{", "thrown", "expect", "(", "illegal", "argument", "exception", "class", ")", ";", "thrown", "expect", "message", "(", "\"", "malformed", "reading", "list", "<", "span", ">", "from", "\"", ")", ";", "span", "bytes", "decoder", "json", "v2", "decode", "list", "(", "new", "byte", "[", "]", "{", "'", "h", "'", ",", "'", "e", "'", ",", "'", "l", "'", ",", "'", "l", "'", ",", "'", "o", "'", "}", ")", ";", "}" ]
[ "creates", "a", "{", "@", "link", "pojo", "serializer", "snapshot", "data", "}", "from", "existing", "snapshotted", "configuration", "of", "a", "{", "@", "link", "pojo", "serializer", "}" ]
[ "static", "<", "t", ">", "pojo", "serializer", "snapshot", "data", "<", "t", ">", "create", "from", "(", "class", "<", "t", ">", "pojo", "class", ",", "field", "[", "]", "fields", ",", "type", "serializer", "snapshot", "<", "?", ">", "[", "]", "existing", "field", "serializer", "snapshots", ",", "linked", "hash", "map", "<", "class", "<", "?", ">", ",", "type", "serializer", "snapshot", "<", "?", ">", ">", "existing", "registered", "subclass", "serializer", "snapshots", ",", "map", "<", "class", "<", "?", ">", ",", "type", "serializer", "snapshot", "<", "?", ">", ">", "existing", "non", "registered", "subclass", "serializer", "snapshots", ")", "{", "final", "linked", "optional", "map", "<", "field", ",", "type", "serializer", "snapshot", "<", "?", ">", ">", "field", "serializer", "snapshots", "=", "new", "linked", "optional", "map", "<", ">", "(", "fields", "length", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "fields", "length", ";", "i", "+", "+", ")", "{", "field", "field", "=", "fields", "[", "i", "]", ";", "string", "field", "name", "=", "(", "field", "=", "=", "null", ")", "?", "get", "dummy", "name", "for", "missing", "field", "(", "i", ")", ":", "field", "get", "name", "(", ")", ";", "field", "serializer", "snapshots", "put", "(", "field", "name", ",", "field", ",", "existing", "field", "serializer", "snapshots", "[", "i", "]", ")", ";", "}", "return", "new", "pojo", "serializer", "snapshot", "data", "<", ">", "(", "pojo", "class", ",", "field", "serializer", "snapshots", ",", "optional", "map", "of", "(", "existing", "registered", "subclass", "serializer", "snapshots", ",", "class", ":", ":", "get", "name", ")", ",", "optional", "map", "of", "(", "existing", "non", "registered", "subclass", "serializer", "snapshots", ",", "class", ":", ":", "get", "name", ")", ")", ";", "}" ]
[ "adds", "a", "route", "to", "the", "given", "handler", "function", "that", "handles", "all", "http", "{", "@", "code", "get", "}", "requests", "that", "match", "the", "given", "pattern", "and", "predicate", "for", "instance", ",", "the", "following", "example", "routes", "get", "requests", "for", "\"", "user", "\"", "that", "accept", "json", "to", "the", "{", "@", "code", "list", "users", "}", "method", "in", "{", "@", "code", "user", "controller", "}", ":", "<", "pre", "class", "=", "\"", "code", "\"", ">", "router", "function", "&", "lt", ";", "server", "response", "&", "gt", ";", "route", "=", "router", "functions", "route", "(", ")", "get", "(", "\"", "user", "\"", ",", "request", "predicates", "accept", "(", "media", "type", "application", "json", ")", ",", "user", "controller", ":", ":", "list", "users", ")", "build", "(", ")", ";" ]
[ "builder", "get", "(", "string", "pattern", ",", "request", "predicate", "predicate", ",", "handler", "function", "<", "server", "response", ">", "handler", "function", ")", ";" ]
[ "draws", "all", "the", "particle", "effects", "call", "{", "@", "link", "#", "begin", "(", ")", "}", "before", "this", "method", "and", "{", "@", "link", "#", "end", "(", ")", "}", "after" ]
[ "public", "void", "draw", "(", ")", "{", "for", "(", "particle", "effect", "effect", ":", "effects", ")", "{", "effect", "draw", "(", ")", ";", "}", "}" ]
[ "writes", "this", "instance", "to", "the", "given", "raw", "data", "object", "this", "gets", "called", "by", "{", "@", "link", "#", "write", "to", "}", "after", "aligning", "the", "cursor", "of", "{", "@", "code", "out", "}", "and", "verifying", "that", "either", "the", "assigned", "file", "offset", "matches", "the", "actual", "cursor", "{", "@", "code", "out", "}", "or", "that", "the", "file", "offset", "was", "not", "previously", "assigned", ",", "in", "which", "case", "it", "gets", "assigned", "to", "{", "@", "code", "out", "}", "'", "s", "cursor" ]
[ "protected", "abstract", "void", "write", "to", "0", "(", "annotated", "output", "out", ")", ";" ]
[ "returns", "the", "drawable", "'", "s", "alpha", "value" ]
[ "public", "int", "get", "alpha", "(", ")", "{", "return", "m", "alpha", ";", "}" ]
[ "creates", "a", "{", "@", "code", "striped", "<", "read", "write", "lock", ">", "}", "with", "lazily", "initialized", ",", "weakly", "referenced", "read", "-", "write", "locks", "every", "lock", "is", "reentrant" ]
[ "public", "static", "striped", "<", "read", "write", "lock", ">", "lazy", "weak", "read", "write", "lock", "(", "int", "stripes", ")", "{", "return", "lazy", "(", "stripes", ",", "weak", "safe", "read", "write", "lock", "supplier", ")", ";", "}" ]
[ "optimize", "(", "trigger", "dexopt", "or", "dex", "2oat", ")", "dexes" ]
[ "public", "static", "boolean", "optimize", "all", "(", "context", "context", ",", "collection", "<", "file", ">", "dex", "files", ",", "file", "optimized", "dir", ",", "boolean", "use", "d", "l", "c", ",", "result", "callback", "cb", ")", "{", "return", "optimize", "all", "(", "context", ",", "dex", "files", ",", "optimized", "dir", ",", "false", ",", "use", "d", "l", "c", ",", "null", ",", "cb", ")", ";", "}" ]
[ "resolve", "the", "given", "resource", "location", "to", "a", "{", "@", "code", "java", "io", "file", "}", ",", "i", "e", "to", "a", "file", "in", "the", "file", "system", "does", "not", "check", "whether", "the", "file", "actually", "exists", ";", "simply", "returns", "the", "file", "that", "the", "given", "location", "would", "correspond", "to" ]
[ "public", "static", "file", "get", "file", "(", "string", "resource", "location", ")", "throws", "file", "not", "found", "exception", "{", "assert", "not", "null", "(", "resource", "location", ",", "\"", "resource", "location", "must", "not", "be", "null", "\"", ")", ";", "if", "(", "resource", "location", "starts", "with", "(", "classpath", "url", "prefix", ")", ")", "{", "string", "path", "=", "resource", "location", "substring", "(", "classpath", "url", "prefix", "length", "(", ")", ")", ";", "string", "description", "=", "\"", "class", "path", "resource", "[", "\"", "+", "path", "+", "\"", "]", "\"", ";", "class", "loader", "cl", "=", "class", "utils", "get", "default", "class", "loader", "(", ")", ";", "url", "url", "=", "(", "cl", "!", "=", "null", "?", "cl", "get", "resource", "(", "path", ")", ":", "class", "loader", "get", "system", "resource", "(", "path", ")", ")", ";", "if", "(", "url", "=", "=", "null", ")", "{", "throw", "new", "file", "not", "found", "exception", "(", "description", "+", "\"", "cannot", "be", "resolved", "to", "absolute", "file", "path", "because", "it", "does", "not", "exist", "\"", ")", ";", "}", "return", "get", "file", "(", "url", ",", "description", ")", ";", "}", "try", "{", "/", "/", "try", "url", "return", "get", "file", "(", "new", "url", "(", "resource", "location", ")", ")", ";", "}", "catch", "(", "malformed", "u", "r", "l", "exception", "ex", ")", "{", "/", "/", "no", "url", "-", ">", "treat", "as", "file", "path", "return", "new", "file", "(", "resource", "location", ")", ";", "}", "}" ]
[ "a", "list", "of", "alternate", "names", "to", "verify", "the", "subject", "identity", "in", "the", "certificate", "presented", "by", "the", "client", "<", "code", ">", "repeated", "string", "subject", "alt", "names", "=", "6", ";", "<", "code", ">" ]
[ "public", "com", "google", "protobuf", "byte", "string", "get", "subject", "alt", "names", "bytes", "(", "int", "index", ")", "{", "return", "subject", "alt", "names", "get", "byte", "string", "(", "index", ")", ";", "}" ]
[ "specify", "the", "job", "'", "s", "durability", ",", "i", "e", "whether", "it", "should", "remain", "stored", "in", "the", "job", "store", "even", "if", "no", "triggers", "point", "to", "it", "anymore" ]
[ "public", "void", "set", "durability", "(", "boolean", "durability", ")", "{", "this", "durability", "=", "durability", ";", "}" ]
[ "returns", "a", "view", "of", "the", "intersection", "of", "this", "range", "set", "with", "the", "given", "range" ]
[ "public", "immutable", "range", "set", "<", "c", ">", "sub", "range", "set", "(", "range", "<", "c", ">", "range", ")", "{", "if", "(", "!", "is", "empty", "(", ")", ")", "{", "range", "<", "c", ">", "span", "=", "span", "(", ")", ";", "if", "(", "range", "encloses", "(", "span", ")", ")", "{", "return", "this", ";", "}", "else", "if", "(", "range", "is", "connected", "(", "span", ")", ")", "{", "return", "new", "immutable", "range", "set", "<", "c", ">", "(", "intersect", "ranges", "(", "range", ")", ")", ";", "}", "}", "return", "of", "(", ")", ";", "}" ]
[ "notify", "that", "the", "given", "model", "has", "had", "its", "data", "changed", "it", "should", "only", "be", "called", "if", "the", "model", "retained", "the", "same", "position" ]
[ "protected", "void", "notify", "model", "changed", "(", "epoxy", "model", "<", "?", ">", "model", ")", "{", "notify", "model", "changed", "(", "model", ",", "null", ")", ";", "}" ]
[ "blocks", "until", "{", "@", "link", "#", "complete", "(", "object", ",", "throwable", ",", "int", ")", "}", "has", "been", "successfully", "called", "throws", "a", "{", "@", "link", "cancellation", "exception", "}", "if", "the", "task", "was", "cancelled", ",", "or", "a", "{", "@", "link", "execution", "exception", "}", "if", "the", "task", "completed", "with", "an", "error" ]
[ "v", "get", "(", ")", "throws", "cancellation", "exception", ",", "execution", "exception", ",", "interrupted", "exception", "{", "/", "/", "acquire", "the", "shared", "lock", "allowing", "interruption", "acquire", "shared", "interruptibly", "(", "-", "1", ")", ";", "return", "get", "value", "(", ")", ";", "}" ]