Datasets:
Anonymous2023
/
KGSum

Dataset card Data Studio Files Community
docstring_tokens
list
code_tokens
list
[ "verifies", "that", "an", "iterator", "is", "unmodifiable", "this", "test", "only", "works", "with", "iterators", "that", "iterate", "over", "a", "finite", "set" ]
[ "public", "static", "void", "assert", "iterator", "is", "unmodifiable", "(", "iterator", "<", "?", ">", "iterator", ")", "{", "while", "(", "iterator", "has", "next", "(", ")", ")", "{", "iterator", "next", "(", ")", ";", "try", "{", "iterator", "remove", "(", ")", ";", "fail", "(", "\"", "remove", "on", "unmodifiable", "iterator", "succeeded", "\"", ")", ";", "}", "catch", "(", "unsupported", "operation", "exception", "expected", ")", "{", "}", "}", "}" ]
[ "get", "the", "number", "of", "triangle", "triplets" ]
[ "public", "long", "get", "number", "of", "triangle", "triplets", "(", ")", "{", "return", "triangle", "triplet", "count", ";", "}" ]
[ "patch", "fake", "classname", "test", ":", "to", "test", "class", "name", "in", "snake", "case", "to", "test", "class", "name", "in", "snake", "case" ]
[ "default", "completable", "future", "<", "response", "entity", "<", "client", ">", ">", "test", "classname", "(", "@", "api", "param", "(", "value", "=", "\"", "client", "model", "\"", ",", "required", "=", "true", ")", "@", "valid", "@", "request", "body", "client", "body", ")", "{", "return", "completable", "future", "supply", "async", "(", "(", ")", "-", ">", "{", "get", "request", "(", ")", "if", "present", "(", "request", "-", ">", "{", "for", "(", "media", "type", "media", "type", ":", "media", "type", "parse", "media", "types", "(", "request", "get", "header", "(", "\"", "accept", "\"", ")", ")", ")", "{", "if", "(", "media", "type", "is", "compatible", "with", "(", "media", "type", "value", "of", "(", "\"", "application", "/", "json", "\"", ")", ")", ")", "{", "string", "example", "string", "=", "\"", "{", "\\", "\"", "client", "\\", "\"", ":", "\\", "\"", "client", "\\", "\"", "}", "\"", ";", "api", "util", "set", "example", "response", "(", "request", ",", "\"", "application", "/", "json", "\"", ",", "example", "string", ")", ";", "break", ";", "}", "}", "}", ")", ";", "return", "new", "response", "entity", "<", ">", "(", "http", "status", "not", "implemented", ")", ";", "}", ",", "runnable", ":", ":", "run", ")", ";", "}" ]
[ "return", "the", "{", "@", "link", "cache", "error", "handler", "}", "to", "use" ]
[ "public", "cache", "error", "handler", "get", "error", "handler", "(", ")", "{", "return", "this", "error", "handler", "obtain", "(", ")", ";", "}" ]
[ "get", "the", "class", "specification", "for", "this", "icon" ]
[ "public", "string", "get", "class", "spec", "(", ")", "{", "return", "class", "spec", ";", "}" ]
[ "alias", "to", "add", "to", "the", "index" ]
[ "public", "string", "get", "alias", "(", ")", "{", "return", "alias", ";", "}" ]
[ "encode", "\"", "-", "corps", "-", "\"", "where", "\"", "-", "ps", "-", "\"", "not", "pronounced", "since", "the", "cognate", "is", "here", "from", "the", "french" ]
[ "boolean", "encode", "rps", "(", ")", "{", "/", "/", "'", "-", "corps", "-", "'", ",", "'", "corpsman", "'", "if", "(", "string", "at", "(", "(", "m", "current", "-", "3", ")", ",", "5", ",", "\"", "corps", "\"", ",", "\"", "\"", ")", "&", "&", "!", "string", "at", "(", "(", "m", "current", "-", "3", ")", ",", "6", ",", "\"", "corpse", "\"", ",", "\"", "\"", ")", ")", "{", "m", "current", "+", "=", "2", ";", "return", "true", ";", "}", "return", "false", ";", "}" ]
[ "returns", "the", "user", "id", "of", "this", "m", "t", "config", "object" ]
[ "public", "string", "get", "user", "id", "(", ")", "{", "return", "user", "id", ";", "}" ]
[ "removes", "the", "int", "value", "from", "the", "set" ]
[ "public", "boolean", "remove", "(", "int", "value", ")", "{", "return", "indexer", "remove", "(", "value", ")", ">", "=", "0", ";", "}" ]
[ "gets", "a", "list", "of", "{", "@", "link", "accumulo", "column", "constraint", "}", "based", "on", "the", "given", "constraint", "id", ",", "excluding", "the", "row", "id", "column" ]
[ "private", "static", "list", "<", "accumulo", "column", "constraint", ">", "get", "column", "constraints", "(", "string", "row", "id", "name", ",", "tuple", "domain", "<", "column", "handle", ">", "constraint", ")", "{", "immutable", "list", "builder", "<", "accumulo", "column", "constraint", ">", "constraint", "builder", "=", "immutable", "list", "builder", "(", ")", ";", "for", "(", "column", "domain", "<", "column", "handle", ">", "column", "domain", ":", "constraint", "get", "column", "domains", "(", ")", "get", "(", ")", ")", "{", "accumulo", "column", "handle", "column", "handle", "=", "(", "accumulo", "column", "handle", ")", "column", "domain", "get", "column", "(", ")", ";", "if", "(", "!", "column", "handle", "get", "name", "(", ")", "equals", "(", "row", "id", "name", ")", ")", "{", "/", "/", "family", "and", "qualifier", "will", "exist", "for", "non", "-", "row", "id", "columns", "constraint", "builder", "add", "(", "new", "accumulo", "column", "constraint", "(", "column", "handle", "get", "name", "(", ")", ",", "column", "handle", "get", "family", "(", ")", "get", "(", ")", ",", "column", "handle", "get", "qualifier", "(", ")", "get", "(", ")", ",", "optional", "of", "(", "column", "domain", "get", "domain", "(", ")", ")", ",", "column", "handle", "is", "indexed", "(", ")", ")", ")", ";", "}", "}", "return", "constraint", "builder", "build", "(", ")", ";", "}" ]
[ "use", "{", "@", "link", "big", "decimal", "type", "info", "}", "to", "retain", "precision", "and", "scale", "of", "decimal" ]
[ "public", "static", "type", "information", "from", "logical", "type", "to", "type", "info", "(", "logical", "type", "type", ")", "{", "data", "type", "data", "type", "=", "from", "logical", "type", "to", "data", "type", "(", "type", ")", "nullable", "(", ")", "bridged", "to", "(", "class", "logical", "type", "converter", "get", "default", "external", "class", "for", "type", "(", "type", ")", ")", ";", "return", "type", "info", "data", "type", "converter", "from", "data", "type", "to", "type", "info", "(", "data", "type", ")", ";", "}" ]
[ "returns", "an", "immutable", "set", "multimap", "containing", "the", "same", "mappings", "as", "{", "@", "code", "multimap", "}", "the", "generated", "multimap", "'", "s", "key", "and", "value", "orderings", "correspond", "to", "the", "iteration", "ordering", "of", "the", "{", "@", "code", "multimap", "as", "map", "(", ")", "}", "view", "repeated", "occurrences", "of", "an", "entry", "in", "the", "multimap", "after", "the", "first", "are", "ignored", "despite", "the", "method", "name", ",", "this", "method", "attempts", "to", "avoid", "actually", "copying", "the", "data", "when", "it", "is", "safe", "to", "do", "so", "the", "exact", "circumstances", "under", "which", "a", "copy", "will", "or", "will", "not", "be", "performed", "are", "undocumented", "and", "subject", "to", "change" ]
[ "public", "static", "<", "k", ",", "v", ">", "immutable", "set", "multimap", "<", "k", ",", "v", ">", "copy", "of", "(", "multimap", "<", "?", "extends", "k", ",", "?", "extends", "v", ">", "multimap", ")", "{", "return", "copy", "of", "(", "multimap", ",", "null", ")", ";", "}" ]
[ "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", "\"", ")", ";", "}" ]
[ "if", "all", "threads", "are", "up", ",", "including", "the", "global", "thread", ",", "set", "to", "running" ]
[ "private", "void", "maybe", "set", "running", "(", ")", "{", "/", "/", "state", "can", "be", "transferred", "to", "running", "if", "all", "threads", "are", "either", "running", "or", "dead", "for", "(", "final", "stream", "thread", "state", "state", ":", "thread", "state", "values", "(", ")", ")", "{", "if", "(", "state", "!", "=", "stream", "thread", "state", "running", "&", "&", "state", "!", "=", "stream", "thread", "state", "dead", ")", "{", "return", ";", "}", "}", "/", "/", "the", "global", "state", "thread", "is", "relevant", "only", "if", "it", "is", "started", "there", "are", "cases", "/", "/", "when", "we", "don", "'", "t", "have", "a", "global", "state", "thread", "at", "all", ",", "e", "g", ",", "when", "we", "don", "'", "t", "have", "global", "k", "tables", "if", "(", "global", "thread", "state", "!", "=", "null", "&", "&", "global", "thread", "state", "!", "=", "global", "stream", "thread", "state", "running", ")", "{", "return", ";", "}", "set", "state", "(", "state", "running", ")", ";", "}" ]
[ "@", "inherit", "doc" ]
[ "public", "int", "get", "c", "(", ")", "{", "return", "c", ";", "}" ]
[ "returns", "the", "local", "output", "path", "used", "by", "this", "blaze", "instance" ]
[ "public", "path", "get", "local", "output", "path", "(", ")", "{", "return", "local", "output", "path", ";", "}" ]
[ "get", "the", "comma", "delimited", "values", "of", "the", "<", "code", ">", "name", "<", "code", ">", "property", "as", "a", "collection", "of", "<", "code", ">", "string", "<", "code", ">", "s", ",", "trimmed", "of", "the", "leading", "and", "trailing", "whitespace", "if", "no", "such", "property", "is", "specified", "then", "empty", "<", "code", ">", "collection", "<", "code", ">", "is", "returned" ]
[ "public", "collection", "<", "string", ">", "get", "trimmed", "string", "collection", "(", "string", "name", ")", "{", "string", "value", "string", "=", "get", "(", "name", ")", ";", "if", "(", "null", "=", "=", "value", "string", ")", "{", "collection", "<", "string", ">", "empty", "=", "new", "array", "list", "<", "string", ">", "(", ")", ";", "return", "empty", ";", "}", "return", "string", "utils", "get", "trimmed", "string", "collection", "(", "value", "string", ")", ";", "}" ]
[ "fetch", "the", "value", "column", "name", "of", "the", "given", "metrics", "name" ]
[ "public", "string", "get", "value", "c", "name", "(", "string", "metrics", "name", ")", "{", "return", "find", "column", "(", "metrics", "name", ")", "value", "c", "name", ";", "}" ]
[ "transfers", "bytes", "from", "`", "file", "channel", "`", "to", "this", "`", "transferable", "channel", "`", "this", "method", "will", "delegate", "to", "{", "@", "link", "file", "channel", "#", "transfer", "to", "(", "long", ",", "long", ",", "java", "nio", "channels", "writable", "byte", "channel", ")", "}", ",", "but", "it", "will", "unwrap", "the", "destination", "channel", ",", "if", "possible", ",", "in", "order", "to", "benefit", "from", "zero", "copy", "this", "is", "required", "because", "the", "fast", "path", "of", "`", "transfer", "to", "`", "is", "only", "executed", "if", "the", "destination", "buffer", "inherits", "from", "an", "internal", "jdk", "class" ]
[ "long", "transfer", "from", "(", "file", "channel", "file", "channel", ",", "long", "position", ",", "long", "count", ")", "throws", "i", "o", "exception", ";" ]
[ "get", "name", "boolean" ]
[ "public", "boolean", "get", "name", "boolean", "(", ")", "{", "return", "name", "boolean", ";", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "final", "int", "hash", "code", "(", ")", "{", "return", "(", "defining", "class", "hash", "code", "(", ")", "*", "31", ")", "^", "nat", "hash", "code", "(", ")", ";", "}" ]
[ "checks", "if", "this", "particular", "object", "handles", "the", "kind", "of", "token", "passed" ]
[ "public", "boolean", "handle", "kind", "(", "text", "kind", ")", "{", "return", "abfs", "delegation", "token", "identifier", "token", "kind", "equals", "(", "kind", ")", ";", "}" ]
[ "check", "to", "see", "if", "the", "current", "lock", "file", "has", "exceeded", "the", "maximum", "allowed", "lease", "time" ]
[ "public", "void", "run", "(", ")", "{", "synchronized", "(", "wait", "lock", ")", "{", "if", "(", "abort", ")", "{", "terminate", "(", ")", ";", "return", ";", "}", "max", "lease", "time", "-", "=", "interval", ";", "long", "mt", "=", "lock", "file", "last", "modified", "(", ")", ";", "if", "(", "mt", "!", "=", "0l", ")", "{", "/", "/", "check", "for", "updated", "lock", "if", "(", "mt", "!", "=", "last", "mod", "time", ")", "{", "/", "/", "discontinue", "waiting", "if", "we", "are", "not", "trying", "to", "create", "lock", "/", "/", "since", "it", "is", "clearly", "not", "stuck", "if", "(", "!", "create", ")", "{", "terminate", "(", ")", ";", "}", "/", "/", "reset", "lease", "timer", "if", "we", "want", "to", "create", "lock", "else", "{", "max", "lease", "time", "=", "max", "lock", "lease", "period", ";", "last", "mod", "time", "=", "mt", ";", "msg", "trace", "(", "this", ",", "get", "lock", "owner", "(", "true", ")", "+", "\"", "grabbed", "lock", "before", "i", "could", ":", "\"", "+", "get", "lock", "i", "d", "(", ")", ")", ";", "}", "return", ";", "/", "/", "lock", "file", "still", "exists", "}", "msg", "trace", "(", "this", ",", "get", "lock", "owner", "(", "true", ")", "+", "\"", "has", "held", "lock", "for", "\"", "+", "(", "(", "max", "lock", "lease", "period", "-", "max", "lease", "time", ")", "/", "1000", ")", "+", "\"", "seconds", ":", "\"", "+", "get", "lock", "i", "d", "(", ")", ")", ";", "if", "(", "max", "lease", "time", ">", "0", ")", "return", ";", "/", "/", "forcefully", "remove", "lock", "file", "if", "max", "lease", "time", "expired", "lock", "file", "delete", "(", ")", ";", "msg", "warn", "(", "this", ",", "\"", "forcefully", "removing", "lock", "owned", "by", "\"", "+", "get", "lock", "owner", "(", "true", ")", "+", "\"", ":", "\"", "+", "get", "lock", "i", "d", "(", ")", ")", ";", "/", "/", "delay", "after", "forceful", "removal", "to", "avoid", "race", "condition", "!", "/", "/", "if", "we", "create", "a", "new", "lock", "file", "immediately", ",", "another", "wait", "task", "/", "/", "could", "remove", "it", "due", "to", "the", "delay", "between", "checking", "the", "last", "modified", "/", "/", "time", "and", "actually", "removing", "the", "file", "try", "{", "thread", "sleep", "(", "1000", ")", ";", "}", "catch", "(", "interrupted", "exception", "e", ")", "{", "create", "=", "false", ";", "}", "}", "/", "/", "attempt", "to", "create", "lock", "if", "requested", "if", "(", "create", ")", "{", "try", "{", "if", "(", "create", "lock", "file", "no", "wait", "(", "false", ")", ")", "{", "msg", "trace", "(", "this", ",", "(", "new", "date", "(", ")", ")", "+", "\"", "lock", "file", ":", "lock", "granted", "after", "wait", ":", "\"", "+", "get", "lock", "i", "d", "(", ")", ")", ";", "+", "+", "lock", "count", ";", "terminate", "(", ")", ";", "}", "else", "{", "/", "/", "create", "failed", "-", "keep", "waiting", "max", "lease", "time", "=", "max", "lock", "lease", "period", ";", "return", ";", "}", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "msg", "show", "error", "(", "this", ",", "null", ",", "\"", "lock", "failure", "\"", ",", "\"", "unable", "to", "write", "to", "lock", "file", ":", "\"", "+", "lock", "file", "get", "absolute", "path", "(", ")", ",", "e", ")", ";", "terminate", "(", ")", ";", "}", "}", "last", "mod", "time", "=", "0l", ";", "}", "}" ]
[ "<", "code", ">", "optional", "string", "msg", "=", "1", ";", "<", "code", ">" ]
[ "public", "builder", "clear", "msg", "(", ")", "{", "bit", "field", "0", "=", "(", "bit", "field", "0", "&", "~", "0x", "0", "0", "0", "0", "0", "0", "0", "1", ")", ";", "msg", "=", "get", "default", "instance", "(", ")", "get", "msg", "(", ")", ";", "on", "changed", "(", ")", ";", "return", "this", ";", "}" ]
[ "returns", "the", "label", "of", "the", "<", "code", ">", "cc", "compiler", "<", "code", ">", "rule", "for", "the", "c", "+", "+", "configuration" ]
[ "public", "label", "get", "rule", "providing", "cc", "toolchain", "provider", "(", ")", "{", "return", "cpp", "options", "crosstool", "top", ";", "}" ]
[ "returns", "true", "if", "this", "path", "can", "be", "modified" ]
[ "public", "boolean", "is", "editable", "(", ")", "{", "return", "is", "editable", ";", "}" ]
[ "copy", "the", "name", "-", "value", "pairs", "from", "the", "provided", "map", "this", "operation", "will", "overwrite", "any", "existing", "values", "use", "{", "@", "link", "#", "copy", "headers", "if", "absent", "(", "map", ")", "}", "to", "avoid", "overwriting", "values" ]
[ "public", "void", "copy", "headers", "(", "@", "nullable", "map", "<", "string", ",", "?", ">", "headers", "to", "copy", ")", "{", "if", "(", "headers", "to", "copy", "=", "=", "null", "|", "|", "this", "headers", "=", "=", "headers", "to", "copy", ")", "{", "return", ";", "}", "headers", "to", "copy", "for", "each", "(", "(", "key", ",", "value", ")", "-", ">", "{", "if", "(", "!", "is", "read", "only", "(", "key", ")", ")", "{", "set", "header", "(", "key", ",", "value", ")", ";", "}", "}", ")", ";", "}" ]
[ "returns", "the", "result", "of", "{", "@", "link", "#", "get", "value", "(", "string", ")", "}", ",", "cast", "as", "the", "given", "type", ",", "throwing", "{", "@", "link", "eval", "exception", "}", "if", "the", "cast", "fails" ]
[ "public", "final", "<", "t", ">", "t", "get", "value", "(", "string", "key", ",", "class", "<", "t", ">", "type", ")", "throws", "eval", "exception", "{", "object", "obj", "=", "get", "value", "(", "key", ")", ";", "if", "(", "obj", "=", "=", "null", ")", "{", "return", "null", ";", "}", "try", "{", "return", "type", "cast", "(", "obj", ")", ";", "}", "catch", "(", "class", "cast", "exception", "unused", ")", "{", "throw", "starlark", "errorf", "(", "\"", "for", "%", "s", "field", ",", "got", "%", "s", ",", "want", "%", "s", "\"", ",", "key", ",", "starlark", "type", "(", "obj", ")", ",", "starlark", "class", "type", "(", "type", ")", ")", ";", "}", "}" ]
[ "return", "a", "newly", "constructed", "{", "@", "link", "processor", "}", "instance", "the", "supplier", "should", "always", "generate", "a", "new", "instance", "each", "time", "{", "@", "link", "processor", "supplier", "#", "get", "(", ")", "}", "gets", "called", "creating", "a", "single", "{", "@", "link", "processor", "}", "object", "and", "returning", "the", "same", "object", "reference", "in", "{", "@", "link", "processor", "supplier", "#", "get", "(", ")", "}", "is", "a", "violation", "of", "the", "supplier", "pattern", "and", "leads", "to", "runtime", "exceptions" ]
[ "processor", "<", "k", ",", "v", ">", "get", "(", ")", ";" ]
[ "create", "the", "common", "{", "@", "link", "container", "launch", "context", "}", "for", "all", "attempts" ]
[ "private", "static", "container", "launch", "context", "create", "common", "container", "launch", "context", "(", "map", "<", "application", "access", "type", ",", "string", ">", "application", "a", "c", "ls", ",", "configuration", "conf", ",", "token", "<", "job", "token", "identifier", ">", "job", "token", ",", "final", "org", "apache", "hadoop", "mapred", "job", "i", "d", "old", "job", "id", ",", "credentials", "credentials", ")", "{", "/", "/", "application", "resources", "map", "<", "string", ",", "local", "resource", ">", "local", "resources", "=", "new", "hash", "map", "<", "string", ",", "local", "resource", ">", "(", ")", ";", "/", "/", "application", "environment", "map", "<", "string", ",", "string", ">", "environment", ";", "/", "/", "service", "data", "map", "<", "string", ",", "byte", "buffer", ">", "service", "data", "=", "new", "hash", "map", "<", "string", ",", "byte", "buffer", ">", "(", ")", ";", "/", "/", "tokens", "byte", "buffer", "task", "credentials", "buffer", "=", "byte", "buffer", "wrap", "(", "new", "byte", "[", "]", "{", "}", ")", ";", "try", "{", "configure", "job", "jar", "(", "conf", ",", "local", "resources", ")", ";", "configure", "job", "conf", "(", "conf", ",", "local", "resources", ",", "old", "job", "id", ")", ";", "/", "/", "setup", "distributed", "cache", "m", "r", "apps", "setup", "distributed", "cache", "(", "conf", ",", "local", "resources", ")", ";", "task", "credentials", "buffer", "=", "configure", "tokens", "(", "job", "token", ",", "credentials", ",", "service", "data", ")", ";", "add", "external", "shuffle", "providers", "(", "conf", ",", "service", "data", ")", ";", "environment", "=", "configure", "env", "(", "conf", ")", ";", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "throw", "new", "yarn", "runtime", "exception", "(", "e", ")", ";", "}", "/", "/", "construct", "the", "actual", "container", "/", "/", "the", "null", "fields", "are", "per", "-", "container", "and", "will", "be", "constructed", "for", "each", "/", "/", "container", "separately", "container", "launch", "context", "container", "=", "container", "launch", "context", "new", "instance", "(", "local", "resources", ",", "environment", ",", "null", ",", "service", "data", ",", "task", "credentials", "buffer", ",", "application", "a", "c", "ls", ")", ";", "return", "container", ";", "}" ]
[ "return", "true", "if", "all", "is", "well" ]
[ "protected", "boolean", "raw", "generate", "recognizer", "(", "string", "grammar", "file", "name", ",", "string", "grammar", "str", ",", "string", "parser", "name", ",", "string", "lexer", "name", ",", "string", "extra", "options", ")", "{", "return", "raw", "generate", "recognizer", "(", "grammar", "file", "name", ",", "grammar", "str", ",", "parser", "name", ",", "lexer", "name", ",", "false", ",", "extra", "options", ")", ";", "}" ]
[ "constructs", "an", "{", "@", "code", "immutable", "sorted", "set", "}", "from", "the", "first", "{", "@", "code", "n", "}", "elements", "of", "{", "@", "code", "contents", "}", "if", "{", "@", "code", "k", "}", "is", "the", "size", "of", "the", "returned", "{", "@", "code", "immutable", "sorted", "set", "}", ",", "then", "the", "sorted", "unique", "elements", "are", "in", "the", "first", "{", "@", "code", "k", "}", "positions", "of", "{", "@", "code", "contents", "}", ",", "and", "{", "@", "code", "contents", "[", "i", "]", "=", "=", "null", "}", "for", "{", "@", "code", "k", "<", "=", "i", "<", "n", "}", "this", "method", "takes", "ownership", "of", "{", "@", "code", "contents", "}", ";", "do", "not", "modify", "{", "@", "code", "contents", "}", "after", "this", "returns" ]
[ "static", "<", "e", ">", "immutable", "sorted", "set", "<", "e", ">", "construct", "(", "comparator", "<", "?", "super", "e", ">", "comparator", ",", "int", "n", ",", "e", "contents", ")", "{", "if", "(", "n", "=", "=", "0", ")", "{", "return", "empty", "set", "(", "comparator", ")", ";", "}", "check", "elements", "not", "null", "(", "contents", ",", "n", ")", ";", "arrays", "sort", "(", "contents", ",", "0", ",", "n", ",", "comparator", ")", ";", "int", "uniques", "=", "1", ";", "for", "(", "int", "i", "=", "1", ";", "i", "<", "n", ";", "i", "+", "+", ")", "{", "e", "cur", "=", "contents", "[", "i", "]", ";", "e", "prev", "=", "contents", "[", "uniques", "-", "1", "]", ";", "if", "(", "comparator", "compare", "(", "cur", ",", "prev", ")", "!", "=", "0", ")", "{", "contents", "[", "uniques", "+", "+", "]", "=", "cur", ";", "}", "}", "arrays", "fill", "(", "contents", ",", "uniques", ",", "n", ",", "null", ")", ";", "if", "(", "uniques", "<", "contents", "length", "/", "2", ")", "{", "/", "/", "deduplication", "eliminated", "many", "of", "the", "elements", "we", "don", "'", "t", "want", "to", "retain", "an", "arbitrarily", "/", "/", "large", "array", "relative", "to", "the", "number", "of", "elements", ",", "so", "we", "cap", "the", "ratio", "contents", "=", "arrays", "copy", "of", "(", "contents", ",", "uniques", ")", ";", "}", "return", "new", "regular", "immutable", "sorted", "set", "<", "e", ">", "(", "immutable", "list", "<", "e", ">", "as", "immutable", "list", "(", "contents", ",", "uniques", ")", ",", "comparator", ")", ";", "}" ]
[ "select", "one", "of", "the", "configured", "local", "interfaces", "at", "random", "we", "use", "a", "random", "interface", "because", "other", "policies", "like", "round", "-", "robin", "are", "less", "effective", "given", "that", "we", "cache", "connections", "to", "datanodes" ]
[ "socket", "address", "get", "random", "local", "interface", "addr", "(", ")", "{", "if", "(", "local", "interface", "addrs", "length", "=", "=", "0", ")", "{", "return", "null", ";", "}", "final", "int", "idx", "=", "r", "next", "int", "(", "local", "interface", "addrs", "length", ")", ";", "final", "socket", "address", "addr", "=", "local", "interface", "addrs", "[", "idx", "]", ";", "log", "debug", "(", "\"", "using", "local", "interface", "{", "}", "\"", ",", "addr", ")", ";", "return", "addr", ";", "}" ]
[ "return", "the", "hex", "string", "of", "sha1", "encryption" ]
[ "public", "static", "string", "encrypt", "s", "h", "a", "1", "to", "string", "(", "final", "string", "data", ")", "{", "if", "(", "data", "=", "=", "null", "|", "|", "data", "length", "(", ")", "=", "=", "0", ")", "return", "\"", "\"", ";", "return", "encrypt", "s", "h", "a", "1", "to", "string", "(", "data", "get", "bytes", "(", ")", ")", ";", "}" ]
[ "return", "filter", "function", "that", "determines", "if", "view", "should", "be", "cached" ]
[ "public", "cache", "filter", "get", "cache", "filter", "(", ")", "{", "return", "this", "cache", "filter", ";", "}" ]
[ "bump", "up", "the", "reference", "count", "for", "the", "shared", "reference", "if", "the", "shared", "-", "reference", "is", "valid" ]
[ "public", "synchronized", "boolean", "add", "reference", "if", "valid", "(", ")", "{", "if", "(", "is", "valid", "(", ")", ")", "{", "add", "reference", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}" ]
[ "toggle", "compact", "sidebar" ]
[ "public", "static", "void", "toggle", "compact", "sidebar", "(", ")", "{", "final", "boolean", "is", "compact", "sidebar", "=", "config", "is", "compact", "sidebar", "(", ")", ";", "config", "set", "compact", "sidebar", "(", "!", "is", "compact", "sidebar", ")", ";", "apply", "compact", "sidebar", "(", "true", ")", ";", "}" ]
[ "model", "tests", "for", "format", "test" ]
[ "public", "void", "test", "format", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "format", "test", "}" ]
[ "model", "tests", "for", "cat", "all", "of" ]
[ "public", "void", "test", "cat", "all", "of", "(", ")", "{", "/", "/", "todo", ":", "test", "cat", "all", "of", "}" ]
[ "required", ":", "a", "valid", "non", "-", "negative", "integer", "port", "number", "<", "code", ">", "uint", "3", "2", "number", "=", "1", ";", "<", "code", ">" ]
[ "public", "builder", "clear", "number", "(", ")", "{", "number", "=", "0", ";", "on", "changed", "(", ")", ";", "return", "this", ";", "}" ]
[ "test", "the", "property", "'", "prefix", "namespace", "boolean", "'" ]
[ "public", "void", "prefix", "namespace", "boolean", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "prefix", "namespace", "boolean", "}" ]
[ "stores", "an", "long", "value", "at", "the", "given", "index", "any", "value", "currently", "at", "that", "index", "will", "be", "replaced", "by", "the", "new", "value" ]
[ "public", "void", "put", "long", "(", "long", "index", ",", "long", "value", ")", "{", "property", "page", "page", "=", "get", "or", "create", "page", "(", "get", "page", "i", "d", "(", "index", ")", ")", ";", "int", "n", "=", "page", "get", "size", "(", ")", ";", "page", "add", "long", "(", "get", "page", "offset", "(", "index", ")", ",", "value", ")", ";", "num", "properties", "+", "=", "page", "get", "size", "(", ")", "-", "n", ";", "}" ]
[ "same", "as", "{", "@", "link", "#", "add", "mask", "range", "(", "string", ",", "string", ")", "}", "but", "uses", "the", "mask", "itself", "as", "a", "key" ]
[ "public", "ip", "range", "aggregation", "builder", "add", "mask", "range", "(", "string", "mask", ")", "{", "return", "add", "range", "(", "new", "range", "(", "mask", ",", "mask", ")", ")", ";", "}" ]
[ "returns", "true", "if", "this", "monitor", "is", "security", "related", "this", "will", "be", "used", "to", "determine", "which", "icon", "will", "be", "used", "in", "the", "navigation", "bar" ]
[ "public", "boolean", "is", "security", "(", ")", "{", "return", "false", ";", "}" ]
[ "for", "types", "that", "support", "it", ",", "return", "the", "extended", "value", "from", "an", "extended", "ephemeral", "owner" ]
[ "public", "long", "get", "value", "(", "long", "ephemeral", "owner", ")", "{", "return", "0", ";", "}" ]
[ "get", "the", "close", "status", "of", "a", "file" ]
[ "public", "boolean", "is", "file", "closed", "(", "final", "path", "src", ")", "throws", "i", "o", "exception", "{", "path", "abs", "f", "=", "fix", "relative", "part", "(", "src", ")", ";", "return", "new", "file", "system", "link", "resolver", "<", "boolean", ">", "(", ")", "{", "@", "override", "public", "boolean", "do", "call", "(", "final", "path", "p", ")", "throws", "i", "o", "exception", "{", "return", "dfs", "is", "file", "closed", "(", "get", "path", "name", "(", "p", ")", ")", ";", "}", "@", "override", "public", "boolean", "next", "(", "final", "file", "system", "fs", ",", "final", "path", "p", ")", "throws", "i", "o", "exception", "{", "if", "(", "fs", "instanceof", "distributed", "file", "system", ")", "{", "distributed", "file", "system", "my", "dfs", "=", "(", "distributed", "file", "system", ")", "fs", ";", "return", "my", "dfs", "is", "file", "closed", "(", "p", ")", ";", "}", "else", "{", "throw", "new", "unsupported", "operation", "exception", "(", "\"", "cannot", "call", "is", "file", "closed", "\"", "+", "\"", "on", "a", "symlink", "to", "a", "non", "-", "distributed", "file", "system", ":", "\"", "+", "src", "+", "\"", "-", ">", "\"", "+", "p", ")", ";", "}", "}", "}", "resolve", "(", "this", ",", "abs", "f", ")", ";", "}" ]
[ "called", "when", "a", "controller", "has", "sent", "a", "custom", "command" ]
[ "session", "result", "on", "custom", "command", "(", "media", "session", "session", ",", "controller", "info", "controller", "info", ",", "session", "command", "custom", "command", ",", "@", "nullable", "bundle", "args", ")", ";" ]
[ "sets", "the", "parse", "observer", "for", "this", "instance" ]
[ "public", "final", "void", "set", "observer", "(", "parse", "observer", "observer", ")", "{", "this", "observer", "=", "observer", ";", "}" ]
[ "returns", "a", "data", "source", "supplier", "that", "will", "on", "get", "submit", "the", "request", "for", "execution", "and", "return", "a", "data", "source", "representing", "the", "pending", "results", "of", "the", "task" ]
[ "public", "supplier", "<", "data", "source", "<", "closeable", "reference", "<", "closeable", "image", ">", ">", ">", "get", "data", "source", "supplier", "(", "final", "image", "request", "image", "request", ",", "final", "object", "caller", "context", ",", "final", "image", "request", "request", "level", "request", "level", ",", "final", "@", "nullable", "request", "listener", "request", "listener", ",", "final", "@", "nullable", "string", "ui", "component", "id", ")", "{", "return", "new", "supplier", "<", "data", "source", "<", "closeable", "reference", "<", "closeable", "image", ">", ">", ">", "(", ")", "{", "@", "override", "public", "data", "source", "<", "closeable", "reference", "<", "closeable", "image", ">", ">", "get", "(", ")", "{", "return", "fetch", "decoded", "image", "(", "image", "request", ",", "caller", "context", ",", "request", "level", ",", "request", "listener", ",", "ui", "component", "id", ")", ";", "}", "@", "override", "public", "string", "to", "string", "(", ")", "{", "return", "objects", "to", "string", "helper", "(", "this", ")", "add", "(", "\"", "uri", "\"", ",", "image", "request", "get", "source", "uri", "(", ")", ")", "to", "string", "(", ")", ";", "}", "}", ";", "}" ]
[ "model", "tests", "for", "order" ]
[ "public", "void", "test", "order", "(", ")", "{", "/", "/", "todo", ":", "test", "order", "}" ]
[ "list", "the", "statuses", "and", "block", "locations", "of", "the", "files", "in", "the", "given", "path", "if", "the", "path", "is", "a", "directory", ",", "if", "recursive", "is", "false", ",", "returns", "files", "in", "the", "directory", ";", "if", "recursive", "is", "true", ",", "return", "files", "in", "the", "subtree", "rooted", "at", "the", "path", "the", "subtree", "is", "traversed", "in", "the", "depth", "-", "first", "order", "if", "the", "path", "is", "a", "file", ",", "return", "the", "file", "'", "s", "status", "and", "block", "locations", "files", "across", "symbolic", "links", "are", "also", "returned" ]
[ "public", "remote", "iterator", "<", "located", "file", "status", ">", "list", "files", "(", "final", "path", "f", ",", "final", "boolean", "recursive", ")", "throws", "access", "control", "exception", ",", "file", "not", "found", "exception", ",", "unsupported", "file", "system", "exception", ",", "i", "o", "exception", "{", "return", "new", "remote", "iterator", "<", "located", "file", "status", ">", "(", ")", "{", "private", "stack", "<", "remote", "iterator", "<", "located", "file", "status", ">", ">", "itors", "=", "new", "stack", "<", "remote", "iterator", "<", "located", "file", "status", ">", ">", "(", ")", ";", "remote", "iterator", "<", "located", "file", "status", ">", "cur", "itor", "=", "list", "located", "status", "(", "f", ")", ";", "located", "file", "status", "cur", "file", ";", "/", "*", "*", "*", "returns", "<", "tt", ">", "true", "<", "/", "tt", ">", "if", "the", "iterator", "has", "more", "files", "*", "*", "@", "return", "<", "tt", ">", "true", "<", "/", "tt", ">", "if", "the", "iterator", "has", "more", "files", "*", "@", "throws", "access", "control", "exception", "if", "not", "allowed", "to", "access", "next", "*", "file", "'", "s", "status", "or", "locations", "*", "@", "throws", "file", "not", "found", "exception", "if", "next", "file", "does", "not", "exist", "any", "more", "*", "@", "throws", "unsupported", "file", "system", "exception", "if", "next", "file", "'", "s", "*", "fs", "is", "unsupported", "*", "@", "throws", "i", "o", "exception", "for", "all", "other", "io", "errors", "*", "for", "example", ",", "name", "node", "is", "not", "avaialbe", "or", "*", "name", "node", "throws", "i", "o", "exception", "due", "to", "an", "error", "*", "while", "getting", "the", "status", "or", "block", "locations", "*", "/", "@", "override", "public", "boolean", "has", "next", "(", ")", "throws", "i", "o", "exception", "{", "while", "(", "cur", "file", "=", "=", "null", ")", "{", "if", "(", "cur", "itor", "has", "next", "(", ")", ")", "{", "handle", "file", "stat", "(", "cur", "itor", "next", "(", ")", ")", ";", "}", "else", "if", "(", "!", "itors", "empty", "(", ")", ")", "{", "cur", "itor", "=", "itors", "pop", "(", ")", ";", "}", "else", "{", "return", "false", ";", "}", "}", "return", "true", ";", "}", "/", "*", "*", "*", "process", "the", "input", "stat", "*", "if", "it", "is", "a", "file", ",", "return", "the", "file", "stat", "*", "if", "it", "is", "a", "directory", ",", "traverse", "the", "directory", "if", "recursive", "is", "true", ";", "*", "ignore", "it", "if", "recursive", "is", "false", "*", "if", "it", "is", "a", "symlink", ",", "resolve", "the", "symlink", "first", "and", "then", "process", "it", "*", "depending", "on", "if", "it", "is", "a", "file", "or", "directory", "*", "@", "param", "stat", "input", "status", "*", "@", "throws", "access", "control", "exception", "if", "access", "is", "denied", "*", "@", "throws", "file", "not", "found", "exception", "if", "file", "is", "not", "found", "*", "@", "throws", "unsupported", "file", "system", "exception", "if", "fs", "is", "not", "supported", "*", "@", "throws", "i", "o", "exception", "for", "all", "other", "io", "errors", "*", "/", "private", "void", "handle", "file", "stat", "(", "located", "file", "status", "stat", ")", "throws", "i", "o", "exception", "{", "if", "(", "stat", "is", "file", "(", ")", ")", "{", "/", "/", "file", "cur", "file", "=", "stat", ";", "}", "else", "if", "(", "stat", "is", "symlink", "(", ")", ")", "{", "/", "/", "symbolic", "link", "/", "/", "resolve", "symbolic", "link", "file", "status", "symstat", "=", "file", "context", "this", "get", "file", "status", "(", "stat", "get", "symlink", "(", ")", ")", ";", "if", "(", "symstat", "is", "file", "(", ")", "|", "|", "(", "recursive", "&", "&", "symstat", "is", "directory", "(", ")", ")", ")", "{", "itors", "push", "(", "cur", "itor", ")", ";", "cur", "itor", "=", "list", "located", "status", "(", "stat", "get", "path", "(", ")", ")", ";", "}", "}", "else", "if", "(", "recursive", ")", "{", "/", "/", "directory", "itors", "push", "(", "cur", "itor", ")", ";", "cur", "itor", "=", "list", "located", "status", "(", "stat", "get", "path", "(", ")", ")", ";", "}", "}", "/", "*", "*", "*", "returns", "the", "next", "file", "'", "s", "status", "with", "its", "block", "locations", "*", "*", "@", "throws", "access", "control", "exception", "if", "not", "allowed", "to", "access", "next", "*", "file", "'", "s", "status", "or", "locations", "*", "@", "throws", "file", "not", "found", "exception", "if", "next", "file", "does", "not", "exist", "any", "more", "*", "@", "throws", "unsupported", "file", "system", "exception", "if", "next", "file", "'", "s", "*", "fs", "is", "unsupported", "*", "@", "throws", "i", "o", "exception", "for", "all", "other", "io", "errors", "*", "for", "example", ",", "name", "node", "is", "not", "avaialbe", "or", "*", "name", "node", "throws", "i", "o", "exception", "due", "to", "an", "error", "*", "while", "getting", "the", "status", "or", "block", "locations", "*", "/", "@", "override", "public", "located", "file", "status", "next", "(", ")", "throws", "i", "o", "exception", "{", "if", "(", "has", "next", "(", ")", ")", "{", "located", "file", "status", "result", "=", "cur", "file", ";", "cur", "file", "=", "null", ";", "return", "result", ";", "}", "throw", "new", "java", "util", "no", "such", "element", "exception", "(", "\"", "no", "more", "entry", "in", "\"", "+", "f", ")", ";", "}", "}", ";", "}" ]
[ "helper", "method", "to", "set", "api", "key", "prefix", "for", "the", "first", "api", "key", "authentication" ]
[ "public", "void", "set", "api", "key", "prefix", "(", "string", "api", "key", "prefix", ")", "{", "for", "(", "authentication", "auth", ":", "authentications", "values", "(", ")", ")", "{", "if", "(", "auth", "instanceof", "api", "key", "auth", ")", "{", "(", "(", "api", "key", "auth", ")", "auth", ")", "set", "api", "key", "prefix", "(", "api", "key", "prefix", ")", ";", "return", ";", "}", "}", "throw", "new", "runtime", "exception", "(", "\"", "no", "api", "key", "authentication", "configured", "!", "\"", ")", ";", "}" ]
[ "test", "the", "property", "'", "file", "'" ]
[ "public", "void", "file", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "file", "}" ]
[ "returns", "an", "id", "associated", "with", "this", "searcher", "if", "exists", "two", "searchers", "with", "the", "same", "searcher", "id", "must", "have", "identical", "lucene", "level", "indices", "(", "i", "e", ",", "identical", "segments", "with", "same", "docs", "using", "same", "doc", "-", "ids", ")" ]
[ "public", "string", "get", "searcher", "id", "(", ")", "{", "return", "null", ";", "}" ]
[ "get", "the", "map", "task", "'", "s", "debug", "script" ]
[ "public", "string", "get", "map", "debug", "script", "(", ")", "{", "return", "get", "(", "job", "context", "map", "debug", "script", ")", ";", "}" ]
[ "clears", "disk", "cache" ]
[ "public", "void", "clear", "disc", "cache", "(", ")", "{", "clear", "disk", "cache", "(", ")", ";", "}" ]
[ "checks", "if", "all", "configurations", "in", "{", "@", "code", "configs", "}", "are", "in", "a", "{", "@", "link", "rule", "stop", "state", "}", "configurations", "meeting", "this", "condition", "have", "reached", "the", "end", "of", "the", "decision", "rule", "(", "local", "context", ")", "or", "end", "of", "start", "rule", "(", "full", "context", ")" ]
[ "public", "static", "boolean", "all", "configs", "in", "rule", "stop", "states", "(", "a", "t", "n", "config", "set", "configs", ")", "{", "for", "(", "a", "t", "n", "config", "config", ":", "configs", ")", "{", "if", "(", "!", "(", "config", "state", "instanceof", "rule", "stop", "state", ")", ")", "{", "return", "false", ";", "}", "}", "return", "true", ";", "}" ]
[ "add", "handlers", "to", "support", "custom", "controller", "method", "return", "value", "types", "using", "this", "option", "does", "not", "override", "the", "built", "-", "in", "support", "for", "handling", "return", "values", "to", "customize", "the", "built", "-", "in", "support", "for", "handling", "return", "values", ",", "configure", "request", "mapping", "handler", "adapter", "directly" ]
[ "default", "void", "add", "return", "value", "handlers", "(", "list", "<", "handler", "method", "return", "value", "handler", ">", "handlers", ")", "{", "}" ]
[ "perform", "resource", "checks", "and", "cache", "the", "results" ]
[ "void", "check", "available", "resources", "(", ")", "{", "long", "resource", "check", "time", "=", "monotonic", "now", "(", ")", ";", "preconditions", "check", "state", "(", "nn", "resource", "checker", "!", "=", "null", ",", "\"", "nn", "resource", "checker", "not", "initialized", "\"", ")", ";", "has", "resources", "available", "=", "nn", "resource", "checker", "has", "available", "disk", "space", "(", ")", ";", "resource", "check", "time", "=", "monotonic", "now", "(", ")", "-", "resource", "check", "time", ";", "name", "node", "get", "name", "node", "metrics", "(", ")", "add", "resource", "check", "time", "(", "resource", "check", "time", ")", ";", "}" ]
[ "get", "attribute", "integer" ]
[ "public", "integer", "get", "attribute", "integer", "(", ")", "{", "return", "attribute", "integer", ";", "}" ]
[ "set", "the", "login", "to", "use", "when", "creating", "connections", "to", "the", "stomp", "broker", "on", "behalf", "of", "connected", "clients", "by", "default", "this", "is", "set", "to", "\"", "guest", "\"" ]
[ "public", "stomp", "broker", "relay", "registration", "set", "client", "login", "(", "string", "login", ")", "{", "assert", "has", "text", "(", "login", ",", "\"", "client", "login", "must", "not", "be", "empty", "\"", ")", ";", "this", "client", "login", "=", "login", ";", "return", "this", ";", "}" ]
[ "returns", "the", "height", "that", "will", "satisfy", "the", "width", "to", "height", "aspect", "ratio", ",", "keeping", "the", "given", "width", "fixed" ]
[ "int", "calculate", "height", "(", "int", "width", ",", "double", "ratio", ")", "{", "if", "(", "ratio", "=", "=", "0", ")", "{", "return", "0", ";", "}", "return", "(", "int", ")", "math", "round", "(", "width", "/", "ratio", ")", ";", "}" ]
[ "{", "@", "inherit", "doc", "}", "this", "action", "is", "implemented", "by", "calling", "{", "@", "link", "lexer", "#", "more", "}" ]
[ "public", "void", "execute", "(", "lexer", "lexer", ")", "{", "lexer", "more", "(", ")", ";", "}" ]
[ "the", "cause", "for", "this", "index", "template", "creation" ]
[ "public", "put", "index", "template", "request", "cause", "(", "string", "cause", ")", "{", "this", "cause", "=", "cause", ";", "return", "this", ";", "}" ]
[ "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", "\"", ")", ";", "}" ]
[ "writes", "the", "given", "float", "to", "the", "current", "position", "and", "increases", "the", "position", "by", "4", "the", "float", "is", "converted", "to", "bytes", "using", "the", "current", "byte", "order" ]
[ "public", "abstract", "byte", "buffer", "put", "float", "(", "float", "value", ")", ";" ]
[ "makes", "the", "cursor", "controller", "visible", "on", "screen", "will", "be", "drawn", "by", "{", "@", "link", "#", "draw", "(", "canvas", ")", "}", "see", "also", "{", "@", "link", "#", "hide", "(", ")", "}" ]
[ "void", "show", "(", ")", ";" ]
[ "get", "array", "array", "of", "model" ]
[ "public", "list", "<", "list", "<", "read", "only", "first", ">", ">", "get", "array", "array", "of", "model", "(", ")", "{", "return", "array", "array", "of", "model", ";", "}" ]
[ "attempt", "to", "drop", "the", "capability", "to", "execute", "for", "the", "process", "this", "is", "best", "effort", "and", "os", "and", "architecture", "dependent", "it", "may", "throw", "any", "throwable" ]
[ "static", "int", "init", "(", "path", "tmp", "file", ")", "throws", "exception", "{", "if", "(", "constants", "linux", ")", "{", "return", "linux", "impl", "(", ")", ";", "}", "else", "if", "(", "constants", "mac", "os", "x", ")", "{", "/", "/", "try", "to", "enable", "both", "mechanisms", "if", "possible", "bsd", "impl", "(", ")", ";", "mac", "impl", "(", "tmp", "file", ")", ";", "return", "1", ";", "}", "else", "if", "(", "constants", "sun", "os", ")", "{", "solaris", "impl", "(", ")", ";", "return", "1", ";", "}", "else", "if", "(", "constants", "free", "bsd", "|", "|", "openbsd", ")", "{", "bsd", "impl", "(", ")", ";", "return", "1", ";", "}", "else", "if", "(", "constants", "windows", ")", "{", "windows", "impl", "(", ")", ";", "return", "1", ";", "}", "else", "{", "throw", "new", "unsupported", "operation", "exception", "(", "\"", "syscall", "filtering", "not", "supported", "for", "os", ":", "'", "\"", "+", "constants", "os", "name", "+", "\"", "'", "\"", ")", ";", "}", "}" ]
[ "close", "and", "clean" ]
[ "public", "void", "close", "and", "clean", "(", ")", "throws", "transaction", "exception", "{", "close", "(", ")", ";", "clean", "(", ")", ";", "}" ]
[ "returns", "whether", "a", "cross", "-", "origin", "request", "will", "include", "credentials", "by", "default", "false" ]
[ "public", "boolean", "get", "include", "credentials", "(", ")", "{", "return", "include", "credentials", ";", "}" ]
[ "gets", "the", "longitude", "for", "the", "given", "point" ]
[ "public", "static", "double", "get", "longitude", "(", "point", "location", ")", "{", "return", "location", "get", "longitude", "(", ")", "/", "coord", "factor", ";", "}" ]
[ "find", "all", "the", "tester", "annotations", "declared", "on", "a", "tester", "class", "or", "method" ]
[ "public", "static", "iterable", "<", "annotation", ">", "get", "tester", "annotations", "(", "annotated", "element", "class", "or", "method", ")", "{", "synchronized", "(", "annotation", "cache", ")", "{", "list", "<", "annotation", ">", "annotations", "=", "annotation", "cache", "get", "(", "class", "or", "method", ")", ";", "if", "(", "annotations", "=", "=", "null", ")", "{", "annotations", "=", "new", "array", "list", "<", ">", "(", ")", ";", "for", "(", "annotation", "a", ":", "class", "or", "method", "get", "declared", "annotations", "(", ")", ")", "{", "if", "(", "a", "annotation", "type", "(", ")", "is", "annotation", "present", "(", "tester", "annotation", "class", ")", ")", "{", "annotations", "add", "(", "a", ")", ";", "}", "}", "annotations", "=", "collections", "unmodifiable", "list", "(", "annotations", ")", ";", "annotation", "cache", "put", "(", "class", "or", "method", ",", "annotations", ")", ";", "}", "return", "annotations", ";", "}", "}" ]
[ "get", "the", "cached", "block", "which", "has", "an", "entry", "-", "point", "of", "addr" ]
[ "code", "block", "get", "block", "with", "entry", "at", "(", "address", "addr", ")", "{", "object", "[", "]", "blocks", "=", "get", "objects", "(", "addr", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "blocks", "length", ";", "i", "+", "+", ")", "{", "code", "block", "block", "=", "(", "code", "block", ")", "blocks", "[", "i", "]", ";", "address", "starts", "[", "]", "=", "block", "get", "start", "addresses", "(", ")", ";", "for", "(", "int", "j", "=", "0", ";", "j", "<", "starts", "length", ";", "j", "+", "+", ")", "{", "if", "(", "starts", "[", "j", "]", "equals", "(", "addr", ")", ")", "{", "return", "block", ";", "}", "}", "}", "return", "null", ";", "}" ]
[ "adds", "a", "global", "{", "@", "link", "request", "listener", "}", "that", "will", "be", "added", "to", "every", "request", "started", "with", "glide", "multiple", "{", "@", "link", "request", "listener", "}", "s", "can", "be", "added", "here", ",", "in", "{", "@", "link", "request", "manager", "}", "scopes", "or", "to", "individual", "{", "@", "link", "request", "builder", "}", "s", "{", "@", "link", "request", "listener", "}", "s", "are", "called", "in", "the", "order", "they", "'", "re", "added", "even", "if", "an", "earlier", "{", "@", "link", "request", "listener", "}", "returns", "{", "@", "code", "true", "}", "from", "{", "@", "link", "request", "listener", "#", "on", "load", "failed", "(", "glide", "exception", ",", "object", ",", "target", ",", "boolean", ")", "}", "or", "{", "@", "link", "request", "listener", "#", "on", "resource", "ready", "(", "object", ",", "object", ",", "target", ",", "data", "source", ",", "boolean", ")", "}", ",", "it", "will", "not", "prevent", "subsequent", "{", "@", "link", "request", "listener", "}", "s", "from", "being", "called", "because", "glide", "requests", "can", "be", "started", "for", "any", "number", "of", "individual", "resource", "types", ",", "any", "listener", "added", "here", "has", "to", "accept", "any", "generic", "resource", "type", "in", "{", "@", "link", "request", "listener", "#", "on", "resource", "ready", "(", "object", ",", "object", ",", "target", ",", "data", "source", ",", "boolean", ")", "}", "if", "you", "must", "base", "the", "behavior", "of", "the", "listener", "on", "the", "resource", "type", ",", "you", "will", "need", "to", "use", "{", "@", "code", "instanceof", "}", "to", "do", "so", "it", "'", "s", "not", "safe", "to", "cast", "resource", "types", "without", "first", "checking", "with", "{", "@", "code", "instanceof", "}" ]
[ "public", "glide", "builder", "add", "global", "request", "listener", "(", "@", "non", "null", "request", "listener", "<", "object", ">", "listener", ")", "{", "if", "(", "default", "request", "listeners", "=", "=", "null", ")", "{", "default", "request", "listeners", "=", "new", "array", "list", "<", ">", "(", ")", ";", "}", "default", "request", "listeners", "add", "(", "listener", ")", ";", "return", "this", ";", "}" ]
[ "predicate", "to", "verify", "login", "details", "are", "defined" ]
[ "public", "boolean", "has", "login", "(", ")", "{", "return", "string", "utils", "is", "not", "empty", "(", "user", ")", ";", "}" ]
[ "uploads", "an", "image", "(", "required", ")" ]
[ "public", "model", "api", "response", "upload", "file", "with", "required", "file", "(", "long", "pet", "id", ",", "file", "required", "file", ",", "string", "additional", "metadata", ")", "throws", "api", "exception", "{", "api", "response", "<", "model", "api", "response", ">", "local", "var", "response", "=", "upload", "file", "with", "required", "file", "with", "http", "info", "(", "pet", "id", ",", "required", "file", ",", "additional", "metadata", ")", ";", "return", "local", "var", "response", "get", "data", "(", ")", ";", "}" ]
[ "apply", "this", "diff", "to", "previous", "state", "in", "order", "to", "obtain", "current", "state" ]
[ "public", "list", "<", "e", ">", "apply", "2", "previous", "(", "final", "list", "<", "e", ">", "previous", ")", "{", "return", "apply", "2", "previous", "(", "previous", ",", "get", "created", "unmodifiable", "(", ")", ",", "get", "deleted", "unmodifiable", "(", ")", ")", ";", "}" ]
[ "configures", "the", "{", "@", "link", "s", "s", "l", "i", "o", "session", "strategy", "}", "to", "use", "relies", "on", "{", "@", "link", "#", "register", "setting", "validators", "(", "cluster", "service", ",", "s", "s", "l", "service", ")", "}", "to", "prevent", "invalid", "usage", "of", "secure", "settings", "in", "the", "ssl", "strategy" ]
[ "private", "static", "s", "s", "l", "i", "o", "session", "strategy", "configure", "ssl", "strategy", "(", "final", "settings", "ssl", "settings", ",", "final", "setting", "<", "settings", ">", "concrete", "setting", ",", "final", "s", "s", "l", "service", "ssl", "service", ")", "{", "final", "s", "s", "l", "i", "o", "session", "strategy", "ssl", "strategy", ";", "if", "(", "s", "s", "l", "configuration", "settings", "without", "prefix", "(", ")", "get", "secure", "settings", "in", "use", "(", "ssl", "settings", ")", "is", "empty", "(", ")", ")", "{", "/", "/", "this", "configuration", "does", "not", "use", "secure", "settings", ",", "so", "it", "is", "possible", "that", "is", "has", "been", "dynamically", "updated", "/", "/", "we", "need", "to", "load", "a", "new", "ssl", "strategy", "in", "case", "these", "settings", "differ", "from", "the", "ones", "that", "the", "ssl", "service", "was", "configured", "with", "ssl", "strategy", "=", "ssl", "service", "ssl", "i", "o", "session", "strategy", "(", "ssl", "settings", ")", ";", "}", "else", "{", "/", "/", "this", "configuration", "uses", "secure", "settings", "we", "cannot", "load", "a", "new", "ssl", "strategy", ",", "as", "the", "secure", "settings", "have", "already", "been", "closed", "/", "/", "due", "to", "#", "register", "setting", "validators", "we", "know", "that", "the", "settings", "not", "been", "dynamically", "updated", ",", "and", "the", "pre", "-", "configured", "strategy", "/", "/", "is", "still", "the", "correct", "configuration", "for", "use", "in", "this", "exporter", "final", "s", "s", "l", "configuration", "ssl", "configuration", "=", "ssl", "service", "get", "s", "s", "l", "configuration", "(", "concrete", "setting", "get", "key", "(", ")", ")", ";", "ssl", "strategy", "=", "ssl", "service", "ssl", "i", "o", "session", "strategy", "(", "ssl", "configuration", ")", ";", "}", "return", "ssl", "strategy", ";", "}" ]
[ "get", "photo", "urls" ]
[ "public", "list", "<", "string", ">", "get", "photo", "urls", "(", ")", "{", "return", "photo", "urls", ";", "}" ]
[ "closes", "the", "current", "{", "@", "code", "zip", "entry", "}", ",", "if", "any", ",", "and", "the", "underlying", "output", "stream", "if", "the", "stream", "is", "already", "closed", "this", "method", "does", "nothing" ]
[ "public", "void", "close", "(", ")", "throws", "i", "o", "exception", "{", "/", "/", "don", "'", "t", "call", "super", "close", "(", ")", "because", "that", "calls", "finish", "(", ")", "conditionally", "if", "(", "!", "closed", ")", "{", "finish", "(", ")", ";", "def", "end", "(", ")", ";", "out", "close", "(", ")", ";", "out", "=", "null", ";", "closed", "=", "true", ";", "}", "}" ]
[ "reloads", "this", "job", "from", "the", "disk", "exposed", "through", "cli", "as", "well", "todo", ":", "think", "about", "exposing", "this", "to", "ui" ]
[ "public", "void", "do", "reload", "(", ")", "throws", "i", "o", "exception", "{", "check", "permission", "(", "configure", ")", ";", "/", "/", "try", "to", "reflect", "the", "changes", "by", "reloading", "get", "config", "file", "(", ")", "unmarshal", "(", "this", ")", ";", "items", "while", "updating", "by", "xml", "(", "new", "not", "really", "role", "sensitive", "callable", "<", "void", ",", "i", "o", "exception", ">", "(", ")", "{", "@", "override", "public", "void", "call", "(", ")", "throws", "i", "o", "exception", "{", "on", "load", "(", "get", "parent", "(", ")", ",", "get", "root", "dir", "(", ")", "get", "name", "(", ")", ")", ";", "return", "null", ";", "}", "}", ")", ";", "jenkins", "get", "(", ")", "rebuild", "dependency", "graph", "async", "(", ")", ";", "saveable", "listener", "fire", "on", "change", "(", "this", ",", "get", "config", "file", "(", ")", ")", ";", "}" ]
[ "apply", "the", "specified", "{", "@", "code", "value", "}", "across", "the", "{", "@", "code", "list", "}", "of", "views", "using", "the", "{", "@", "code", "property", "}" ]
[ "public", "static", "<", "t", "extends", "view", ",", "v", ">", "void", "set", "(", "@", "non", "null", "list", "<", "t", ">", "list", ",", "@", "non", "null", "property", "<", "?", "super", "t", ",", "v", ">", "setter", ",", "@", "nullable", "v", "value", ")", "{", "/", "/", "noinspection", "for", "loop", "replaceable", "by", "for", "each", "for", "(", "int", "i", "=", "0", ",", "count", "=", "list", "size", "(", ")", ";", "i", "<", "count", ";", "i", "+", "+", ")", "{", "setter", "set", "(", "list", "get", "(", "i", ")", ",", "value", ")", ";", "}", "}" ]
[ "called", "when", "the", "state", "changes" ]
[ "void", "on", "state", "changed", "(", "@", "view", "mode", "int", "new", "state", ")", ";" ]
[ "creates", "a", "{", "@", "link", "paired", "stats", "accumulator", "}", "filled", "with", "the", "given", "lists", "of", "{", "@", "code", "x", "}", "and", "{", "@", "code", "y", "}", "values", ",", "which", "must", "be", "of", "the", "same", "size", ",", "added", "in", "groups", "of", "{", "@", "code", "partition", "size", "}", "using", "{", "@", "link", "paired", "stats", "accumulator", "#", "add", "all", "(", "paired", "stats", ")", "}" ]
[ "static", "paired", "stats", "accumulator", "create", "partitioned", "filled", "paired", "stats", "accumulator", "(", "list", "<", "double", ">", "x", "values", ",", "list", "<", "double", ">", "y", "values", ",", "int", "partition", "size", ")", "{", "check", "argument", "(", "x", "values", "size", "(", ")", "=", "=", "y", "values", "size", "(", ")", ")", ";", "check", "argument", "(", "partition", "size", ">", "0", ")", ";", "paired", "stats", "accumulator", "accumulator", "=", "new", "paired", "stats", "accumulator", "(", ")", ";", "list", "<", "list", "<", "double", ">", ">", "x", "partitions", "=", "lists", "partition", "(", "x", "values", ",", "partition", "size", ")", ";", "list", "<", "list", "<", "double", ">", ">", "y", "partitions", "=", "lists", "partition", "(", "y", "values", ",", "partition", "size", ")", ";", "for", "(", "int", "index", "=", "0", ";", "index", "<", "x", "partitions", "size", "(", ")", ";", "index", "+", "+", ")", "{", "accumulator", "add", "all", "(", "create", "paired", "stats", "of", "(", "x", "partitions", "get", "(", "index", ")", ",", "y", "partitions", "get", "(", "index", ")", ")", ")", ";", "}", "return", "accumulator", ";", "}" ]
[ "returns", "the", "unsigned", "{", "@", "code", "byte", "}", "value", "represented", "by", "a", "string", "with", "the", "given", "radix" ]
[ "public", "static", "byte", "parse", "unsigned", "byte", "(", "string", "string", ",", "int", "radix", ")", "{", "int", "parse", "=", "integer", "parse", "int", "(", "check", "not", "null", "(", "string", ")", ",", "radix", ")", ";", "/", "/", "we", "need", "to", "throw", "a", "number", "format", "exception", ",", "so", "we", "have", "to", "duplicate", "checked", "cast", "=", "(", "if", "(", "parse", ">", ">", "byte", "size", "=", "=", "0", ")", "{", "return", "(", "byte", ")", "parse", ";", "}", "else", "{", "throw", "new", "number", "format", "exception", "(", "\"", "out", "of", "range", ":", "\"", "+", "parse", ")", ";", "}", "}" ]
[ "get", "current", "user", "'", "s", "id" ]
[ "string", "get", "id", "(", ")", ";" ]
[ "restrict", "the", "resulting", "differences", "to", "the", "indicated", "address", "set" ]
[ "public", "void", "restrict", "results", "(", "address", "set", "view", "p", "1", "address", "set", ",", "task", "monitor", "monitor", ")", "{", "merge", "engine", "restrict", "results", "(", "p", "1", "address", "set", ")", ";", "differences", "changed", "(", "monitor", ")", ";", "}" ]
[ "uri", "for", "source", "document", "or", "msg" ]
[ "q", "$", "cite", "(", "string", "uri", ")", ";" ]
[ "late", "flushed", "data", "on", "a", "v", "1", "v", "1" ]
[ "public", "void", "late", "remote", "endpoint", "ca", "(", ")", "{", "span", "v", "2", "=", "span", "new", "builder", "(", ")", "trace", "id", "(", "\"", "1", "\"", ")", "id", "(", "\"", "2", "\"", ")", "kind", "(", "kind", "server", ")", "remote", "endpoint", "(", "frontend", ")", "build", "(", ")", ";", "v", "1", "span", "v", "1", "=", "v", "1", "span", "new", "builder", "(", ")", "trace", "id", "(", "1l", ")", "id", "(", "2l", ")", "add", "binary", "annotation", "(", "\"", "ca", "\"", ",", "frontend", ")", "build", "(", ")", ";", "assert", "that", "(", "v", "2", "span", "converter", "convert", "(", "v", "2", ")", ")", "using", "recursive", "comparison", "(", ")", "is", "equal", "to", "(", "v", "1", ")", ";", "assert", "that", "(", "v", "1", "span", "converter", "convert", "(", "v", "1", ")", ")", "contains", "exactly", "(", "v", "2", ")", ";", "}" ]
[ "get", "the", "system", "properties" ]
[ "public", "configuration", "get", "system", "properties", "(", ")", "{", "return", "system", "properties", ";", "}" ]
[ "recover", "the", "shortest", "paths", "from", "the", "source", "to", "the", "given", "destination", ",", "if", "it", "is", "reachable" ]
[ "public", "collection", "<", "deque", "<", "e", ">", ">", "compute", "optimal", "paths", "to", "(", "v", "dst", ")", "{", "set", "<", "deque", "<", "e", ">", ">", "paths", "=", "new", "hash", "set", "<", ">", "(", ")", ";", "add", "paths", "to", "(", "paths", ",", "dst", ")", ";", "return", "paths", ";", "}" ]
[ "gets", "the", "name", "of", "the", "templating", "engine", "to", "target", "this", "option", "allows", "a", "user", "to", "target", "an", "engine", "which", "differs", "from", "the", "generator", "default", ",", "or", "to", "refer", "to", "their", "own", "fully", "qualified", "type", "name", "of", "a", "custom", "template", "engine", "adapter" ]
[ "public", "string", "get", "templating", "engine", "name", "(", ")", "{", "return", "templating", "engine", "name", ";", "}" ]
[ "get", "a", "delegation", "token", "by", "invoking", "{", "@", "link", "custom", "delegation", "token", "manager", "#", "get", "delegation", "token", "(", "string", ")", "}", "if", "the", "token", "returned", "already", "has", "a", "kind", ";", "that", "is", "used", "if", "not", ",", "then", "the", "token", "kind", "is", "set", "to", "{", "@", "link", "abfs", "delegation", "token", "identifier", "#", "token", "kind", "}", ",", "which", "implicitly", "resets", "any", "token", "renewer", "class" ]
[ "public", "token", "<", "delegation", "token", "identifier", ">", "get", "delegation", "token", "(", "string", "renewer", ")", "throws", "i", "o", "exception", "{", "log", "debug", "(", "\"", "requesting", "delegation", "token", "for", "{", "}", "\"", ",", "renewer", ")", ";", "token", "<", "delegation", "token", "identifier", ">", "token", "=", "token", "manager", "get", "delegation", "token", "(", "renewer", ")", ";", "if", "(", "token", "get", "kind", "(", ")", "=", "=", "null", ")", "{", "/", "/", "if", "a", "token", "type", "is", "not", "set", ",", "use", "the", "default", "/", "/", "note", ":", "this", "also", "sets", "the", "renewer", "to", "null", "token", "set", "kind", "(", "abfs", "delegation", "token", "identifier", "token", "kind", ")", ";", "}", "return", "token", ";", "}" ]
[ "stops", "and", "removes", "all", "volume", "scanners", "this", "function", "is", "called", "on", "shutdown", "it", "will", "return", "even", "if", "some", "of", "the", "scanners", "don", "'", "t", "terminate", "in", "time", "since", "the", "scanners", "are", "daemon", "threads", "and", "do", "not", "alter", "the", "block", "content", ",", "it", "is", "safe", "to", "ignore", "such", "conditions", "on", "shutdown" ]
[ "public", "synchronized", "void", "remove", "all", "volume", "scanners", "(", ")", "{", "for", "(", "entry", "<", "string", ",", "volume", "scanner", ">", "entry", ":", "scanners", "entry", "set", "(", ")", ")", "{", "entry", "get", "value", "(", ")", "shutdown", "(", ")", ";", "}", "for", "(", "entry", "<", "string", ",", "volume", "scanner", ">", "entry", ":", "scanners", "entry", "set", "(", ")", ")", "{", "uninterruptibles", "join", "uninterruptibly", "(", "entry", "get", "value", "(", ")", ",", "get", "join", "volume", "scanners", "time", "out", "ms", "(", ")", ",", "time", "unit", "milliseconds", ")", ";", "}", "scanners", "clear", "(", ")", ";", "}" ]
[ "write", "header", ",", "take", "version", "as", "input" ]
[ "public", "void", "header", "(", "string", "version", ")", "{", "out", "print", "(", "\"", "<", "?", "xml", "version", "=", "\\", "\"", "\"", ")", ";", "out", "print", "(", "version", ")", ";", "out", "println", "(", "\"", "\\", "\"", "?", ">", "\"", ")", ";", "out", "flush", "(", ")", ";", "tags", "written", "+", "+", ";", "}" ]
[ "releases", "any", "resources", "being", "used" ]
[ "public", "void", "destroy", "(", ")", "{", "keystores", "factory", "destroy", "(", ")", ";", "}" ]
[ "test", "the", "property", "'", "name", "'" ]
[ "public", "void", "name", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "name", "}" ]
[ "enable", "or", "disable", "cubemap", "seamless", "feature", "default", "is", "true", "if", "supported", "should", "only", "be", "called", "if", "this", "feature", "is", "supported", "(", "see", "{", "@", "link", "#", "supports", "cube", "map", "seamless", "(", ")", "}", ")" ]
[ "public", "void", "enable", "cube", "map", "seamless", "(", "boolean", "enable", ")", "{", "if", "(", "enable", ")", "{", "gl", "2", "0", "gl", "enable", "(", "gl32", "gl", "texture", "cube", "map", "seamless", ")", ";", "}", "else", "{", "gl", "2", "0", "gl", "disable", "(", "gl32", "gl", "texture", "cube", "map", "seamless", ")", ";", "}", "}" ]
[ "refreshes", "the", "left", "side", "of", "this", "panel" ]
[ "public", "void", "refresh", "left", "panel", "(", ")", "{", "refresh", "panel", "(", "left", ")", ";", "}" ]