Anonymous2023/KGSum · Datasets at Hugging Face

docstring_tokens list	code_tokens list
[ "notification", "from", "the", "program", "domain", "object", "change", "listener", "that", "a", "fragment", "was", "moved", ";", "update", "all", "the", "view", "maps" ]	[ "void", "fragment", "moved", "(", ")", "{", "iterator", "<", "string", ">", "iter", "=", "provider", "map", "key", "set", "(", ")", "iterator", "(", ")", ";", "while", "(", "iter", "has", "next", "(", ")", ")", "{", "string", "tree", "name", "=", "iter", "next", "(", ")", ";", "tree", "view", "provider", "provider", "=", "provider", "map", "get", "(", "tree", "name", ")", ";", "provider", "notify", "listeners", "(", ")", ";", "}", "}" ]
[ "sets", "the", "state", "of", "the", "container", "in", "the", "container", "spec", "it", "is", "write", "protected" ]	[ "public", "void", "set", "container", "state", "(", "container", "state", "state", ")", "{", "this", "write", "lock", "lock", "(", ")", ";", "try", "{", "container", "state", "cur", "state", "=", "container", "spec", "get", "state", "(", ")", ";", "if", "(", "!", "cur", "state", "equals", "(", "state", ")", ")", "{", "container", "spec", "set", "state", "(", "state", ")", ";", "log", "info", "(", "\"", "{", "}", "spec", "state", "state", "changed", "from", "{", "}", "-", ">", "{", "}", "\"", ",", "get", "comp", "instance", "id", "(", ")", ",", "cur", "state", ",", "state", ")", ";", "}", "}", "finally", "{", "this", "write", "lock", "unlock", "(", ")", ";", "}", "}" ]
[ "return", "true", "if", "this", "is", "a", "server", "-", "side", "channel", "and", "the", "connected", "client", "has", "indicated", "that", "it", "supports", "re", "-", "authentication", ",", "otherwise", "false" ]	[ "boolean", "connected", "client", "supports", "reauthentication", "(", ")", "{", "return", "authenticator", "connected", "client", "supports", "reauthentication", "(", ")", ";", "}" ]
[ "get", "boolean", "from", "segments" ]	[ "public", "static", "boolean", "get", "boolean", "(", "memory", "segment", "[", "]", "segments", ",", "int", "offset", ")", "{", "if", "(", "in", "first", "segment", "(", "segments", ",", "offset", ",", "1", ")", ")", "{", "return", "segments", "[", "0", "]", "get", "boolean", "(", "offset", ")", ";", "}", "else", "{", "return", "get", "boolean", "multi", "segments", "(", "segments", ",", "offset", ")", ";", "}", "}" ]
[ "setup", "the", "support", "for", "building", "python" ]	[ "public", "abstract", "void", "setup", "(", "mock", "tools", "config", "config", ")", "throws", "i", "o", "exception", ";" ]
[ "associates", "all", "of", "{", "@", "code", "map", "'", "s", "}", "keys", "and", "values", "in", "the", "built", "map", "duplicate", "keys", "are", "not", "allowed", ",", "and", "will", "cause", "{", "@", "link", "#", "build", "}", "to", "fail" ]	[ "public", "<", "t", "extends", "b", ">", "builder", "<", "b", ">", "put", "all", "(", "map", "<", "?", "extends", "class", "<", "?", "extends", "t", ">", ",", "?", "extends", "t", ">", "map", ")", "{", "for", "(", "entry", "<", "?", "extends", "class", "<", "?", "extends", "t", ">", ",", "?", "extends", "t", ">", "entry", ":", "map", "entry", "set", "(", ")", ")", "{", "class", "<", "?", "extends", "t", ">", "type", "=", "entry", "get", "key", "(", ")", ";", "t", "value", "=", "entry", "get", "value", "(", ")", ";", "map", "builder", "put", "(", "type", ",", "cast", "(", "type", ",", "value", ")", ")", ";", "}", "return", "this", ";", "}" ]
[ "{", "@", "inherit", "doc", "}" ]	[ "public", "output", "committer", "get", "output", "committer", "(", "task", "attempt", "context", "context", ")", "throws", "i", "o", "exception", "{", "return", "new", "copy", "committer", "(", "get", "output", "path", "(", "context", ")", ",", "context", ")", ";", "}" ]
[ "gets", "the", "intersected", "set", "of", "addresses", "between", "a", "mapped", "memory", "block", ",", "and", "some", "other", "address", "set" ]	[ "private", "address", "set", "get", "mapped", "intersection", "(", "memory", "block", "mapped", "block", ",", "address", "set", "set", ")", "{", "address", "set", "mapped", "intersection", "=", "new", "address", "set", "(", ")", ";", "list", "<", "memory", "block", "source", "info", ">", "source", "infos", "=", "mapped", "block", "get", "source", "infos", "(", ")", ";", "/", "/", "mapped", "blocks", "can", "only", "ever", "have", "one", "source", "info", "memory", "block", "source", "info", "info", "=", "source", "infos", "get", "(", "0", ")", ";", "address", "range", "range", "=", "info", "get", "mapped", "range", "(", ")", "get", "(", ")", ";", "address", "set", "resolved", "intersection", "=", "set", "intersect", "(", "new", "address", "set", "(", "range", ")", ")", ";", "for", "(", "address", "range", "resolved", "range", ":", "resolved", "intersection", ")", "{", "address", "range", "mapped", "range", "=", "get", "mapped", "range", "(", "mapped", "block", ",", "resolved", "range", ")", ";", "if", "(", "mapped", "range", "!", "=", "null", ")", "{", "mapped", "intersection", "add", "(", "mapped", "range", ")", ";", "}", "}", "return", "mapped", "intersection", ";", "}" ]
[ "this", "test", "validates", "that", "an", "index", "which", "is", "out", "of", "bounds", "throws", "an", "index", "out", "of", "bounds", "exception" ]	[ "public", "void", "test", "out", "of", "tuple", "bounds", "dataset", "1", "(", ")", "{", "final", "execution", "environment", "env", "=", "execution", "environment", "get", "execution", "environment", "(", ")", ";", "data", "set", "<", "tuple", "5", "<", "integer", ",", "long", ",", "string", ",", "long", ",", "integer", ">", ">", "tuple", "ds", "=", "env", "from", "collection", "(", "empty", "tuple", "data", ",", "tuple", "type", "info", ")", ";", "/", "/", "should", "not", "work", ",", "key", "out", "of", "tuple", "bounds", "tuple", "ds", "min", "by", "(", "5", ")", ";", "}" ]
[ "recalculate", "queue", "usage", "ratio" ]	[ "public", "void", "recalculate", "queue", "usage", "ratio", "(", "resource", "cluster", "resource", ",", "string", "node", "partition", ")", "{", "write", "lock", "lock", "(", ")", ";", "try", "{", "resource", "usage", "queue", "resource", "usage", "=", "get", "queue", "resource", "usage", "(", ")", ";", "if", "(", "node", "partition", "=", "=", "null", ")", "{", "for", "(", "string", "partition", ":", "sets", "union", "(", "get", "queue", "capacities", "(", ")", "get", "node", "partitions", "set", "(", ")", ",", "queue", "resource", "usage", "get", "node", "partitions", "set", "(", ")", ")", ")", "{", "users", "manager", "update", "usage", "ratio", "(", "partition", ",", "cluster", "resource", ")", ";", "}", "}", "else", "{", "users", "manager", "update", "usage", "ratio", "(", "node", "partition", ",", "cluster", "resource", ")", ";", "}", "}", "finally", "{", "write", "lock", "unlock", "(", ")", ";", "}", "}" ]
[ "accepts", "and", "serves", "the", "job", "description" ]	[ "public", "void", "do", "description", "(", "stapler", "request", "req", ",", "stapler", "response", "rsp", ")", "throws", "i", "o", "exception", "{", "if", "(", "req", "get", "method", "(", ")", "equals", "(", "\"", "get", "\"", ")", ")", "{", "/", "/", "read", "rsp", "set", "content", "type", "(", "\"", "text", "/", "plain", ";", "charset", "=", "utf", "-", "8", "\"", ")", ";", "rsp", "get", "writer", "(", ")", "write", "(", "util", "fix", "null", "(", "this", "get", "description", "(", ")", ")", ")", ";", "return", ";", "}", "if", "(", "req", "get", "method", "(", ")", "equals", "(", "\"", "post", "\"", ")", ")", "{", "check", "permission", "(", "configure", ")", ";", "/", "/", "submission", "if", "(", "req", "get", "parameter", "(", "\"", "description", "\"", ")", "!", "=", "null", ")", "{", "this", "set", "description", "(", "req", "get", "parameter", "(", "\"", "description", "\"", ")", ")", ";", "rsp", "send", "error", "(", "sc", "no", "content", ")", ";", "return", ";", "}", "}", "/", "/", "huh", "?", "rsp", "send", "error", "(", "sc", "bad", "request", ")", ";", "}" ]
[ "test", "token", "serialization" ]	[ "public", "void", "test", "token", "serialization", "(", ")", "throws", "i", "o", "exception", "{", "/", "/", "get", "a", "token", "token", "<", "token", "identifier", ">", "source", "token", "=", "new", "token", "<", "token", "identifier", ">", "(", ")", ";", "source", "token", "set", "service", "(", "new", "text", "(", "\"", "service", "\"", ")", ")", ";", "/", "/", "write", "it", "to", "an", "output", "buffer", "data", "output", "buffer", "out", "=", "new", "data", "output", "buffer", "(", ")", ";", "source", "token", "write", "(", "out", ")", ";", "/", "/", "read", "the", "token", "back", "data", "input", "buffer", "in", "=", "new", "data", "input", "buffer", "(", ")", ";", "in", "reset", "(", "out", "get", "data", "(", ")", ",", "out", "get", "length", "(", ")", ")", ";", "token", "<", "token", "identifier", ">", "dest", "token", "=", "new", "token", "<", "token", "identifier", ">", "(", ")", ";", "dest", "token", "read", "fields", "(", "in", ")", ";", "assert", "true", "(", "check", "equal", "(", "source", "token", ",", "dest", "token", ")", ")", ";", "}" ]
[ "handles", "cases", "of", "updates", "involving", "initialization", ",", "resizing", ",", "creating", "new", "cells", ",", "andor", "contention", "see", "above", "for", "explanation", "this", "method", "suffers", "the", "usual", "non", "-", "modularity", "problems", "of", "optimistic", "retry", "code", ",", "relying", "on", "rechecked", "sets", "of", "reads" ]	[ "final", "void", "retry", "update", "(", "long", "x", ",", "hash", "code", "hc", ",", "boolean", "was", "uncontended", ")", "{", "int", "h", "=", "hc", "code", ";", "boolean", "collide", "=", "false", ";", "/", "/", "true", "if", "last", "slot", "nonempty", "for", "(", ";", ";", ")", "{", "cell", "[", "]", "as", ";", "cell", "a", ";", "int", "n", ";", "long", "v", ";", "if", "(", "(", "as", "=", "cells", ")", "!", "=", "null", "&", "&", "(", "n", "=", "as", "length", ")", ">", "0", ")", "{", "if", "(", "(", "a", "=", "as", "[", "(", "n", "-", "1", ")", "&", "h", "]", ")", "=", "=", "null", ")", "{", "if", "(", "busy", "=", "=", "0", ")", "{", "/", "/", "try", "to", "attach", "new", "cell", "cell", "r", "=", "new", "cell", "(", "x", ")", ";", "/", "/", "optimistically", "create", "if", "(", "busy", "=", "=", "0", "&", "&", "cas", "busy", "(", ")", ")", "{", "boolean", "created", "=", "false", ";", "try", "{", "/", "/", "recheck", "under", "lock", "cell", "[", "]", "rs", ";", "int", "m", ",", "j", ";", "if", "(", "(", "rs", "=", "cells", ")", "!", "=", "null", "&", "&", "(", "m", "=", "rs", "length", ")", ">", "0", "&", "&", "rs", "[", "j", "=", "(", "m", "-", "1", ")", "&", "h", "]", "=", "=", "null", ")", "{", "rs", "[", "j", "]", "=", "r", ";", "created", "=", "true", ";", "}", "}", "finally", "{", "busy", "=", "0", ";", "}", "if", "(", "created", ")", "{", "break", ";", "}", "continue", ";", "/", "/", "slot", "is", "now", "non", "-", "empty", "}", "}", "collide", "=", "false", ";", "}", "else", "if", "(", "!", "was", "uncontended", ")", "/", "/", "cas", "already", "known", "to", "fail", "{", "was", "uncontended", "=", "true", ";", "/", "/", "continue", "after", "rehash", "}", "else", "if", "(", "a", "cas", "(", "v", "=", "a", "value", ",", "fn", "(", "v", ",", "x", ")", ")", ")", "{", "break", ";", "}", "else", "if", "(", "n", ">", "=", "ncpu", "\|", "\|", "cells", "!", "=", "as", ")", "{", "collide", "=", "false", ";", "/", "/", "at", "max", "size", "or", "stale", "}", "else", "if", "(", "!", "collide", ")", "{", "collide", "=", "true", ";", "}", "else", "if", "(", "busy", "=", "=", "0", "&", "&", "cas", "busy", "(", ")", ")", "{", "try", "{", "if", "(", "cells", "=", "=", "as", ")", "{", "/", "/", "expand", "table", "unless", "stale", "cell", "[", "]", "rs", "=", "new", "cell", "[", "n", "<", "<", "1", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "n", ";", "+", "+", "i", ")", "{", "rs", "[", "i", "]", "=", "as", "[", "i", "]", ";", "}", "cells", "=", "rs", ";", "}", "}", "finally", "{", "busy", "=", "0", ";", "}", "collide", "=", "false", ";", "continue", ";", "/", "/", "retry", "with", "expanded", "table", "}", "h", "^", "=", "h", "<", "<", "13", ";", "/", "/", "rehash", "h", "^", "=", "h", ">", ">", ">", "17", ";", "h", "^", "=", "h", "<", "<", "5", ";", "}", "else", "if", "(", "busy", "=", "=", "0", "&", "&", "cells", "=", "=", "as", "&", "&", "cas", "busy", "(", ")", ")", "{", "boolean", "init", "=", "false", ";", "try", "{", "/", "/", "initialize", "table", "if", "(", "cells", "=", "=", "as", ")", "{", "cell", "[", "]", "rs", "=", "new", "cell", "[", "2", "]", ";", "rs", "[", "h", "&", "1", "]", "=", "new", "cell", "(", "x", ")", ";", "cells", "=", "rs", ";", "init", "=", "true", ";", "}", "}", "finally", "{", "busy", "=", "0", ";", "}", "if", "(", "init", ")", "{", "break", ";", "}", "}", "else", "if", "(", "cas", "base", "(", "v", "=", "base", ",", "fn", "(", "v", ",", "x", ")", ")", ")", "{", "break", ";", "/", "/", "fall", "back", "on", "using", "base", "}", "}", "hc", "code", "=", "h", ";", "/", "/", "record", "index", "for", "next", "time", "}" ]
[ "a", "shard", "iterator", "with", "just", "this", "shard", "in", "it" ]	[ "public", "shard", "iterator", "shards", "it", "(", ")", "{", "return", "new", "plain", "shard", "iterator", "(", "shard", "id", ",", "as", "list", ")", ";", "}" ]
[ "get", "namespace", "array" ]	[ "public", "list", "<", "integer", ">", "get", "namespace", "array", "(", ")", "{", "return", "namespace", "array", ";", "}" ]
[ "set", "the", "table", "instance", "associated", "with", "this", "master", "table", "record" ]	[ "void", "set", "table", "(", "table", "table", ")", "{", "this", "table", "=", "table", ";", "}" ]
[ "use", "the", "hide", "selected", "action", "states", "to", "determine", "what", "vertices", "are", "shown", ":", "unselected", "vertices", "only", "selected", "vertices", "only", "both", "selected", "and", "unselected", "vertices", "are", "shown", "neither", "selected", "nor", "unselected", "vertices", "are", "shown" ]	[ "private", "void", "manage", "vertex", "display", "(", ")", "{", "boolean", "hide", "selected", "=", "hide", "selected", "action", "is", "selected", "(", ")", ";", "boolean", "hide", "unselected", "=", "hide", "unselected", "action", "is", "selected", "(", ")", ";", "mutable", "selected", "state", "<", "attributed", "vertex", ">", "selected", "vertex", "state", "=", "viewer", "get", "selected", "vertex", "state", "(", ")", ";", "if", "(", "hide", "selected", "&", "&", "hide", "unselected", ")", "{", "viewer", "get", "render", "context", "(", ")", "set", "vertex", "include", "predicate", "(", "v", "-", ">", "false", ")", ";", "}", "else", "if", "(", "hide", "selected", ")", "{", "viewer", "get", "render", "context", "(", ")", "set", "vertex", "include", "predicate", "(", "predicate", "not", "(", "selected", "vertex", "state", ":", ":", "is", "selected", ")", ")", ";", "}", "else", "if", "(", "hide", "unselected", ")", "{", "viewer", "get", "render", "context", "(", ")", "set", "vertex", "include", "predicate", "(", "selected", "vertex", "state", ":", ":", "is", "selected", ")", ";", "}", "else", "{", "viewer", "get", "render", "context", "(", ")", "set", "vertex", "include", "predicate", "(", "v", "-", ">", "true", ")", ";", "}", "viewer", "repaint", "(", ")", ";", "}" ]
[ "returns", "a", "predicate", "that", "evaluates", "to", "{", "@", "code", "true", "}", "if", "each", "of", "its", "components", "evaluates", "to", "{", "@", "code", "true", "}", "the", "components", "are", "evaluated", "in", "order", ",", "and", "evaluation", "will", "be", "\"", "short", "-", "circuited", "\"", "as", "soon", "as", "a", "false", "predicate", "is", "found", "it", "defensively", "copies", "the", "array", "passed", "in", ",", "so", "future", "changes", "to", "it", "won", "'", "t", "alter", "the", "behavior", "of", "this", "predicate", "if", "{", "@", "code", "components", "}", "is", "empty", ",", "the", "returned", "predicate", "will", "always", "evaluate", "to", "{", "@", "code", "true", "}" ]	[ "public", "static", "<", "t", ">", "predicate", "<", "t", ">", "and", "(", "predicate", "<", "?", "super", "t", ">", "components", ")", "{", "return", "new", "and", "predicate", "<", "t", ">", "(", "defensive", "copy", "(", "components", ")", ")", ";", "}" ]
[ "todo", ":", "based", "on", "how", "frequently", "this", "is", "called", ",", "we", "might", "want", "to", "club", "counting", "pending", "and", "active", "apps", "in", "the", "same", "method" ]	[ "public", "int", "get", "num", "active", "apps", "(", ")", "{", "int", "num", "active", "apps", "=", "0", ";", "read", "lock", "lock", "(", ")", ";", "try", "{", "for", "(", "f", "s", "app", "attempt", "attempt", ":", "runnable", "apps", ")", "{", "if", "(", "!", "attempt", "is", "pending", "(", ")", ")", "{", "num", "active", "apps", "+", "+", ";", "}", "}", "}", "finally", "{", "read", "lock", "unlock", "(", ")", ";", "}", "return", "num", "active", "apps", ";", "}" ]
[ "tests", "to", "check", "time", "spent", "on", "waiting", "for", "tasks", "to", "be", "complete", "on", "a", "blocking", "queue", "in", "{", "@", "link", "abfs", "output", "stream", "}" ]	[ "public", "void", "test", "abfs", "output", "stream", "time", "spent", "on", "wait", "task", "(", ")", "{", "describe", "(", "\"", "testing", "time", "spent", "on", "waiting", "for", "task", "to", "be", "completed", "in", "\"", "+", "\"", "abfs", "output", "stream", "\"", ")", ";", "abfs", "output", "stream", "statistics", "impl", "abfs", "output", "stream", "statistics", "=", "new", "abfs", "output", "stream", "statistics", "impl", "(", ")", ";", "/", "/", "test", "for", "initial", "value", "of", "time", "spent", "wait", "task", "assert", "equals", "(", "\"", "mismatch", "in", "time", "spent", "on", "waiting", "for", "tasks", "to", "complete", "\"", ",", "0", ",", "abfs", "output", "stream", "statistics", "get", "time", "spent", "on", "task", "wait", "(", ")", ")", ";", "abfs", "output", "stream", "statistics", "time", "spent", "task", "wait", "(", ")", ";", "/", "/", "test", "for", "one", "op", "call", "value", "of", "time", "spent", "wait", "task", "assert", "equals", "(", "\"", "mismatch", "in", "time", "spent", "on", "waiting", "for", "tasks", "to", "complete", "\"", ",", "1", ",", "abfs", "output", "stream", "statistics", "get", "time", "spent", "on", "task", "wait", "(", ")", ")", ";", "/", "/", "reset", "statistics", "for", "the", "next", "test", "abfs", "output", "stream", "statistics", "=", "new", "abfs", "output", "stream", "statistics", "impl", "(", ")", ";", "/", "", "", "entering", "multiple", "values", "for", "time", "spent", "task", "wait", "(", ")", "to", "check", "the", "", "summation", "is", "happening", "correctly", "also", "calculating", "the", "expected", "result", "", "/", "for", "(", "int", "i", "=", "0", ";", "i", "<", "operations", ";", "i", "+", "+", ")", "{", "abfs", "output", "stream", "statistics", "time", "spent", "task", "wait", "(", ")", ";", "}", "/", "", "", "test", "to", "check", "correct", "value", "of", "time", "spent", "task", "wait", "after", "operations", "", "number", "of", "op", "calls", "", "/", "assert", "equals", "(", "\"", "mismatch", "in", "time", "spent", "on", "waiting", "for", "tasks", "to", "complete", "\"", ",", "operations", ",", "abfs", "output", "stream", "statistics", "get", "time", "spent", "on", "task", "wait", "(", ")", ")", ";", "}" ]
[ "should", "the", "upper", "bound", "be", "included", "or", "not", "defaults", "to", "{", "@", "code", "true", "}" ]	[ "public", "range", "query", "builder", "include", "upper", "(", "boolean", "include", "upper", ")", "{", "this", "include", "upper", "=", "include", "upper", ";", "return", "this", ";", "}" ]
[ "puts", "a", "runtime", "[", "in", "]", "visible", "[", "type", "]", "annotations", "attribute", "containing", "this", "annotations", "and", "all", "its", "predecessors", "(", "see", "{", "@", "link", "#", "previous", "annotation", "}", "in", "the", "given", "byte", "vector", "annotations", "are", "put", "in", "the", "same", "order", "they", "have", "been", "visited" ]	[ "void", "put", "annotations", "(", "final", "int", "attribute", "name", "index", ",", "final", "byte", "vector", "output", ")", "{", "int", "attribute", "length", "=", "2", ";", "/", "/", "for", "num", "annotations", "int", "num", "annotations", "=", "0", ";", "annotation", "writer", "annotation", "writer", "=", "this", ";", "annotation", "writer", "first", "annotation", "=", "null", ";", "while", "(", "annotation", "writer", "!", "=", "null", ")", "{", "/", "/", "in", "case", "the", "user", "forgot", "to", "call", "visit", "end", "(", ")", "annotation", "writer", "visit", "end", "(", ")", ";", "attribute", "length", "+", "=", "annotation", "writer", "annotation", "length", ";", "num", "annotations", "+", "+", ";", "first", "annotation", "=", "annotation", "writer", ";", "annotation", "writer", "=", "annotation", "writer", "previous", "annotation", ";", "}", "output", "put", "short", "(", "attribute", "name", "index", ")", ";", "output", "put", "int", "(", "attribute", "length", ")", ";", "output", "put", "short", "(", "num", "annotations", ")", ";", "annotation", "writer", "=", "first", "annotation", ";", "while", "(", "annotation", "writer", "!", "=", "null", ")", "{", "output", "put", "byte", "array", "(", "annotation", "writer", "annotation", "data", ",", "0", ",", "annotation", "writer", "annotation", "length", ")", ";", "annotation", "writer", "=", "annotation", "writer", "next", "annotation", ";", "}", "}" ]
[ "sets", "the", "{", "@", "link", "sensitivity", "detector", "}", "to", "use" ]	[ "protected", "b", "header", "sensitivity", "detector", "(", "sensitivity", "detector", "header", "sensitivity", "detector", ")", "{", "enforce", "non", "codec", "constraints", "(", "\"", "header", "sensitivity", "detector", "\"", ")", ";", "this", "header", "sensitivity", "detector", "=", "check", "not", "null", "(", "header", "sensitivity", "detector", ",", "\"", "header", "sensitivity", "detector", "\"", ")", ";", "return", "self", "(", ")", ";", "}" ]
[ "return", "the", "registered", "{", "@", "link", "cors", "configuration", "}", "objects", ",", "keyed", "by", "path", "pattern" ]	[ "protected", "map", "<", "string", ",", "cors", "configuration", ">", "get", "cors", "configurations", "(", ")", "{", "map", "<", "string", ",", "cors", "configuration", ">", "configs", "=", "collection", "utils", "new", "linked", "hash", "map", "(", "this", "registrations", "size", "(", ")", ")", ";", "for", "(", "cors", "registration", "registration", ":", "this", "registrations", ")", "{", "configs", "put", "(", "registration", "get", "path", "pattern", "(", ")", ",", "registration", "get", "cors", "configuration", "(", ")", ")", ";", "}", "return", "configs", ";", "}" ]
[ "whether", "to", "ensure", "messages", "are", "received", "in", "the", "order", "of", "publication" ]	[ "public", "boolean", "is", "preserve", "publish", "order", "(", ")", "{", "return", "this", "preserve", "publish", "order", ";", "}" ]
[ "returns", "a", "frozen", "{", "@", "link", "args", "}", "representation", "corresponding", "to", "an", "already", "-", "registered", "action" ]	[ "public", "static", "args", "for", "registered", "action", "(", "command", "line", "and", "param", "file", "info", "command", "line", "and", "param", "file", "info", ",", "immutable", "set", "<", "artifact", ">", "directory", "inputs", ")", "{", "return", "new", "frozen", "args", "(", "command", "line", "and", "param", "file", "info", "command", "line", ",", "command", "line", "and", "param", "file", "info", "param", "file", "info", ",", "directory", "inputs", ")", ";", "}" ]
[ "submits", "a", "disk", "balancer", "plan", "to", "the", "datanode" ]	[ "public", "void", "submit", "disk", "balancer", "plan", "(", "string", "plan", "i", "d", ",", "long", "plan", "version", ",", "string", "plan", "file", ",", "string", "plan", "data", ",", "boolean", "skip", "date", "check", ")", "throws", "i", "o", "exception", "{", "try", "{", "submit", "disk", "balancer", "plan", "request", "proto", "request", "=", "submit", "disk", "balancer", "plan", "request", "proto", "new", "builder", "(", ")", "set", "plan", "i", "d", "(", "plan", "i", "d", ")", "set", "plan", "version", "(", "plan", "version", ")", "set", "plan", "file", "(", "plan", "file", ")", "set", "plan", "(", "plan", "data", ")", "set", "ignore", "date", "check", "(", "skip", "date", "check", ")", "build", "(", ")", ";", "rpc", "proxy", "submit", "disk", "balancer", "plan", "(", "null", "controller", ",", "request", ")", ";", "}", "catch", "(", "service", "exception", "e", ")", "{", "throw", "protobuf", "helper", "get", "remote", "exception", "(", "e", ")", ";", "}", "}" ]
[ "set", "the", "connect", "timeout", "(", "in", "milliseconds", ")", "a", "value", "of", "0", "means", "no", "timeout", ",", "otherwise", "values", "must", "be", "between", "1", "and", "{", "@", "link", "integer", "#", "max", "value", "}" ]	[ "public", "api", "client", "set", "connect", "timeout", "(", "int", "connection", "timeout", ")", "{", "this", "connection", "timeout", "=", "connection", "timeout", ";", "http", "client", "property", "(", "client", "properties", "connect", "timeout", ",", "connection", "timeout", ")", ";", "return", "this", ";", "}" ]
[ "returns", "true", "if", "the", "dashed", "-", "line", "effect", "is", "enabled", "for", "highlight", "lines", ",", "false", "if", "not", "default", ":", "disabled" ]	[ "public", "boolean", "is", "dashed", "highlight", "line", "enabled", "(", ")", "{", "return", "m", "highlight", "dash", "path", "effect", "=", "=", "null", "?", "false", ":", "true", ";", "}" ]
[ "checks", "whether", "a", "throwable", "chain", "contains", "a", "specific", "error", "message", "and", "returns", "the", "corresponding", "throwable" ]	[ "public", "static", "optional", "<", "throwable", ">", "find", "throwable", "with", "message", "(", "throwable", "throwable", ",", "string", "search", "message", ")", "{", "if", "(", "throwable", "=", "=", "null", "\|", "\|", "search", "message", "=", "=", "null", ")", "{", "return", "optional", "empty", "(", ")", ";", "}", "throwable", "t", "=", "throwable", ";", "while", "(", "t", "!", "=", "null", ")", "{", "if", "(", "t", "get", "message", "(", ")", "!", "=", "null", "&", "&", "t", "get", "message", "(", ")", "contains", "(", "search", "message", ")", ")", "{", "return", "optional", "of", "(", "t", ")", ";", "}", "else", "{", "t", "=", "t", "get", "cause", "(", ")", ";", "}", "}", "return", "optional", "empty", "(", ")", ";", "}" ]
[ "creates", "and", "returns", "a", "properly", "-", "sized", "array", "with", "the", "given", "number", "of", "buckets" ]	[ "static", "object", "create", "table", "(", "int", "buckets", ")", "{", "if", "(", "buckets", "<", "2", "\|", "\|", "buckets", ">", "ints", "max", "power", "of", "two", "\|", "\|", "integer", "highest", "one", "bit", "(", "buckets", ")", "!", "=", "buckets", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "must", "be", "power", "of", "2", "between", "2", "^", "1", "and", "2", "^", "30", ":", "\"", "+", "buckets", ")", ";", "}", "if", "(", "buckets", "<", "=", "byte", "max", "size", ")", "{", "return", "new", "byte", "[", "buckets", "]", ";", "}", "else", "if", "(", "buckets", "<", "=", "short", "max", "size", ")", "{", "return", "new", "short", "[", "buckets", "]", ";", "}", "else", "{", "return", "new", "int", "[", "buckets", "]", ";", "}", "}" ]
[ "key", "set", "add", "throws", "unsupported", "operation", "exception", "if", "no", "default", "mapped", "value" ]	[ "public", "void", "test", "add", "4", "(", ")", "{", "set", "full", "=", "map", "5", "(", ")", "key", "set", "(", ")", ";", "try", "{", "full", "add", "(", "three", ")", ";", "should", "throw", "(", ")", ";", "}", "catch", "(", "unsupported", "operation", "exception", "success", ")", "{", "}", "}" ]
[ "find", "the", "fields", "constant", "that", "matches", "name", ",", "or", "null", "if", "its", "not", "found" ]	[ "public", "static", "fields", "find", "by", "name", "(", "string", "name", ")", "{", "return", "by", "name", "get", "(", "name", ")", ";", "}" ]
[ "remove", "listener", "for", "key" ]	[ "public", "void", "un", "listen", "(", "string", "key", ",", "record", "listener", "listener", ")", "{", "notifier", "deregister", "listener", "(", "key", ",", "listener", ")", ";", "}" ]
[ "select", "the", "content", "-", "type", "header", "'", "s", "value", "from", "the", "given", "array", ":", "if", "json", "exists", "in", "the", "given", "array", ",", "use", "it", ";", "otherwise", "use", "the", "first", "one", "of", "the", "array" ]	[ "protected", "string", "select", "header", "content", "type", "(", "string", "[", "]", "content", "types", ")", "{", "if", "(", "content", "types", "length", "=", "=", "0", ")", "{", "return", "\"", "application", "/", "json", "\"", ";", "}", "for", "(", "string", "content", "type", ":", "content", "types", ")", "{", "if", "(", "is", "json", "mime", "(", "content", "type", ")", ")", "{", "return", "content", "type", ";", "}", "}", "return", "content", "types", "[", "0", "]", ";", "}" ]
[ "sets", "a", "handshake", "timeout", "for", "this", "connection", "profile" ]	[ "public", "builder", "set", "handshake", "timeout", "(", "time", "value", "handshake", "timeout", ")", "{", "if", "(", "handshake", "timeout", "millis", "(", ")", "<", "0", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "handshake", "timeout", "must", "be", "non", "-", "negative", "but", "was", ":", "\"", "+", "handshake", "timeout", ")", ";", "}", "this", "handshake", "timeout", "=", "handshake", "timeout", ";", "return", "this", ";", "}" ]
[ "returns", "the", "current", "bit", "offset" ]	[ "public", "int", "get", "position", "(", ")", "{", "return", "byte", "offset", "*", "8", "+", "bit", "offset", ";", "}" ]
[ "returns", "an", "empty", "immutable", "range", "map" ]	[ "public", "static", "<", "k", "extends", "comparable", "<", "?", ">", ",", "v", ">", "immutable", "range", "map", "<", "k", ",", "v", ">", "of", "(", ")", "{", "return", "(", "immutable", "range", "map", "<", "k", ",", "v", ">", ")", "empty", ";", "}" ]
[ "sets", "application", "id" ]	[ "public", "void", "set", "application", "id", "(", "string", "application", "id", ")", "{", "this", "application", "id", "=", "application", "id", ";", "}" ]
[ "determine", "if", "the", "components", "in", "the", "data", "type", "use", "relative", "offsets", "or", "pointers" ]	[ "protected", "final", "boolean", "is", "relative", "(", ")", "{", "return", "is", "relative", ";", "}" ]
[ "creates", "a", "new", "fid", "databse", "and", "fid", "file" ]	[ "public", "void", "create", "new", "fid", "database", "(", "file", "db", "file", ")", "throws", "i", "o", "exception", "{", "fid", "d", "b", "create", "new", "fid", "database", "(", "db", "file", ")", ";", "fid", "file", "new", "fid", "file", "=", "new", "fid", "file", "(", "this", ",", "db", "file", ",", "false", ")", ";", "load", "fid", "files", "(", ")", ";", "fid", "files", "add", "(", "new", "fid", "file", ")", ";", "save", "to", "preferences", "(", ")", ";", "notify", "listeners", "(", ")", ";", "}" ]
[ "return", "the", "expression", "string" ]	[ "public", "final", "string", "get", "expression", "string", "(", ")", "{", "return", "this", "expression", "string", ";", "}" ]
[ "the", "key", "that", "must", "be", "sent", "back", "to", "sql", "to", "access", "the", "next", "page", "of", "results", "if", "equal", "to", "\"", "\"", "then", "there", "is", "no", "next", "page" ]	[ "public", "string", "cursor", "(", ")", "{", "return", "cursor", ";", "}" ]
[ "checks", "if", "the", "given", "field", "is", "a", "valid", "pojo", "field", ":", "-", "it", "is", "public", "or", "-", "there", "are", "getter", "and", "setter", "methods", "for", "the", "field" ]	[ "private", "boolean", "is", "valid", "pojo", "field", "(", "field", "f", ",", "class", "<", "?", ">", "clazz", ",", "list", "<", "type", ">", "type", "hierarchy", ")", "{", "if", "(", "modifier", "is", "public", "(", "f", "get", "modifiers", "(", ")", ")", ")", "{", "return", "true", ";", "}", "else", "{", "boolean", "has", "getter", "=", "false", ",", "has", "setter", "=", "false", ";", "final", "string", "field", "name", "low", "=", "f", "get", "name", "(", ")", "to", "lower", "case", "(", ")", "replace", "all", "(", "\"", "\"", ",", "\"", "\"", ")", ";", "type", "field", "type", "=", "f", "get", "generic", "type", "(", ")", ";", "class", "<", "?", ">", "field", "type", "wrapper", "=", "class", "utils", "primitive", "to", "wrapper", "(", "f", "get", "type", "(", ")", ")", ";", "type", "variable", "<", "?", ">", "field", "type", "generic", "=", "null", ";", "if", "(", "field", "type", "instanceof", "type", "variable", ")", "{", "field", "type", "generic", "=", "(", "type", "variable", "<", "?", ">", ")", "field", "type", ";", "field", "type", "=", "materialize", "type", "variable", "(", "type", "hierarchy", ",", "(", "type", "variable", "<", "?", ">", ")", "field", "type", ")", ";", "}", "for", "(", "method", "m", ":", "clazz", "get", "methods", "(", ")", ")", "{", "final", "string", "method", "name", "low", "=", "m", "get", "name", "(", ")", "ends", "with", "(", "\"", "$", "eq", "\"", ")", "?", "m", "get", "name", "(", ")", "to", "lower", "case", "(", ")", "replace", "all", "(", "\"", "\"", ",", "\"", "\"", ")", "replace", "first", "(", "\"", "\\", "\\", "$", "eq", "$", "\"", ",", "\"", "\\", "\\", "$", "eq", "\"", ")", ":", "m", "get", "name", "(", ")", "to", "lower", "case", "(", ")", "replace", "all", "(", "\"", "\"", ",", "\"", "\"", ")", ";", "/", "/", "check", "for", "getter", "if", "(", "/", "/", "the", "name", "should", "be", "\"", "get", "<", "field", "name", ">", "\"", "or", "\"", "<", "field", "name", ">", "\"", "(", "for", "scala", ")", "or", "/", "/", "\"", "is", "<", "field", "name", ">", "\"", "for", "boolean", "fields", "(", "method", "name", "low", "equals", "(", "\"", "get", "\"", "+", "field", "name", "low", ")", "\|", "\|", "method", "name", "low", "equals", "(", "\"", "is", "\"", "+", "field", "name", "low", ")", "\|", "\|", "method", "name", "low", "equals", "(", "field", "name", "low", ")", ")", "&", "&", "/", "/", "no", "arguments", "for", "the", "getter", "m", "get", "parameter", "types", "(", ")", "length", "=", "=", "0", "&", "&", "/", "/", "return", "type", "is", "same", "as", "field", "type", "(", "or", "the", "generic", "variant", "of", "it", ")", "(", "m", "get", "generic", "return", "type", "(", ")", "equals", "(", "field", "type", ")", "\|", "\|", "(", "m", "get", "return", "type", "(", ")", "equals", "(", "field", "type", "wrapper", ")", ")", "\|", "\|", "(", "m", "get", "generic", "return", "type", "(", ")", "equals", "(", "field", "type", "generic", ")", ")", ")", ")", "{", "has", "getter", "=", "true", ";", "}", "/", "/", "check", "for", "setters", "(", "<", "field", "name", ">", "$", "eq", "for", "scala", ")", "if", "(", "(", "method", "name", "low", "equals", "(", "\"", "set", "\"", "+", "field", "name", "low", ")", "\|", "\|", "method", "name", "low", "equals", "(", "field", "name", "low", "+", "\"", "$", "eq", "\"", ")", ")", "&", "&", "m", "get", "parameter", "types", "(", ")", "length", "=", "=", "1", "&", "&", "/", "/", "one", "parameter", "of", "the", "field", "'", "s", "type", "(", "m", "get", "generic", "parameter", "types", "(", ")", "[", "0", "]", "equals", "(", "field", "type", ")", "\|", "\|", "(", "m", "get", "parameter", "types", "(", ")", "[", "0", "]", "equals", "(", "field", "type", "wrapper", ")", ")", "\|", "\|", "(", "m", "get", "generic", "parameter", "types", "(", ")", "[", "0", "]", "equals", "(", "field", "type", "generic", ")", ")", ")", "&", "&", "/", "/", "return", "type", "is", "void", "(", "or", "the", "class", "self", ")", "(", "m", "get", "return", "type", "(", ")", "equals", "(", "void", "type", ")", "\|", "\|", "m", "get", "return", "type", "(", ")", "equals", "(", "clazz", ")", ")", ")", "{", "has", "setter", "=", "true", ";", "}", "}", "if", "(", "has", "getter", "&", "&", "has", "setter", ")", "{", "return", "true", ";", "}", "else", "{", "if", "(", "!", "has", "getter", "&", "&", "clazz", "!", "=", "row", "class", ")", "{", "log", "info", "(", "clazz", "+", "\"", "does", "not", "contain", "a", "getter", "for", "field", "\"", "+", "f", "get", "name", "(", ")", ")", ";", "}", "if", "(", "!", "has", "setter", "&", "&", "clazz", "!", "=", "row", "class", ")", "{", "log", "info", "(", "clazz", "+", "\"", "does", "not", "contain", "a", "setter", "for", "field", "\"", "+", "f", "get", "name", "(", ")", ")", ";", "}", "return", "false", ";", "}", "}", "}" ]
[ "create", "the", "x", "content", "header", "for", "any", "{", "@", "link", "base", "nodes", "response", "}" ]	[ "public", "static", "<", "node", "response", "extends", "base", "node", "response", ">", "void", "build", "nodes", "header", "(", "final", "x", "content", "builder", "builder", ",", "final", "params", "params", ",", "final", "base", "nodes", "response", "<", "node", "response", ">", "response", ")", "throws", "i", "o", "exception", "{", "final", "int", "successful", "=", "response", "get", "nodes", "(", ")", "size", "(", ")", ";", "final", "int", "failed", "=", "response", "failures", "(", ")", "size", "(", ")", ";", "build", "nodes", "header", "(", "builder", ",", "params", ",", "successful", "+", "failed", ",", "successful", ",", "failed", ",", "response", "failures", "(", ")", ")", ";", "}" ]
[ "register", "a", "callback", "listener", "and", "async", "task", "will", "start", "executing", "right", "away" ]	[ "public", "void", "listen", "(", "find", "callback", "<", "t", ">", "callback", ")", "{", "cb", "=", "callback", ";", "execute", "(", ")", ";", "}" ]
[ "set", "the", "maximum", "number", "of", "instructions", "in", "a", "single", "run", "which", "contain", "the", "same", "byte", "values", "disassembly", "flow", "will", "stop", "and", "be", "flagged", "when", "this", "threshold", "is", "encountered", "this", "check", "is", "set", "to", "max", "repeat", "pattern", "length", "by", "default", ",", "and", "can", "be", "disabled", "by", "setting", "a", "value", "of", "-", "1", "note", ":", "this", "restriction", "will", "only", "work", "for", "those", "cases", "where", "a", "given", "repeated", "byte", "results", "in", "an", "instruction", "which", "has", "a", "fall", "-", "through" ]	[ "public", "void", "set", "repeat", "pattern", "limit", "(", "int", "max", "instructions", ")", "{", "repeat", "instruction", "byte", "tracker", "set", "repeat", "pattern", "limit", "(", "max", "instructions", ")", ";", "}" ]
[ "set", "the", "minimum", "number", "of", "idle", "objects", "in", "the", "pool", "default", "is", "0" ]	[ "public", "void", "set", "min", "idle", "(", "int", "min", "idle", ")", "{", "this", "min", "idle", "=", "min", "idle", ";", "}" ]
[ "sets", "if", "the", "encoder", "should", "queue", "frames", "if", "the", "maximum", "number", "of", "concurrent", "streams", "would", "otherwise", "be", "exceeded" ]	[ "protected", "b", "encoder", "enforce", "max", "concurrent", "streams", "(", "boolean", "encoder", "enforce", "max", "concurrent", "streams", ")", "{", "enforce", "non", "codec", "constraints", "(", "\"", "encoder", "enforce", "max", "concurrent", "streams", "\"", ")", ";", "this", "encoder", "enforce", "max", "concurrent", "streams", "=", "encoder", "enforce", "max", "concurrent", "streams", ";", "return", "self", "(", ")", ";", "}" ]
[ "<", "code", ">", "merge", "references", "<", "code", ">", "merges", "all", "references", "in", "the", "specified", "address", "set", "from", "the", "second", "program", "based", "on", "the", "current", "merge", "filter", "setting", "it", "merges", "them", "into", "the", "merge", "program" ]	[ "void", "merge", "references", "(", "address", "set", "view", "p", "1", "merge", "set", ",", "program", "merge", "filter", "filter", ",", "task", "monitor", "monitor", ")", "throws", "cancelled", "exception", "{", "boolean", "merge", "refs", "=", "(", "filter", "get", "filter", "(", "program", "merge", "filter", "references", ")", "=", "=", "program", "merge", "filter", "replace", ")", ";", "if", "(", "!", "merge", "refs", ")", "{", "return", ";", "}", "program", "diff", "filter", "ref", "diff", "filter", "=", "new", "program", "diff", "filter", "(", "program", "diff", "filter", "reference", "diffs", ")", ";", "address", "set", "view", "ref", "diff", "set", "=", "program", "diff", "get", "differences", "(", "ref", "diff", "filter", ",", "monitor", ")", ";", "address", "set", "view", "diff", "addr", "set", "=", "p", "1", "merge", "set", "intersect", "(", "ref", "diff", "set", ")", ";", "address", "set", "diff", "addr", "set", "2", "=", "diff", "utility", "get", "compatible", "address", "set", "(", "diff", "addr", "set", ",", "program", "2", ")", ";", "merger", "replace", "references", "(", "diff", "addr", "set", "2", ",", "monitor", ")", ";", "}" ]
[ "resolves", "symlink", ",", "if", "the", "given", "file", "is", "a", "symlink", "otherwise", "return", "null", "if", "the", "resolution", "fails", ",", "report", "an", "error" ]	[ "public", "static", "string", "resolve", "symlink", "(", "@", "non", "null", "file", "link", ")", "throws", "i", "o", "exception", "{", "try", "{", "path", "path", "=", "file", "to", "path", "(", "link", ")", ";", "return", "files", "read", "symbolic", "link", "(", "path", ")", "to", "string", "(", ")", ";", "}", "catch", "(", "unsupported", "operation", "exception", "\|", "file", "system", "exception", "x", ")", "{", "/", "/", "no", "symlinks", "on", "this", "platform", "(", "windows", "?", ")", ",", "/", "/", "or", "not", "a", "link", "(", "/", "/", "thrown", "(", "\"", "incorrect", "function", "\"", ")", "on", "jdk", "7u", "2", "1", "in", "windows", "2012", "when", "called", "on", "a", "non", "-", "symlink", ",", "/", "/", "rather", "than", "not", "link", "exception", ",", "contrary", "to", "documentation", "maybe", "only", "when", "not", "on", "ntfs", "?", ")", "?", "return", "null", ";", "}", "catch", "(", "i", "o", "exception", "x", ")", "{", "throw", "x", ";", "}", "catch", "(", "exception", "x", ")", "{", "throw", "new", "i", "o", "exception", "(", "x", ")", ";", "}", "}" ]
[ "excluded", "and", "favored", "nodes", "are", "not", "verified", "and", "will", "be", "ignored", "by", "placement", "policy", "if", "they", "are", "not", "in", "the", "same", "nameservice", "as", "the", "file" ]	[ "public", "located", "block", "add", "block", "(", "string", "src", ",", "string", "client", "name", ",", "extended", "block", "previous", ",", "datanode", "info", "[", "]", "excluded", "nodes", ",", "long", "file", "id", ",", "string", "[", "]", "favored", "nodes", ",", "enum", "set", "<", "add", "block", "flag", ">", "add", "block", "flags", ")", "throws", "i", "o", "exception", "{", "rpc", "server", "check", "operation", "(", "name", "node", "operation", "category", "write", ")", ";", "remote", "method", "method", "=", "new", "remote", "method", "(", "\"", "add", "block", "\"", ",", "new", "class", "<", "?", ">", "[", "]", "{", "string", "class", ",", "string", "class", ",", "extended", "block", "class", ",", "datanode", "info", "[", "]", "class", ",", "long", "class", ",", "string", "[", "]", "class", ",", "enum", "set", "class", "}", ",", "new", "remote", "param", "(", ")", ",", "client", "name", ",", "previous", ",", "excluded", "nodes", ",", "file", "id", ",", "favored", "nodes", ",", "add", "block", "flags", ")", ";", "if", "(", "previous", "!", "=", "null", ")", "{", "return", "rpc", "client", "invoke", "single", "(", "previous", ",", "method", ",", "located", "block", "class", ")", ";", "}", "final", "list", "<", "remote", "location", ">", "locations", "=", "rpc", "server", "get", "locations", "for", "path", "(", "src", ",", "true", ")", ";", "/", "/", "todo", "verify", "the", "excluded", "nodes", "and", "favored", "nodes", "are", "acceptable", "to", "this", "nn", "return", "rpc", "client", "invoke", "sequential", "(", "locations", ",", "method", ",", "located", "block", "class", ",", "null", ")", ";", "}" ]
[ "returns", "the", "bottom", "gutter", "(", "black", "bar", ")", "height", "in", "screen", "coordinates" ]	[ "public", "int", "get", "bottom", "gutter", "height", "(", ")", "{", "return", "screen", "y", ";", "}" ]
[ "check", "if", "a", "string", "starts", "with", "a", "specified", "prefix", "(", "optionally", "case", "insensitive", ")" ]	[ "private", "static", "boolean", "starts", "with", "(", "string", "str", ",", "string", "prefix", ",", "boolean", "ignore", "case", ")", "{", "if", "(", "str", "=", "=", "null", "\|", "\|", "prefix", "=", "=", "null", ")", "{", "return", "(", "str", "=", "=", "null", "&", "&", "prefix", "=", "=", "null", ")", ";", "}", "if", "(", "prefix", "length", "(", ")", ">", "str", "length", "(", ")", ")", "{", "return", "false", ";", "}", "return", "str", "region", "matches", "(", "ignore", "case", ",", "0", ",", "prefix", ",", "0", ",", "prefix", "length", "(", ")", ")", ";", "}" ]
[ "expires", "the", "zk", "session", "associated", "with", "service", "'", "from", "idx", "'", ",", "and", "waits", "until", "service", "'", "to", "idx", "'", "takes", "over" ]	[ "public", "void", "expire", "and", "verify", "failover", "(", "int", "from", "idx", ",", "int", "to", "idx", ")", "throws", "exception", "{", "preconditions", "check", "argument", "(", "from", "idx", "!", "=", "to", "idx", ")", ";", "get", "elector", "(", "from", "idx", ")", "prevent", "session", "reestablishment", "for", "tests", "(", ")", ";", "try", "{", "expire", "active", "lock", "holder", "(", "from", "idx", ")", ";", "wait", "for", "h", "a", "state", "(", "from", "idx", ",", "h", "a", "service", "state", "standby", ")", ";", "wait", "for", "h", "a", "state", "(", "to", "idx", ",", "h", "a", "service", "state", "active", ")", ";", "}", "finally", "{", "get", "elector", "(", "from", "idx", ")", "allow", "session", "reestablishment", "for", "tests", "(", ")", ";", "}", "}" ]
[ "specifies", "a", "{", "@", "link", "key", "selector", "}", "for", "elements", "from", "the", "second", "input", "with", "explicit", "type", "information", "for", "the", "key", "type" ]	[ "public", "equal", "to", "equal", "to", "(", "key", "selector", "<", "t2", ",", "key", ">", "key", "selector", ",", "type", "information", "<", "key", ">", "key", "type", ")", "{", "require", "non", "null", "(", "key", "selector", ")", ";", "require", "non", "null", "(", "key", "type", ")", ";", "if", "(", "!", "key", "type", "equals", "(", "this", "key", "type", ")", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "the", "keys", "for", "the", "two", "inputs", "are", "not", "equal", ":", "\"", "+", "\"", "first", "key", "=", "\"", "+", "this", "key", "type", "+", "\"", ",", "second", "key", "=", "\"", "+", "key", "type", ")", ";", "}", "return", "new", "equal", "to", "(", "input", "2", "clean", "(", "key", "selector", ")", ")", ";", "}", "/", "/", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-" ]
[ "reboot", "the", "device", "to", "bootloader", "requires", "root", "permission" ]	[ "public", "static", "boolean", "reboot", "2", "bootloader", "(", ")", "{", "shell", "utils", "command", "result", "result", "=", "shell", "utils", "exec", "cmd", "(", "\"", "reboot", "bootloader", "\"", ",", "true", ")", ";", "return", "result", "result", "=", "=", "0", ";", "}" ]
[ "disable", "litho", "animations", "this", "might", "be", "useful", "for", "cases", "where", "within", "a", "test", "method", "you", "can", "enable", "animations", "for", "certain", "actions", ",", "while", "disabling", "it", "for", "others", "all", "within", "single", "test", "method", "note", "that", "there", "is", "no", "need", "to", "disable", "on", "tear", "down", "of", "the", "test", "class", "as", "we", "make", "sure", "to", "turn", "animation", "back", "to", "its", "original", "value", "when", "every", "test", "method", "finishes" ]	[ "public", "void", "disable", "(", ")", "{", "components", "configuration", "force", "enable", "transitions", "for", "instrumentation", "tests", "=", "false", ";", "}" ]
[ "set", "the", "thread", "pool", "executor", "'", "s", "core", "pool", "size", "default", "is", "1", "<", "b", ">", "this", "setting", "can", "be", "modified", "at", "runtime", ",", "for", "example", "through", "jmx", "<", "b", ">" ]	[ "public", "void", "set", "core", "pool", "size", "(", "int", "core", "pool", "size", ")", "{", "synchronized", "(", "this", "pool", "size", "monitor", ")", "{", "this", "core", "pool", "size", "=", "core", "pool", "size", ";", "if", "(", "this", "thread", "pool", "executor", "!", "=", "null", ")", "{", "this", "thread", "pool", "executor", "set", "core", "pool", "size", "(", "core", "pool", "size", ")", ";", "}", "}", "}" ]
[ "returns", "the", "list", "of", "output", "symlinks" ]	[ "public", "immutable", "set", "<", "fileset", "output", "symlink", ">", "get", "symlinks", "(", ")", "{", "return", "symlinks", ";", "}" ]
[ "an", "implementation", "of", "the", "graceful", "stop", "sequence", "recommended", "by", "{", "@", "link", "executor", "service", "}" ]	[ "public", "static", "void", "shutdown", "gracefully", "(", "executor", "service", "executor", ",", "long", "timeout", ",", "time", "unit", "time", "unit", ")", "{", "/", "/", "disable", "new", "tasks", "from", "being", "submitted", "executor", "shutdown", "(", ")", ";", "try", "{", "/", "/", "wait", "a", "while", "for", "existing", "tasks", "to", "terminate", "if", "(", "!", "executor", "await", "termination", "(", "timeout", ",", "time", "unit", ")", ")", "{", "executor", "shutdown", "now", "(", ")", ";", "/", "/", "wait", "a", "while", "for", "tasks", "to", "respond", "to", "being", "cancelled", "if", "(", "!", "executor", "await", "termination", "(", "timeout", ",", "time", "unit", ")", ")", "{", "log", "warn", "(", "string", "format", "(", "\"", "%", "s", "didn", "'", "t", "terminate", "!", "\"", ",", "executor", ")", ")", ";", "}", "}", "}", "catch", "(", "interrupted", "exception", "ie", ")", "{", "/", "/", "(", "re", "-", ")", "cancel", "if", "current", "thread", "also", "interrupted", "executor", "shutdown", "now", "(", ")", ";", "/", "/", "preserve", "interrupt", "status", "thread", "current", "thread", "(", ")", "interrupt", "(", ")", ";", "}", "}" ]
[ "this", "only", "returns", "after", "all", "input", "queues", "are", "empty" ]	[ "public", "void", "wait", "for", "input", "processing", "(", ")", "throws", "exception", "{", "while", "(", "task", "thread", "is", "alive", "(", ")", ")", "{", "boolean", "all", "empty", "=", "true", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "num", "input", "gates", ";", "i", "+", "+", ")", "{", "if", "(", "!", "input", "gates", "[", "i", "]", "all", "queues", "empty", "(", ")", ")", "{", "all", "empty", "=", "false", ";", "}", "}", "if", "(", "all", "empty", ")", "{", "break", ";", "}", "}", "/", "/", "wait", "for", "all", "currently", "available", "input", "has", "been", "processed", "final", "atomic", "boolean", "all", "input", "processed", "=", "new", "atomic", "boolean", "(", ")", ";", "final", "mailbox", "processor", "mailbox", "processor", "=", "task", "thread", "task", "mailbox", "processor", ";", "final", "mailbox", "executor", "mailbox", "executor", "=", "mailbox", "processor", "get", "main", "mailbox", "executor", "(", ")", ";", "while", "(", "task", "thread", "is", "alive", "(", ")", ")", "{", "try", "{", "final", "count", "down", "latch", "latch", "=", "new", "count", "down", "latch", "(", "1", ")", ";", "mailbox", "executor", "execute", "(", "(", ")", "-", ">", "{", "all", "input", "processed", "set", "(", "mailbox", "processor", "is", "default", "action", "unavailable", "(", ")", ")", ";", "latch", "count", "down", "(", ")", ";", "}", ",", "\"", "query", "-", "whether", "-", "process", "input", "-", "has", "-", "suspend", "-", "itself", "\"", ")", ";", "/", "/", "mail", "could", "be", "dropped", "due", "to", "task", "exception", ",", "so", "we", "do", "timed", "-", "await", "here", "latch", "await", "(", "1", ",", "time", "unit", "seconds", ")", ";", "}", "catch", "(", "rejected", "execution", "exception", "ex", ")", "{", "/", "/", "loop", "until", "task", "thread", "exit", "for", "possible", "task", "exception", "}", "if", "(", "all", "input", "processed", "get", "(", ")", ")", "{", "break", ";", "}", "try", "{", "thread", "sleep", "(", "1", ")", ";", "}", "catch", "(", "interrupted", "exception", "ignored", ")", "{", "}", "}", "throwable", "error", "=", "task", "thread", "get", "error", "(", ")", ";", "if", "(", "error", "!", "=", "null", ")", "{", "throw", "new", "exception", "(", "\"", "exception", "in", "the", "task", "thread", "\"", ",", "error", ")", ";", "}", "}" ]
[ "serializes", "transaction", "header", "and", "transaction", "data", "into", "a", "byte", "buffer" ]	[ "public", "static", "byte", "[", "]", "marshall", "txn", "entry", "(", "txn", "header", "hdr", ",", "record", "txn", ")", "throws", "i", "o", "exception", "{", "return", "marshall", "txn", "entry", "(", "hdr", ",", "txn", ",", "null", ")", ";", "}" ]
[ "a", "sensible", "definition", "of", "{", "@", "link", "#", "sub", "multiset", "(", "object", ",", "bound", "type", ",", "object", ",", "bound", "type", ")", "}", "in", "terms", "of", "{", "@", "link", "#", "head", "multiset", "(", "object", ",", "bound", "type", ")", "head", "multiset", "}", "and", "{", "@", "link", "#", "tail", "multiset", "(", "object", ",", "bound", "type", ")", "tail", "multiset", "}", "if", "you", "override", "either", "of", "these", "methods", ",", "you", "may", "wish", "to", "override", "{", "@", "link", "#", "sub", "multiset", "(", "object", ",", "bound", "type", ",", "object", ",", "bound", "type", ")", "}", "to", "forward", "to", "this", "implementation" ]	[ "protected", "sorted", "multiset", "<", "e", ">", "standard", "sub", "multiset", "(", "e", "lower", "bound", ",", "bound", "type", "lower", "bound", "type", ",", "e", "upper", "bound", ",", "bound", "type", "upper", "bound", "type", ")", "{", "return", "tail", "multiset", "(", "lower", "bound", ",", "lower", "bound", "type", ")", "head", "multiset", "(", "upper", "bound", ",", "upper", "bound", "type", ")", ";", "}" ]
[ "gets", "the", "number", "of", "job", "vertices", "currently", "held", "by", "this", "execution", "graph" ]	[ "public", "int", "get", "number", "of", "execution", "job", "vertices", "(", ")", "{", "return", "this", "vertices", "in", "creation", "order", "size", "(", ")", ";", "}" ]
[ "get", "the", "value", "of", "the", "'", "{", "@", "code", "target", "}", "'", "attribute" ]	[ "public", "string", "get", "target", "(", ")", "{", "return", "this", "target", ";", "}" ]
[ "returns", "1", "if", "write", "has", "been", "stopped" ]	[ "public", "void", "enable", "is", "write", "stopped", "(", ")", "{", "this", "properties", "add", "(", "rocks", "d", "b", "property", "is", "write", "stopped", "get", "rocks", "d", "b", "property", "(", ")", ")", ";", "}" ]
[ "test", "once", "update", "more", "than", "one", "level", "is", "not", "allowed" ]	[ "public", "void", "test", "once", "update", "more", "than", "one", "level", "(", ")", "{", "try", "{", "heap", "head", "index", "update", "level", "(", "heap", "head", "index", "get", "level", "(", ")", "+", "2", ")", ";", "assert", "fail", "(", "\"", "should", "have", "thrown", "exception", "\"", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "assert", "assert", "true", "(", "e", "instanceof", "illegal", "argument", "exception", ")", ";", "}", "}" ]
[ "shutdown", "the", "chain", "of", "interceptors", "when", "the", "object", "is", "destroyed" ]	[ "protected", "void", "finalize", "(", ")", "{", "root", "interceptor", "shutdown", "(", ")", ";", "}" ]
[ "sets", "the", "message", "below", "the", "progress", "meter", "in", "the", "current", "phase", "progress", "area" ]	[ "void", "update", "progress", "details", "(", "string", "progress", "description", ")", "{", "provider", "update", "progress", "details", "(", "progress", "description", ")", ";", "}" ]
[ "traverses", "an", "iterator", "and", "removes", "every", "element", "that", "belongs", "to", "the", "provided", "collection", "the", "iterator", "will", "be", "left", "exhausted", ":", "its", "{", "@", "code", "has", "next", "(", ")", "}", "method", "will", "return", "{", "@", "code", "false", "}" ]	[ "public", "static", "boolean", "remove", "all", "(", "iterator", "<", "?", ">", "remove", "from", ",", "collection", "<", "?", ">", "elements", "to", "remove", ")", "{", "check", "not", "null", "(", "elements", "to", "remove", ")", ";", "boolean", "result", "=", "false", ";", "while", "(", "remove", "from", "has", "next", "(", ")", ")", "{", "if", "(", "elements", "to", "remove", "contains", "(", "remove", "from", "next", "(", ")", ")", ")", "{", "remove", "from", "remove", "(", ")", ";", "result", "=", "true", ";", "}", "}", "return", "result", ";", "}" ]
[ "attempt", "to", "gracefully", "cleanup", "the", "rollup", "job", "so", "it", "can", "be", "terminated", "this", "tries", "to", "remove", "the", "job", "from", "the", "scheduler", ",", "and", "potentially", "any", "other", "cleanup", "operations", "in", "the", "future" ]	[ "synchronized", "void", "shutdown", "(", ")", "{", "try", "{", "logger", "info", "(", "\"", "rollup", "indexer", "[", "\"", "+", "job", "get", "config", "(", ")", "get", "id", "(", ")", "+", "\"", "]", "received", "abort", "request", ",", "stopping", "indexer", "\"", ")", ";", "scheduler", "engine", "remove", "(", "schedule", "name", "+", "\"", "\"", "+", "job", "get", "config", "(", ")", "get", "id", "(", ")", ")", ";", "scheduler", "engine", "unregister", "(", "this", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "mark", "as", "failed", "(", "e", ")", ";", "return", ";", "}", "mark", "as", "completed", "(", ")", ";", "}" ]
[ "set", "the", "admin", "state", "of", "the", "datanode" ]	[ "public", "void", "set", "admin", "state", "(", "final", "admin", "states", "admin", "state", ")", "{", "this", "admin", "state", "=", "admin", "state", ";", "}" ]
[ "the", "given", "substream", "is", "drained" ]	[ "state", "substream", "drained", "(", "substream", "substream", ")", "{", "check", "state", "(", "!", "pass", "through", ",", "\"", "already", "pass", "through", "\"", ")", ";", "collection", "<", "substream", ">", "drained", "substreams", ";", "if", "(", "substream", "closed", ")", "{", "drained", "substreams", "=", "this", "drained", "substreams", ";", "}", "else", "if", "(", "this", "drained", "substreams", "is", "empty", "(", ")", ")", "{", "/", "/", "optimize", "for", "0", "-", "retry", ",", "which", "is", "most", "of", "the", "cases", "drained", "substreams", "=", "collections", "singleton", "list", "(", "substream", ")", ";", "}", "else", "{", "drained", "substreams", "=", "new", "array", "list", "<", ">", "(", "this", "drained", "substreams", ")", ";", "drained", "substreams", "add", "(", "substream", ")", ";", "drained", "substreams", "=", "collections", "unmodifiable", "collection", "(", "drained", "substreams", ")", ";", "}", "boolean", "pass", "through", "=", "winning", "substream", "!", "=", "null", ";", "list", "<", "buffer", "entry", ">", "buffer", "=", "this", "buffer", ";", "if", "(", "pass", "through", ")", "{", "check", "state", "(", "winning", "substream", "=", "=", "substream", ",", "\"", "another", "rpc", "attempt", "has", "already", "committed", "\"", ")", ";", "buffer", "=", "null", ";", "}", "return", "new", "state", "(", "buffer", ",", "drained", "substreams", ",", "active", "hedges", ",", "winning", "substream", ",", "cancelled", ",", "pass", "through", ",", "hedging", "frozen", ",", "hedging", "attempt", "count", ")", ";", "}" ]
[ "encode", "the", "given", "source", "into", "an", "encoded", "string", "using", "the", "rules", "specified", "by", "the", "given", "component", "and", "with", "the", "given", "options" ]	[ "static", "string", "encode", "uri", "component", "(", "string", "source", ",", "charset", "charset", ",", "type", "type", ")", "{", "if", "(", "!", "string", "utils", "has", "length", "(", "source", ")", ")", "{", "return", "source", ";", "}", "assert", "not", "null", "(", "charset", ",", "\"", "charset", "must", "not", "be", "null", "\"", ")", ";", "assert", "not", "null", "(", "type", ",", "\"", "type", "must", "not", "be", "null", "\"", ")", ";", "byte", "[", "]", "bytes", "=", "source", "get", "bytes", "(", "charset", ")", ";", "boolean", "original", "=", "true", ";", "for", "(", "byte", "b", ":", "bytes", ")", "{", "if", "(", "!", "type", "is", "allowed", "(", "b", ")", ")", "{", "original", "=", "false", ";", "break", ";", "}", "}", "if", "(", "original", ")", "{", "return", "source", ";", "}", "byte", "array", "output", "stream", "baos", "=", "new", "byte", "array", "output", "stream", "(", "bytes", "length", ")", ";", "for", "(", "byte", "b", ":", "bytes", ")", "{", "if", "(", "type", "is", "allowed", "(", "b", ")", ")", "{", "baos", "write", "(", "b", ")", ";", "}", "else", "{", "baos", "write", "(", "'", "%", "'", ")", ";", "char", "hex", "1", "=", "character", "to", "upper", "case", "(", "character", "for", "digit", "(", "(", "b", ">", ">", "4", ")", "&", "0x", "f", ",", "16", ")", ")", ";", "char", "hex", "2", "=", "character", "to", "upper", "case", "(", "character", "for", "digit", "(", "b", "&", "0x", "f", ",", "16", ")", ")", ";", "baos", "write", "(", "hex", "1", ")", ";", "baos", "write", "(", "hex", "2", ")", ";", "}", "}", "return", "stream", "utils", "copy", "to", "string", "(", "baos", ",", "charset", ")", ";", "}" ]
[ "transition", "to", "the", "completed", "state", "and", "set", "the", "value" ]	[ "boolean", "set", "(", "@", "nullable", "decl", "v", "v", ")", "{", "return", "complete", "(", "v", ",", "null", ",", "completed", ")", ";", "}" ]
[ "test", "the", "property", "'", "declawed", "'" ]	[ "public", "void", "declawed", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "declawed", "}" ]
[ "specify", "the", "target", "class", "explicitly", ",", "to", "avoid", "any", "kind", "of", "access", "to", "the", "target", "bean", "(", "for", "example", ",", "to", "avoid", "initialization", "of", "a", "factory", "bean", "instance", ")", "default", "is", "to", "detect", "the", "type", "automatically", ",", "through", "a", "{", "@", "code", "get", "type", "}", "call", "on", "the", "bean", "factory", "(", "or", "even", "a", "full", "{", "@", "code", "get", "bean", "}", "call", "as", "fallback", ")" ]	[ "public", "void", "set", "target", "class", "(", "class", "<", "?", ">", "target", "class", ")", "{", "this", "target", "class", "=", "target", "class", ";", "}" ]
[ "test", "the", "property", "'", "small", "camel", "'" ]	[ "public", "void", "small", "camel", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "small", "camel", "}" ]
[ "makes", "sure", "that", "annotations", "in", "the", "polling", "output", "is", "handled", "correctly" ]	[ "@", "test", "public", "void", "polling", "output", "(", ")", "throws", "exception", "{", "free", "style", "project", "p", "=", "r", "create", "free", "style", "project", "(", ")", ";", "p", "set", "scm", "(", "new", "polling", "s", "c", "m", "(", ")", ")", ";", "s", "c", "m", "trigger", "t", "=", "new", "s", "c", "m", "trigger", "(", "\"", "@", "daily", "\"", ")", ";", "t", "start", "(", "p", ",", "true", ")", ";", "p", "add", "trigger", "(", "t", ")", ";", "r", "build", "and", "assert", "success", "(", "p", ")", ";", "/", "/", "poll", "now", "t", "new", "runner", "(", ")", "run", "(", ")", ";", "html", "page", "log", "=", "r", "create", "web", "client", "(", ")", "get", "page", "(", "p", ",", "\"", "scm", "poll", "log", "\"", ")", ";", "string", "text", "=", "log", "as", "text", "(", ")", ";", "assert", "true", "(", "text", ",", "text", "contains", "(", "\"", "$", "$", "$", "hello", "from", "polling", "\"", ")", ")", ";", "}" ]
[ "sends", "the", "rss", "feed", "to", "the", "client", "using", "a", "specific", "feed", "adapter" ]	[ "public", "static", "void", "rss", "(", "stapler", "request", "req", ",", "stapler", "response", "rsp", ",", "string", "title", ",", "string", "url", ",", "run", "list", "run", "list", ",", "feed", "adapter", "<", "run", ">", "feed", "adapter", ")", "throws", "i", "o", "exception", ",", "servlet", "exception", "{", "final", "feed", "adapter", "<", "run", ">", "feed", "adapter", "=", "feed", "adapter", "=", "=", "null", "?", "run", "feed", "adapter", ":", "feed", "adapter", ";", "forward", "to", "rss", "(", "title", ",", "url", ",", "run", "list", ",", "feed", "adapter", ",", "req", ",", "rsp", ")", ";", "}" ]
[ "checks", "the", "revocation", "status", "of", "the", "given", "certificate" ]	[ "default", "void", "check", "(", "final", "x", "5", "0", "9", "certificate", "certificate", ")", "throws", "general", "security", "exception", "{", "}" ]
[ "verify", "that", "configured", "paths", "are", "normalized", "by", "removing", "redundant", "separators" ]	[ "public", "void", "test", "protected", "dir", "normalization", "1", "(", ")", "{", "configuration", "conf", "=", "new", "hdfs", "configuration", "(", ")", ";", "conf", "set", "(", "common", "configuration", "keys", "fs", "protected", "directories", ",", "\"", "/", "foo", "/", "/", "bar", "\"", ")", ";", "collection", "<", "string", ">", "paths", "=", "f", "s", "directory", "parse", "protected", "directories", "(", "conf", ")", ";", "assert", "that", "(", "paths", "size", "(", ")", ",", "is", "(", "1", ")", ")", ";", "assert", "that", "(", "paths", "iterator", "(", ")", "next", "(", ")", ",", "is", "(", "\"", "/", "foo", "/", "bar", "\"", ")", ")", ";", "}" ]
[ "get", "attribute", "boolean" ]	[ "public", "boolean", "is", "attribute", "boolean", "(", ")", "{", "return", "attribute", "boolean", ";", "}" ]
[ "returns", "the", "current", "cpu", "utilization", "of", "the", "current", "process", "in", "ms", "the", "returned", "array", "contains", "the", "following", "information", ":", "the", "1st", "entry", "is", "the", "number", "of", "ms", "that", "the", "process", "has", "executed", "in", "user", "mode", ",", "and", "the", "2nd", "entry", "is", "the", "number", "of", "ms", "that", "the", "process", "has", "executed", "in", "kernel", "mode", "reads", "procselfstat", "to", "obtain", "this", "information" ]	[ "public", "long", "[", "]", "get", "cpu", "utilization", "in", "ms", "(", ")", "{", "return", "new", "long", "[", "]", "{", "cpu", "utilization", "in", "jiffies", "[", "0", "]", "", "10", ",", "cpu", "utilization", "in", "jiffies", "[", "1", "]", "", "10", "}", ";", "}" ]
[ "to", "string", "address", "string" ]	[ "public", "static", "string", "to", "string", "address", "(", "inet", "socket", "address", "address", ")", "{", "return", "address", "get", "address", "(", ")", "get", "host", "address", "(", ")", "+", "\"", ":", "\"", "+", "address", "get", "port", "(", ")", ";", "}" ]
[ "number", "of", "retries", "that", "had", "to", "be", "attempted", "due", "to", "bulk", "actions", "being", "rejected" ]	[ "public", "long", "get", "bulk", "retries", "(", ")", "{", "return", "bulk", "retries", ";", "}" ]
[ "validate", "the", "bug", "fix", "for", "hadoop", "-", "17089", "please", "note", "that", "we", "were", "never", "able", "to", "reproduce", "this", "except", "during", "a", "spark", "job", "that", "ran", "for", "multiple", "days", "and", "in", "a", "hacked", "-", "up", "azure", "-", "storage", "sdk", "that", "added", "sleep", "before", "and", "after", "the", "call", "to", "factory", "set", "namespace", "aware", "(", "true", ")", "as", "shown", "in", "the", "description", "of" ]	[ "public", "void", "test", "concurrent", "list", "(", ")", "throws", "exception", "{", "final", "path", "test", "dir", "=", "new", "path", "(", "\"", "/", "tmp", "/", "data", "-", "loss", "/", "11230174258112", "/", "temporary", "/", "0", "/", "temporary", "/", "attempt", "20200624190514", "0006", "m", "0", "\"", ")", ";", "final", "path", "test", "file", "=", "new", "path", "(", "test", "dir", ",", "\"", "part", "-", "00004", "-", "1", "5ea", "8", "7b", "1", "-", "3", "1", "2c", "-", "4fdf", "-", "1820", "-", "9", "5afb", "3dfc", "1c", "3", "-", "a", "0", "1", "0", "snappy", "parquet", "\"", ")", ";", "fs", "create", "(", "test", "file", ")", "close", "(", ")", ";", "list", "<", "list", "task", ">", "tasks", "=", "new", "array", "list", "<", ">", "(", "thread", "count", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "thread", "count", ";", "i", "+", "+", ")", "{", "tasks", "add", "(", "new", "list", "task", "(", "fs", ",", "test", "dir", ")", ")", ";", "}", "executor", "service", "es", "=", "null", ";", "try", "{", "es", "=", "executors", "new", "fixed", "thread", "pool", "(", "thread", "count", ")", ";", "list", "<", "future", "<", "integer", ">", ">", "futures", "=", "es", "invoke", "all", "(", "tasks", ")", ";", "for", "(", "future", "<", "integer", ">", "future", ":", "futures", ")", "{", "assert", "assert", "true", "(", "future", "is", "done", "(", ")", ")", ";", "/", "/", "we", "are", "using", "callable", "<", "v", ">", ",", "so", "if", "an", "exception", "/", "/", "occurred", "during", "the", "operation", ",", "it", "will", "be", "thrown", "/", "/", "when", "we", "call", "get", "long", "file", "count", "=", "future", "get", "(", ")", ";", "assert", "equals", "(", "\"", "the", "list", "should", "always", "contain", "1", "file", "\"", ",", "1", ",", "file", "count", ")", ";", "}", "}", "finally", "{", "if", "(", "es", "!", "=", "null", ")", "{", "es", "shutdown", "now", "(", ")", ";", "}", "}", "}" ]
[ "loads", "the", "reference", "value", "from", "the", "variable", "with", "the", "given", "index" ]	[ "public", "reference", "value", "aload", "(", "int", "index", ")", "{", "return", "load", "(", "index", ")", "reference", "value", "(", ")", ";", "}" ]
[ "place", "an", "order", "for", "a", "pet" ]	[ "public", "void", "place", "order", "test", "(", ")", "{", "order", "body", "=", "null", ";", "/", "/", "order", "response", "=", "api", "place", "order", "(", "body", ")", ";", "/", "/", "assert", "not", "null", "(", "response", ")", ";", "/", "/", "todo", ":", "test", "validations", "}" ]
[ "return", "whether", "network", "is", "connected", "must", "hold", "{", "@", "code", "<", "uses", "-", "permission", "android", ":", "name", "=", "\"", "android", "permission", "access", "network", "state", "\"", ">", "}" ]	[ "public", "static", "boolean", "is", "connected", "(", ")", "{", "network", "info", "info", "=", "get", "active", "network", "info", "(", ")", ";", "return", "info", "!", "=", "null", "&", "&", "info", "is", "connected", "(", ")", ";", "}" ]
[ "number", "of", "{", "@", "link", "executor", "}", "s", "that", "are", "configured", "for", "this", "computer", "when", "this", "value", "is", "decreased", ",", "it", "is", "temporarily", "possible", "for", "{", "@", "link", "#", "executors", "}", "to", "have", "a", "larger", "number", "than", "this" ]	[ "public", "int", "get", "num", "executors", "(", ")", "{", "return", "num", "executors", ";", "}" ]
[ "controls", "where", "the", "user", "is", "sent", "to", "after", "a", "logout", "by", "default", ",", "it", "'", "s", "the", "top", "page", "of", "hudson", ",", "but", "you", "can", "return", "arbitrary", "url" ]	[ "protected", "string", "get", "post", "log", "out", "url", "2", "(", "stapler", "request", "req", ",", "authentication", "auth", ")", "{", "if", "(", "util", "is", "overridden", "(", "security", "realm", "class", ",", "get", "class", "(", ")", ",", "\"", "get", "post", "log", "out", "url", "\"", ",", "stapler", "request", "class", ",", "org", "acegisecurity", "authentication", "class", ")", "&", "&", "!", "inside", "get", "post", "log", "out", "url", "get", "(", ")", ")", "{", "inside", "get", "post", "log", "out", "url", "set", "(", "true", ")", ";", "try", "{", "return", "get", "post", "log", "out", "url", "(", "req", ",", "org", "acegisecurity", "authentication", "from", "spring", "(", "auth", ")", ")", ";", "}", "finally", "{", "inside", "get", "post", "log", "out", "url", "set", "(", "false", ")", ";", "}", "}", "return", "req", "get", "context", "path", "(", ")", "+", "\"", "/", "\"", ";", "}" ]
[ "returns", "path", "to", "xpack", "codebase", "path" ]	[ "static", "path", "get", "elasticsearch", "codebase", "(", ")", "{", "url", "url", "=", "x", "pack", "build", "class", "get", "protection", "domain", "(", ")", "get", "code", "source", "(", ")", "get", "location", "(", ")", ";", "try", "{", "return", "path", "utils", "get", "(", "url", "to", "u", "r", "i", "(", ")", ")", ";", "}", "catch", "(", "u", "r", "i", "syntax", "exception", "bogus", ")", "{", "throw", "new", "runtime", "exception", "(", "bogus", ")", ";", "}", "}" ]
[ "common", "{", "@", "link", "android", "resources", "processor", "builder", "}", "builder", "for", "top", "-", "level", "targets", "the", "builder", "will", "be", "populated", "with", "commonly", "-", "used", "settings", "and", "outputs" ]	[ "private", "static", "android", "resources", "processor", "builder", "builder", "for", "top", "level", "target", "(", "android", "data", "context", "data", "context", ",", "stamped", "android", "manifest", "manifest", ",", "string", "proguard", "prefix", ",", "map", "<", "string", ",", "string", ">", "manifest", "values", ")", "{", "return", "new", "android", "resources", "processor", "builder", "(", ")", "/", "/", "settings", "set", "debug", "(", "data", "context", "use", "debug", "(", ")", ")", "set", "java", "package", "(", "manifest", "get", "package", "(", ")", ")", "set", "application", "id", "(", "manifest", "values", "get", "(", "\"", "application", "id", "\"", ")", ")", "set", "version", "code", "(", "manifest", "values", "get", "(", "\"", "version", "code", "\"", ")", ")", "set", "version", "name", "(", "manifest", "values", "get", "(", "\"", "version", "name", "\"", ")", ")", "set", "throw", "on", "resource", "conflict", "(", "data", "context", "throw", "on", "resource", "conflict", "(", ")", ")", "/", "/", "output", "set", "proguard", "out", "(", "proguard", "helper", "get", "proguard", "config", "artifact", "(", "data", "context", "get", "label", "(", ")", ",", "data", "context", "get", "action", "construction", "context", "(", ")", ",", "proguard", "prefix", ")", ")", ";", "}" ]
[ "template", "method", "that", "allows", "for", "custom", "message", "mapping", "invoked", "when", "{", "@", "link", "#", "set", "target", "type", "}", "is", "not", "{", "@", "link", "message", "type", "#", "text", "}", "or", "{", "@", "link", "message", "type", "#", "bytes", "}", "the", "default", "implementation", "throws", "an", "{", "@", "link", "illegal", "argument", "exception", "}" ]	[ "protected", "message", "map", "to", "message", "(", "object", "object", ",", "session", "session", ",", "object", "writer", "object", "writer", ",", "message", "type", "target", "type", ")", "throws", "j", "m", "s", "exception", ",", "i", "o", "exception", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "unsupported", "message", "type", "[", "\"", "+", "target", "type", "+", "\"", "]", "mapping", "jackson", "2", "message", "converter", "by", "default", "only", "supports", "text", "messages", "and", "bytes", "messages", "\"", ")", ";", "}" ]
[ "topology", ":", "source", "(", "parallelism", "=", "1", ")", "-", "-", "(", "forward", ")", "-", "-", ">", "map", "1", "(", "parallelism", "=", "1", ")", "-", "-", "(", "rescale", ")", "-", "-", ">", "map", "2", "(", "parallelism", "=", "2", ")", "-", "-", "(", "rebalance", ")", "-", "-", ">", "sink", "(", "parallelism", "=", "2", ")" ]	[ "private", "static", "stream", "graph", "create", "stream", "graph", "(", ")", "{", "final", "stream", "execution", "environment", "env", "=", "stream", "execution", "environment", "get", "execution", "environment", "(", ")", ";", "final", "data", "stream", "<", "integer", ">", "source", "=", "env", "from", "elements", "(", "1", ",", "2", ",", "3", ")", "set", "parallelism", "(", "1", ")", ";", "final", "data", "stream", "<", "integer", ">", "forward", "=", "new", "data", "stream", "<", ">", "(", "env", ",", "new", "partition", "transformation", "<", ">", "(", "source", "get", "transformation", "(", ")", ",", "new", "forward", "partitioner", "<", ">", "(", ")", ",", "shuffle", "mode", "undefined", ")", ")", ";", "final", "data", "stream", "<", "integer", ">", "map", "1", "=", "forward", "map", "(", "i", "-", ">", "i", ")", "start", "new", "chain", "(", ")", "set", "parallelism", "(", "1", ")", ";", "final", "data", "stream", "<", "integer", ">", "rescale", "=", "new", "data", "stream", "<", ">", "(", "env", ",", "new", "partition", "transformation", "<", ">", "(", "map", "1", "get", "transformation", "(", ")", ",", "new", "rescale", "partitioner", "<", ">", "(", ")", ",", "shuffle", "mode", "undefined", ")", ")", ";", "final", "data", "stream", "<", "integer", ">", "map", "2", "=", "rescale", "map", "(", "i", "-", ">", "i", ")", "set", "parallelism", "(", "2", ")", ";", "map", "2", "rebalance", "(", ")", "print", "(", ")", "set", "parallelism", "(", "2", ")", ";", "return", "env", "get", "stream", "graph", "(", ")", ";", "}" ]
[ "recursively", "explore", "the", "given", "path", "and", "enforce", "the", "limits", "for", "resource", "localization", "this", "method", "assumes", "that", "there", "are", "no", "symlinks", "in", "the", "directory", "structure" ]	[ "private", "void", "explore", "path", "(", "configuration", "job", ",", "path", "p", ",", "limit", "checker", "limit", "checker", ",", "map", "<", "uri", ",", "file", "status", ">", "stat", "cache", ")", "throws", "i", "o", "exception", "{", "path", "path", "with", "scheme", "=", "p", ";", "if", "(", "!", "path", "with", "scheme", "to", "uri", "(", ")", "is", "absolute", "(", ")", ")", "{", "/", "/", "the", "path", "does", "not", "have", "a", "scheme", ",", "so", "we", "assume", "it", "is", "a", "path", "from", "the", "/", "/", "local", "filesystem", "file", "system", "local", "fs", "=", "file", "system", "get", "local", "(", "job", ")", ";", "path", "with", "scheme", "=", "local", "fs", "make", "qualified", "(", "p", ")", ";", "}", "file", "status", "status", "=", "get", "file", "status", "(", "stat", "cache", ",", "job", ",", "path", "with", "scheme", ")", ";", "if", "(", "status", "is", "directory", "(", ")", ")", "{", "file", "status", "[", "]", "status", "array", "=", "path", "with", "scheme", "get", "file", "system", "(", "job", ")", "list", "status", "(", "path", "with", "scheme", ")", ";", "for", "(", "file", "status", "s", ":", "status", "array", ")", "{", "explore", "path", "(", "job", ",", "s", "get", "path", "(", ")", ",", "limit", "checker", ",", "stat", "cache", ")", ";", "}", "}", "else", "{", "limit", "checker", "add", "file", "(", "path", "with", "scheme", ",", "status", "get", "len", "(", ")", ")", ";", "}", "}" ]
[ "returns", "the", "address", "in", "the", "field", "or", "null", "if", "the", "address", "can", "'", "t", "be", "parsed" ]	[ "public", "address", "get", "address", "(", ")", "{", "string", "addr", "str", "=", "text", "field", "get", "text", "(", ")", ";", "address", "space", "space", "=", "get", "address", "space", "(", ")", ";", "try", "{", "return", "space", "get", "address", "(", "addr", "str", ")", ";", "}", "catch", "(", "address", "format", "exception", "e", ")", "{", "return", "null", ";", "}", "}" ]
[ "create", "a", "request", "builder", "with", "the", "given", "method", "and", "url" ]	[ "static", "builder", "create", "(", "http", "method", "method", ",", "uri", "url", ")", "{", "return", "new", "default", "client", "request", "builder", "(", "method", ",", "url", ")", ";", "}" ]

[ "notification", "from", "the", "program", "domain", "object", "change", "listener", "that", "a", "fragment", "was", "moved", ";", "update", "all", "the", "view", "maps" ]

[ "void", "fragment", "moved", "(", ")", "{", "iterator", "<", "string", ">", "iter", "=", "provider", "map", "key", "set", "(", ")", "iterator", "(", ")", ";", "while", "(", "iter", "has", "next", "(", ")", ")", "{", "string", "tree", "name", "=", "iter", "next", "(", ")", ";", "tree", "view", "provider", "provider", "=", "provider", "map", "get", "(", "tree", "name", ")", ";", "provider", "notify", "listeners", "(", ")", ";", "}", "}" ]

[ "sets", "the", "state", "of", "the", "container", "in", "the", "container", "spec", "it", "is", "write", "protected" ]

[ "public", "void", "set", "container", "state", "(", "container", "state", "state", ")", "{", "this", "write", "lock", "lock", "(", ")", ";", "try", "{", "container", "state", "cur", "state", "=", "container", "spec", "get", "state", "(", ")", ";", "if", "(", "!", "cur", "state", "equals", "(", "state", ")", ")", "{", "container", "spec", "set", "state", "(", "state", ")", ";", "log", "info", "(", "\"", "{", "}", "spec", "state", "state", "changed", "from", "{", "}", "-", ">", "{", "}", "\"", ",", "get", "comp", "instance", "id", "(", ")", ",", "cur", "state", ",", "state", ")", ";", "}", "}", "finally", "{", "this", "write", "lock", "unlock", "(", ")", ";", "}", "}" ]

[ "return", "true", "if", "this", "is", "a", "server", "-", "side", "channel", "and", "the", "connected", "client", "has", "indicated", "that", "it", "supports", "re", "-", "authentication", ",", "otherwise", "false" ]

[ "boolean", "connected", "client", "supports", "reauthentication", "(", ")", "{", "return", "authenticator", "connected", "client", "supports", "reauthentication", "(", ")", ";", "}" ]

[ "get", "boolean", "from", "segments" ]

[ "public", "static", "boolean", "get", "boolean", "(", "memory", "segment", "[", "]", "segments", ",", "int", "offset", ")", "{", "if", "(", "in", "first", "segment", "(", "segments", ",", "offset", ",", "1", ")", ")", "{", "return", "segments", "[", "0", "]", "get", "boolean", "(", "offset", ")", ";", "}", "else", "{", "return", "get", "boolean", "multi", "segments", "(", "segments", ",", "offset", ")", ";", "}", "}" ]

[ "setup", "the", "support", "for", "building", "python" ]

[ "public", "abstract", "void", "setup", "(", "mock", "tools", "config", "config", ")", "throws", "i", "o", "exception", ";" ]

[ "associates", "all", "of", "{", "@", "code", "map", "'", "s", "}", "keys", "and", "values", "in", "the", "built", "map", "duplicate", "keys", "are", "not", "allowed", ",", "and", "will", "cause", "{", "@", "link", "#", "build", "}", "to", "fail" ]

[ "public", "<", "t", "extends", "b", ">", "builder", "<", "b", ">", "put", "all", "(", "map", "<", "?", "extends", "class", "<", "?", "extends", "t", ">", ",", "?", "extends", "t", ">", "map", ")", "{", "for", "(", "entry", "<", "?", "extends", "class", "<", "?", "extends", "t", ">", ",", "?", "extends", "t", ">", "entry", ":", "map", "entry", "set", "(", ")", ")", "{", "class", "<", "?", "extends", "t", ">", "type", "=", "entry", "get", "key", "(", ")", ";", "t", "value", "=", "entry", "get", "value", "(", ")", ";", "map", "builder", "put", "(", "type", ",", "cast", "(", "type", ",", "value", ")", ")", ";", "}", "return", "this", ";", "}" ]

[ "{", "@", "inherit", "doc", "}" ]

[ "public", "output", "committer", "get", "output", "committer", "(", "task", "attempt", "context", "context", ")", "throws", "i", "o", "exception", "{", "return", "new", "copy", "committer", "(", "get", "output", "path", "(", "context", ")", ",", "context", ")", ";", "}" ]

[ "gets", "the", "intersected", "set", "of", "addresses", "between", "a", "mapped", "memory", "block", ",", "and", "some", "other", "address", "set" ]

[ "private", "address", "set", "get", "mapped", "intersection", "(", "memory", "block", "mapped", "block", ",", "address", "set", "set", ")", "{", "address", "set", "mapped", "intersection", "=", "new", "address", "set", "(", ")", ";", "list", "<", "memory", "block", "source", "info", ">", "source", "infos", "=", "mapped", "block", "get", "source", "infos", "(", ")", ";", "/", "/", "mapped", "blocks", "can", "only", "ever", "have", "one", "source", "info", "memory", "block", "source", "info", "info", "=", "source", "infos", "get", "(", "0", ")", ";", "address", "range", "range", "=", "info", "get", "mapped", "range", "(", ")", "get", "(", ")", ";", "address", "set", "resolved", "intersection", "=", "set", "intersect", "(", "new", "address", "set", "(", "range", ")", ")", ";", "for", "(", "address", "range", "resolved", "range", ":", "resolved", "intersection", ")", "{", "address", "range", "mapped", "range", "=", "get", "mapped", "range", "(", "mapped", "block", ",", "resolved", "range", ")", ";", "if", "(", "mapped", "range", "!", "=", "null", ")", "{", "mapped", "intersection", "add", "(", "mapped", "range", ")", ";", "}", "}", "return", "mapped", "intersection", ";", "}" ]

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

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

[ "recalculate", "queue", "usage", "ratio" ]

[ "public", "void", "recalculate", "queue", "usage", "ratio", "(", "resource", "cluster", "resource", ",", "string", "node", "partition", ")", "{", "write", "lock", "lock", "(", ")", ";", "try", "{", "resource", "usage", "queue", "resource", "usage", "=", "get", "queue", "resource", "usage", "(", ")", ";", "if", "(", "node", "partition", "=", "=", "null", ")", "{", "for", "(", "string", "partition", ":", "sets", "union", "(", "get", "queue", "capacities", "(", ")", "get", "node", "partitions", "set", "(", ")", ",", "queue", "resource", "usage", "get", "node", "partitions", "set", "(", ")", ")", ")", "{", "users", "manager", "update", "usage", "ratio", "(", "partition", ",", "cluster", "resource", ")", ";", "}", "}", "else", "{", "users", "manager", "update", "usage", "ratio", "(", "node", "partition", ",", "cluster", "resource", ")", ";", "}", "}", "finally", "{", "write", "lock", "unlock", "(", ")", ";", "}", "}" ]

[ "accepts", "and", "serves", "the", "job", "description" ]

[ "public", "void", "do", "description", "(", "stapler", "request", "req", ",", "stapler", "response", "rsp", ")", "throws", "i", "o", "exception", "{", "if", "(", "req", "get", "method", "(", ")", "equals", "(", "\"", "get", "\"", ")", ")", "{", "/", "/", "read", "rsp", "set", "content", "type", "(", "\"", "text", "/", "plain", ";", "charset", "=", "utf", "-", "8", "\"", ")", ";", "rsp", "get", "writer", "(", ")", "write", "(", "util", "fix", "null", "(", "this", "get", "description", "(", ")", ")", ")", ";", "return", ";", "}", "if", "(", "req", "get", "method", "(", ")", "equals", "(", "\"", "post", "\"", ")", ")", "{", "check", "permission", "(", "configure", ")", ";", "/", "/", "submission", "if", "(", "req", "get", "parameter", "(", "\"", "description", "\"", ")", "!", "=", "null", ")", "{", "this", "set", "description", "(", "req", "get", "parameter", "(", "\"", "description", "\"", ")", ")", ";", "rsp", "send", "error", "(", "sc", "no", "content", ")", ";", "return", ";", "}", "}", "/", "/", "huh", "?", "rsp", "send", "error", "(", "sc", "bad", "request", ")", ";", "}" ]

[ "test", "token", "serialization" ]

[ "public", "void", "test", "token", "serialization", "(", ")", "throws", "i", "o", "exception", "{", "/", "/", "get", "a", "token", "token", "<", "token", "identifier", ">", "source", "token", "=", "new", "token", "<", "token", "identifier", ">", "(", ")", ";", "source", "token", "set", "service", "(", "new", "text", "(", "\"", "service", "\"", ")", ")", ";", "/", "/", "write", "it", "to", "an", "output", "buffer", "data", "output", "buffer", "out", "=", "new", "data", "output", "buffer", "(", ")", ";", "source", "token", "write", "(", "out", ")", ";", "/", "/", "read", "the", "token", "back", "data", "input", "buffer", "in", "=", "new", "data", "input", "buffer", "(", ")", ";", "in", "reset", "(", "out", "get", "data", "(", ")", ",", "out", "get", "length", "(", ")", ")", ";", "token", "<", "token", "identifier", ">", "dest", "token", "=", "new", "token", "<", "token", "identifier", ">", "(", ")", ";", "dest", "token", "read", "fields", "(", "in", ")", ";", "assert", "true", "(", "check", "equal", "(", "source", "token", ",", "dest", "token", ")", ")", ";", "}" ]

[ "handles", "cases", "of", "updates", "involving", "initialization", ",", "resizing", ",", "creating", "new", "cells", ",", "andor", "contention", "see", "above", "for", "explanation", "this", "method", "suffers", "the", "usual", "non", "-", "modularity", "problems", "of", "optimistic", "retry", "code", ",", "relying", "on", "rechecked", "sets", "of", "reads" ]

[ "final", "void", "retry", "update", "(", "long", "x", ",", "hash", "code", "hc", ",", "boolean", "was", "uncontended", ")", "{", "int", "h", "=", "hc", "code", ";", "boolean", "collide", "=", "false", ";", "/", "/", "true", "if", "last", "slot", "nonempty", "for", "(", ";", ";", ")", "{", "cell", "[", "]", "as", ";", "cell", "a", ";", "int", "n", ";", "long", "v", ";", "if", "(", "(", "as", "=", "cells", ")", "!", "=", "null", "&", "&", "(", "n", "=", "as", "length", ")", ">", "0", ")", "{", "if", "(", "(", "a", "=", "as", "[", "(", "n", "-", "1", ")", "&", "h", "]", ")", "=", "=", "null", ")", "{", "if", "(", "busy", "=", "=", "0", ")", "{", "/", "/", "try", "to", "attach", "new", "cell", "cell", "r", "=", "new", "cell", "(", "x", ")", ";", "/", "/", "optimistically", "create", "if", "(", "busy", "=", "=", "0", "&", "&", "cas", "busy", "(", ")", ")", "{", "boolean", "created", "=", "false", ";", "try", "{", "/", "/", "recheck", "under", "lock", "cell", "[", "]", "rs", ";", "int", "m", ",", "j", ";", "if", "(", "(", "rs", "=", "cells", ")", "!", "=", "null", "&", "&", "(", "m", "=", "rs", "length", ")", ">", "0", "&", "&", "rs", "[", "j", "=", "(", "m", "-", "1", ")", "&", "h", "]", "=", "=", "null", ")", "{", "rs", "[", "j", "]", "=", "r", ";", "created", "=", "true", ";", "}", "}", "finally", "{", "busy", "=", "0", ";", "}", "if", "(", "created", ")", "{", "break", ";", "}", "continue", ";", "/", "/", "slot", "is", "now", "non", "-", "empty", "}", "}", "collide", "=", "false", ";", "}", "else", "if", "(", "!", "was", "uncontended", ")", "/", "/", "cas", "already", "known", "to", "fail", "{", "was", "uncontended", "=", "true", ";", "/", "/", "continue", "after", "rehash", "}", "else", "if", "(", "a", "cas", "(", "v", "=", "a", "value", ",", "fn", "(", "v", ",", "x", ")", ")", ")", "{", "break", ";", "}", "else", "if", "(", "n", ">", "=", "ncpu", "|", "|", "cells", "!", "=", "as", ")", "{", "collide", "=", "false", ";", "/", "/", "at", "max", "size", "or", "stale", "}", "else", "if", "(", "!", "collide", ")", "{", "collide", "=", "true", ";", "}", "else", "if", "(", "busy", "=", "=", "0", "&", "&", "cas", "busy", "(", ")", ")", "{", "try", "{", "if", "(", "cells", "=", "=", "as", ")", "{", "/", "/", "expand", "table", "unless", "stale", "cell", "[", "]", "rs", "=", "new", "cell", "[", "n", "<", "<", "1", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "n", ";", "+", "+", "i", ")", "{", "rs", "[", "i", "]", "=", "as", "[", "i", "]", ";", "}", "cells", "=", "rs", ";", "}", "}", "finally", "{", "busy", "=", "0", ";", "}", "collide", "=", "false", ";", "continue", ";", "/", "/", "retry", "with", "expanded", "table", "}", "h", "^", "=", "h", "<", "<", "13", ";", "/", "/", "rehash", "h", "^", "=", "h", ">", ">", ">", "17", ";", "h", "^", "=", "h", "<", "<", "5", ";", "}", "else", "if", "(", "busy", "=", "=", "0", "&", "&", "cells", "=", "=", "as", "&", "&", "cas", "busy", "(", ")", ")", "{", "boolean", "init", "=", "false", ";", "try", "{", "/", "/", "initialize", "table", "if", "(", "cells", "=", "=", "as", ")", "{", "cell", "[", "]", "rs", "=", "new", "cell", "[", "2", "]", ";", "rs", "[", "h", "&", "1", "]", "=", "new", "cell", "(", "x", ")", ";", "cells", "=", "rs", ";", "init", "=", "true", ";", "}", "}", "finally", "{", "busy", "=", "0", ";", "}", "if", "(", "init", ")", "{", "break", ";", "}", "}", "else", "if", "(", "cas", "base", "(", "v", "=", "base", ",", "fn", "(", "v", ",", "x", ")", ")", ")", "{", "break", ";", "/", "/", "fall", "back", "on", "using", "base", "}", "}", "hc", "code", "=", "h", ";", "/", "/", "record", "index", "for", "next", "time", "}" ]

[ "a", "shard", "iterator", "with", "just", "this", "shard", "in", "it" ]

[ "public", "shard", "iterator", "shards", "it", "(", ")", "{", "return", "new", "plain", "shard", "iterator", "(", "shard", "id", ",", "as", "list", ")", ";", "}" ]

[ "get", "namespace", "array" ]

[ "public", "list", "<", "integer", ">", "get", "namespace", "array", "(", ")", "{", "return", "namespace", "array", ";", "}" ]

[ "set", "the", "table", "instance", "associated", "with", "this", "master", "table", "record" ]

[ "void", "set", "table", "(", "table", "table", ")", "{", "this", "table", "=", "table", ";", "}" ]

[ "use", "the", "hide", "selected", "action", "states", "to", "determine", "what", "vertices", "are", "shown", ":", "unselected", "vertices", "only", "selected", "vertices", "only", "both", "selected", "and", "unselected", "vertices", "are", "shown", "neither", "selected", "nor", "unselected", "vertices", "are", "shown" ]

[ "private", "void", "manage", "vertex", "display", "(", ")", "{", "boolean", "hide", "selected", "=", "hide", "selected", "action", "is", "selected", "(", ")", ";", "boolean", "hide", "unselected", "=", "hide", "unselected", "action", "is", "selected", "(", ")", ";", "mutable", "selected", "state", "<", "attributed", "vertex", ">", "selected", "vertex", "state", "=", "viewer", "get", "selected", "vertex", "state", "(", ")", ";", "if", "(", "hide", "selected", "&", "&", "hide", "unselected", ")", "{", "viewer", "get", "render", "context", "(", ")", "set", "vertex", "include", "predicate", "(", "v", "-", ">", "false", ")", ";", "}", "else", "if", "(", "hide", "selected", ")", "{", "viewer", "get", "render", "context", "(", ")", "set", "vertex", "include", "predicate", "(", "predicate", "not", "(", "selected", "vertex", "state", ":", ":", "is", "selected", ")", ")", ";", "}", "else", "if", "(", "hide", "unselected", ")", "{", "viewer", "get", "render", "context", "(", ")", "set", "vertex", "include", "predicate", "(", "selected", "vertex", "state", ":", ":", "is", "selected", ")", ";", "}", "else", "{", "viewer", "get", "render", "context", "(", ")", "set", "vertex", "include", "predicate", "(", "v", "-", ">", "true", ")", ";", "}", "viewer", "repaint", "(", ")", ";", "}" ]

[ "returns", "a", "predicate", "that", "evaluates", "to", "{", "@", "code", "true", "}", "if", "each", "of", "its", "components", "evaluates", "to", "{", "@", "code", "true", "}", "the", "components", "are", "evaluated", "in", "order", ",", "and", "evaluation", "will", "be", "\"", "short", "-", "circuited", "\"", "as", "soon", "as", "a", "false", "predicate", "is", "found", "it", "defensively", "copies", "the", "array", "passed", "in", ",", "so", "future", "changes", "to", "it", "won", "'", "t", "alter", "the", "behavior", "of", "this", "predicate", "if", "{", "@", "code", "components", "}", "is", "empty", ",", "the", "returned", "predicate", "will", "always", "evaluate", "to", "{", "@", "code", "true", "}" ]

[ "public", "static", "<", "t", ">", "predicate", "<", "t", ">", "and", "(", "predicate", "<", "?", "super", "t", ">", "components", ")", "{", "return", "new", "and", "predicate", "<", "t", ">", "(", "defensive", "copy", "(", "components", ")", ")", ";", "}" ]

[ "todo", ":", "based", "on", "how", "frequently", "this", "is", "called", ",", "we", "might", "want", "to", "club", "counting", "pending", "and", "active", "apps", "in", "the", "same", "method" ]

[ "public", "int", "get", "num", "active", "apps", "(", ")", "{", "int", "num", "active", "apps", "=", "0", ";", "read", "lock", "lock", "(", ")", ";", "try", "{", "for", "(", "f", "s", "app", "attempt", "attempt", ":", "runnable", "apps", ")", "{", "if", "(", "!", "attempt", "is", "pending", "(", ")", ")", "{", "num", "active", "apps", "+", "+", ";", "}", "}", "}", "finally", "{", "read", "lock", "unlock", "(", ")", ";", "}", "return", "num", "active", "apps", ";", "}" ]

[ "tests", "to", "check", "time", "spent", "on", "waiting", "for", "tasks", "to", "be", "complete", "on", "a", "blocking", "queue", "in", "{", "@", "link", "abfs", "output", "stream", "}" ]

[ "public", "void", "test", "abfs", "output", "stream", "time", "spent", "on", "wait", "task", "(", ")", "{", "describe", "(", "\"", "testing", "time", "spent", "on", "waiting", "for", "task", "to", "be", "completed", "in", "\"", "+", "\"", "abfs", "output", "stream", "\"", ")", ";", "abfs", "output", "stream", "statistics", "impl", "abfs", "output", "stream", "statistics", "=", "new", "abfs", "output", "stream", "statistics", "impl", "(", ")", ";", "/", "/", "test", "for", "initial", "value", "of", "time", "spent", "wait", "task", "assert", "equals", "(", "\"", "mismatch", "in", "time", "spent", "on", "waiting", "for", "tasks", "to", "complete", "\"", ",", "0", ",", "abfs", "output", "stream", "statistics", "get", "time", "spent", "on", "task", "wait", "(", ")", ")", ";", "abfs", "output", "stream", "statistics", "time", "spent", "task", "wait", "(", ")", ";", "/", "/", "test", "for", "one", "op", "call", "value", "of", "time", "spent", "wait", "task", "assert", "equals", "(", "\"", "mismatch", "in", "time", "spent", "on", "waiting", "for", "tasks", "to", "complete", "\"", ",", "1", ",", "abfs", "output", "stream", "statistics", "get", "time", "spent", "on", "task", "wait", "(", ")", ")", ";", "/", "/", "reset", "statistics", "for", "the", "next", "test", "abfs", "output", "stream", "statistics", "=", "new", "abfs", "output", "stream", "statistics", "impl", "(", ")", ";", "/", "*", "*", "entering", "multiple", "values", "for", "time", "spent", "task", "wait", "(", ")", "to", "check", "the", "*", "summation", "is", "happening", "correctly", "also", "calculating", "the", "expected", "result", "*", "/", "for", "(", "int", "i", "=", "0", ";", "i", "<", "operations", ";", "i", "+", "+", ")", "{", "abfs", "output", "stream", "statistics", "time", "spent", "task", "wait", "(", ")", ";", "}", "/", "*", "*", "test", "to", "check", "correct", "value", "of", "time", "spent", "task", "wait", "after", "operations", "*", "number", "of", "op", "calls", "*", "/", "assert", "equals", "(", "\"", "mismatch", "in", "time", "spent", "on", "waiting", "for", "tasks", "to", "complete", "\"", ",", "operations", ",", "abfs", "output", "stream", "statistics", "get", "time", "spent", "on", "task", "wait", "(", ")", ")", ";", "}" ]

[ "should", "the", "upper", "bound", "be", "included", "or", "not", "defaults", "to", "{", "@", "code", "true", "}" ]

[ "public", "range", "query", "builder", "include", "upper", "(", "boolean", "include", "upper", ")", "{", "this", "include", "upper", "=", "include", "upper", ";", "return", "this", ";", "}" ]

[ "puts", "a", "runtime", "[", "in", "]", "visible", "[", "type", "]", "annotations", "attribute", "containing", "this", "annotations", "and", "all", "its", "predecessors", "(", "see", "{", "@", "link", "#", "previous", "annotation", "}", "in", "the", "given", "byte", "vector", "annotations", "are", "put", "in", "the", "same", "order", "they", "have", "been", "visited" ]

[ "void", "put", "annotations", "(", "final", "int", "attribute", "name", "index", ",", "final", "byte", "vector", "output", ")", "{", "int", "attribute", "length", "=", "2", ";", "/", "/", "for", "num", "annotations", "int", "num", "annotations", "=", "0", ";", "annotation", "writer", "annotation", "writer", "=", "this", ";", "annotation", "writer", "first", "annotation", "=", "null", ";", "while", "(", "annotation", "writer", "!", "=", "null", ")", "{", "/", "/", "in", "case", "the", "user", "forgot", "to", "call", "visit", "end", "(", ")", "annotation", "writer", "visit", "end", "(", ")", ";", "attribute", "length", "+", "=", "annotation", "writer", "annotation", "length", ";", "num", "annotations", "+", "+", ";", "first", "annotation", "=", "annotation", "writer", ";", "annotation", "writer", "=", "annotation", "writer", "previous", "annotation", ";", "}", "output", "put", "short", "(", "attribute", "name", "index", ")", ";", "output", "put", "int", "(", "attribute", "length", ")", ";", "output", "put", "short", "(", "num", "annotations", ")", ";", "annotation", "writer", "=", "first", "annotation", ";", "while", "(", "annotation", "writer", "!", "=", "null", ")", "{", "output", "put", "byte", "array", "(", "annotation", "writer", "annotation", "data", ",", "0", ",", "annotation", "writer", "annotation", "length", ")", ";", "annotation", "writer", "=", "annotation", "writer", "next", "annotation", ";", "}", "}" ]

[ "sets", "the", "{", "@", "link", "sensitivity", "detector", "}", "to", "use" ]

[ "protected", "b", "header", "sensitivity", "detector", "(", "sensitivity", "detector", "header", "sensitivity", "detector", ")", "{", "enforce", "non", "codec", "constraints", "(", "\"", "header", "sensitivity", "detector", "\"", ")", ";", "this", "header", "sensitivity", "detector", "=", "check", "not", "null", "(", "header", "sensitivity", "detector", ",", "\"", "header", "sensitivity", "detector", "\"", ")", ";", "return", "self", "(", ")", ";", "}" ]

[ "return", "the", "registered", "{", "@", "link", "cors", "configuration", "}", "objects", ",", "keyed", "by", "path", "pattern" ]

[ "protected", "map", "<", "string", ",", "cors", "configuration", ">", "get", "cors", "configurations", "(", ")", "{", "map", "<", "string", ",", "cors", "configuration", ">", "configs", "=", "collection", "utils", "new", "linked", "hash", "map", "(", "this", "registrations", "size", "(", ")", ")", ";", "for", "(", "cors", "registration", "registration", ":", "this", "registrations", ")", "{", "configs", "put", "(", "registration", "get", "path", "pattern", "(", ")", ",", "registration", "get", "cors", "configuration", "(", ")", ")", ";", "}", "return", "configs", ";", "}" ]

[ "whether", "to", "ensure", "messages", "are", "received", "in", "the", "order", "of", "publication" ]

[ "public", "boolean", "is", "preserve", "publish", "order", "(", ")", "{", "return", "this", "preserve", "publish", "order", ";", "}" ]

[ "returns", "a", "frozen", "{", "@", "link", "args", "}", "representation", "corresponding", "to", "an", "already", "-", "registered", "action" ]

[ "public", "static", "args", "for", "registered", "action", "(", "command", "line", "and", "param", "file", "info", "command", "line", "and", "param", "file", "info", ",", "immutable", "set", "<", "artifact", ">", "directory", "inputs", ")", "{", "return", "new", "frozen", "args", "(", "command", "line", "and", "param", "file", "info", "command", "line", ",", "command", "line", "and", "param", "file", "info", "param", "file", "info", ",", "directory", "inputs", ")", ";", "}" ]

[ "submits", "a", "disk", "balancer", "plan", "to", "the", "datanode" ]

[ "public", "void", "submit", "disk", "balancer", "plan", "(", "string", "plan", "i", "d", ",", "long", "plan", "version", ",", "string", "plan", "file", ",", "string", "plan", "data", ",", "boolean", "skip", "date", "check", ")", "throws", "i", "o", "exception", "{", "try", "{", "submit", "disk", "balancer", "plan", "request", "proto", "request", "=", "submit", "disk", "balancer", "plan", "request", "proto", "new", "builder", "(", ")", "set", "plan", "i", "d", "(", "plan", "i", "d", ")", "set", "plan", "version", "(", "plan", "version", ")", "set", "plan", "file", "(", "plan", "file", ")", "set", "plan", "(", "plan", "data", ")", "set", "ignore", "date", "check", "(", "skip", "date", "check", ")", "build", "(", ")", ";", "rpc", "proxy", "submit", "disk", "balancer", "plan", "(", "null", "controller", ",", "request", ")", ";", "}", "catch", "(", "service", "exception", "e", ")", "{", "throw", "protobuf", "helper", "get", "remote", "exception", "(", "e", ")", ";", "}", "}" ]

[ "set", "the", "connect", "timeout", "(", "in", "milliseconds", ")", "a", "value", "of", "0", "means", "no", "timeout", ",", "otherwise", "values", "must", "be", "between", "1", "and", "{", "@", "link", "integer", "#", "max", "value", "}" ]

[ "public", "api", "client", "set", "connect", "timeout", "(", "int", "connection", "timeout", ")", "{", "this", "connection", "timeout", "=", "connection", "timeout", ";", "http", "client", "property", "(", "client", "properties", "connect", "timeout", ",", "connection", "timeout", ")", ";", "return", "this", ";", "}" ]

[ "returns", "true", "if", "the", "dashed", "-", "line", "effect", "is", "enabled", "for", "highlight", "lines", ",", "false", "if", "not", "default", ":", "disabled" ]

[ "public", "boolean", "is", "dashed", "highlight", "line", "enabled", "(", ")", "{", "return", "m", "highlight", "dash", "path", "effect", "=", "=", "null", "?", "false", ":", "true", ";", "}" ]

[ "checks", "whether", "a", "throwable", "chain", "contains", "a", "specific", "error", "message", "and", "returns", "the", "corresponding", "throwable" ]

[ "public", "static", "optional", "<", "throwable", ">", "find", "throwable", "with", "message", "(", "throwable", "throwable", ",", "string", "search", "message", ")", "{", "if", "(", "throwable", "=", "=", "null", "|", "|", "search", "message", "=", "=", "null", ")", "{", "return", "optional", "empty", "(", ")", ";", "}", "throwable", "t", "=", "throwable", ";", "while", "(", "t", "!", "=", "null", ")", "{", "if", "(", "t", "get", "message", "(", ")", "!", "=", "null", "&", "&", "t", "get", "message", "(", ")", "contains", "(", "search", "message", ")", ")", "{", "return", "optional", "of", "(", "t", ")", ";", "}", "else", "{", "t", "=", "t", "get", "cause", "(", ")", ";", "}", "}", "return", "optional", "empty", "(", ")", ";", "}" ]

[ "creates", "and", "returns", "a", "properly", "-", "sized", "array", "with", "the", "given", "number", "of", "buckets" ]

[ "static", "object", "create", "table", "(", "int", "buckets", ")", "{", "if", "(", "buckets", "<", "2", "|", "|", "buckets", ">", "ints", "max", "power", "of", "two", "|", "|", "integer", "highest", "one", "bit", "(", "buckets", ")", "!", "=", "buckets", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "must", "be", "power", "of", "2", "between", "2", "^", "1", "and", "2", "^", "30", ":", "\"", "+", "buckets", ")", ";", "}", "if", "(", "buckets", "<", "=", "byte", "max", "size", ")", "{", "return", "new", "byte", "[", "buckets", "]", ";", "}", "else", "if", "(", "buckets", "<", "=", "short", "max", "size", ")", "{", "return", "new", "short", "[", "buckets", "]", ";", "}", "else", "{", "return", "new", "int", "[", "buckets", "]", ";", "}", "}" ]

[ "key", "set", "add", "throws", "unsupported", "operation", "exception", "if", "no", "default", "mapped", "value" ]

[ "public", "void", "test", "add", "4", "(", ")", "{", "set", "full", "=", "map", "5", "(", ")", "key", "set", "(", ")", ";", "try", "{", "full", "add", "(", "three", ")", ";", "should", "throw", "(", ")", ";", "}", "catch", "(", "unsupported", "operation", "exception", "success", ")", "{", "}", "}" ]

[ "find", "the", "fields", "constant", "that", "matches", "name", ",", "or", "null", "if", "its", "not", "found" ]

[ "public", "static", "fields", "find", "by", "name", "(", "string", "name", ")", "{", "return", "by", "name", "get", "(", "name", ")", ";", "}" ]

[ "remove", "listener", "for", "key" ]

[ "public", "void", "un", "listen", "(", "string", "key", ",", "record", "listener", "listener", ")", "{", "notifier", "deregister", "listener", "(", "key", ",", "listener", ")", ";", "}" ]

[ "select", "the", "content", "-", "type", "header", "'", "s", "value", "from", "the", "given", "array", ":", "if", "json", "exists", "in", "the", "given", "array", ",", "use", "it", ";", "otherwise", "use", "the", "first", "one", "of", "the", "array" ]

[ "protected", "string", "select", "header", "content", "type", "(", "string", "[", "]", "content", "types", ")", "{", "if", "(", "content", "types", "length", "=", "=", "0", ")", "{", "return", "\"", "application", "/", "json", "\"", ";", "}", "for", "(", "string", "content", "type", ":", "content", "types", ")", "{", "if", "(", "is", "json", "mime", "(", "content", "type", ")", ")", "{", "return", "content", "type", ";", "}", "}", "return", "content", "types", "[", "0", "]", ";", "}" ]

[ "sets", "a", "handshake", "timeout", "for", "this", "connection", "profile" ]

[ "public", "builder", "set", "handshake", "timeout", "(", "time", "value", "handshake", "timeout", ")", "{", "if", "(", "handshake", "timeout", "millis", "(", ")", "<", "0", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "handshake", "timeout", "must", "be", "non", "-", "negative", "but", "was", ":", "\"", "+", "handshake", "timeout", ")", ";", "}", "this", "handshake", "timeout", "=", "handshake", "timeout", ";", "return", "this", ";", "}" ]

[ "returns", "the", "current", "bit", "offset" ]

[ "public", "int", "get", "position", "(", ")", "{", "return", "byte", "offset", "*", "8", "+", "bit", "offset", ";", "}" ]

[ "returns", "an", "empty", "immutable", "range", "map" ]

[ "public", "static", "<", "k", "extends", "comparable", "<", "?", ">", ",", "v", ">", "immutable", "range", "map", "<", "k", ",", "v", ">", "of", "(", ")", "{", "return", "(", "immutable", "range", "map", "<", "k", ",", "v", ">", ")", "empty", ";", "}" ]

[ "sets", "application", "id" ]

[ "public", "void", "set", "application", "id", "(", "string", "application", "id", ")", "{", "this", "application", "id", "=", "application", "id", ";", "}" ]

[ "determine", "if", "the", "components", "in", "the", "data", "type", "use", "relative", "offsets", "or", "pointers" ]

[ "protected", "final", "boolean", "is", "relative", "(", ")", "{", "return", "is", "relative", ";", "}" ]

[ "creates", "a", "new", "fid", "databse", "and", "fid", "file" ]

[ "public", "void", "create", "new", "fid", "database", "(", "file", "db", "file", ")", "throws", "i", "o", "exception", "{", "fid", "d", "b", "create", "new", "fid", "database", "(", "db", "file", ")", ";", "fid", "file", "new", "fid", "file", "=", "new", "fid", "file", "(", "this", ",", "db", "file", ",", "false", ")", ";", "load", "fid", "files", "(", ")", ";", "fid", "files", "add", "(", "new", "fid", "file", ")", ";", "save", "to", "preferences", "(", ")", ";", "notify", "listeners", "(", ")", ";", "}" ]

[ "return", "the", "expression", "string" ]

[ "public", "final", "string", "get", "expression", "string", "(", ")", "{", "return", "this", "expression", "string", ";", "}" ]

[ "the", "key", "that", "must", "be", "sent", "back", "to", "sql", "to", "access", "the", "next", "page", "of", "results", "if", "equal", "to", "\"", "\"", "then", "there", "is", "no", "next", "page" ]

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

[ "checks", "if", "the", "given", "field", "is", "a", "valid", "pojo", "field", ":", "-", "it", "is", "public", "or", "-", "there", "are", "getter", "and", "setter", "methods", "for", "the", "field" ]

[ "private", "boolean", "is", "valid", "pojo", "field", "(", "field", "f", ",", "class", "<", "?", ">", "clazz", ",", "list", "<", "type", ">", "type", "hierarchy", ")", "{", "if", "(", "modifier", "is", "public", "(", "f", "get", "modifiers", "(", ")", ")", ")", "{", "return", "true", ";", "}", "else", "{", "boolean", "has", "getter", "=", "false", ",", "has", "setter", "=", "false", ";", "final", "string", "field", "name", "low", "=", "f", "get", "name", "(", ")", "to", "lower", "case", "(", ")", "replace", "all", "(", "\"", "\"", ",", "\"", "\"", ")", ";", "type", "field", "type", "=", "f", "get", "generic", "type", "(", ")", ";", "class", "<", "?", ">", "field", "type", "wrapper", "=", "class", "utils", "primitive", "to", "wrapper", "(", "f", "get", "type", "(", ")", ")", ";", "type", "variable", "<", "?", ">", "field", "type", "generic", "=", "null", ";", "if", "(", "field", "type", "instanceof", "type", "variable", ")", "{", "field", "type", "generic", "=", "(", "type", "variable", "<", "?", ">", ")", "field", "type", ";", "field", "type", "=", "materialize", "type", "variable", "(", "type", "hierarchy", ",", "(", "type", "variable", "<", "?", ">", ")", "field", "type", ")", ";", "}", "for", "(", "method", "m", ":", "clazz", "get", "methods", "(", ")", ")", "{", "final", "string", "method", "name", "low", "=", "m", "get", "name", "(", ")", "ends", "with", "(", "\"", "$", "eq", "\"", ")", "?", "m", "get", "name", "(", ")", "to", "lower", "case", "(", ")", "replace", "all", "(", "\"", "\"", ",", "\"", "\"", ")", "replace", "first", "(", "\"", "\\", "\\", "$", "eq", "$", "\"", ",", "\"", "\\", "\\", "$", "eq", "\"", ")", ":", "m", "get", "name", "(", ")", "to", "lower", "case", "(", ")", "replace", "all", "(", "\"", "\"", ",", "\"", "\"", ")", ";", "/", "/", "check", "for", "getter", "if", "(", "/", "/", "the", "name", "should", "be", "\"", "get", "<", "field", "name", ">", "\"", "or", "\"", "<", "field", "name", ">", "\"", "(", "for", "scala", ")", "or", "/", "/", "\"", "is", "<", "field", "name", ">", "\"", "for", "boolean", "fields", "(", "method", "name", "low", "equals", "(", "\"", "get", "\"", "+", "field", "name", "low", ")", "|", "|", "method", "name", "low", "equals", "(", "\"", "is", "\"", "+", "field", "name", "low", ")", "|", "|", "method", "name", "low", "equals", "(", "field", "name", "low", ")", ")", "&", "&", "/", "/", "no", "arguments", "for", "the", "getter", "m", "get", "parameter", "types", "(", ")", "length", "=", "=", "0", "&", "&", "/", "/", "return", "type", "is", "same", "as", "field", "type", "(", "or", "the", "generic", "variant", "of", "it", ")", "(", "m", "get", "generic", "return", "type", "(", ")", "equals", "(", "field", "type", ")", "|", "|", "(", "m", "get", "return", "type", "(", ")", "equals", "(", "field", "type", "wrapper", ")", ")", "|", "|", "(", "m", "get", "generic", "return", "type", "(", ")", "equals", "(", "field", "type", "generic", ")", ")", ")", ")", "{", "has", "getter", "=", "true", ";", "}", "/", "/", "check", "for", "setters", "(", "<", "field", "name", ">", "$", "eq", "for", "scala", ")", "if", "(", "(", "method", "name", "low", "equals", "(", "\"", "set", "\"", "+", "field", "name", "low", ")", "|", "|", "method", "name", "low", "equals", "(", "field", "name", "low", "+", "\"", "$", "eq", "\"", ")", ")", "&", "&", "m", "get", "parameter", "types", "(", ")", "length", "=", "=", "1", "&", "&", "/", "/", "one", "parameter", "of", "the", "field", "'", "s", "type", "(", "m", "get", "generic", "parameter", "types", "(", ")", "[", "0", "]", "equals", "(", "field", "type", ")", "|", "|", "(", "m", "get", "parameter", "types", "(", ")", "[", "0", "]", "equals", "(", "field", "type", "wrapper", ")", ")", "|", "|", "(", "m", "get", "generic", "parameter", "types", "(", ")", "[", "0", "]", "equals", "(", "field", "type", "generic", ")", ")", ")", "&", "&", "/", "/", "return", "type", "is", "void", "(", "or", "the", "class", "self", ")", "(", "m", "get", "return", "type", "(", ")", "equals", "(", "void", "type", ")", "|", "|", "m", "get", "return", "type", "(", ")", "equals", "(", "clazz", ")", ")", ")", "{", "has", "setter", "=", "true", ";", "}", "}", "if", "(", "has", "getter", "&", "&", "has", "setter", ")", "{", "return", "true", ";", "}", "else", "{", "if", "(", "!", "has", "getter", "&", "&", "clazz", "!", "=", "row", "class", ")", "{", "log", "info", "(", "clazz", "+", "\"", "does", "not", "contain", "a", "getter", "for", "field", "\"", "+", "f", "get", "name", "(", ")", ")", ";", "}", "if", "(", "!", "has", "setter", "&", "&", "clazz", "!", "=", "row", "class", ")", "{", "log", "info", "(", "clazz", "+", "\"", "does", "not", "contain", "a", "setter", "for", "field", "\"", "+", "f", "get", "name", "(", ")", ")", ";", "}", "return", "false", ";", "}", "}", "}" ]

[ "create", "the", "x", "content", "header", "for", "any", "{", "@", "link", "base", "nodes", "response", "}" ]

[ "public", "static", "<", "node", "response", "extends", "base", "node", "response", ">", "void", "build", "nodes", "header", "(", "final", "x", "content", "builder", "builder", ",", "final", "params", "params", ",", "final", "base", "nodes", "response", "<", "node", "response", ">", "response", ")", "throws", "i", "o", "exception", "{", "final", "int", "successful", "=", "response", "get", "nodes", "(", ")", "size", "(", ")", ";", "final", "int", "failed", "=", "response", "failures", "(", ")", "size", "(", ")", ";", "build", "nodes", "header", "(", "builder", ",", "params", ",", "successful", "+", "failed", ",", "successful", ",", "failed", ",", "response", "failures", "(", ")", ")", ";", "}" ]

[ "register", "a", "callback", "listener", "and", "async", "task", "will", "start", "executing", "right", "away" ]

[ "public", "void", "listen", "(", "find", "callback", "<", "t", ">", "callback", ")", "{", "cb", "=", "callback", ";", "execute", "(", ")", ";", "}" ]

[ "set", "the", "maximum", "number", "of", "instructions", "in", "a", "single", "run", "which", "contain", "the", "same", "byte", "values", "disassembly", "flow", "will", "stop", "and", "be", "flagged", "when", "this", "threshold", "is", "encountered", "this", "check", "is", "set", "to", "max", "repeat", "pattern", "length", "by", "default", ",", "and", "can", "be", "disabled", "by", "setting", "a", "value", "of", "-", "1", "note", ":", "this", "restriction", "will", "only", "work", "for", "those", "cases", "where", "a", "given", "repeated", "byte", "results", "in", "an", "instruction", "which", "has", "a", "fall", "-", "through" ]

[ "public", "void", "set", "repeat", "pattern", "limit", "(", "int", "max", "instructions", ")", "{", "repeat", "instruction", "byte", "tracker", "set", "repeat", "pattern", "limit", "(", "max", "instructions", ")", ";", "}" ]

[ "set", "the", "minimum", "number", "of", "idle", "objects", "in", "the", "pool", "default", "is", "0" ]

[ "public", "void", "set", "min", "idle", "(", "int", "min", "idle", ")", "{", "this", "min", "idle", "=", "min", "idle", ";", "}" ]

[ "sets", "if", "the", "encoder", "should", "queue", "frames", "if", "the", "maximum", "number", "of", "concurrent", "streams", "would", "otherwise", "be", "exceeded" ]

[ "protected", "b", "encoder", "enforce", "max", "concurrent", "streams", "(", "boolean", "encoder", "enforce", "max", "concurrent", "streams", ")", "{", "enforce", "non", "codec", "constraints", "(", "\"", "encoder", "enforce", "max", "concurrent", "streams", "\"", ")", ";", "this", "encoder", "enforce", "max", "concurrent", "streams", "=", "encoder", "enforce", "max", "concurrent", "streams", ";", "return", "self", "(", ")", ";", "}" ]

[ "<", "code", ">", "merge", "references", "<", "code", ">", "merges", "all", "references", "in", "the", "specified", "address", "set", "from", "the", "second", "program", "based", "on", "the", "current", "merge", "filter", "setting", "it", "merges", "them", "into", "the", "merge", "program" ]

[ "void", "merge", "references", "(", "address", "set", "view", "p", "1", "merge", "set", ",", "program", "merge", "filter", "filter", ",", "task", "monitor", "monitor", ")", "throws", "cancelled", "exception", "{", "boolean", "merge", "refs", "=", "(", "filter", "get", "filter", "(", "program", "merge", "filter", "references", ")", "=", "=", "program", "merge", "filter", "replace", ")", ";", "if", "(", "!", "merge", "refs", ")", "{", "return", ";", "}", "program", "diff", "filter", "ref", "diff", "filter", "=", "new", "program", "diff", "filter", "(", "program", "diff", "filter", "reference", "diffs", ")", ";", "address", "set", "view", "ref", "diff", "set", "=", "program", "diff", "get", "differences", "(", "ref", "diff", "filter", ",", "monitor", ")", ";", "address", "set", "view", "diff", "addr", "set", "=", "p", "1", "merge", "set", "intersect", "(", "ref", "diff", "set", ")", ";", "address", "set", "diff", "addr", "set", "2", "=", "diff", "utility", "get", "compatible", "address", "set", "(", "diff", "addr", "set", ",", "program", "2", ")", ";", "merger", "replace", "references", "(", "diff", "addr", "set", "2", ",", "monitor", ")", ";", "}" ]

[ "resolves", "symlink", ",", "if", "the", "given", "file", "is", "a", "symlink", "otherwise", "return", "null", "if", "the", "resolution", "fails", ",", "report", "an", "error" ]

[ "public", "static", "string", "resolve", "symlink", "(", "@", "non", "null", "file", "link", ")", "throws", "i", "o", "exception", "{", "try", "{", "path", "path", "=", "file", "to", "path", "(", "link", ")", ";", "return", "files", "read", "symbolic", "link", "(", "path", ")", "to", "string", "(", ")", ";", "}", "catch", "(", "unsupported", "operation", "exception", "|", "file", "system", "exception", "x", ")", "{", "/", "/", "no", "symlinks", "on", "this", "platform", "(", "windows", "?", ")", ",", "/", "/", "or", "not", "a", "link", "(", "/", "/", "thrown", "(", "\"", "incorrect", "function", "\"", ")", "on", "jdk", "7u", "2", "1", "in", "windows", "2012", "when", "called", "on", "a", "non", "-", "symlink", ",", "/", "/", "rather", "than", "not", "link", "exception", ",", "contrary", "to", "documentation", "maybe", "only", "when", "not", "on", "ntfs", "?", ")", "?", "return", "null", ";", "}", "catch", "(", "i", "o", "exception", "x", ")", "{", "throw", "x", ";", "}", "catch", "(", "exception", "x", ")", "{", "throw", "new", "i", "o", "exception", "(", "x", ")", ";", "}", "}" ]

[ "excluded", "and", "favored", "nodes", "are", "not", "verified", "and", "will", "be", "ignored", "by", "placement", "policy", "if", "they", "are", "not", "in", "the", "same", "nameservice", "as", "the", "file" ]

[ "public", "located", "block", "add", "block", "(", "string", "src", ",", "string", "client", "name", ",", "extended", "block", "previous", ",", "datanode", "info", "[", "]", "excluded", "nodes", ",", "long", "file", "id", ",", "string", "[", "]", "favored", "nodes", ",", "enum", "set", "<", "add", "block", "flag", ">", "add", "block", "flags", ")", "throws", "i", "o", "exception", "{", "rpc", "server", "check", "operation", "(", "name", "node", "operation", "category", "write", ")", ";", "remote", "method", "method", "=", "new", "remote", "method", "(", "\"", "add", "block", "\"", ",", "new", "class", "<", "?", ">", "[", "]", "{", "string", "class", ",", "string", "class", ",", "extended", "block", "class", ",", "datanode", "info", "[", "]", "class", ",", "long", "class", ",", "string", "[", "]", "class", ",", "enum", "set", "class", "}", ",", "new", "remote", "param", "(", ")", ",", "client", "name", ",", "previous", ",", "excluded", "nodes", ",", "file", "id", ",", "favored", "nodes", ",", "add", "block", "flags", ")", ";", "if", "(", "previous", "!", "=", "null", ")", "{", "return", "rpc", "client", "invoke", "single", "(", "previous", ",", "method", ",", "located", "block", "class", ")", ";", "}", "final", "list", "<", "remote", "location", ">", "locations", "=", "rpc", "server", "get", "locations", "for", "path", "(", "src", ",", "true", ")", ";", "/", "/", "todo", "verify", "the", "excluded", "nodes", "and", "favored", "nodes", "are", "acceptable", "to", "this", "nn", "return", "rpc", "client", "invoke", "sequential", "(", "locations", ",", "method", ",", "located", "block", "class", ",", "null", ")", ";", "}" ]

[ "returns", "the", "bottom", "gutter", "(", "black", "bar", ")", "height", "in", "screen", "coordinates" ]

[ "public", "int", "get", "bottom", "gutter", "height", "(", ")", "{", "return", "screen", "y", ";", "}" ]

[ "check", "if", "a", "string", "starts", "with", "a", "specified", "prefix", "(", "optionally", "case", "insensitive", ")" ]

[ "private", "static", "boolean", "starts", "with", "(", "string", "str", ",", "string", "prefix", ",", "boolean", "ignore", "case", ")", "{", "if", "(", "str", "=", "=", "null", "|", "|", "prefix", "=", "=", "null", ")", "{", "return", "(", "str", "=", "=", "null", "&", "&", "prefix", "=", "=", "null", ")", ";", "}", "if", "(", "prefix", "length", "(", ")", ">", "str", "length", "(", ")", ")", "{", "return", "false", ";", "}", "return", "str", "region", "matches", "(", "ignore", "case", ",", "0", ",", "prefix", ",", "0", ",", "prefix", "length", "(", ")", ")", ";", "}" ]

[ "expires", "the", "zk", "session", "associated", "with", "service", "'", "from", "idx", "'", ",", "and", "waits", "until", "service", "'", "to", "idx", "'", "takes", "over" ]

[ "public", "void", "expire", "and", "verify", "failover", "(", "int", "from", "idx", ",", "int", "to", "idx", ")", "throws", "exception", "{", "preconditions", "check", "argument", "(", "from", "idx", "!", "=", "to", "idx", ")", ";", "get", "elector", "(", "from", "idx", ")", "prevent", "session", "reestablishment", "for", "tests", "(", ")", ";", "try", "{", "expire", "active", "lock", "holder", "(", "from", "idx", ")", ";", "wait", "for", "h", "a", "state", "(", "from", "idx", ",", "h", "a", "service", "state", "standby", ")", ";", "wait", "for", "h", "a", "state", "(", "to", "idx", ",", "h", "a", "service", "state", "active", ")", ";", "}", "finally", "{", "get", "elector", "(", "from", "idx", ")", "allow", "session", "reestablishment", "for", "tests", "(", ")", ";", "}", "}" ]

[ "specifies", "a", "{", "@", "link", "key", "selector", "}", "for", "elements", "from", "the", "second", "input", "with", "explicit", "type", "information", "for", "the", "key", "type" ]

[ "public", "equal", "to", "equal", "to", "(", "key", "selector", "<", "t2", ",", "key", ">", "key", "selector", ",", "type", "information", "<", "key", ">", "key", "type", ")", "{", "require", "non", "null", "(", "key", "selector", ")", ";", "require", "non", "null", "(", "key", "type", ")", ";", "if", "(", "!", "key", "type", "equals", "(", "this", "key", "type", ")", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "the", "keys", "for", "the", "two", "inputs", "are", "not", "equal", ":", "\"", "+", "\"", "first", "key", "=", "\"", "+", "this", "key", "type", "+", "\"", ",", "second", "key", "=", "\"", "+", "key", "type", ")", ";", "}", "return", "new", "equal", "to", "(", "input", "2", "clean", "(", "key", "selector", ")", ")", ";", "}", "/", "/", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-" ]

[ "reboot", "the", "device", "to", "bootloader", "requires", "root", "permission" ]

[ "public", "static", "boolean", "reboot", "2", "bootloader", "(", ")", "{", "shell", "utils", "command", "result", "result", "=", "shell", "utils", "exec", "cmd", "(", "\"", "reboot", "bootloader", "\"", ",", "true", ")", ";", "return", "result", "result", "=", "=", "0", ";", "}" ]

[ "disable", "litho", "animations", "this", "might", "be", "useful", "for", "cases", "where", "within", "a", "test", "method", "you", "can", "enable", "animations", "for", "certain", "actions", ",", "while", "disabling", "it", "for", "others", "all", "within", "single", "test", "method", "note", "that", "there", "is", "no", "need", "to", "disable", "on", "tear", "down", "of", "the", "test", "class", "as", "we", "make", "sure", "to", "turn", "animation", "back", "to", "its", "original", "value", "when", "every", "test", "method", "finishes" ]

[ "public", "void", "disable", "(", ")", "{", "components", "configuration", "force", "enable", "transitions", "for", "instrumentation", "tests", "=", "false", ";", "}" ]

[ "set", "the", "thread", "pool", "executor", "'", "s", "core", "pool", "size", "default", "is", "1", "<", "b", ">", "this", "setting", "can", "be", "modified", "at", "runtime", ",", "for", "example", "through", "jmx", "<", "b", ">" ]

[ "public", "void", "set", "core", "pool", "size", "(", "int", "core", "pool", "size", ")", "{", "synchronized", "(", "this", "pool", "size", "monitor", ")", "{", "this", "core", "pool", "size", "=", "core", "pool", "size", ";", "if", "(", "this", "thread", "pool", "executor", "!", "=", "null", ")", "{", "this", "thread", "pool", "executor", "set", "core", "pool", "size", "(", "core", "pool", "size", ")", ";", "}", "}", "}" ]

[ "returns", "the", "list", "of", "output", "symlinks" ]

[ "public", "immutable", "set", "<", "fileset", "output", "symlink", ">", "get", "symlinks", "(", ")", "{", "return", "symlinks", ";", "}" ]

[ "an", "implementation", "of", "the", "graceful", "stop", "sequence", "recommended", "by", "{", "@", "link", "executor", "service", "}" ]

[ "public", "static", "void", "shutdown", "gracefully", "(", "executor", "service", "executor", ",", "long", "timeout", ",", "time", "unit", "time", "unit", ")", "{", "/", "/", "disable", "new", "tasks", "from", "being", "submitted", "executor", "shutdown", "(", ")", ";", "try", "{", "/", "/", "wait", "a", "while", "for", "existing", "tasks", "to", "terminate", "if", "(", "!", "executor", "await", "termination", "(", "timeout", ",", "time", "unit", ")", ")", "{", "executor", "shutdown", "now", "(", ")", ";", "/", "/", "wait", "a", "while", "for", "tasks", "to", "respond", "to", "being", "cancelled", "if", "(", "!", "executor", "await", "termination", "(", "timeout", ",", "time", "unit", ")", ")", "{", "log", "warn", "(", "string", "format", "(", "\"", "%", "s", "didn", "'", "t", "terminate", "!", "\"", ",", "executor", ")", ")", ";", "}", "}", "}", "catch", "(", "interrupted", "exception", "ie", ")", "{", "/", "/", "(", "re", "-", ")", "cancel", "if", "current", "thread", "also", "interrupted", "executor", "shutdown", "now", "(", ")", ";", "/", "/", "preserve", "interrupt", "status", "thread", "current", "thread", "(", ")", "interrupt", "(", ")", ";", "}", "}" ]

[ "this", "only", "returns", "after", "all", "input", "queues", "are", "empty" ]

[ "public", "void", "wait", "for", "input", "processing", "(", ")", "throws", "exception", "{", "while", "(", "task", "thread", "is", "alive", "(", ")", ")", "{", "boolean", "all", "empty", "=", "true", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "num", "input", "gates", ";", "i", "+", "+", ")", "{", "if", "(", "!", "input", "gates", "[", "i", "]", "all", "queues", "empty", "(", ")", ")", "{", "all", "empty", "=", "false", ";", "}", "}", "if", "(", "all", "empty", ")", "{", "break", ";", "}", "}", "/", "/", "wait", "for", "all", "currently", "available", "input", "has", "been", "processed", "final", "atomic", "boolean", "all", "input", "processed", "=", "new", "atomic", "boolean", "(", ")", ";", "final", "mailbox", "processor", "mailbox", "processor", "=", "task", "thread", "task", "mailbox", "processor", ";", "final", "mailbox", "executor", "mailbox", "executor", "=", "mailbox", "processor", "get", "main", "mailbox", "executor", "(", ")", ";", "while", "(", "task", "thread", "is", "alive", "(", ")", ")", "{", "try", "{", "final", "count", "down", "latch", "latch", "=", "new", "count", "down", "latch", "(", "1", ")", ";", "mailbox", "executor", "execute", "(", "(", ")", "-", ">", "{", "all", "input", "processed", "set", "(", "mailbox", "processor", "is", "default", "action", "unavailable", "(", ")", ")", ";", "latch", "count", "down", "(", ")", ";", "}", ",", "\"", "query", "-", "whether", "-", "process", "input", "-", "has", "-", "suspend", "-", "itself", "\"", ")", ";", "/", "/", "mail", "could", "be", "dropped", "due", "to", "task", "exception", ",", "so", "we", "do", "timed", "-", "await", "here", "latch", "await", "(", "1", ",", "time", "unit", "seconds", ")", ";", "}", "catch", "(", "rejected", "execution", "exception", "ex", ")", "{", "/", "/", "loop", "until", "task", "thread", "exit", "for", "possible", "task", "exception", "}", "if", "(", "all", "input", "processed", "get", "(", ")", ")", "{", "break", ";", "}", "try", "{", "thread", "sleep", "(", "1", ")", ";", "}", "catch", "(", "interrupted", "exception", "ignored", ")", "{", "}", "}", "throwable", "error", "=", "task", "thread", "get", "error", "(", ")", ";", "if", "(", "error", "!", "=", "null", ")", "{", "throw", "new", "exception", "(", "\"", "exception", "in", "the", "task", "thread", "\"", ",", "error", ")", ";", "}", "}" ]

[ "serializes", "transaction", "header", "and", "transaction", "data", "into", "a", "byte", "buffer" ]

[ "public", "static", "byte", "[", "]", "marshall", "txn", "entry", "(", "txn", "header", "hdr", ",", "record", "txn", ")", "throws", "i", "o", "exception", "{", "return", "marshall", "txn", "entry", "(", "hdr", ",", "txn", ",", "null", ")", ";", "}" ]

[ "a", "sensible", "definition", "of", "{", "@", "link", "#", "sub", "multiset", "(", "object", ",", "bound", "type", ",", "object", ",", "bound", "type", ")", "}", "in", "terms", "of", "{", "@", "link", "#", "head", "multiset", "(", "object", ",", "bound", "type", ")", "head", "multiset", "}", "and", "{", "@", "link", "#", "tail", "multiset", "(", "object", ",", "bound", "type", ")", "tail", "multiset", "}", "if", "you", "override", "either", "of", "these", "methods", ",", "you", "may", "wish", "to", "override", "{", "@", "link", "#", "sub", "multiset", "(", "object", ",", "bound", "type", ",", "object", ",", "bound", "type", ")", "}", "to", "forward", "to", "this", "implementation" ]

[ "protected", "sorted", "multiset", "<", "e", ">", "standard", "sub", "multiset", "(", "e", "lower", "bound", ",", "bound", "type", "lower", "bound", "type", ",", "e", "upper", "bound", ",", "bound", "type", "upper", "bound", "type", ")", "{", "return", "tail", "multiset", "(", "lower", "bound", ",", "lower", "bound", "type", ")", "head", "multiset", "(", "upper", "bound", ",", "upper", "bound", "type", ")", ";", "}" ]

[ "gets", "the", "number", "of", "job", "vertices", "currently", "held", "by", "this", "execution", "graph" ]

[ "public", "int", "get", "number", "of", "execution", "job", "vertices", "(", ")", "{", "return", "this", "vertices", "in", "creation", "order", "size", "(", ")", ";", "}" ]

[ "get", "the", "value", "of", "the", "'", "{", "@", "code", "target", "}", "'", "attribute" ]

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

[ "returns", "1", "if", "write", "has", "been", "stopped" ]

[ "public", "void", "enable", "is", "write", "stopped", "(", ")", "{", "this", "properties", "add", "(", "rocks", "d", "b", "property", "is", "write", "stopped", "get", "rocks", "d", "b", "property", "(", ")", ")", ";", "}" ]

[ "test", "once", "update", "more", "than", "one", "level", "is", "not", "allowed" ]

[ "public", "void", "test", "once", "update", "more", "than", "one", "level", "(", ")", "{", "try", "{", "heap", "head", "index", "update", "level", "(", "heap", "head", "index", "get", "level", "(", ")", "+", "2", ")", ";", "assert", "fail", "(", "\"", "should", "have", "thrown", "exception", "\"", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "assert", "assert", "true", "(", "e", "instanceof", "illegal", "argument", "exception", ")", ";", "}", "}" ]

[ "shutdown", "the", "chain", "of", "interceptors", "when", "the", "object", "is", "destroyed" ]

[ "protected", "void", "finalize", "(", ")", "{", "root", "interceptor", "shutdown", "(", ")", ";", "}" ]

[ "sets", "the", "message", "below", "the", "progress", "meter", "in", "the", "current", "phase", "progress", "area" ]

[ "void", "update", "progress", "details", "(", "string", "progress", "description", ")", "{", "provider", "update", "progress", "details", "(", "progress", "description", ")", ";", "}" ]

[ "traverses", "an", "iterator", "and", "removes", "every", "element", "that", "belongs", "to", "the", "provided", "collection", "the", "iterator", "will", "be", "left", "exhausted", ":", "its", "{", "@", "code", "has", "next", "(", ")", "}", "method", "will", "return", "{", "@", "code", "false", "}" ]

[ "public", "static", "boolean", "remove", "all", "(", "iterator", "<", "?", ">", "remove", "from", ",", "collection", "<", "?", ">", "elements", "to", "remove", ")", "{", "check", "not", "null", "(", "elements", "to", "remove", ")", ";", "boolean", "result", "=", "false", ";", "while", "(", "remove", "from", "has", "next", "(", ")", ")", "{", "if", "(", "elements", "to", "remove", "contains", "(", "remove", "from", "next", "(", ")", ")", ")", "{", "remove", "from", "remove", "(", ")", ";", "result", "=", "true", ";", "}", "}", "return", "result", ";", "}" ]

[ "attempt", "to", "gracefully", "cleanup", "the", "rollup", "job", "so", "it", "can", "be", "terminated", "this", "tries", "to", "remove", "the", "job", "from", "the", "scheduler", ",", "and", "potentially", "any", "other", "cleanup", "operations", "in", "the", "future" ]

[ "synchronized", "void", "shutdown", "(", ")", "{", "try", "{", "logger", "info", "(", "\"", "rollup", "indexer", "[", "\"", "+", "job", "get", "config", "(", ")", "get", "id", "(", ")", "+", "\"", "]", "received", "abort", "request", ",", "stopping", "indexer", "\"", ")", ";", "scheduler", "engine", "remove", "(", "schedule", "name", "+", "\"", "\"", "+", "job", "get", "config", "(", ")", "get", "id", "(", ")", ")", ";", "scheduler", "engine", "unregister", "(", "this", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "mark", "as", "failed", "(", "e", ")", ";", "return", ";", "}", "mark", "as", "completed", "(", ")", ";", "}" ]

[ "set", "the", "admin", "state", "of", "the", "datanode" ]

[ "public", "void", "set", "admin", "state", "(", "final", "admin", "states", "admin", "state", ")", "{", "this", "admin", "state", "=", "admin", "state", ";", "}" ]

[ "the", "given", "substream", "is", "drained" ]

[ "state", "substream", "drained", "(", "substream", "substream", ")", "{", "check", "state", "(", "!", "pass", "through", ",", "\"", "already", "pass", "through", "\"", ")", ";", "collection", "<", "substream", ">", "drained", "substreams", ";", "if", "(", "substream", "closed", ")", "{", "drained", "substreams", "=", "this", "drained", "substreams", ";", "}", "else", "if", "(", "this", "drained", "substreams", "is", "empty", "(", ")", ")", "{", "/", "/", "optimize", "for", "0", "-", "retry", ",", "which", "is", "most", "of", "the", "cases", "drained", "substreams", "=", "collections", "singleton", "list", "(", "substream", ")", ";", "}", "else", "{", "drained", "substreams", "=", "new", "array", "list", "<", ">", "(", "this", "drained", "substreams", ")", ";", "drained", "substreams", "add", "(", "substream", ")", ";", "drained", "substreams", "=", "collections", "unmodifiable", "collection", "(", "drained", "substreams", ")", ";", "}", "boolean", "pass", "through", "=", "winning", "substream", "!", "=", "null", ";", "list", "<", "buffer", "entry", ">", "buffer", "=", "this", "buffer", ";", "if", "(", "pass", "through", ")", "{", "check", "state", "(", "winning", "substream", "=", "=", "substream", ",", "\"", "another", "rpc", "attempt", "has", "already", "committed", "\"", ")", ";", "buffer", "=", "null", ";", "}", "return", "new", "state", "(", "buffer", ",", "drained", "substreams", ",", "active", "hedges", ",", "winning", "substream", ",", "cancelled", ",", "pass", "through", ",", "hedging", "frozen", ",", "hedging", "attempt", "count", ")", ";", "}" ]

[ "encode", "the", "given", "source", "into", "an", "encoded", "string", "using", "the", "rules", "specified", "by", "the", "given", "component", "and", "with", "the", "given", "options" ]

[ "static", "string", "encode", "uri", "component", "(", "string", "source", ",", "charset", "charset", ",", "type", "type", ")", "{", "if", "(", "!", "string", "utils", "has", "length", "(", "source", ")", ")", "{", "return", "source", ";", "}", "assert", "not", "null", "(", "charset", ",", "\"", "charset", "must", "not", "be", "null", "\"", ")", ";", "assert", "not", "null", "(", "type", ",", "\"", "type", "must", "not", "be", "null", "\"", ")", ";", "byte", "[", "]", "bytes", "=", "source", "get", "bytes", "(", "charset", ")", ";", "boolean", "original", "=", "true", ";", "for", "(", "byte", "b", ":", "bytes", ")", "{", "if", "(", "!", "type", "is", "allowed", "(", "b", ")", ")", "{", "original", "=", "false", ";", "break", ";", "}", "}", "if", "(", "original", ")", "{", "return", "source", ";", "}", "byte", "array", "output", "stream", "baos", "=", "new", "byte", "array", "output", "stream", "(", "bytes", "length", ")", ";", "for", "(", "byte", "b", ":", "bytes", ")", "{", "if", "(", "type", "is", "allowed", "(", "b", ")", ")", "{", "baos", "write", "(", "b", ")", ";", "}", "else", "{", "baos", "write", "(", "'", "%", "'", ")", ";", "char", "hex", "1", "=", "character", "to", "upper", "case", "(", "character", "for", "digit", "(", "(", "b", ">", ">", "4", ")", "&", "0x", "f", ",", "16", ")", ")", ";", "char", "hex", "2", "=", "character", "to", "upper", "case", "(", "character", "for", "digit", "(", "b", "&", "0x", "f", ",", "16", ")", ")", ";", "baos", "write", "(", "hex", "1", ")", ";", "baos", "write", "(", "hex", "2", ")", ";", "}", "}", "return", "stream", "utils", "copy", "to", "string", "(", "baos", ",", "charset", ")", ";", "}" ]

[ "transition", "to", "the", "completed", "state", "and", "set", "the", "value" ]

[ "boolean", "set", "(", "@", "nullable", "decl", "v", "v", ")", "{", "return", "complete", "(", "v", ",", "null", ",", "completed", ")", ";", "}" ]

[ "test", "the", "property", "'", "declawed", "'" ]

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

[ "specify", "the", "target", "class", "explicitly", ",", "to", "avoid", "any", "kind", "of", "access", "to", "the", "target", "bean", "(", "for", "example", ",", "to", "avoid", "initialization", "of", "a", "factory", "bean", "instance", ")", "default", "is", "to", "detect", "the", "type", "automatically", ",", "through", "a", "{", "@", "code", "get", "type", "}", "call", "on", "the", "bean", "factory", "(", "or", "even", "a", "full", "{", "@", "code", "get", "bean", "}", "call", "as", "fallback", ")" ]

[ "public", "void", "set", "target", "class", "(", "class", "<", "?", ">", "target", "class", ")", "{", "this", "target", "class", "=", "target", "class", ";", "}" ]

[ "test", "the", "property", "'", "small", "camel", "'" ]

[ "public", "void", "small", "camel", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "small", "camel", "}" ]

[ "makes", "sure", "that", "annotations", "in", "the", "polling", "output", "is", "handled", "correctly" ]

[ "@", "test", "public", "void", "polling", "output", "(", ")", "throws", "exception", "{", "free", "style", "project", "p", "=", "r", "create", "free", "style", "project", "(", ")", ";", "p", "set", "scm", "(", "new", "polling", "s", "c", "m", "(", ")", ")", ";", "s", "c", "m", "trigger", "t", "=", "new", "s", "c", "m", "trigger", "(", "\"", "@", "daily", "\"", ")", ";", "t", "start", "(", "p", ",", "true", ")", ";", "p", "add", "trigger", "(", "t", ")", ";", "r", "build", "and", "assert", "success", "(", "p", ")", ";", "/", "/", "poll", "now", "t", "new", "runner", "(", ")", "run", "(", ")", ";", "html", "page", "log", "=", "r", "create", "web", "client", "(", ")", "get", "page", "(", "p", ",", "\"", "scm", "poll", "log", "\"", ")", ";", "string", "text", "=", "log", "as", "text", "(", ")", ";", "assert", "true", "(", "text", ",", "text", "contains", "(", "\"", "$", "$", "$", "hello", "from", "polling", "\"", ")", ")", ";", "}" ]

[ "sends", "the", "rss", "feed", "to", "the", "client", "using", "a", "specific", "feed", "adapter" ]

[ "public", "static", "void", "rss", "(", "stapler", "request", "req", ",", "stapler", "response", "rsp", ",", "string", "title", ",", "string", "url", ",", "run", "list", "run", "list", ",", "feed", "adapter", "<", "run", ">", "feed", "adapter", ")", "throws", "i", "o", "exception", ",", "servlet", "exception", "{", "final", "feed", "adapter", "<", "run", ">", "feed", "adapter", "=", "feed", "adapter", "=", "=", "null", "?", "run", "feed", "adapter", ":", "feed", "adapter", ";", "forward", "to", "rss", "(", "title", ",", "url", ",", "run", "list", ",", "feed", "adapter", ",", "req", ",", "rsp", ")", ";", "}" ]

[ "checks", "the", "revocation", "status", "of", "the", "given", "certificate" ]

[ "default", "void", "check", "(", "final", "x", "5", "0", "9", "certificate", "certificate", ")", "throws", "general", "security", "exception", "{", "}" ]

[ "verify", "that", "configured", "paths", "are", "normalized", "by", "removing", "redundant", "separators" ]

[ "public", "void", "test", "protected", "dir", "normalization", "1", "(", ")", "{", "configuration", "conf", "=", "new", "hdfs", "configuration", "(", ")", ";", "conf", "set", "(", "common", "configuration", "keys", "fs", "protected", "directories", ",", "\"", "/", "foo", "/", "/", "bar", "\"", ")", ";", "collection", "<", "string", ">", "paths", "=", "f", "s", "directory", "parse", "protected", "directories", "(", "conf", ")", ";", "assert", "that", "(", "paths", "size", "(", ")", ",", "is", "(", "1", ")", ")", ";", "assert", "that", "(", "paths", "iterator", "(", ")", "next", "(", ")", ",", "is", "(", "\"", "/", "foo", "/", "bar", "\"", ")", ")", ";", "}" ]

[ "get", "attribute", "boolean" ]

[ "public", "boolean", "is", "attribute", "boolean", "(", ")", "{", "return", "attribute", "boolean", ";", "}" ]

[ "returns", "the", "current", "cpu", "utilization", "of", "the", "current", "process", "in", "ms", "the", "returned", "array", "contains", "the", "following", "information", ":", "the", "1st", "entry", "is", "the", "number", "of", "ms", "that", "the", "process", "has", "executed", "in", "user", "mode", ",", "and", "the", "2nd", "entry", "is", "the", "number", "of", "ms", "that", "the", "process", "has", "executed", "in", "kernel", "mode", "reads", "procselfstat", "to", "obtain", "this", "information" ]

[ "public", "long", "[", "]", "get", "cpu", "utilization", "in", "ms", "(", ")", "{", "return", "new", "long", "[", "]", "{", "cpu", "utilization", "in", "jiffies", "[", "0", "]", "*", "10", ",", "cpu", "utilization", "in", "jiffies", "[", "1", "]", "*", "10", "}", ";", "}" ]

[ "to", "string", "address", "string" ]

[ "public", "static", "string", "to", "string", "address", "(", "inet", "socket", "address", "address", ")", "{", "return", "address", "get", "address", "(", ")", "get", "host", "address", "(", ")", "+", "\"", ":", "\"", "+", "address", "get", "port", "(", ")", ";", "}" ]

[ "number", "of", "retries", "that", "had", "to", "be", "attempted", "due", "to", "bulk", "actions", "being", "rejected" ]

[ "public", "long", "get", "bulk", "retries", "(", ")", "{", "return", "bulk", "retries", ";", "}" ]

[ "validate", "the", "bug", "fix", "for", "hadoop", "-", "17089", "please", "note", "that", "we", "were", "never", "able", "to", "reproduce", "this", "except", "during", "a", "spark", "job", "that", "ran", "for", "multiple", "days", "and", "in", "a", "hacked", "-", "up", "azure", "-", "storage", "sdk", "that", "added", "sleep", "before", "and", "after", "the", "call", "to", "factory", "set", "namespace", "aware", "(", "true", ")", "as", "shown", "in", "the", "description", "of" ]

[ "public", "void", "test", "concurrent", "list", "(", ")", "throws", "exception", "{", "final", "path", "test", "dir", "=", "new", "path", "(", "\"", "/", "tmp", "/", "data", "-", "loss", "/", "11230174258112", "/", "temporary", "/", "0", "/", "temporary", "/", "attempt", "20200624190514", "0006", "m", "0", "\"", ")", ";", "final", "path", "test", "file", "=", "new", "path", "(", "test", "dir", ",", "\"", "part", "-", "00004", "-", "1", "5ea", "8", "7b", "1", "-", "3", "1", "2c", "-", "4fdf", "-", "1820", "-", "9", "5afb", "3dfc", "1c", "3", "-", "a", "0", "1", "0", "snappy", "parquet", "\"", ")", ";", "fs", "create", "(", "test", "file", ")", "close", "(", ")", ";", "list", "<", "list", "task", ">", "tasks", "=", "new", "array", "list", "<", ">", "(", "thread", "count", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "thread", "count", ";", "i", "+", "+", ")", "{", "tasks", "add", "(", "new", "list", "task", "(", "fs", ",", "test", "dir", ")", ")", ";", "}", "executor", "service", "es", "=", "null", ";", "try", "{", "es", "=", "executors", "new", "fixed", "thread", "pool", "(", "thread", "count", ")", ";", "list", "<", "future", "<", "integer", ">", ">", "futures", "=", "es", "invoke", "all", "(", "tasks", ")", ";", "for", "(", "future", "<", "integer", ">", "future", ":", "futures", ")", "{", "assert", "assert", "true", "(", "future", "is", "done", "(", ")", ")", ";", "/", "/", "we", "are", "using", "callable", "<", "v", ">", ",", "so", "if", "an", "exception", "/", "/", "occurred", "during", "the", "operation", ",", "it", "will", "be", "thrown", "/", "/", "when", "we", "call", "get", "long", "file", "count", "=", "future", "get", "(", ")", ";", "assert", "equals", "(", "\"", "the", "list", "should", "always", "contain", "1", "file", "\"", ",", "1", ",", "file", "count", ")", ";", "}", "}", "finally", "{", "if", "(", "es", "!", "=", "null", ")", "{", "es", "shutdown", "now", "(", ")", ";", "}", "}", "}" ]

[ "loads", "the", "reference", "value", "from", "the", "variable", "with", "the", "given", "index" ]

[ "public", "reference", "value", "aload", "(", "int", "index", ")", "{", "return", "load", "(", "index", ")", "reference", "value", "(", ")", ";", "}" ]

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

[ "public", "void", "place", "order", "test", "(", ")", "{", "order", "body", "=", "null", ";", "/", "/", "order", "response", "=", "api", "place", "order", "(", "body", ")", ";", "/", "/", "assert", "not", "null", "(", "response", ")", ";", "/", "/", "todo", ":", "test", "validations", "}" ]

[ "return", "whether", "network", "is", "connected", "must", "hold", "{", "@", "code", "<", "uses", "-", "permission", "android", ":", "name", "=", "\"", "android", "permission", "access", "network", "state", "\"", ">", "}" ]

[ "public", "static", "boolean", "is", "connected", "(", ")", "{", "network", "info", "info", "=", "get", "active", "network", "info", "(", ")", ";", "return", "info", "!", "=", "null", "&", "&", "info", "is", "connected", "(", ")", ";", "}" ]

[ "number", "of", "{", "@", "link", "executor", "}", "s", "that", "are", "configured", "for", "this", "computer", "when", "this", "value", "is", "decreased", ",", "it", "is", "temporarily", "possible", "for", "{", "@", "link", "#", "executors", "}", "to", "have", "a", "larger", "number", "than", "this" ]

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

[ "controls", "where", "the", "user", "is", "sent", "to", "after", "a", "logout", "by", "default", ",", "it", "'", "s", "the", "top", "page", "of", "hudson", ",", "but", "you", "can", "return", "arbitrary", "url" ]

[ "protected", "string", "get", "post", "log", "out", "url", "2", "(", "stapler", "request", "req", ",", "authentication", "auth", ")", "{", "if", "(", "util", "is", "overridden", "(", "security", "realm", "class", ",", "get", "class", "(", ")", ",", "\"", "get", "post", "log", "out", "url", "\"", ",", "stapler", "request", "class", ",", "org", "acegisecurity", "authentication", "class", ")", "&", "&", "!", "inside", "get", "post", "log", "out", "url", "get", "(", ")", ")", "{", "inside", "get", "post", "log", "out", "url", "set", "(", "true", ")", ";", "try", "{", "return", "get", "post", "log", "out", "url", "(", "req", ",", "org", "acegisecurity", "authentication", "from", "spring", "(", "auth", ")", ")", ";", "}", "finally", "{", "inside", "get", "post", "log", "out", "url", "set", "(", "false", ")", ";", "}", "}", "return", "req", "get", "context", "path", "(", ")", "+", "\"", "/", "\"", ";", "}" ]

[ "returns", "path", "to", "xpack", "codebase", "path" ]

[ "static", "path", "get", "elasticsearch", "codebase", "(", ")", "{", "url", "url", "=", "x", "pack", "build", "class", "get", "protection", "domain", "(", ")", "get", "code", "source", "(", ")", "get", "location", "(", ")", ";", "try", "{", "return", "path", "utils", "get", "(", "url", "to", "u", "r", "i", "(", ")", ")", ";", "}", "catch", "(", "u", "r", "i", "syntax", "exception", "bogus", ")", "{", "throw", "new", "runtime", "exception", "(", "bogus", ")", ";", "}", "}" ]

[ "common", "{", "@", "link", "android", "resources", "processor", "builder", "}", "builder", "for", "top", "-", "level", "targets", "the", "builder", "will", "be", "populated", "with", "commonly", "-", "used", "settings", "and", "outputs" ]

[ "private", "static", "android", "resources", "processor", "builder", "builder", "for", "top", "level", "target", "(", "android", "data", "context", "data", "context", ",", "stamped", "android", "manifest", "manifest", ",", "string", "proguard", "prefix", ",", "map", "<", "string", ",", "string", ">", "manifest", "values", ")", "{", "return", "new", "android", "resources", "processor", "builder", "(", ")", "/", "/", "settings", "set", "debug", "(", "data", "context", "use", "debug", "(", ")", ")", "set", "java", "package", "(", "manifest", "get", "package", "(", ")", ")", "set", "application", "id", "(", "manifest", "values", "get", "(", "\"", "application", "id", "\"", ")", ")", "set", "version", "code", "(", "manifest", "values", "get", "(", "\"", "version", "code", "\"", ")", ")", "set", "version", "name", "(", "manifest", "values", "get", "(", "\"", "version", "name", "\"", ")", ")", "set", "throw", "on", "resource", "conflict", "(", "data", "context", "throw", "on", "resource", "conflict", "(", ")", ")", "/", "/", "output", "set", "proguard", "out", "(", "proguard", "helper", "get", "proguard", "config", "artifact", "(", "data", "context", "get", "label", "(", ")", ",", "data", "context", "get", "action", "construction", "context", "(", ")", ",", "proguard", "prefix", ")", ")", ";", "}" ]

[ "template", "method", "that", "allows", "for", "custom", "message", "mapping", "invoked", "when", "{", "@", "link", "#", "set", "target", "type", "}", "is", "not", "{", "@", "link", "message", "type", "#", "text", "}", "or", "{", "@", "link", "message", "type", "#", "bytes", "}", "the", "default", "implementation", "throws", "an", "{", "@", "link", "illegal", "argument", "exception", "}" ]

[ "protected", "message", "map", "to", "message", "(", "object", "object", ",", "session", "session", ",", "object", "writer", "object", "writer", ",", "message", "type", "target", "type", ")", "throws", "j", "m", "s", "exception", ",", "i", "o", "exception", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "unsupported", "message", "type", "[", "\"", "+", "target", "type", "+", "\"", "]", "mapping", "jackson", "2", "message", "converter", "by", "default", "only", "supports", "text", "messages", "and", "bytes", "messages", "\"", ")", ";", "}" ]

[ "topology", ":", "source", "(", "parallelism", "=", "1", ")", "-", "-", "(", "forward", ")", "-", "-", ">", "map", "1", "(", "parallelism", "=", "1", ")", "-", "-", "(", "rescale", ")", "-", "-", ">", "map", "2", "(", "parallelism", "=", "2", ")", "-", "-", "(", "rebalance", ")", "-", "-", ">", "sink", "(", "parallelism", "=", "2", ")" ]

[ "private", "static", "stream", "graph", "create", "stream", "graph", "(", ")", "{", "final", "stream", "execution", "environment", "env", "=", "stream", "execution", "environment", "get", "execution", "environment", "(", ")", ";", "final", "data", "stream", "<", "integer", ">", "source", "=", "env", "from", "elements", "(", "1", ",", "2", ",", "3", ")", "set", "parallelism", "(", "1", ")", ";", "final", "data", "stream", "<", "integer", ">", "forward", "=", "new", "data", "stream", "<", ">", "(", "env", ",", "new", "partition", "transformation", "<", ">", "(", "source", "get", "transformation", "(", ")", ",", "new", "forward", "partitioner", "<", ">", "(", ")", ",", "shuffle", "mode", "undefined", ")", ")", ";", "final", "data", "stream", "<", "integer", ">", "map", "1", "=", "forward", "map", "(", "i", "-", ">", "i", ")", "start", "new", "chain", "(", ")", "set", "parallelism", "(", "1", ")", ";", "final", "data", "stream", "<", "integer", ">", "rescale", "=", "new", "data", "stream", "<", ">", "(", "env", ",", "new", "partition", "transformation", "<", ">", "(", "map", "1", "get", "transformation", "(", ")", ",", "new", "rescale", "partitioner", "<", ">", "(", ")", ",", "shuffle", "mode", "undefined", ")", ")", ";", "final", "data", "stream", "<", "integer", ">", "map", "2", "=", "rescale", "map", "(", "i", "-", ">", "i", ")", "set", "parallelism", "(", "2", ")", ";", "map", "2", "rebalance", "(", ")", "print", "(", ")", "set", "parallelism", "(", "2", ")", ";", "return", "env", "get", "stream", "graph", "(", ")", ";", "}" ]

[ "recursively", "explore", "the", "given", "path", "and", "enforce", "the", "limits", "for", "resource", "localization", "this", "method", "assumes", "that", "there", "are", "no", "symlinks", "in", "the", "directory", "structure" ]

[ "private", "void", "explore", "path", "(", "configuration", "job", ",", "path", "p", ",", "limit", "checker", "limit", "checker", ",", "map", "<", "uri", ",", "file", "status", ">", "stat", "cache", ")", "throws", "i", "o", "exception", "{", "path", "path", "with", "scheme", "=", "p", ";", "if", "(", "!", "path", "with", "scheme", "to", "uri", "(", ")", "is", "absolute", "(", ")", ")", "{", "/", "/", "the", "path", "does", "not", "have", "a", "scheme", ",", "so", "we", "assume", "it", "is", "a", "path", "from", "the", "/", "/", "local", "filesystem", "file", "system", "local", "fs", "=", "file", "system", "get", "local", "(", "job", ")", ";", "path", "with", "scheme", "=", "local", "fs", "make", "qualified", "(", "p", ")", ";", "}", "file", "status", "status", "=", "get", "file", "status", "(", "stat", "cache", ",", "job", ",", "path", "with", "scheme", ")", ";", "if", "(", "status", "is", "directory", "(", ")", ")", "{", "file", "status", "[", "]", "status", "array", "=", "path", "with", "scheme", "get", "file", "system", "(", "job", ")", "list", "status", "(", "path", "with", "scheme", ")", ";", "for", "(", "file", "status", "s", ":", "status", "array", ")", "{", "explore", "path", "(", "job", ",", "s", "get", "path", "(", ")", ",", "limit", "checker", ",", "stat", "cache", ")", ";", "}", "}", "else", "{", "limit", "checker", "add", "file", "(", "path", "with", "scheme", ",", "status", "get", "len", "(", ")", ")", ";", "}", "}" ]

[ "returns", "the", "address", "in", "the", "field", "or", "null", "if", "the", "address", "can", "'", "t", "be", "parsed" ]

[ "public", "address", "get", "address", "(", ")", "{", "string", "addr", "str", "=", "text", "field", "get", "text", "(", ")", ";", "address", "space", "space", "=", "get", "address", "space", "(", ")", ";", "try", "{", "return", "space", "get", "address", "(", "addr", "str", ")", ";", "}", "catch", "(", "address", "format", "exception", "e", ")", "{", "return", "null", ";", "}", "}" ]

[ "create", "a", "request", "builder", "with", "the", "given", "method", "and", "url" ]

[ "static", "builder", "create", "(", "http", "method", "method", ",", "uri", "url", ")", "{", "return", "new", "default", "client", "request", "builder", "(", "method", ",", "url", ")", ";", "}" ]