Datasets:
Anonymous2023
/
KGSum

Dataset card Data Studio Files Community
docstring_tokens
list
code_tokens
list
[ "test", "to", "make", "sure", "name", "node", "feature", "support", "previous", "features" ]
[ "public", "void", "test", "name", "node", "feature", "(", ")", "{", "final", "layout", "feature", "first", "=", "name", "node", "layout", "version", "feature", "rolling", "upgrade", ";", "assert", "true", "(", "name", "node", "layout", "version", "supports", "(", "last", "non", "reserved", "common", "feature", ",", "first", "get", "info", "(", ")", "get", "layout", "version", "(", ")", ")", ")", ";", "assert", "equals", "(", "last", "common", "feature", "get", "info", "(", ")", "get", "layout", "version", "(", ")", "-", "1", ",", "first", "get", "info", "(", ")", "get", "layout", "version", "(", ")", ")", ";", "}" ]
[ "test", "the", "property", "'", "class", "name", "'" ]
[ "public", "void", "class", "name", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "class", "name", "}" ]
[ "buld", "the", "user", "path", "-", "switches", "to", "the", "system", "path", "if", "the", "user", "is", "\"", "\"", "it", "also", "cross", "-", "converts", "the", "username", "to", "ascii", "via", "punycode" ]
[ "public", "static", "string", "home", "path", "for", "user", "(", "string", "username", ")", "{", "preconditions", "check", "argument", "(", "username", "!", "=", "null", ",", "\"", "null", "user", "\"", ")", ";", "/", "/", "catch", "recursion", "if", "(", "username", "starts", "with", "(", "registry", "constants", "path", "users", ")", ")", "{", "return", "username", ";", "}", "if", "(", "username", "is", "empty", "(", ")", ")", "{", "return", "registry", "constants", "path", "system", "services", ";", "}", "/", "/", "convert", "username", "to", "registry", "name", "string", "converted", "name", "=", "convert", "username", "(", "username", ")", ";", "return", "registry", "path", "utils", "join", "(", "registry", "constants", "path", "users", ",", "encode", "for", "registry", "(", "converted", "name", ")", ")", ";", "}" ]
[ "gets", "the", "block", "with", "the", "given", "label" ]
[ "public", "byte", "block", "label", "to", "block", "(", "int", "label", ")", "{", "int", "idx", "=", "index", "of", "label", "(", "label", ")", ";", "if", "(", "idx", "<", "0", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "no", "such", "label", ":", "\"", "+", "hex", "u", "2", "(", "label", ")", ")", ";", "}", "return", "get", "(", "idx", ")", ";", "}" ]
[ "test", "the", "property", "'", "int", "6", "4", "'" ]
[ "public", "void", "int", "6", "4", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "int", "6", "4", "}" ]
[ "returns", "allowed", "methods", "for", "a", "specific", "uri", "for", "{", "@", "code", "options", "}", ",", "use", "{", "@", "link", "#", "all", "allowed", "methods", "(", ")", "}", "instead", "of", "this", "method" ]
[ "public", "set", "<", "http", "method", ">", "allowed", "methods", "(", "string", "uri", ")", "{", "query", "string", "decoder", "decoder", "=", "new", "query", "string", "decoder", "(", "uri", ")", ";", "string", "[", "]", "tokens", "=", "path", "pattern", "remove", "slashes", "at", "both", "ends", "(", "decoder", "path", "(", ")", ")", "split", "(", "\"", "/", "\"", ")", ";", "if", "(", "any", "method", "router", "any", "matched", "(", "tokens", ")", ")", "{", "return", "all", "allowed", "methods", "(", ")", ";", "}", "set", "<", "http", "method", ">", "ret", "=", "new", "hash", "set", "<", "http", "method", ">", "(", "routers", "size", "(", ")", ")", ";", "for", "(", "map", "entry", "<", "http", "method", ",", "methodless", "router", "<", "t", ">", ">", "entry", ":", "routers", "entry", "set", "(", ")", ")", "{", "methodless", "router", "<", "t", ">", "router", "=", "entry", "get", "value", "(", ")", ";", "if", "(", "router", "any", "matched", "(", "tokens", ")", ")", "{", "http", "method", "method", "=", "entry", "get", "key", "(", ")", ";", "ret", "add", "(", "method", ")", ";", "}", "}", "return", "ret", ";", "}" ]
[ "sets", "the", "column", "for", "this", "filter", "row" ]
[ "public", "void", "set", "column", "data", "(", "column", "filter", "data", "<", "?", ">", "column", "data", ")", "{", "do", "set", "column", "data", "(", "column", "data", ")", ";", "dialog", "model", "dialog", "filter", "row", "changed", "(", "this", ")", ";", "}" ]
[ "gets", "the", "{", "@", "link", "language", "description", "}", "for", "this", "object", "'", "s", "{", "@", "link", "language", "i", "d", "}" ]
[ "public", "language", "description", "get", "language", "description", "(", ")", "throws", "language", "not", "found", "exception", "{", "return", "default", "language", "service", "get", "language", "service", "(", ")", "get", "language", "description", "(", "language", "i", "d", ")", ";", "}" ]
[ "regression", "test", "for", "hdfs", "-", "14557", "which", "verifies", "that", "an", "edit", "log", "filled", "with", "only", "\"", "-", "1", "\"", "bytes", "is", "moved", "aside", "and", "does", "not", "prevent", "the", "journal", "node", "from", "starting" ]
[ "public", "void", "test", "scan", "edit", "that", "failed", "during", "pre", "allocate", "(", ")", "throws", "exception", "{", "configuration", "conf", "=", "new", "configuration", "(", ")", ";", "file", "edit", "log", "=", "new", "file", "(", "generic", "test", "utils", "get", "temp", "path", "(", "\"", "test", "corrupt", "edit", "log", "\"", ")", ")", ";", "file", "output", "stream", "os", "=", "new", "file", "output", "stream", "(", "edit", "log", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "1024", ";", "i", "+", "+", ")", "{", "os", "write", "(", "-", "1", ")", ";", "}", "os", "close", "(", ")", ";", "f", "s", "edit", "log", "loader", "edit", "log", "validation", "val", "=", "edit", "log", "file", "input", "stream", "scan", "edit", "log", "(", "edit", "log", ",", "1234", ",", "false", ")", ";", "assert", "equals", "(", "true", ",", "val", "has", "corrupt", "header", "(", ")", ")", ";", "assert", "equals", "(", "hdfs", "server", "constants", "invalid", "txid", ",", "val", "get", "end", "tx", "id", "(", ")", ")", ";", "}" ]
[ "prepares", "the", "playlist" ]
[ "public", "void", "prepare", "(", "@", "nullable", "transfer", "listener", "media", "transfer", "listener", ")", "{", "assertions", "check", "state", "(", "!", "is", "prepared", ")", ";", "this", "media", "transfer", "listener", "=", "media", "transfer", "listener", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "media", "source", "holders", "size", "(", ")", ";", "i", "+", "+", ")", "{", "media", "source", "holder", "media", "source", "holder", "=", "media", "source", "holders", "get", "(", "i", ")", ";", "prepare", "child", "source", "(", "media", "source", "holder", ")", ";", "enabled", "media", "source", "holders", "add", "(", "media", "source", "holder", ")", ";", "}", "is", "prepared", "=", "true", ";", "}" ]
[ "values", "from", "the", "last", "time", "{", "@", "link", "#", "run", "for", "doc", "(", "int", ")", "}", "was", "called", "this", "array", "is", "mutable", "and", "will", "change", "with", "the", "next", "call", "of", "{", "@", "link", "#", "run", "for", "doc", "(", "int", ")", "}", "it", "is", "also", "oversized", "and", "will", "contain", "garbage", "at", "all", "indices", "at", "and", "above", "{", "@", "link", "#", "count", "(", ")", "}" ]
[ "public", "final", "long", "[", "]", "values", "(", ")", "{", "return", "values", ";", "}" ]
[ "returns", "true", "if", "the", "component", "is", "in", "the", "focused", "visible", "range" ]
[ "private", "static", "boolean", "is", "in", "focused", "range", "(", "extension", "state", "<", "visibility", "mount", "extension", "state", ">", "extension", "state", ",", "rect", "component", "bounds", ",", "rect", "component", "visible", "bounds", ")", "{", "final", "host", "host", "=", "get", "root", "host", "(", "extension", "state", ")", ";", "if", "(", "host", "=", "=", "null", ")", "{", "return", "false", ";", "}", "final", "view", "parent", "=", "(", "view", ")", "host", "get", "parent", "(", ")", ";", "if", "(", "parent", "=", "=", "null", ")", "{", "return", "false", ";", "}", "final", "int", "half", "viewport", "area", "=", "parent", "get", "width", "(", ")", "*", "parent", "get", "height", "(", ")", "/", "2", ";", "final", "int", "total", "component", "area", "=", "compute", "rect", "area", "(", "component", "bounds", ")", ";", "final", "int", "visible", "component", "area", "=", "compute", "rect", "area", "(", "component", "visible", "bounds", ")", ";", "/", "/", "the", "component", "has", "entered", "the", "focused", "range", "either", "if", "it", "is", "larger", "than", "half", "of", "the", "viewport", "/", "/", "and", "it", "occupies", "at", "least", "half", "of", "the", "viewport", "or", "if", "it", "is", "smaller", "than", "half", "of", "the", "viewport", "/", "/", "and", "it", "is", "fully", "visible", "return", "(", "total", "component", "area", ">", "=", "half", "viewport", "area", ")", "?", "(", "visible", "component", "area", ">", "=", "half", "viewport", "area", ")", ":", "component", "bounds", "equals", "(", "component", "visible", "bounds", ")", ";", "}" ]
[ "fill", "the", "parameter", "rule", "with", "parsed", "items" ]
[ "public", "static", "void", "fill", "exception", "flow", "items", "(", "param", "flow", "rule", "rule", ")", "{", "if", "(", "rule", "!", "=", "null", ")", "{", "if", "(", "rule", "get", "param", "flow", "item", "list", "(", ")", "=", "=", "null", ")", "{", "rule", "set", "param", "flow", "item", "list", "(", "new", "array", "list", "<", "param", "flow", "item", ">", "(", ")", ")", ";", "}", "map", "<", "object", ",", "integer", ">", "item", "map", "=", "parse", "hot", "items", "(", "rule", "get", "param", "flow", "item", "list", "(", ")", ")", ";", "rule", "set", "parsed", "hot", "items", "(", "item", "map", ")", ";", "}", "}" ]
[ "test", "conversion", "to", "long" ]
[ "public", "void", "test", "conversion", "to", "long", "(", ")", "{", "data", "type", "to", "=", "long", ";", "{", "converter", "conversion", "=", "converter", "for", "(", "double", ",", "to", ")", ";", "assert", "null", "(", "conversion", "convert", "(", "null", ")", ")", ";", "assert", "equals", "(", "10l", ",", "conversion", "convert", "(", "10", "0", ")", ")", ";", "assert", "equals", "(", "10l", ",", "conversion", "convert", "(", "10", "1", ")", ")", ";", "assert", "equals", "(", "11l", ",", "conversion", "convert", "(", "10", "6", ")", ")", ";", "exception", "e", "=", "expect", "throws", "(", "ql", "illegal", "argument", "exception", "class", ",", "(", ")", "-", ">", "conversion", "convert", "(", "double", "max", "value", ")", ")", ";", "assert", "equals", "(", "\"", "[", "\"", "+", "double", "max", "value", "+", "\"", "]", "out", "of", "[", "long", "]", "range", "\"", ",", "e", "get", "message", "(", ")", ")", ";", "}", "{", "converter", "conversion", "=", "converter", "for", "(", "integer", ",", "to", ")", ";", "assert", "null", "(", "conversion", "convert", "(", "null", ")", ")", ";", "assert", "equals", "(", "10l", ",", "conversion", "convert", "(", "10", ")", ")", ";", "assert", "equals", "(", "-", "134l", ",", "conversion", "convert", "(", "-", "134", ")", ")", ";", "}", "{", "converter", "conversion", "=", "converter", "for", "(", "boolean", ",", "to", ")", ";", "assert", "null", "(", "conversion", "convert", "(", "null", ")", ")", ";", "assert", "equals", "(", "1l", ",", "conversion", "convert", "(", "true", ")", ")", ";", "assert", "equals", "(", "0l", ",", "conversion", "convert", "(", "false", ")", ")", ";", "}", "{", "converter", "conversion", "=", "converter", "for", "(", "datetime", ",", "to", ")", ";", "assert", "null", "(", "conversion", "convert", "(", "null", ")", ")", ";", "assert", "equals", "(", "123456789101l", ",", "conversion", "convert", "(", "as", "date", "time", "(", "123456789101l", ")", ")", ")", ";", "assert", "equals", "(", "-", "123456789101l", ",", "conversion", "convert", "(", "as", "date", "time", "(", "-", "123456789101l", ")", ")", ")", ";", "}", "{", "converter", "conversion", "=", "converter", "for", "(", "keyword", ",", "to", ")", ";", "assert", "null", "(", "conversion", "convert", "(", "null", ")", ")", ";", "assert", "equals", "(", "1l", ",", "conversion", "convert", "(", "\"", "1", "\"", ")", ")", ";", "assert", "equals", "(", "0l", ",", "conversion", "convert", "(", "\"", "-", "0", "\"", ")", ")", ";", "exception", "e", "=", "expect", "throws", "(", "ql", "illegal", "argument", "exception", "class", ",", "(", ")", "-", ">", "conversion", "convert", "(", "\"", "0xff", "\"", ")", ")", ";", "assert", "equals", "(", "\"", "cannot", "cast", "[", "0xff", "]", "to", "[", "long", "]", "\"", ",", "e", "get", "message", "(", ")", ")", ";", "}", "}" ]
[ "get", "the", "results", "of", "a", "{", "@", "link", "criteria", "}", "query" ]
[ "protected", "list", "<", "e", ">", "list", "(", "criteria", "criteria", ")", "throws", "hibernate", "exception", "{", "return", "require", "non", "null", "(", "criteria", ")", "list", "(", ")", ";", "}" ]
[ "find", "all", "the", "tester", "annotations", "declared", "on", "a", "tester", "class", "or", "method" ]
[ "public", "static", "iterable", "<", "annotation", ">", "get", "tester", "annotations", "(", "annotated", "element", "class", "or", "method", ")", "{", "synchronized", "(", "annotation", "cache", ")", "{", "list", "<", "annotation", ">", "annotations", "=", "annotation", "cache", "get", "(", "class", "or", "method", ")", ";", "if", "(", "annotations", "=", "=", "null", ")", "{", "annotations", "=", "new", "array", "list", "<", ">", "(", ")", ";", "for", "(", "annotation", "a", ":", "class", "or", "method", "get", "declared", "annotations", "(", ")", ")", "{", "if", "(", "a", "annotation", "type", "(", ")", "is", "annotation", "present", "(", "tester", "annotation", "class", ")", ")", "{", "annotations", "add", "(", "a", ")", ";", "}", "}", "annotations", "=", "collections", "unmodifiable", "list", "(", "annotations", ")", ";", "annotation", "cache", "put", "(", "class", "or", "method", ",", "annotations", ")", ";", "}", "return", "annotations", ";", "}", "}" ]
[ "the", "task", "output", "a", "record", "with", "a", "partition", "number", "attached" ]
[ "public", "void", "partitioned", "output", "(", "int", "reduce", ",", "k", "key", ",", "v", "value", ")", "throws", "i", "o", "exception", "{", "pipes", "partitioner", "set", "next", "partition", "(", "reduce", ")", ";", "collector", "collect", "(", "key", ",", "value", ")", ";", "}" ]
[ "sets", "the", "number", "of", "minimal", "prefix", "characters", "that", "must", "match", "in", "order", "be", "a", "candidate", "suggestion", "defaults", "to", "1", "increasing", "this", "number", "improves", "suggest", "performance", "usually", "misspellings", "don", "'", "t", "occur", "in", "the", "beginning", "of", "terms" ]
[ "public", "direct", "candidate", "generator", "builder", "prefix", "length", "(", "int", "prefix", "length", ")", "{", "this", "prefix", "length", "=", "prefix", "length", ";", "return", "this", ";", "}" ]
[ "returns", "table", "entry", "size", "in", "bytes" ]
[ "int", "get", "table", "entry", "size", "(", ")", "{", "return", "table", "offset", "get", "table", "entry", "size", "(", ")", ";", "}" ]
[ "returns", "the", "file", "relative", "to", "the", "named", "module", "'", "s", "directory" ]
[ "public", "static", "resource", "file", "get", "module", "file", "(", "string", "module", "name", ",", "string", "relative", "path", ")", "throws", "file", "not", "found", "exception", "{", "check", "app", "initialized", "(", ")", ";", "return", "app", "get", "file", "in", "module", "(", "relative", "path", ",", "module", "name", ")", ";", "}" ]
[ "gets", "all", "the", "already", "computed", "configured", "targets" ]
[ "protected", "iterable", "<", "configured", "target", ">", "get", "all", "configured", "targets", "(", ")", "{", "return", "skyframe", "executor", "test", "utils", "get", "all", "existing", "configured", "targets", "(", "get", "skyframe", "executor", "(", ")", ")", ";", "}" ]
[ "convert", "the", "given", "object", "to", "string", "with", "each", "line", "indented", "by", "4", "spaces", "(", "except", "the", "first", "line", ")" ]
[ "private", "string", "to", "indented", "string", "(", "object", "o", ")", "{", "if", "(", "o", "=", "=", "null", ")", "{", "return", "\"", "null", "\"", ";", "}", "return", "o", "to", "string", "(", ")", "replace", "(", "\"", "\\", "n", "\"", ",", "\"", "\\", "n", "\"", ")", ";", "}" ]
[ "<", "code", ">", "optional", "aapt", "pb", "styled", "string", "styled", "str", "=", "4", ";", "<", "code", ">" ]
[ "public", "com", "android", "aapt", "resources", "styled", "string", "get", "styled", "str", "(", ")", "{", "return", "styled", "str", "=", "=", "null", "?", "com", "android", "aapt", "resources", "styled", "string", "get", "default", "instance", "(", ")", ":", "styled", "str", ";", "}" ]
[ "sets", "the", "group", "for", "the", "action", "in", "the", "tool", "bar", "actions", "in", "the", "same", "group", "will", "appear", "next", "to", "other", "actions", "in", "the", "same", "group", "and", "actions", "in", "different", "groups", "will", "be", "separated", "by", "menu", "dividers", "<", "b", ">", "note", ":", "you", "must", "call", "{", "@", "link", "#", "tool", "bar", "icon", "(", "icon", ")", "}", "or", "{", "@", "link", "#", "tool", "bar", "icon", "(", "string", ")", "}", "for", "this", "action", "to", "appear", "in", "the", "toolbar", "calling", "this", "method", "without", "the", "other", "will", "not", "cause", "this", "action", "to", "be", "placed", "in", "the", "tool", "bar", "<", "b", ">" ]
[ "public", "b", "tool", "bar", "group", "(", "string", "group", ")", "{", "tool", "bar", "group", "=", "group", ";", "return", "self", "(", ")", ";", "}" ]
[ "indicate", "that", "source", "should", "be", "returned", ",", "with", "an", "\"", "include", "\"", "andor", "\"", "exclude", "\"", "set", "which", "can", "include", "simple", "wildcard", "elements" ]
[ "public", "update", "request", "fetch", "source", "(", "@", "nullable", "string", "[", "]", "includes", ",", "@", "nullable", "string", "[", "]", "excludes", ")", "{", "fetch", "source", "context", "context", "=", "this", "fetch", "source", "context", "=", "=", "null", "?", "fetch", "source", "context", "fetch", "source", ":", "this", "fetch", "source", "context", ";", "this", "fetch", "source", "context", "=", "new", "fetch", "source", "context", "(", "context", "fetch", "source", "(", ")", ",", "includes", ",", "excludes", ")", ";", "return", "this", ";", "}" ]
[ "checks", "whether", "the", "given", "{", "@", "link", "logical", "type", "}", "is", "supported", "in", "h", "base", "connector" ]
[ "public", "static", "boolean", "is", "supported", "type", "(", "logical", "type", "type", ")", "{", "/", "/", "ordered", "by", "type", "root", "definition", "switch", "(", "type", "get", "type", "root", "(", ")", ")", "{", "case", "char", ":", "case", "varchar", ":", "case", "boolean", ":", "case", "binary", ":", "case", "varbinary", ":", "case", "decimal", ":", "case", "tinyint", ":", "case", "smallint", ":", "case", "integer", ":", "case", "date", ":", "case", "interval", "year", "month", ":", "case", "bigint", ":", "case", "interval", "day", "time", ":", "case", "float", ":", "case", "double", ":", "return", "true", ";", "case", "time", "without", "time", "zone", ":", "final", "int", "time", "precision", "=", "get", "precision", "(", "type", ")", ";", "if", "(", "time", "precision", "<", "min", "time", "precision", "|", "|", "time", "precision", ">", "max", "time", "precision", ")", "{", "throw", "new", "unsupported", "operation", "exception", "(", "string", "format", "(", "\"", "the", "precision", "%", "s", "of", "time", "type", "is", "out", "of", "the", "range", "[", "%", "s", ",", "%", "s", "]", "supported", "by", "\"", "+", "\"", "h", "base", "connector", "\"", ",", "time", "precision", ",", "min", "time", "precision", ",", "max", "time", "precision", ")", ")", ";", "}", "return", "true", ";", "case", "timestamp", "without", "time", "zone", ":", "case", "timestamp", "with", "local", "time", "zone", ":", "final", "int", "timestamp", "precision", "=", "get", "precision", "(", "type", ")", ";", "if", "(", "timestamp", "precision", "<", "min", "timestamp", "precision", "|", "|", "timestamp", "precision", ">", "max", "timestamp", "precision", ")", "{", "throw", "new", "unsupported", "operation", "exception", "(", "string", "format", "(", "\"", "the", "precision", "%", "s", "of", "timestamp", "type", "is", "out", "of", "the", "range", "[", "%", "s", ",", "%", "s", "]", "supported", "by", "\"", "+", "\"", "h", "base", "connector", "\"", ",", "timestamp", "precision", ",", "min", "timestamp", "precision", ",", "max", "timestamp", "precision", ")", ")", ";", "}", "return", "true", ";", "case", "timestamp", "with", "time", "zone", ":", "case", "array", ":", "case", "multiset", ":", "case", "map", ":", "case", "row", ":", "case", "structured", "type", ":", "case", "distinct", "type", ":", "case", "raw", ":", "case", "null", ":", "case", "symbol", ":", "case", "unresolved", ":", "return", "false", ";", "default", ":", "throw", "new", "illegal", "argument", "exception", "(", ")", ";", "}", "}" ]
[ "returns", "the", "key", "'", "s", "current", "value", "and", "increments", "the", "stored", "value", "if", "the", "key", "is", "not", "in", "the", "map", ",", "default", "value", "+", "increment", "is", "put", "into", "the", "map", "and", "default", "value", "is", "returned" ]
[ "public", "int", "get", "and", "increment", "(", "k", "key", ",", "int", "default", "value", ",", "int", "increment", ")", "{", "int", "i", "=", "locate", "key", "(", "key", ")", ";", "if", "(", "i", ">", "=", "0", ")", "{", "/", "/", "existing", "key", "was", "found", "int", "old", "value", "=", "value", "table", "[", "i", "]", ";", "value", "table", "[", "i", "]", "+", "=", "increment", ";", "return", "old", "value", ";", "}", "i", "=", "-", "(", "i", "+", "1", ")", ";", "/", "/", "empty", "space", "was", "found", "key", "table", "[", "i", "]", "=", "key", ";", "value", "table", "[", "i", "]", "=", "default", "value", "+", "increment", ";", "if", "(", "+", "+", "size", ">", "=", "threshold", ")", "resize", "(", "key", "table", "length", "<", "<", "1", ")", ";", "return", "default", "value", ";", "}" ]
[ "write", "specific", "seal", "to", "the", "output", "archive", "and", "close", "the", "output", "stream", "currently", ",", "only", "checked", "output", "stream", "will", "write", "it", "'", "s", "check", "sum", "to", "the", "end", "of", "the", "stream" ]
[ "public", "static", "void", "seal", "stream", "(", "checked", "output", "stream", "os", ",", "output", "archive", "oa", ")", "throws", "i", "o", "exception", "{", "long", "val", "=", "os", "get", "checksum", "(", ")", "get", "value", "(", ")", ";", "oa", "write", "long", "(", "val", ",", "\"", "val", "\"", ")", ";", "oa", "write", "string", "(", "\"", "/", "\"", ",", "\"", "path", "\"", ")", ";", "}" ]
[ "a", "default", "method", "for", "creating", "an", "action", "context", "for", "this", "provider", ",", "using", "the", "given", "{", "@", "link", "action", "context", "#", "get", "context", "object", "(", ")", "context", "object", "}", "and", "component" ]
[ "protected", "action", "context", "create", "context", "(", "component", "source", "component", ",", "object", "context", "object", ")", "{", "return", "new", "action", "context", "(", "this", ",", "source", "component", ")", "set", "context", "object", "(", "context", "object", ")", ";", "}" ]
[ "determine", "if", "the", "specified", "annotation", "is", "either", "directly", "present", "or", "meta", "-", "present", "equivalent", "to", "calling", "{", "@", "code", "get", "(", "annotation", "type", ")", "is", "present", "(", ")", "}" ]
[ "boolean", "is", "present", "(", "string", "annotation", "type", ")", ";" ]
[ "test", ":", "pass", "illegal", "adaptive", "rate", "and", "illegal", "initial", "lfu", "cache", "fraction", "expected", "result", ":", "fall", "back", "and", "use", "the", "default", "adaptive", "rate", "and", "initial", "lfu", "fraction", "values" ]
[ "public", "void", "test", "pass", "illegal", "arguments", "to", "the", "cache", "constructor", "(", ")", "{", "final", "int", "illegal", "adaptive", "rate", "=", "-", "1", ";", "final", "int", "illegal", "l", "f", "u", "cache", "fraction", "promil", "=", "abstract", "adaptive", "counting", "memory", "cache", "min", "fraction", "promil", "-", "1", ";", "m", "cache", "=", "create", "dummy", "adaptive", "counting", "memory", "cache", "(", "m", "params", "supplier", ",", "m", "cache", "trim", "strategy", ",", "m", "value", "descriptor", ",", "illegal", "adaptive", "rate", ",", "1", ",", "2", ",", "illegal", "l", "f", "u", "cache", "fraction", "promil", ")", ";", "assert", "not", "null", "(", "m", "cache", ")", ";", "assert", "equals", "(", "m", "cache", "m", "l", "f", "u", "fraction", "promil", ",", "abstract", "adaptive", "counting", "memory", "cache", "default", "lfu", "fraction", "promil", ")", ";", "assert", "equals", "(", "string", "value", "of", "(", "m", "cache", "m", "adaptive", "rate", "promil", ")", ",", "string", "value", "of", "(", "abstract", "adaptive", "counting", "memory", "cache", "default", "adaptive", "rate", "promil", ")", ")", ";", "}" ]
[ "current", "protocol", "configuration", ",", "to", "replace", "xml", "config", ":", "<", "prev", ">", "&", "lt", ";", "dubbo", ":", "protocol", "name", "=", "\"", "dubbo", "\"", "port", "=", "\"", "12345", "\"", "&", "gt", ";", "<", "prev", ">" ]
[ "public", "protocol", "config", "protocol", "config", "(", ")", "{", "protocol", "config", "protocol", "config", "=", "new", "protocol", "config", "(", ")", ";", "protocol", "config", "set", "name", "(", "\"", "dubbo", "\"", ")", ";", "protocol", "config", "set", "port", "(", "12345", ")", ";", "return", "protocol", "config", ";", "}" ]
[ "appends", "an", "element", "to", "the", "end", "of", "the", "list", ",", "after", "validating", "that", "mutation", "is", "allowed" ]
[ "public", "void", "add", "element", "(", "e", "element", ")", "throws", "eval", "exception", "{", "starlark", "check", "mutable", "(", "this", ")", ";", "grow", "(", "size", "+", "1", ")", ";", "elems", "[", "size", "+", "+", "]", "=", "element", ";", "}" ]
[ "returns", "true", "if", "the", "input", "data", "buffer", "is", "empty", "and", "#", "set", "input", "(", ")", "should", "be", "called", "to", "provide", "more", "input" ]
[ "public", "synchronized", "boolean", "needs", "input", "(", ")", "{", "return", "!", "(", "compressed", "direct", "buf", "remaining", "(", ")", ">", "0", "|", "|", "uncompressed", "direct", "buf", "remaining", "(", ")", "=", "=", "0", "|", "|", "user", "buf", "len", ">", "0", ")", ";", "}" ]
[ "returns", "(", "a", "+", "b", ")", "mod", "m", "precondition", ":", "{", "@", "code", "0", "<", "=", "a", "}", ",", "{", "@", "code", "b", "<", "m", "<", "2", "^", "63", "}" ]
[ "private", "long", "plus", "mod", "(", "long", "a", ",", "long", "b", ",", "long", "m", ")", "{", "return", "(", "a", ">", "=", "m", "-", "b", ")", "?", "(", "a", "+", "b", "-", "m", ")", ":", "(", "a", "+", "b", ")", ";", "}" ]
[ "find", "an", "edits", "file", "spanning", "the", "given", "transaction", "id", "range", "if", "no", "such", "file", "exists", ",", "an", "exception", "is", "thrown" ]
[ "file", "find", "finalized", "edits", "file", "(", "long", "start", "tx", "id", ",", "long", "end", "tx", "id", ")", "throws", "i", "o", "exception", "{", "file", "ret", "=", "new", "file", "(", "sd", "get", "current", "dir", "(", ")", ",", "n", "n", "storage", "get", "finalized", "edits", "file", "name", "(", "start", "tx", "id", ",", "end", "tx", "id", ")", ")", ";", "if", "(", "!", "ret", "exists", "(", ")", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "no", "edits", "file", "for", "range", "\"", "+", "start", "tx", "id", "+", "\"", "-", "\"", "+", "end", "tx", "id", ")", ";", "}", "return", "ret", ";", "}" ]
[ "convenient", "call", "for", "{", "@", "link", "org", "greenrobot", "greendao", "abstract", "dao", "#", "refresh", "(", "object", ")", "}", "entity", "must", "attached", "to", "an", "entity", "context" ]
[ "public", "void", "refresh", "(", ")", "{", "throw", "if", "detached", "(", ")", ";", "my", "dao", "refresh", "(", "this", ")", ";", "}" ]
[ "returns", "the", "number", "of", "page", "reclaims", "(", "soft", "page", "faults", ")", "during", "command", "execution", ",", "if", "available" ]
[ "public", "long", "get", "page", "reclaims", "(", ")", "{", "return", "resource", "usage", "proto", "get", "minflt", "(", ")", ";", "}" ]
[ "return", "the", "datanode", "descriptor", "for", "the", "given", "datanode" ]
[ "public", "static", "datanode", "descriptor", "get", "datanode", "(", "final", "f", "s", "namesystem", "ns", ",", "datanode", "i", "d", "id", ")", "throws", "i", "o", "exception", "{", "ns", "read", "lock", "(", ")", ";", "try", "{", "return", "ns", "get", "block", "manager", "(", ")", "get", "datanode", "manager", "(", ")", "get", "datanode", "(", "id", ")", ";", "}", "finally", "{", "ns", "read", "unlock", "(", ")", ";", "}", "}" ]
[ "shuts", "down", "the", "standard", "schedulers", "the", "operation", "is", "idempotent", "and", "thread", "-", "safe" ]
[ "public", "static", "void", "shutdown", "(", ")", "{", "computation", "(", ")", "shutdown", "(", ")", ";", "io", "(", ")", "shutdown", "(", ")", ";", "new", "thread", "(", ")", "shutdown", "(", ")", ";", "single", "(", ")", "shutdown", "(", ")", ";", "trampoline", "(", ")", "shutdown", "(", ")", ";", "scheduler", "pool", "factory", "shutdown", "(", ")", ";", "}" ]
[ "{", "@", "link", "s", "c", "med", "item", "}", "needs", "to", "be", "an", "instance", "of", "{", "@", "link", "abstract", "project", "}", "this", "method", "must", "be", "always", "implemented", "as", "{", "@", "code", "(", "abstract", "project", ")", "this", "}", ",", "but", "defining", "this", "method", "emphasizes", "the", "fact", "that", "this", "cast", "must", "be", "doable" ]
[ "abstract", "project", "<", "?", ",", "?", ">", "as", "project", "(", ")", ";" ]
[ "adds", "an", "identity", "link", "for", "the", "given", "user", "id", "with", "the", "specified", "type", ",", "but", "only", "if", "the", "user", "is", "not", "associated", "with", "the", "execution", "entity", "yet" ]
[ "public", "identity", "link", "entity", "involve", "user", "(", "execution", "entity", "execution", "entity", ",", "string", "user", "id", ",", "string", "type", ")", "{", "for", "(", "identity", "link", "entity", "identity", "link", ":", "execution", "entity", "get", "identity", "links", "(", ")", ")", "{", "if", "(", "identity", "link", "is", "user", "(", ")", "&", "&", "identity", "link", "get", "user", "id", "(", ")", "equals", "(", "user", "id", ")", ")", "{", "return", "identity", "link", ";", "}", "}", "return", "add", "identity", "link", "(", "execution", "entity", ",", "user", "id", ",", "null", ",", "type", ")", ";", "}" ]
[ "sets", "whether", "the", "rewind", "button", "is", "shown" ]
[ "public", "void", "set", "show", "rewind", "button", "(", "boolean", "show", "rewind", "button", ")", "{", "assertions", "check", "state", "not", "null", "(", "controller", ")", ";", "controller", "set", "show", "rewind", "button", "(", "show", "rewind", "button", ")", ";", "}" ]
[ "return", "a", "map", "of", "column", "names", "to", "constraints" ]
[ "public", "map", "<", "string", ",", "presto", "thrift", "domain", ">", "get", "domains", "(", ")", "{", "return", "domains", ";", "}" ]
[ "read", "a", "variable", "-", "sized", "unsigned", "integer", "and", "return", "it", "as", "a", "java", "signed", "int", "unsigned", "32", "bit", "int", "values", "larger", "than", "java", "'", "s", "signed", "integer", "max", "value", "are", "not", "supported", "and", "will", "throw", "an", "i", "o", "exception" ]
[ "public", "static", "int", "read", "var", "sized", "u", "int", "(", "binary", "reader", "reader", ",", "int", "size", ")", "throws", "i", "o", "exception", "{", "switch", "(", "size", ")", "{", "case", "1", ":", "return", "reader", "read", "next", "unsigned", "byte", "(", ")", ";", "case", "2", ":", "return", "reader", "read", "next", "unsigned", "short", "(", ")", ";", "case", "4", ":", "long", "l", "=", "reader", "read", "next", "unsigned", "int", "(", ")", ";", "if", "(", "l", "<", "0", "|", "|", "l", ">", "integer", "max", "value", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "unsigned", "int", "value", "too", "large", ":", "\"", "+", "l", ")", ";", "}", "return", "(", "int", ")", "l", ";", "}", "throw", "new", "i", "o", "exception", "(", "\"", "unsupported", "variable", "-", "sized", "int", ":", "\"", "+", "size", ")", ";", "}" ]
[ "the", "{", "@", "link", "one", "byte", "to", "three", "strings", "decoder", "}", "decodes", "this", "{", "@", "code", "byte", "[", "]", "}", "into", "three", "messages" ]
[ "private", "static", "byte", "buf", "new", "one", "message", "(", ")", "{", "return", "unpooled", "wrapped", "buffer", "(", "new", "byte", "[", "]", "{", "1", "}", ")", ";", "}" ]
[ "returns", "the", "number", "of", "milliseconds", "since", "time", "given", "by", "start", "nano", "time", ",", "which", "must", "have", "been", "previously", "returned", "from", "a", "call", "to", "{", "@", "link", "system", "#", "nano", "time", "(", ")", "}" ]
[ "static", "long", "millis", "elapsed", "since", "(", "long", "start", "nano", "time", ")", "{", "return", "nanoseconds", "to", "millis", "(", "system", "nano", "time", "(", ")", "-", "start", "nano", "time", ")", ";", "}", "/", "/", "void", "assert", "terminates", "promptly", "(", "long", "timeout", "millis", ",", "runnable", "r", ")", "{", "/", "/", "long", "start", "time", "=", "system", "nano", "time", "(", ")", ";", "/", "/", "try", "{", "/", "/", "r", "run", "(", ")", ";", "/", "/", "}", "catch", "(", "throwable", "fail", ")", "{", "thread", "unexpected", "exception", "(", "fail", ")", ";", "}", "/", "/", "if", "(", "millis", "elapsed", "since", "(", "start", "time", ")", ">", "timeout", "millis", "/", "2", ")", "/", "/", "throw", "new", "assertion", "failed", "error", "(", "\"", "did", "not", "return", "promptly", "\"", ")", ";", "/", "/", "}", "/", "/", "void", "assert", "terminates", "promptly", "(", "runnable", "r", ")", "{", "/", "/", "assert", "terminates", "promptly", "(", "long", "delay", "ms", "/", "2", ",", "r", ")", ";", "/", "/", "}" ]
[ "runs", "all", "jsr166", "unit", "tests", "using", "junit", "textui", "test", "runner", "optional", "command", "line", "arg", "provides", "the", "number", "of", "iterations", "to", "repeat", "running", "the", "tests" ]
[ "public", "static", "void", "main", "(", "string", "[", "]", "args", ")", "{", "if", "(", "use", "security", "manager", ")", "{", "system", "err", "println", "(", "\"", "setting", "a", "permissive", "security", "manager", "\"", ")", ";", "policy", "set", "policy", "(", "permissive", "policy", "(", ")", ")", ";", "system", "set", "security", "manager", "(", "new", "security", "manager", "(", ")", ")", ";", "}", "int", "iters", "=", "(", "args", "length", "=", "=", "0", ")", "?", "1", ":", "integer", "parse", "int", "(", "args", "[", "0", "]", ")", ";", "test", "s", "=", "suite", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "iters", ";", "+", "+", "i", ")", "{", "junit", "textui", "test", "runner", "run", "(", "s", ")", ";", "system", "gc", "(", ")", ";", "system", "run", "finalization", "(", ")", ";", "}", "system", "exit", "(", "0", ")", ";", "}" ]
[ "convert", "the", "given", "object", "to", "string", "with", "each", "line", "indented", "by", "4", "spaces", "(", "except", "the", "first", "line", ")" ]
[ "private", "string", "to", "indented", "string", "(", "object", "o", ")", "{", "if", "(", "o", "=", "=", "null", ")", "{", "return", "\"", "null", "\"", ";", "}", "return", "o", "to", "string", "(", ")", "replace", "(", "\"", "\\", "n", "\"", ",", "\"", "\\", "n", "\"", ")", ";", "}" ]
[ "add", "cookies", "from", "{", "@", "link", "#", "get", "headers", "(", ")", "}", "to", "the", "underlying", "request", "this", "method", "is", "called", "once", "only" ]
[ "protected", "abstract", "void", "apply", "cookies", "(", ")", ";" ]
[ "used", "to", "print", "a", "error", "message" ]
[ "public", "void", "print", "error", "string", "(", "final", "string", "value", ")", "{", "this", "error", "println", "(", "value", ")", ";", "}" ]
[ "return", "the", "sql", "type", "for", "the", "given", "parameter", ",", "if", "registered" ]
[ "public", "int", "get", "sql", "type", "(", "string", "param", "name", ")", "{", "assert", "not", "null", "(", "param", "name", ",", "\"", "parameter", "name", "must", "not", "be", "null", "\"", ")", ";", "return", "this", "sql", "types", "get", "or", "default", "(", "param", "name", ",", "type", "unknown", ")", ";", "}" ]
[ "adds", "the", "given", "mount", "links", "to", "config", "sources", "contains", "mount", "link", "src", "and", "the", "respective", "index", "location", "in", "targets", "contains", "the", "target", "uri" ]
[ "void", "add", "mount", "links", "(", "string", "mount", "table", ",", "string", "[", "]", "sources", ",", "string", "[", "]", "targets", ",", "configuration", "config", ")", "throws", "i", "o", "exception", ",", "u", "r", "i", "syntax", "exception", "{", "view", "fs", "test", "setup", "add", "mount", "links", "to", "conf", "(", "mount", "table", ",", "sources", ",", "targets", ",", "config", ")", ";", "}" ]
[ "opens", "an", "input", "stream", "on", "the", "file", "so", "its", "contents", "can", "be", "read" ]
[ "public", "input", "stream", "open", "(", "boolean", "no", "follow", "links", ")", "throws", "i", "o", "exception", "{", "return", "open", "(", ")", ";", "}" ]
[ "gets", "the", "compiler", "flags", "corresponding", "to", "the", "full", "bitcode", "file", ",", "or", "returns", "an", "empty", "list", "if", "it", "doesn", "'", "t", "exist" ]
[ "public", "immutable", "list", "<", "string", ">", "get", "copts", "(", "artifact", "full", "bitcode", ")", "{", "if", "(", "!", "contains", "bitcode", "file", "(", "full", "bitcode", ")", ")", "{", "return", "immutable", "list", "of", "(", ")", ";", "}", "return", "lto", "bitcode", "files", "get", "(", "full", "bitcode", ")", "get", "copts", "(", ")", ";", "}" ]
[ "test", "the", "property", "'", "attribute", "integer", "'" ]
[ "public", "void", "attribute", "integer", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "attribute", "integer", "}" ]
[ "notify", "a", "server", "of", "the", "completion", "of", "a", "submitted", "job", "the", "user", "must", "have", "configured", "m", "r", "job", "config", "mr", "job", "end", "notification", "url" ]
[ "public", "void", "notify", "(", "job", "report", "job", "report", ")", "throws", "interrupted", "exception", "{", "/", "/", "do", "string", "replacements", "for", "job", "id", "and", "job", "status", "if", "(", "user", "url", "contains", "(", "job", "id", ")", ")", "{", "user", "url", "=", "user", "url", "replace", "(", "job", "id", ",", "job", "report", "get", "job", "id", "(", ")", "to", "string", "(", ")", ")", ";", "}", "if", "(", "user", "url", "contains", "(", "job", "status", ")", ")", "{", "user", "url", "=", "user", "url", "replace", "(", "job", "status", ",", "job", "report", "get", "job", "state", "(", ")", "to", "string", "(", ")", ")", ";", "}", "/", "/", "create", "the", "url", ",", "ensure", "sanity", "try", "{", "url", "to", "notify", "=", "new", "url", "(", "user", "url", ")", ";", "}", "catch", "(", "malformed", "u", "r", "l", "exception", "mue", ")", "{", "log", "get", "log", "(", ")", "warn", "(", "\"", "job", "end", "notification", "couldn", "'", "t", "parse", "\"", "+", "user", "url", ",", "mue", ")", ";", "return", ";", "}", "/", "/", "send", "notification", "boolean", "success", "=", "false", ";", "while", "(", "num", "tries", "-", "-", ">", "0", "&", "&", "!", "success", ")", "{", "log", "get", "log", "(", ")", "info", "(", "\"", "job", "end", "notification", "attempts", "left", "\"", "+", "num", "tries", ")", ";", "success", "=", "notify", "u", "r", "l", "once", "(", ")", ";", "if", "(", "!", "success", ")", "{", "thread", "sleep", "(", "wait", "interval", ")", ";", "}", "}", "if", "(", "!", "success", ")", "{", "log", "get", "log", "(", ")", "warn", "(", "\"", "job", "end", "notification", "failed", "to", "notify", ":", "\"", "+", "url", "to", "notify", ")", ";", "}", "else", "{", "log", "get", "log", "(", ")", "info", "(", "\"", "job", "end", "notification", "succeeded", "for", "\"", "+", "job", "report", "get", "job", "id", "(", ")", ")", ";", "}", "}" ]
[ "parse", "the", "timeout", "key", "in", "the", "spawn", "execution", "info", ",", "if", "it", "exists", "otherwise", ",", "return", "{", "@", "link", "duration", "#", "zero", "}" ]
[ "public", "static", "duration", "get", "timeout", "(", "spawn", "spawn", ")", "throws", "exec", "exception", "{", "return", "get", "timeout", "(", "spawn", ",", "duration", "zero", ")", ";", "}" ]
[ "sets", "fill", "to", "1", "and", "expand", "to", "true" ]
[ "public", "vertical", "group", "grow", "(", ")", "{", "expand", "=", "true", ";", "fill", "=", "1", ";", "return", "this", ";", "}" ]
[ "convert", "the", "given", "object", "to", "string", "with", "each", "line", "indented", "by", "4", "spaces", "(", "except", "the", "first", "line", ")" ]
[ "private", "static", "string", "to", "indented", "string", "(", "object", "o", ")", "{", "if", "(", "o", "=", "=", "null", ")", "{", "return", "\"", "null", "\"", ";", "}", "return", "o", "to", "string", "(", ")", "replace", "(", "\"", "\\", "n", "\"", ",", "\"", "\\", "n", "\"", ")", ";", "}" ]
[ "signals", "the", "container", "id" ]
[ "private", "void", "signal", "to", "container", "(", "string", "container", "id", "str", ",", "signal", "container", "command", "command", ")", "throws", "yarn", "exception", ",", "i", "o", "exception", "{", "container", "id", "container", "id", "=", "container", "id", "from", "string", "(", "container", "id", "str", ")", ";", "sysout", "println", "(", "\"", "signalling", "container", "\"", "+", "container", "id", "str", ")", ";", "client", "signal", "to", "container", "(", "container", "id", ",", "command", ")", ";", "}" ]
[ "this", "test", "relies", "on", "the", "hash", "function", "used", "by", "the", "{", "@", "link", "data", "stream", "#", "key", "by", "}", ",", "which", "is", "assumed", "to", "be", "{", "@", "link", "math", "utils", "#", "murmur", "hash", "}", "for", "the", "test", "to", "pass", "all", "flat", "mappers", "must", "see", "at", "least", "two", "records", "in", "the", "iteration", ",", "which", "can", "only", "be", "achieved", "if", "the", "hashed", "values", "of", "the", "input", "keys", "map", "to", "a", "complete", "congruence", "system", "given", "that", "the", "test", "is", "designed", "for", "3", "parallel", "flat", "mapper", "instances", "keys", "chosen", "from", "the", "[", "1", ",", "3", "]", "range", "are", "a", "suitable", "choice" ]
[ "public", "void", "test", "group", "by", "feedback", "(", ")", "throws", "exception", "{", "int", "num", "retries", "=", "5", ";", "int", "timeout", "scale", "=", "1", ";", "for", "(", "int", "num", "retry", "=", "0", ";", "num", "retry", "<", "num", "retries", ";", "num", "retry", "+", "+", ")", "{", "try", "{", "stream", "execution", "environment", "env", "=", "stream", "execution", "environment", "get", "execution", "environment", "(", ")", ";", "env", "set", "parallelism", "(", "parallelism", "-", "1", ")", ";", "env", "get", "config", "(", ")", "set", "max", "parallelism", "(", "env", "get", "parallelism", "(", ")", ")", ";", "key", "selector", "<", "integer", ",", "integer", ">", "key", "=", "new", "key", "selector", "<", "integer", ",", "integer", ">", "(", ")", "{", "@", "override", "public", "integer", "get", "key", "(", "integer", "value", ")", "throws", "exception", "{", "return", "value", "%", "3", ";", "}", "}", ";", "data", "stream", "<", "integer", ">", "source", "=", "env", "from", "elements", "(", "1", ",", "2", ",", "3", ")", "map", "(", "no", "op", "int", "map", ")", "name", "(", "\"", "parallelize", "map", "\"", ")", ";", "iterative", "stream", "<", "integer", ">", "it", "=", "source", "key", "by", "(", "key", ")", "iterate", "(", "3000", "*", "timeout", "scale", ")", ";", "data", "stream", "<", "integer", ">", "head", "=", "it", "flat", "map", "(", "new", "rich", "flat", "map", "function", "<", "integer", ",", "integer", ">", "(", ")", "{", "int", "received", "=", "0", ";", "int", "key", "=", "-", "1", ";", "@", "override", "public", "void", "flat", "map", "(", "integer", "value", ",", "collector", "<", "integer", ">", "out", ")", "throws", "exception", "{", "received", "+", "+", ";", "if", "(", "key", "=", "=", "-", "1", ")", "{", "key", "=", "math", "utils", "murmur", "hash", "(", "value", "%", "3", ")", "%", "3", ";", "}", "else", "{", "assert", "equals", "(", "key", ",", "math", "utils", "murmur", "hash", "(", "value", "%", "3", ")", "%", "3", ")", ";", "}", "if", "(", "value", ">", "0", ")", "{", "out", "collect", "(", "value", "-", "1", ")", ";", "}", "}", "@", "override", "public", "void", "close", "(", ")", "{", "assert", "true", "(", "received", ">", "1", ")", ";", "}", "}", ")", ";", "it", "close", "with", "(", "head", "key", "by", "(", "key", ")", "union", "(", "head", "map", "(", "no", "op", "int", "map", ")", "key", "by", "(", "key", ")", ")", ")", "add", "sink", "(", "new", "receive", "check", "no", "op", "sink", "<", "integer", ">", "(", ")", ")", ";", "env", "execute", "(", ")", ";", "break", ";", "/", "/", "success", "}", "catch", "(", "throwable", "t", ")", "{", "log", "info", "(", "\"", "run", "\"", "+", "(", "num", "retry", "+", "1", ")", "+", "\"", "/", "\"", "+", "num", "retries", "+", "\"", "failed", "\"", ",", "t", ")", ";", "if", "(", "num", "retry", ">", "=", "num", "retries", "-", "1", ")", "{", "throw", "t", ";", "}", "else", "{", "timeout", "scale", "*", "=", "2", ";", "}", "}", "}", "}" ]
[ "advances", "{", "@", "link", "#", "first", "sample", "to", "output", "index", "}", "to", "point", "to", "the", "sync", "sample", "before", "the", "specified", "seek", "time", "in", "the", "current", "fragment" ]
[ "public", "void", "seek", "(", "long", "time", "us", ")", "{", "int", "search", "index", "=", "current", "sample", "index", ";", "while", "(", "search", "index", "<", "fragment", "sample", "count", "&", "&", "fragment", "get", "sample", "presentation", "time", "us", "(", "search", "index", ")", "<", "time", "us", ")", "{", "if", "(", "fragment", "sample", "is", "sync", "frame", "table", "[", "search", "index", "]", ")", "{", "first", "sample", "to", "output", "index", "=", "search", "index", ";", "}", "search", "index", "+", "+", ";", "}", "}" ]
[ "hook", "for", "validating", "the", "node", "after", "network", "services", "are", "started", "but", "before", "the", "cluster", "service", "is", "started", "and", "before", "the", "network", "service", "starts", "accepting", "incoming", "network", "requests" ]
[ "protected", "void", "validate", "node", "before", "accepting", "requests", "(", "final", "bootstrap", "context", "context", ",", "final", "bound", "transport", "address", "bound", "transport", "address", ",", "list", "<", "bootstrap", "check", ">", "bootstrap", "checks", ")", "throws", "node", "validation", "exception", "{", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "int", "write", "sleb", "1", "2", "8", "(", "int", "value", ")", "{", "if", "(", "stretchy", ")", "{", "ensure", "capacity", "(", "cursor", "+", "5", ")", ";", "/", "/", "pessimistic", "}", "int", "cursor", "before", "=", "cursor", ";", "leb", "1", "2", "8", "write", "signed", "leb", "1", "2", "8", "(", "this", ",", "value", ")", ";", "return", "(", "cursor", "-", "cursor", "before", ")", ";", "}" ]
[ "test", "the", "property", "'", "username", "'" ]
[ "public", "void", "username", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "username", "}" ]
[ "get", "the", "job", "queue", "name" ]
[ "public", "string", "get", "job", "queue", "name", "(", ")", "{", "if", "(", "datum", "get", "job", "queue", "name", "(", ")", "!", "=", "null", ")", "{", "return", "datum", "get", "job", "queue", "name", "(", ")", "to", "string", "(", ")", ";", "}", "return", "null", ";", "}" ]
[ "given", "a", "list", "of", "keys", "in", "the", "order", "of", "preference", ",", "returns", "a", "value", "for", "the", "key", "in", "the", "given", "order", "from", "the", "configuration" ]
[ "public", "static", "string", "get", "conf", "value", "(", "string", "default", "value", ",", "string", "key", "suffix", ",", "configuration", "conf", ",", "string", "keys", ")", "{", "string", "value", "=", "null", ";", "for", "(", "string", "key", ":", "keys", ")", "{", "key", "=", "add", "suffix", "(", "key", ",", "key", "suffix", ")", ";", "value", "=", "conf", "get", "(", "key", ")", ";", "if", "(", "value", "!", "=", "null", ")", "{", "break", ";", "}", "}", "if", "(", "value", "=", "=", "null", ")", "{", "value", "=", "default", "value", ";", "}", "return", "value", ";", "}" ]
[ "indicate", "whether", "default", "formatters", "should", "be", "registered", "or", "not", "by", "default", ",", "built", "-", "in", "formatters", "are", "registered", "this", "flag", "can", "be", "used", "to", "turn", "that", "off", "and", "rely", "on", "explicitly", "registered", "formatters", "only" ]
[ "public", "void", "set", "register", "default", "formatters", "(", "boolean", "register", "default", "formatters", ")", "{", "this", "register", "default", "formatters", "=", "register", "default", "formatters", ";", "}" ]
[ "test", "the", "property", "'", "date", "'" ]
[ "public", "void", "date", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "date", "}" ]
[ "an", "option", "indicating", "whether", "or", "not", "to", "clear", "existing", "defined", "data", "in", "order", "to", "create", "new", "data", "<", "br", ">", "default", "is", "false" ]
[ "public", "boolean", "should", "clear", "defined", "data", "(", ")", "{", "return", "clear", "defined", "data", ";", "}" ]
[ "this", "implementation", "rolls", "back", "to", "the", "given", "jdbc", "3", "0", "savepoint" ]
[ "public", "void", "rollback", "to", "savepoint", "(", "object", "savepoint", ")", "throws", "transaction", "exception", "{", "connection", "holder", "con", "holder", "=", "get", "connection", "holder", "for", "savepoint", "(", ")", ";", "try", "{", "con", "holder", "get", "connection", "(", ")", "rollback", "(", "(", "savepoint", ")", "savepoint", ")", ";", "con", "holder", "reset", "rollback", "only", "(", ")", ";", "}", "catch", "(", "throwable", "ex", ")", "{", "throw", "new", "transaction", "system", "exception", "(", "\"", "could", "not", "roll", "back", "to", "jdbc", "savepoint", "\"", ",", "ex", ")", ";", "}", "}" ]
[ "test", "more", "randomly", "so", "it", "covers", "some", "special", "cases", "like", "when", "some", "racks", "already", "have", "2", "replicas", ",", "while", "some", "racks", "have", "none", ",", "we", "should", "choose", "the", "racks", "that", "have", "none" ]
[ "private", "void", "do", "test", "choose", "target", "special", "case", "(", ")", "throws", "exception", "{", "string", "client", "machine", "=", "\"", "client", "foo", "com", "\"", ";", "/", "/", "test", "5", "files", "string", "src", "=", "\"", "/", "testfile", "1", "\"", ";", "/", "/", "create", "the", "file", "with", "client", "machine", "hdfs", "file", "status", "file", "status", "=", "namesystem", "start", "file", "(", "src", ",", "perm", ",", "client", "machine", ",", "client", "machine", ",", "enum", "set", "of", "(", "create", "flag", "create", ")", ",", "true", ",", "(", "short", ")", "20", ",", "default", "block", "size", ",", "null", ",", "null", ",", "null", ",", "false", ")", ";", "/", "/", "test", "choose", "target", "for", "new", "file", "located", "block", "located", "block", "=", "name", "node", "rpc", "add", "block", "(", "src", ",", "client", "machine", ",", "null", ",", "null", ",", "file", "status", "get", "file", "id", "(", ")", ",", "null", ",", "null", ")", ";", "do", "test", "located", "block", "(", "20", ",", "located", "block", ")", ";", "datanode", "info", "[", "]", "locs", "=", "located", "block", "get", "locations", "(", ")", ";", "string", "[", "]", "storage", "i", "ds", "=", "located", "block", "get", "storage", "i", "ds", "(", ")", ";", "for", "(", "int", "time", "=", "0", ";", "time", "<", "5", ";", "time", "+", "+", ")", "{", "shuffle", "(", "locs", ",", "storage", "i", "ds", ")", ";", "for", "(", "int", "i", "=", "1", ";", "i", "<", "locs", "length", ";", "i", "+", "+", ")", "{", "datanode", "info", "[", "]", "part", "locs", "=", "new", "datanode", "info", "[", "i", "]", ";", "string", "[", "]", "part", "storage", "i", "ds", "=", "new", "string", "[", "i", "]", ";", "system", "arraycopy", "(", "locs", ",", "0", ",", "part", "locs", ",", "0", ",", "i", ")", ";", "system", "arraycopy", "(", "storage", "i", "ds", ",", "0", ",", "part", "storage", "i", "ds", ",", "0", ",", "i", ")", ";", "for", "(", "int", "j", "=", "1", ";", "j", "<", "20", "-", "i", ";", "j", "+", "+", ")", "{", "located", "block", "additional", "located", "block", "=", "name", "node", "rpc", "get", "additional", "datanode", "(", "src", ",", "file", "status", "get", "file", "id", "(", ")", ",", "located", "block", "get", "block", "(", ")", ",", "part", "locs", ",", "part", "storage", "i", "ds", ",", "new", "datanode", "info", "[", "0", "]", ",", "j", ",", "client", "machine", ")", ";", "do", "test", "located", "block", "(", "i", "+", "j", ",", "additional", "located", "block", ")", ";", "}", "}", "}", "}" ]
[ "callback", "method", "for", "when", "existing", "records", "are", "deleted", "used", "for", "maintaining", "indexes", "only", "may", "be", "called", "before", "the", "old", "record", "is", "actually", "deleted" ]
[ "void", "deleted", "record", "(", "d", "b", "record", "old", "record", ")", "throws", "i", "o", "exception", "{", "/", "/", "delete", "secondary", "index", "entries", "for", "(", "int", "indexed", "column", ":", "indexed", "columns", ")", "{", "index", "table", "index", "table", "=", "secondary", "indexes", "get", "(", "indexed", "column", ")", ";", "index", "table", "delete", "entry", "(", "old", "record", ")", ";", "}", "}" ]
[ "creates", "a", "{", "@", "link", "parquet", "writer", "factory", "}", "for", "the", "given", "type", "the", "type", "should", "represent", "a", "protobuf", "message" ]
[ "public", "static", "<", "t", "extends", "message", ">", "parquet", "writer", "factory", "<", "t", ">", "for", "type", "(", "class", "<", "t", ">", "type", ")", "{", "parquet", "builder", "<", "t", ">", "builder", "=", "(", "out", ")", "-", ">", "new", "parquet", "proto", "writer", "builder", "<", ">", "(", "out", ",", "type", ")", "build", "(", ")", ";", "return", "new", "parquet", "writer", "factory", "<", ">", "(", "builder", ")", ";", "}", "/", "/", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-" ]
[ "gets", "an", "existing", "configured", "target" ]
[ "protected", "configured", "target", "get", "existing", "configured", "target", "(", "string", "target", ")", "throws", "interrupted", "exception", ",", "label", "syntax", "exception", "{", "configured", "target", "existing", "configured", "target", "=", "skyframe", "executor", "test", "utils", "get", "existing", "configured", "target", "(", "get", "skyframe", "executor", "(", ")", ",", "label", "(", "target", ")", ",", "get", "target", "configuration", "(", ")", ")", ";", "assert", "with", "message", "(", "target", ")", "that", "(", "existing", "configured", "target", ")", "is", "not", "null", "(", ")", ";", "return", "existing", "configured", "target", ";", "}" ]
[ "returns", "true", "if", "the", "map", "has", "one", "or", "more", "items" ]
[ "public", "boolean", "not", "empty", "(", ")", "{", "return", "size", ">", "0", ";", "}" ]
[ "creates", "a", "{", "@", "link", "private", "key", "}", "from", "the", "contents", "of", "{", "@", "code", "b", "reader", "}", "that", "contains", "an", "ec", "private", "key", "encoded", "in", "open", "s", "s", "l", "traditional", "format" ]
[ "private", "static", "private", "key", "parse", "open", "ssl", "e", "c", "(", "buffered", "reader", "b", "reader", ",", "supplier", "<", "char", "[", "]", ">", "password", "supplier", ")", "throws", "i", "o", "exception", ",", "general", "security", "exception", "{", "string", "builder", "sb", "=", "new", "string", "builder", "(", ")", ";", "string", "line", "=", "b", "reader", "read", "line", "(", ")", ";", "map", "<", "string", ",", "string", ">", "pem", "headers", "=", "new", "hash", "map", "<", ">", "(", ")", ";", "while", "(", "line", "!", "=", "null", ")", "{", "if", "(", "openssl", "ec", "footer", "equals", "(", "line", "trim", "(", ")", ")", ")", "{", "break", ";", "}", "/", "/", "parse", "pem", "headers", "according", "to", "https", ":", "/", "/", "www", "ietf", "org", "/", "rfc", "/", "rfc", "1", "4", "2", "1", "txt", "if", "(", "line", "contains", "(", "\"", ":", "\"", ")", ")", "{", "string", "[", "]", "header", "=", "line", "split", "(", "\"", ":", "\"", ")", ";", "pem", "headers", "put", "(", "header", "[", "0", "]", "trim", "(", ")", ",", "header", "[", "1", "]", "trim", "(", ")", ")", ";", "}", "else", "{", "sb", "append", "(", "line", "trim", "(", ")", ")", ";", "}", "line", "=", "b", "reader", "read", "line", "(", ")", ";", "}", "if", "(", "null", "=", "=", "line", "|", "|", "openssl", "ec", "footer", "equals", "(", "line", "trim", "(", ")", ")", "=", "=", "false", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "malformed", "pem", "file", ",", "pem", "footer", "is", "invalid", "or", "missing", "\"", ")", ";", "}", "byte", "[", "]", "key", "bytes", "=", "possibly", "decrypt", "p", "k", "c", "s", "1", "key", "(", "pem", "headers", ",", "sb", "to", "string", "(", ")", ",", "password", "supplier", ")", ";", "key", "factory", "key", "factory", "=", "key", "factory", "get", "instance", "(", "\"", "ec", "\"", ")", ";", "e", "c", "private", "key", "spec", "ec", "spec", "=", "parse", "ec", "der", "(", "key", "bytes", ")", ";", "return", "key", "factory", "generate", "private", "(", "ec", "spec", ")", ";", "}" ]
[ "returns", "the", "last", "committed", "segments", "info", "for", "this", "store" ]
[ "public", "segment", "infos", "read", "last", "committed", "segments", "info", "(", ")", "throws", "i", "o", "exception", "{", "fail", "if", "corrupted", "(", ")", ";", "try", "{", "return", "read", "segments", "info", "(", "null", ",", "directory", "(", ")", ")", ";", "}", "catch", "(", "corrupt", "index", "exception", "|", "index", "format", "too", "old", "exception", "|", "index", "format", "too", "new", "exception", "ex", ")", "{", "mark", "store", "corrupted", "(", "ex", ")", ";", "throw", "ex", ";", "}", "}" ]
[ "get", "map", "array", "anytype" ]
[ "public", "map", "<", "string", ",", "list", "<", "object", ">", ">", "get", "map", "array", "anytype", "(", ")", "{", "return", "map", "array", "anytype", ";", "}" ]
[ "prepares", "a", "http", "challenge", "the", "verification", "of", "this", "challenge", "expects", "a", "file", "with", "a", "certain", "content", "to", "be", "reachable", "at", "a", "given", "path", "under", "the", "domain", "to", "be", "tested" ]
[ "private", "challenge", "http", "challenge", "(", "final", "authorization", "auth", ")", "{", "val", "challenge", "=", "locator", "find", "(", "auth", ")", ";", "acme", "challenge", "repository", "add", "(", "challenge", "get", "token", "(", ")", ",", "challenge", "get", "authorization", "(", ")", ")", ";", "return", "challenge", ";", "}" ]
[ "returns", "a", "generic", "iso", "datetime", "parser", "where", "the", "date", "is", "mandatory", "and", "the", "time", "is", "optional", "the", "returned", "formatter", "can", "only", "be", "used", "for", "parsing", ",", "printing", "is", "unsupported", "this", "parser", "only", "parses", "local", "datetimes", "this", "parser", "is", "initialised", "with", "the", "local", "(", "utc", ")", "time", "zone", "the", "parser", "is", "strict", "by", "default", ",", "thus", "time", "string", "{", "@", "code", "24", ":", "00", "}", "cannot", "be", "parsed", "it", "accepts", "formats", "described", "by", "the", "following", "syntax", ":", "datetime", "=", "date", "-", "element", "[", "'", "t", "'", "time", "-", "element", "]", "date", "-", "element", "=", "std", "-", "date", "-", "element", "|", "ord", "-", "date", "-", "element", "|", "week", "-", "date", "-", "element", "std", "-", "date", "-", "element", "=", "yyyy", "[", "'", "-", "'", "mm", "[", "'", "-", "'", "dd", "]", "]", "ord", "-", "date", "-", "element", "=", "yyyy", "[", "'", "-", "'", "ddd", "]", "week", "-", "date", "-", "element", "=", "xxxx", "'", "-", "w", "'", "ww", "[", "'", "-", "'", "e", "]", "time", "-", "element", "=", "hh", "[", "minute", "-", "element", "]", "|", "[", "fraction", "]", "minute", "-", "element", "=", "'", ":", "'", "mm", "[", "second", "-", "element", "]", "|", "[", "fraction", "]", "second", "-", "element", "=", "'", ":", "'", "ss", "[", "fraction", "]", "fraction", "=", "(", "'", "'", "|", "'", ",", "'", ")", "digit", "+" ]
[ "public", "static", "date", "time", "formatter", "local", "date", "optional", "time", "parser", "(", ")", "{", "return", "constants", "ldotp", ";", "}", "/", "/", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-", "-" ]
[ "remove", "old", "blocks" ]
[ "public", "synchronized", "void", "cleanup", "(", ")", "{", "long", "cur", "time", "=", "time", "monotonic", "now", "(", ")", ";", "/", "/", "check", "if", "old", "win", "is", "older", "than", "win", "width", "if", "(", "last", "cleanup", "time", "+", "win", "time", "interval", "<", "=", "cur", "time", ")", "{", "/", "/", "purge", "the", "old", "window", "moved", "blocks", "set", "(", "old", "win", ",", "moved", "blocks", "get", "(", "cur", "win", ")", ")", ";", "moved", "blocks", "set", "(", "cur", "win", ",", "new", "map", "(", ")", ")", ";", "last", "cleanup", "time", "=", "cur", "time", ";", "}", "}" ]
[ "this", "test", "validates", "the", "correctness", "of", "{", "@", "link", "file", "util", "#", "sym", "link", "(", "string", ",", "string", ")", "}", "in", "case", "we", "want", "to", "use", "a", "link", "for", "2", "different", "files" ]
[ "public", "void", "test", "symlink", "2", "different", "file", "(", ")", "throws", "i", "o", "exception", "{", "file", "file", "=", "new", "file", "(", "del", ",", "file", ")", ";", "file", "file", "second", "=", "new", "file", "(", "del", ",", "file", "+", "\"", "1", "\"", ")", ";", "file", "link", "=", "new", "file", "(", "del", ",", "\"", "link", "\"", ")", ";", "/", "/", "create", "a", "symbolic", "link", "/", "/", "the", "operation", "should", "succeed", "int", "result", "=", "file", "util", "sym", "link", "(", "file", "get", "absolute", "path", "(", ")", ",", "link", "get", "absolute", "path", "(", ")", ")", ";", "assert", "assert", "equals", "(", "0", ",", "result", ")", ";", "/", "/", "the", "operation", "should", "fail", "and", "returns", "1", "result", "=", "file", "util", "sym", "link", "(", "file", "second", "get", "absolute", "path", "(", ")", ",", "link", "get", "absolute", "path", "(", ")", ")", ";", "assert", "assert", "equals", "(", "1", ",", "result", ")", ";", "}" ]
[ "convert", "the", "given", "object", "to", "string", "with", "each", "line", "indented", "by", "4", "spaces", "(", "except", "the", "first", "line", ")" ]
[ "private", "string", "to", "indented", "string", "(", "java", "lang", "object", "o", ")", "{", "if", "(", "o", "=", "=", "null", ")", "{", "return", "\"", "null", "\"", ";", "}", "return", "o", "to", "string", "(", ")", "replace", "(", "\"", "\\", "n", "\"", ",", "\"", "\\", "n", "\"", ")", ";", "}" ]
[ "<", "code", ">", "optional", "string", "prefix", "=", "1", ";", "<", "code", ">" ]
[ "public", "java", "lang", "string", "get", "prefix", "(", ")", "{", "return", "prefix", ";", "}" ]
[ "updates", "the", "cache", "params", "(", "constraints", ")", "if", "enough", "time", "has", "passed", "since", "the", "last", "update" ]
[ "private", "synchronized", "void", "maybe", "update", "cache", "params", "(", ")", "{", "if", "(", "m", "last", "cache", "params", "check", "+", "m", "memory", "cache", "params", "params", "check", "interval", "ms", ">", "system", "clock", "uptime", "millis", "(", ")", ")", "{", "return", ";", "}", "m", "last", "cache", "params", "check", "=", "system", "clock", "uptime", "millis", "(", ")", ";", "m", "memory", "cache", "params", "=", "preconditions", "check", "not", "null", "(", "m", "memory", "cache", "params", "supplier", "get", "(", ")", ",", "\"", "m", "memory", "cache", "params", "supplier", "returned", "null", "\"", ")", ";", "}" ]
[ "－", "long", "max", "," ]
[ "public", "static", "long", "next", "long", "(", "random", "random", ")", "{", "long", "n", "=", "random", "next", "long", "(", ")", ";", "if", "(", "n", "=", "=", "long", "min", "value", ")", "{", "n", "=", "0", ";", "/", "/", "corner", "case", "}", "else", "{", "n", "=", "math", "abs", "(", "n", ")", ";", "}", "return", "n", ";", "}" ]
[ "sets", "the", "parameters", "that", "control", "how", "seek", "operations", "are", "performed" ]
[ "void", "set", "seek", "parameters", "(", "@", "nullable", "seek", "parameters", "seek", "parameters", ")", ";" ]
[ "test", "for", "{", "@", "link", "validation", "bean", "}", "with", "a", "validator", "(", "{", "@", "link", "test", "validator", "}", ")", "specified", "in", "a", "custom", "{", "@", "link", "org", "springframework", "messaging", "handler", "annotation", "support", "message", "handler", "method", "factory", "}", "the", "test", "should", "throw", "a", "{", "@", "link", "org", "springframework", "jms", "listener", "adapter", "listener", "execution", "failed", "exception", "}" ]
[ "protected", "void", "test", "jms", "handler", "method", "factory", "configuration", "(", "application", "context", "context", ")", "throws", "j", "m", "s", "exception", "{", "jms", "listener", "container", "test", "factory", "simple", "factory", "=", "context", "get", "bean", "(", "\"", "default", "factory", "\"", ",", "jms", "listener", "container", "test", "factory", "class", ")", ";", "assert", "that", "(", "simple", "factory", "get", "listener", "containers", "(", ")", "size", "(", ")", ")", "is", "equal", "to", "(", "1", ")", ";", "method", "jms", "listener", "endpoint", "endpoint", "=", "(", "method", "jms", "listener", "endpoint", ")", "simple", "factory", "get", "listener", "containers", "(", ")", "get", "(", "0", ")", "get", "endpoint", "(", ")", ";", "simple", "message", "listener", "container", "container", "=", "new", "simple", "message", "listener", "container", "(", ")", ";", "endpoint", "setup", "listener", "container", "(", "container", ")", ";", "messaging", "message", "listener", "adapter", "listener", "=", "(", "messaging", "message", "listener", "adapter", ")", "container", "get", "message", "listener", "(", ")", ";", "listener", "on", "message", "(", "new", "stub", "text", "message", "(", "\"", "fail", "validation", "\"", ")", ",", "mock", "(", "session", "class", ")", ")", ";", "}" ]
[ "wait", "for", "request", "completion", "with", "timeout" ]
[ "private", "void", "wait", "for", "packet", "finish", "(", "reply", "header", "r", ",", "packet", "packet", ")", "throws", "interrupted", "exception", "{", "long", "wait", "start", "time", "=", "time", "current", "elapsed", "time", "(", ")", ";", "while", "(", "!", "packet", "finished", ")", "{", "packet", "wait", "(", "request", "timeout", ")", ";", "if", "(", "!", "packet", "finished", "&", "&", "(", "(", "time", "current", "elapsed", "time", "(", ")", "-", "wait", "start", "time", ")", ">", "=", "request", "timeout", ")", ")", "{", "log", "error", "(", "\"", "timeout", "error", "occurred", "for", "the", "packet", "'", "{", "}", "'", "\"", ",", "packet", ")", ";", "r", "set", "err", "(", "code", "requesttimeout", "int", "value", "(", ")", ")", ";", "break", ";", "}", "}", "}" ]
[ "allocate", "a", "{", "@", "link", "byte", "buf", "}", "if", "it", "is", "a", "direct", "or", "heap", "buffer", "depends", "on", "the", "actual", "implementation" ]
[ "byte", "buf", "buffer", "(", ")", ";" ]
[ "get", "fake", ":", "to", "test", "enum", "parameters", "to", "test", "enum", "parameters" ]
[ "default", "response", "entity", "<", "void", ">", "test", "enum", "parameters", "(", "@", "api", "param", "(", "value", "=", "\"", "header", "parameter", "enum", "test", "(", "string", "array", ")", "\"", ",", "allowable", "values", "=", "\"", ">", ",", "$", "\"", ")", "@", "request", "header", "(", "value", "=", "\"", "enum", "header", "string", "array", "\"", ",", "required", "=", "false", ")", "optional", "<", "list", "<", "string", ">", ">", "enum", "header", "string", "array", ",", "@", "api", "param", "(", "value", "=", "\"", "header", "parameter", "enum", "test", "(", "string", ")", "\"", ",", "allowable", "values", "=", "\"", "abc", ",", "-", "efg", ",", "(", "xyz", ")", "\"", ",", "default", "value", "=", "\"", "-", "efg", "\"", ")", "@", "request", "header", "(", "value", "=", "\"", "enum", "header", "string", "\"", ",", "required", "=", "false", ")", "optional", "<", "string", ">", "enum", "header", "string", ",", "@", "api", "param", "(", "value", "=", "\"", "query", "parameter", "enum", "test", "(", "string", "array", ")", "\"", ",", "allowable", "values", "=", "\"", ">", ",", "$", "\"", ")", "@", "valid", "@", "request", "param", "(", "value", "=", "\"", "enum", "query", "string", "array", "\"", ",", "required", "=", "false", ")", "optional", "<", "list", "<", "string", ">", ">", "enum", "query", "string", "array", ",", "@", "api", "param", "(", "value", "=", "\"", "query", "parameter", "enum", "test", "(", "string", ")", "\"", ",", "allowable", "values", "=", "\"", "abc", ",", "-", "efg", ",", "(", "xyz", ")", "\"", ",", "default", "value", "=", "\"", "-", "efg", "\"", ")", "@", "valid", "@", "request", "param", "(", "value", "=", "\"", "enum", "query", "string", "\"", ",", "required", "=", "false", ",", "default", "value", "=", "\"", "-", "efg", "\"", ")", "optional", "<", "string", ">", "enum", "query", "string", ",", "@", "api", "param", "(", "value", "=", "\"", "query", "parameter", "enum", "test", "(", "double", ")", "\"", ",", "allowable", "values", "=", "\"", "1", ",", "-", "2", "\"", ")", "@", "valid", "@", "request", "param", "(", "value", "=", "\"", "enum", "query", "integer", "\"", ",", "required", "=", "false", ")", "optional", "<", "integer", ">", "enum", "query", "integer", ",", "@", "api", "param", "(", "value", "=", "\"", "query", "parameter", "enum", "test", "(", "double", ")", "\"", ",", "allowable", "values", "=", "\"", "1", "1", ",", "-", "1", "2", "\"", ")", "@", "valid", "@", "request", "param", "(", "value", "=", "\"", "enum", "query", "double", "\"", ",", "required", "=", "false", ")", "optional", "<", "double", ">", "enum", "query", "double", ",", "@", "api", "param", "(", "value", "=", "\"", "form", "parameter", "enum", "test", "(", "string", "array", ")", "\"", ",", "allowable", "values", "=", "\"", ">", ",", "$", "\"", ")", "@", "valid", "@", "request", "part", "(", "value", "=", "\"", "enum", "form", "string", "array", "\"", ",", "required", "=", "false", ")", "list", "<", "string", ">", "enum", "form", "string", "array", ",", "@", "api", "param", "(", "value", "=", "\"", "form", "parameter", "enum", "test", "(", "string", ")", "\"", ",", "allowable", "values", "=", "\"", "abc", ",", "-", "efg", ",", "(", "xyz", ")", "\"", ",", "default", "value", "=", "\"", "-", "efg", "\"", ")", "@", "valid", "@", "request", "part", "(", "value", "=", "\"", "enum", "form", "string", "\"", ",", "required", "=", "false", ")", "string", "enum", "form", "string", ")", "{", "return", "new", "response", "entity", "<", ">", "(", "http", "status", "not", "implemented", ")", ";", "}" ]
[ "menu", "listener", "for", "project", "|", "add", "view" ]
[ "private", "void", "open", "project", "view", "(", ")", "{", "if", "(", "file", "chooser", "=", "=", "null", ")", "{", "file", "chooser", "=", "plugin", "create", "file", "chooser", "(", "last", "viewed", "project", "directory", ")", ";", "}", "project", "locator", "project", "view", "=", "plugin", "choose", "project", "(", "file", "chooser", ",", "\"", "select", "\"", ",", "last", "viewed", "project", "directory", ")", ";", "if", "(", "project", "view", "!", "=", "null", ")", "{", "open", "view", "(", "project", "view", "get", "u", "r", "l", "(", ")", ")", ";", "}", "}" ]
[ "get", "fake", ":", "to", "test", "enum", "parameters", "to", "test", "enum", "parameters" ]
[ "default", "response", "entity", "<", "void", ">", "test", "enum", "parameters", "(", "@", "api", "param", "(", "value", "=", "\"", "header", "parameter", "enum", "test", "(", "string", "array", ")", "\"", ",", "allowable", "values", "=", "\"", ">", ",", "$", "\"", ")", "@", "request", "header", "(", "value", "=", "\"", "enum", "header", "string", "array", "\"", ",", "required", "=", "false", ")", "list", "<", "string", ">", "enum", "header", "string", "array", ",", "@", "api", "param", "(", "value", "=", "\"", "header", "parameter", "enum", "test", "(", "string", ")", "\"", ",", "allowable", "values", "=", "\"", "abc", ",", "-", "efg", ",", "(", "xyz", ")", "\"", ",", "default", "value", "=", "\"", "-", "efg", "\"", ")", "@", "request", "header", "(", "value", "=", "\"", "enum", "header", "string", "\"", ",", "required", "=", "false", ")", "string", "enum", "header", "string", ",", "@", "api", "param", "(", "value", "=", "\"", "query", "parameter", "enum", "test", "(", "string", "array", ")", "\"", ",", "allowable", "values", "=", "\"", ">", ",", "$", "\"", ")", "@", "valid", "@", "request", "param", "(", "value", "=", "\"", "enum", "query", "string", "array", "\"", ",", "required", "=", "false", ")", "list", "<", "string", ">", "enum", "query", "string", "array", ",", "@", "api", "param", "(", "value", "=", "\"", "query", "parameter", "enum", "test", "(", "string", ")", "\"", ",", "allowable", "values", "=", "\"", "abc", ",", "-", "efg", ",", "(", "xyz", ")", "\"", ",", "default", "value", "=", "\"", "-", "efg", "\"", ")", "@", "valid", "@", "request", "param", "(", "value", "=", "\"", "enum", "query", "string", "\"", ",", "required", "=", "false", ",", "default", "value", "=", "\"", "-", "efg", "\"", ")", "string", "enum", "query", "string", ",", "@", "api", "param", "(", "value", "=", "\"", "query", "parameter", "enum", "test", "(", "double", ")", "\"", ",", "allowable", "values", "=", "\"", "1", ",", "-", "2", "\"", ")", "@", "valid", "@", "request", "param", "(", "value", "=", "\"", "enum", "query", "integer", "\"", ",", "required", "=", "false", ")", "integer", "enum", "query", "integer", ",", "@", "api", "param", "(", "value", "=", "\"", "query", "parameter", "enum", "test", "(", "double", ")", "\"", ",", "allowable", "values", "=", "\"", "1", "1", ",", "-", "1", "2", "\"", ")", "@", "valid", "@", "request", "param", "(", "value", "=", "\"", "enum", "query", "double", "\"", ",", "required", "=", "false", ")", "double", "enum", "query", "double", ",", "@", "api", "param", "(", "value", "=", "\"", "form", "parameter", "enum", "test", "(", "string", "array", ")", "\"", ",", "allowable", "values", "=", "\"", ">", ",", "$", "\"", ")", "@", "valid", "@", "request", "part", "(", "value", "=", "\"", "enum", "form", "string", "array", "\"", ",", "required", "=", "false", ")", "list", "<", "string", ">", "enum", "form", "string", "array", ",", "@", "api", "param", "(", "value", "=", "\"", "form", "parameter", "enum", "test", "(", "string", ")", "\"", ",", "allowable", "values", "=", "\"", "abc", ",", "-", "efg", ",", "(", "xyz", ")", "\"", ",", "default", "value", "=", "\"", "-", "efg", "\"", ")", "@", "valid", "@", "request", "part", "(", "value", "=", "\"", "enum", "form", "string", "\"", ",", "required", "=", "false", ")", "string", "enum", "form", "string", ")", "{", "return", "new", "response", "entity", "<", ">", "(", "http", "status", "not", "implemented", ")", ";", "}" ]
[ "return", "the", "parcelable", "in", "cache" ]
[ "public", "static", "<", "t", ">", "t", "get", "parcelable", "(", "@", "non", "null", "final", "string", "key", ",", "@", "non", "null", "final", "parcelable", "creator", "<", "t", ">", "creator", ",", "final", "t", "default", "value", ",", "@", "non", "null", "final", "cache", "double", "utils", "cache", "double", "utils", ")", "{", "return", "cache", "double", "utils", "get", "parcelable", "(", "key", ",", "creator", ",", "default", "value", ")", ";", "}", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "about", "serializable", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "/" ]
[ "disables", "caching", "of", "the", "generated", "json", "default", "is", "{", "@", "code", "true", "}", ",", "which", "will", "prevent", "the", "client", "from", "caching", "the", "generated", "json" ]
[ "public", "void", "set", "disable", "caching", "(", "boolean", "disable", "caching", ")", "{", "this", "disable", "caching", "=", "disable", "caching", ";", "}" ]
[ "return", "the", "logo", "of", "activity" ]
[ "public", "static", "drawable", "get", "activity", "logo", "(", "@", "non", "null", "final", "activity", "activity", ")", "{", "return", "get", "activity", "logo", "(", "activity", "get", "component", "name", "(", ")", ")", ";", "}" ]
[ "the", "future", "uri", "of", "the", "completed", "upload" ]
[ "listenable", "future", "<", "string", ">", "uri", "future", "(", ")", ";" ]
[ "set", "the", "name", "of", "the", "initializer", "method", "the", "default", "is", "{", "@", "code", "null", "}", "in", "which", "case", "there", "is", "no", "initializer", "method" ]
[ "public", "void", "set", "init", "method", "name", "(", "@", "nullable", "string", "init", "method", "name", ")", "{", "this", "init", "method", "name", "=", "init", "method", "name", ";", "}" ]