docstring_tokens
list | code_tokens
list |
|---|---|
[
"test",
"the",
"property",
"'",
"bool",
"item",
"'"
]
| [
"public",
"void",
"bool",
"item",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"bool",
"item",
"}"
]
|
[
"test",
"the",
"property",
"'",
"prefix",
"ns",
"boolean",
"'"
]
| [
"public",
"void",
"prefix",
"ns",
"boolean",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"prefix",
"ns",
"boolean",
"}"
]
|
[
"test",
"{",
"@",
"code",
"bloom",
"map",
"file",
"writer",
"}",
"constructors"
]
| [
"public",
"void",
"test",
"bloom",
"map",
"file",
"constructors",
"(",
")",
"{",
"bloom",
"map",
"file",
"writer",
"writer",
"=",
"null",
";",
"try",
"{",
"file",
"system",
"ts",
"=",
"file",
"system",
"get",
"(",
"conf",
")",
";",
"string",
"test",
"file",
"name",
"=",
"test",
"file",
"to",
"string",
"(",
")",
";",
"writer",
"=",
"new",
"bloom",
"map",
"file",
"writer",
"(",
"conf",
",",
"ts",
",",
"test",
"file",
"name",
",",
"int",
"writable",
"class",
",",
"text",
"class",
",",
"compression",
"type",
"block",
",",
"default",
"codec",
",",
"default",
"progress",
")",
";",
"assert",
"not",
"null",
"(",
"\"",
"test",
"bloom",
"map",
"file",
"constructors",
"error",
"!",
"!",
"!",
"\"",
",",
"writer",
")",
";",
"writer",
"close",
"(",
")",
";",
"writer",
"=",
"new",
"bloom",
"map",
"file",
"writer",
"(",
"conf",
",",
"ts",
",",
"test",
"file",
"name",
",",
"int",
"writable",
"class",
",",
"text",
"class",
",",
"compression",
"type",
"block",
",",
"default",
"progress",
")",
";",
"assert",
"not",
"null",
"(",
"\"",
"test",
"bloom",
"map",
"file",
"constructors",
"error",
"!",
"!",
"!",
"\"",
",",
"writer",
")",
";",
"writer",
"close",
"(",
")",
";",
"writer",
"=",
"new",
"bloom",
"map",
"file",
"writer",
"(",
"conf",
",",
"ts",
",",
"test",
"file",
"name",
",",
"int",
"writable",
"class",
",",
"text",
"class",
",",
"compression",
"type",
"block",
")",
";",
"assert",
"not",
"null",
"(",
"\"",
"test",
"bloom",
"map",
"file",
"constructors",
"error",
"!",
"!",
"!",
"\"",
",",
"writer",
")",
";",
"writer",
"close",
"(",
")",
";",
"writer",
"=",
"new",
"bloom",
"map",
"file",
"writer",
"(",
"conf",
",",
"ts",
",",
"test",
"file",
"name",
",",
"int",
"writable",
"class",
",",
"text",
"class",
",",
"compression",
"type",
"record",
",",
"default",
"codec",
",",
"default",
"progress",
")",
";",
"assert",
"not",
"null",
"(",
"\"",
"test",
"bloom",
"map",
"file",
"constructors",
"error",
"!",
"!",
"!",
"\"",
",",
"writer",
")",
";",
"writer",
"close",
"(",
")",
";",
"writer",
"=",
"new",
"bloom",
"map",
"file",
"writer",
"(",
"conf",
",",
"ts",
",",
"test",
"file",
"name",
",",
"int",
"writable",
"class",
",",
"text",
"class",
",",
"compression",
"type",
"record",
",",
"default",
"progress",
")",
";",
"assert",
"not",
"null",
"(",
"\"",
"test",
"bloom",
"map",
"file",
"constructors",
"error",
"!",
"!",
"!",
"\"",
",",
"writer",
")",
";",
"writer",
"close",
"(",
")",
";",
"writer",
"=",
"new",
"bloom",
"map",
"file",
"writer",
"(",
"conf",
",",
"ts",
",",
"test",
"file",
"name",
",",
"int",
"writable",
"class",
",",
"text",
"class",
",",
"compression",
"type",
"record",
")",
";",
"assert",
"not",
"null",
"(",
"\"",
"test",
"bloom",
"map",
"file",
"constructors",
"error",
"!",
"!",
"!",
"\"",
",",
"writer",
")",
";",
"writer",
"close",
"(",
")",
";",
"writer",
"=",
"new",
"bloom",
"map",
"file",
"writer",
"(",
"conf",
",",
"ts",
",",
"test",
"file",
"name",
",",
"writable",
"comparator",
"get",
"(",
"text",
"class",
")",
",",
"text",
"class",
")",
";",
"assert",
"not",
"null",
"(",
"\"",
"test",
"bloom",
"map",
"file",
"constructors",
"error",
"!",
"!",
"!",
"\"",
",",
"writer",
")",
";",
"writer",
"close",
"(",
")",
";",
"}",
"catch",
"(",
"exception",
"ex",
")",
"{",
"fail",
"(",
"\"",
"test",
"bloom",
"map",
"file",
"constructors",
"error",
"!",
"!",
"!",
"\"",
")",
";",
"}",
"finally",
"{",
"i",
"o",
"utils",
"cleanup",
"with",
"logger",
"(",
"log",
",",
"writer",
")",
";",
"}",
"}"
]
|
[
"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",
")",
";",
"}"
]
|
[
"returns",
"a",
"{",
"@",
"link",
"request",
"options",
"}",
"object",
"with",
"{",
"@",
"link",
"#",
"center",
"crop",
"(",
")",
"}",
"set"
]
| [
"public",
"static",
"request",
"options",
"center",
"crop",
"transform",
"(",
")",
"{",
"if",
"(",
"center",
"crop",
"options",
"=",
"=",
"null",
")",
"{",
"center",
"crop",
"options",
"=",
"new",
"request",
"options",
"(",
")",
"center",
"crop",
"(",
")",
"auto",
"clone",
"(",
")",
";",
"}",
"return",
"center",
"crop",
"options",
";",
"}"
]
|
[
"rename",
"the",
"file",
"that",
"backs",
"this",
"message",
"set"
]
| [
"public",
"void",
"rename",
"to",
"(",
"file",
"f",
")",
"throws",
"i",
"o",
"exception",
"{",
"try",
"{",
"utils",
"atomic",
"move",
"with",
"fallback",
"(",
"file",
"to",
"path",
"(",
")",
",",
"f",
"to",
"path",
"(",
")",
")",
";",
"}",
"finally",
"{",
"this",
"file",
"=",
"f",
";",
"}",
"}"
]
|
[
"add",
"loaded",
"metadata",
"of",
"a",
"data",
"volume",
"to",
"{",
"@",
"link",
"data",
"storage",
"}"
]
| [
"public",
"void",
"build",
"(",
")",
"{",
"assert",
"this",
"sd",
"!",
"=",
"null",
";",
"synchronized",
"(",
"storage",
")",
"{",
"for",
"(",
"map",
"entry",
"<",
"string",
",",
"list",
"<",
"storage",
"directory",
">",
">",
"e",
":",
"bp",
"storage",
"dir",
"map",
"entry",
"set",
"(",
")",
")",
"{",
"final",
"string",
"bpid",
"=",
"e",
"get",
"key",
"(",
")",
";",
"block",
"pool",
"slice",
"storage",
"bp",
"storage",
"=",
"this",
"storage",
"bp",
"storage",
"map",
"get",
"(",
"bpid",
")",
";",
"assert",
"bp",
"storage",
"!",
"=",
"null",
";",
"for",
"(",
"storage",
"directory",
"bp",
"sd",
":",
"e",
"get",
"value",
"(",
")",
")",
"{",
"bp",
"storage",
"add",
"storage",
"dir",
"(",
"bp",
"sd",
")",
";",
"}",
"}",
"storage",
"add",
"storage",
"dir",
"(",
"sd",
")",
";",
"}",
"}"
]
|
[
"this",
"method",
"is",
"deprecated",
"and",
"will",
"be",
"removed",
"in",
"the",
"future",
"releases",
"handle",
"async",
"db",
"operation",
"in",
"your",
"own",
"logic",
"instead"
]
| [
"public",
"static",
"count",
"executor",
"count",
"async",
"(",
"final",
"class",
"<",
"?",
">",
"model",
"class",
")",
"{",
"return",
"count",
"async",
"(",
"base",
"utility",
"change",
"case",
"(",
"d",
"b",
"utility",
"get",
"table",
"name",
"by",
"class",
"name",
"(",
"model",
"class",
"get",
"name",
"(",
")",
")",
")",
")",
";",
"}"
]
|
[
"a",
"callback",
"when",
"a",
"task",
"is",
"no",
"longer",
"being",
"tracked"
]
| [
"public",
"void",
"task",
"removed",
"(",
"task",
"task",
")",
";"
]
|
[
"sets",
"the",
"cryptographic",
"parameters",
"which",
"are",
"used",
"to",
"sign",
"http",
"requests"
]
| [
"public",
"void",
"set",
"algorithm",
"parameter",
"spec",
"(",
"algorithm",
"parameter",
"spec",
"parameter",
"spec",
")",
"{",
"this",
"parameter",
"spec",
"=",
"parameter",
"spec",
";",
"}"
]
|
[
"sets",
"the",
"environment",
"variable",
"overrides",
"in",
"addition",
"to",
"what",
"the",
"current",
"process",
"is",
"inherited",
"(",
"if",
"this",
"is",
"going",
"to",
"be",
"launched",
"from",
"a",
"agent",
"agent",
",",
"that",
"becomes",
"the",
"\"",
"current",
"\"",
"process",
")",
",",
"these",
"variables",
"will",
"be",
"also",
"set"
]
| [
"public",
"proc",
"starter",
"envs",
"(",
"@",
"non",
"null",
"map",
"<",
"string",
",",
"string",
">",
"overrides",
")",
"{",
"this",
"envs",
"=",
"util",
"map",
"to",
"env",
"(",
"overrides",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"if",
"the",
"requested",
"service",
"is",
"unknown",
",",
"the",
"call",
"will",
"fail",
"with",
"status",
"not",
"found"
]
| [
"public",
"void",
"check",
"(",
"io",
"grpc",
"health",
"v",
"1",
"health",
"check",
"request",
"request",
",",
"io",
"grpc",
"stub",
"stream",
"observer",
"<",
"io",
"grpc",
"health",
"v",
"1",
"health",
"check",
"response",
">",
"response",
"observer",
")",
"{",
"io",
"grpc",
"stub",
"client",
"calls",
"async",
"unary",
"call",
"(",
"get",
"channel",
"(",
")",
"new",
"call",
"(",
"get",
"check",
"method",
"(",
")",
",",
"get",
"call",
"options",
"(",
")",
")",
",",
"request",
",",
"response",
"observer",
")",
";",
"}"
]
|
[
"get",
"the",
"foreground",
"color",
"to",
"display",
"for",
"the",
"given",
"suggestion",
"in",
"the",
"list"
]
| [
"protected",
"color",
"get",
"completion",
"foreground",
"(",
"t",
"sel",
",",
"boolean",
"is",
"selected",
",",
"boolean",
"cell",
"has",
"focus",
")",
"{",
"return",
"null",
";",
"}"
]
|
[
"override",
"this",
"to",
"handle",
"{",
"@",
"link",
"client",
"#",
"get",
"(",
"get",
"request",
")",
"}",
"calls",
"from",
"parsers",
"builders"
]
| [
"protected",
"get",
"response",
"execute",
"get",
"(",
"get",
"request",
"get",
"request",
")",
"{",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
"\"",
"this",
"test",
"can",
"'",
"t",
"handle",
"get",
"requests",
"\"",
")",
";",
"}"
]
|
[
"called",
"when",
"someone",
"tried",
"to",
"add",
"a",
"task",
"to",
"{",
"@",
"link",
"single",
"thread",
"event",
"executor",
"}",
"but",
"this",
"failed",
"due",
"capacity",
"restrictions"
]
| [
"void",
"rejected",
"(",
"runnable",
"task",
",",
"single",
"thread",
"event",
"executor",
"executor",
")",
";"
]
|
[
"get",
"wrapped",
"array"
]
| [
"public",
"list",
"<",
"integer",
">",
"get",
"wrapped",
"array",
"(",
")",
"{",
"return",
"wrapped",
"array",
";",
"}"
]
|
[
"set",
"the",
"total",
"number",
"of",
"blocks",
"in",
"the",
"system",
"if",
"safe",
"mode",
"is",
"not",
"currently",
"on",
",",
"this",
"is",
"a",
"no",
"-",
"op"
]
| [
"public",
"void",
"set",
"block",
"total",
"(",
"long",
"total",
")",
"{",
"if",
"(",
"bm",
"safe",
"mode",
"is",
"in",
"safe",
"mode",
"(",
")",
")",
"{",
"bm",
"safe",
"mode",
"set",
"block",
"total",
"(",
"total",
")",
";",
"bm",
"safe",
"mode",
"check",
"safe",
"mode",
"(",
")",
";",
"}",
"}"
]
|
[
"get",
"key",
"provider",
"if",
"present"
]
| [
"public",
"key",
"provider",
"get",
"key",
"provider",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"dfs",
"get",
"client",
"(",
")",
"get",
"key",
"provider",
"(",
")",
";",
"}"
]
|
[
"set",
"a",
"custom",
"response",
"interceptor",
"this",
"is",
"useful",
"for",
"logging",
",",
"monitoring",
"or",
"extraction",
"of",
"header",
"variables"
]
| [
"public",
"api",
"client",
"set",
"response",
"interceptor",
"(",
"consumer",
"<",
"http",
"response",
"<",
"input",
"stream",
">",
">",
"interceptor",
")",
"{",
"this",
"response",
"interceptor",
"=",
"interceptor",
";",
"return",
"this",
";",
"}"
]
|
[
"set",
"the",
"class",
"that",
"each",
"row",
"should",
"be",
"mapped",
"to"
]
| [
"public",
"void",
"set",
"mapped",
"class",
"(",
"class",
"<",
"t",
">",
"mapped",
"class",
")",
"{",
"if",
"(",
"this",
"mapped",
"class",
"=",
"=",
"null",
")",
"{",
"initialize",
"(",
"mapped",
"class",
")",
";",
"}",
"else",
"{",
"if",
"(",
"this",
"mapped",
"class",
"!",
"=",
"mapped",
"class",
")",
"{",
"throw",
"new",
"invalid",
"data",
"access",
"api",
"usage",
"exception",
"(",
"\"",
"the",
"mapped",
"class",
"can",
"not",
"be",
"reassigned",
"to",
"map",
"to",
"\"",
"+",
"mapped",
"class",
"+",
"\"",
"since",
"it",
"is",
"already",
"providing",
"mapping",
"for",
"\"",
"+",
"this",
"mapped",
"class",
")",
";",
"}",
"}",
"}"
]
|
[
"returns",
"a",
"required",
"hash",
"shuffle",
"type"
]
| [
"public",
"static",
"required",
"shuffle",
"hash",
"(",
"int",
"[",
"]",
"keys",
")",
"{",
"preconditions",
"check",
"argument",
"(",
"keys",
"length",
">",
"0",
",",
"\"",
"hash",
"keys",
"must",
"no",
"be",
"empty",
"\"",
")",
";",
"return",
"new",
"required",
"shuffle",
"(",
"shuffle",
"type",
"hash",
",",
"keys",
")",
";",
"}"
]
|
[
"parses",
"the",
"mnemonic",
"key",
"from",
"the",
"menu",
"items",
"text"
]
| [
"public",
"static",
"char",
"get",
"mnemonic",
"key",
"(",
"string",
"str",
")",
"{",
"int",
"amp",
"loc",
"=",
"str",
"index",
"of",
"(",
"'",
"&",
"'",
")",
";",
"char",
"mk",
"=",
"'",
"\\",
"0",
"'",
";",
"if",
"(",
"amp",
"loc",
">",
"=",
"0",
"&",
"&",
"amp",
"loc",
"<",
"str",
"length",
"(",
")",
"-",
"1",
")",
"{",
"mk",
"=",
"str",
"char",
"at",
"(",
"amp",
"loc",
"+",
"1",
")",
";",
"}",
"return",
"mk",
";",
"}"
]
|
[
"test",
"pipes",
"map",
"runner",
"test",
"the",
"transfer",
"data",
"from",
"reader"
]
| [
"public",
"void",
"test",
"runner",
"(",
")",
"throws",
"exception",
"{",
"/",
"/",
"clean",
"old",
"password",
"files",
"file",
"[",
"]",
"psw",
"=",
"clean",
"token",
"password",
"file",
"(",
")",
";",
"try",
"{",
"record",
"reader",
"<",
"float",
"writable",
",",
"null",
"writable",
">",
"r",
"reader",
"=",
"new",
"reader",
"pipes",
"map",
"runner",
"(",
")",
";",
"job",
"conf",
"conf",
"=",
"new",
"job",
"conf",
"(",
")",
";",
"conf",
"set",
"(",
"submitter",
"is",
"java",
"rr",
",",
"\"",
"true",
"\"",
")",
";",
"/",
"/",
"for",
"stdour",
"and",
"stderror",
"conf",
"set",
"(",
"m",
"r",
"job",
"config",
"task",
"attempt",
"id",
",",
"task",
"name",
")",
";",
"combine",
"output",
"collector",
"<",
"int",
"writable",
",",
"text",
">",
"output",
"=",
"new",
"combine",
"output",
"collector",
"<",
"int",
"writable",
",",
"text",
">",
"(",
"new",
"counters",
"counter",
"(",
")",
",",
"new",
"progress",
"(",
")",
")",
";",
"file",
"system",
"fs",
"=",
"new",
"raw",
"local",
"file",
"system",
"(",
")",
";",
"fs",
"initialize",
"(",
"fs",
"constants",
"local",
"fs",
"uri",
",",
"conf",
")",
";",
"writer",
"<",
"int",
"writable",
",",
"text",
">",
"wr",
"=",
"new",
"writer",
"<",
"int",
"writable",
",",
"text",
">",
"(",
"conf",
",",
"fs",
"create",
"(",
"new",
"path",
"(",
"work",
"space",
"+",
"file",
"separator",
"+",
"\"",
"outfile",
"\"",
")",
")",
",",
"int",
"writable",
"class",
",",
"text",
"class",
",",
"null",
",",
"null",
",",
"true",
")",
";",
"output",
"set",
"writer",
"(",
"wr",
")",
";",
"/",
"/",
"stub",
"for",
"client",
"file",
"f",
"command",
"=",
"get",
"file",
"command",
"(",
"\"",
"org",
"apache",
"hadoop",
"mapred",
"pipes",
"pipe",
"application",
"runnable",
"stub",
"\"",
")",
";",
"conf",
"set",
"(",
"m",
"r",
"job",
"config",
"cache",
"localfiles",
",",
"f",
"command",
"get",
"absolute",
"path",
"(",
")",
")",
";",
"/",
"/",
"token",
"for",
"authorization",
"token",
"<",
"a",
"m",
"r",
"m",
"token",
"identifier",
">",
"token",
"=",
"new",
"token",
"<",
"a",
"m",
"r",
"m",
"token",
"identifier",
">",
"(",
"\"",
"user",
"\"",
"get",
"bytes",
"(",
")",
",",
"\"",
"password",
"\"",
"get",
"bytes",
"(",
")",
",",
"new",
"text",
"(",
"\"",
"kind",
"\"",
")",
",",
"new",
"text",
"(",
"\"",
"service",
"\"",
")",
")",
";",
"token",
"cache",
"set",
"job",
"token",
"(",
"token",
",",
"conf",
"get",
"credentials",
"(",
")",
")",
";",
"conf",
"set",
"boolean",
"(",
"m",
"r",
"job",
"config",
"skip",
"records",
",",
"true",
")",
";",
"test",
"task",
"reporter",
"reporter",
"=",
"new",
"test",
"task",
"reporter",
"(",
")",
";",
"pipes",
"map",
"runner",
"<",
"float",
"writable",
",",
"null",
"writable",
",",
"int",
"writable",
",",
"text",
">",
"runner",
"=",
"new",
"pipes",
"map",
"runner",
"<",
"float",
"writable",
",",
"null",
"writable",
",",
"int",
"writable",
",",
"text",
">",
"(",
")",
";",
"init",
"std",
"out",
"(",
"conf",
")",
";",
"runner",
"configure",
"(",
"conf",
")",
";",
"runner",
"run",
"(",
"r",
"reader",
",",
"output",
",",
"reporter",
")",
";",
"string",
"std",
"out",
"=",
"read",
"std",
"out",
"(",
"conf",
")",
";",
"/",
"/",
"test",
"part",
"of",
"translated",
"data",
"as",
"common",
"file",
"for",
"client",
"and",
"test",
"-",
"/",
"/",
"clients",
"std",
"out",
"/",
"/",
"check",
"version",
"assert",
"true",
"(",
"std",
"out",
"contains",
"(",
"\"",
"current",
"protocol",
"version",
":",
"0",
"\"",
")",
")",
";",
"/",
"/",
"check",
"key",
"and",
"value",
"classes",
"assert",
"true",
"(",
"std",
"out",
"contains",
"(",
"\"",
"key",
"class",
":",
"org",
"apache",
"hadoop",
"io",
"float",
"writable",
"\"",
")",
")",
";",
"assert",
"true",
"(",
"std",
"out",
"contains",
"(",
"\"",
"value",
"class",
":",
"org",
"apache",
"hadoop",
"io",
"null",
"writable",
"\"",
")",
")",
";",
"/",
"/",
"test",
"have",
"sent",
"all",
"data",
"from",
"reader",
"assert",
"true",
"(",
"std",
"out",
"contains",
"(",
"\"",
"value",
":",
"0",
"0",
"\"",
")",
")",
";",
"assert",
"true",
"(",
"std",
"out",
"contains",
"(",
"\"",
"value",
":",
"9",
"0",
"\"",
")",
")",
";",
"}",
"finally",
"{",
"if",
"(",
"psw",
"!",
"=",
"null",
")",
"{",
"/",
"/",
"remove",
"password",
"files",
"for",
"(",
"file",
"file",
":",
"psw",
")",
"{",
"file",
"delete",
"(",
")",
";",
"}",
"}",
"}",
"}"
]
|
[
"this",
"method",
"serializes",
"the",
"specified",
"object",
"into",
"its",
"equivalent",
"representation",
"as",
"a",
"tree",
"of",
"{",
"@",
"link",
"json",
"element",
"}",
"s",
"this",
"method",
"should",
"be",
"used",
"when",
"the",
"specified",
"object",
"is",
"not",
"a",
"generic",
"type",
"this",
"method",
"uses",
"{",
"@",
"link",
"class",
"#",
"get",
"class",
"(",
")",
"}",
"to",
"get",
"the",
"type",
"for",
"the",
"specified",
"object",
",",
"but",
"the",
"{",
"@",
"code",
"get",
"class",
"(",
")",
"}",
"loses",
"the",
"generic",
"type",
"information",
"because",
"of",
"the",
"type",
"erasure",
"feature",
"of",
"java",
"note",
"that",
"this",
"method",
"works",
"fine",
"if",
"the",
"any",
"of",
"the",
"object",
"fields",
"are",
"of",
"generic",
"type",
",",
"just",
"the",
"object",
"itself",
"should",
"not",
"be",
"of",
"a",
"generic",
"type",
"if",
"the",
"object",
"is",
"of",
"generic",
"type",
",",
"use",
"{",
"@",
"link",
"#",
"to",
"json",
"tree",
"(",
"object",
",",
"type",
")",
"}",
"instead"
]
| [
"public",
"json",
"element",
"to",
"json",
"tree",
"(",
"object",
"src",
")",
"{",
"if",
"(",
"src",
"=",
"=",
"null",
")",
"{",
"return",
"json",
"null",
"instance",
";",
"}",
"return",
"to",
"json",
"tree",
"(",
"src",
",",
"src",
"get",
"class",
"(",
")",
")",
";",
"}"
]
|
[
"helper",
"method",
"to",
"easily",
"create",
"a",
"map",
"with",
"keys",
"of",
"type",
"string",
"and",
"values",
"of",
"type",
"object",
"null",
"values",
"are",
"allowed"
]
| [
"public",
"static",
"map",
"<",
"string",
",",
"object",
">",
"map",
"(",
"object",
"objects",
")",
"{",
"return",
"map",
"of",
"class",
"(",
"object",
"class",
",",
"objects",
")",
";",
"}"
]
|
[
"the",
"optinal",
"style",
"from",
"which",
"this",
"style",
"inherits",
"attributes",
"<",
"code",
">",
"optional",
"aapt",
"pb",
"reference",
"parent",
"=",
"1",
";",
"<",
"code",
">"
]
| [
"public",
"com",
"android",
"aapt",
"resources",
"reference",
"get",
"parent",
"(",
")",
"{",
"return",
"instance",
"get",
"parent",
"(",
")",
";",
"}"
]
|
[
"get",
"the",
"temp",
"path",
"for",
"this",
"cluster"
]
| [
"public",
"path",
"get",
"temp",
"path",
"for",
"cluster",
"(",
"string",
"clustername",
")",
"{",
"path",
"cluster",
"dir",
"=",
"build",
"cluster",
"dir",
"path",
"(",
"clustername",
")",
";",
"return",
"new",
"path",
"(",
"cluster",
"dir",
",",
"yarn",
"service",
"constants",
"tmp",
"dir",
"prefix",
")",
";",
"}"
]
|
[
"{",
"@",
"inherit",
"doc",
"}"
]
| [
"public",
"boolean",
"is",
"wrapper",
"for",
"(",
"class",
"<",
"?",
">",
"iface",
")",
"throws",
"s",
"q",
"l",
"exception",
"{",
"check",
"closed",
"(",
")",
";",
"return",
"false",
";",
"}"
]
|
[
"returns",
"a",
"status",
"object",
"describing",
"the",
"use",
"and",
"capacity",
"of",
"the",
"filesystem",
"if",
"the",
"filesystem",
"has",
"multiple",
"partitions",
",",
"the",
"use",
"and",
"capacity",
"of",
"the",
"root",
"partition",
"is",
"reflected"
]
| [
"public",
"fs",
"status",
"get",
"status",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"get",
"status",
"(",
"null",
")",
";",
"}"
]
|
[
"clear",
"all",
"objects",
"from",
"the",
"save",
"state"
]
| [
"public",
"void",
"clear",
"(",
")",
"{",
"map",
"clear",
"(",
")",
";",
"}"
]
|
[
"this",
"method",
"ensures",
"that",
"popup",
"and",
"main",
"players",
"have",
"different",
"look",
"we",
"use",
"one",
"layout",
"for",
"both",
"players",
"and",
"need",
"to",
"decide",
"what",
"to",
"show",
"and",
"what",
"to",
"hide",
"additional",
"measuring",
"should",
"be",
"done",
"inside",
"{",
"@",
"link",
"#",
"setup",
"elements",
"size",
"}"
]
| [
"private",
"void",
"setup",
"elements",
"visibility",
"(",
")",
"{",
"if",
"(",
"popup",
"player",
"selected",
"(",
")",
")",
"{",
"binding",
"full",
"screen",
"button",
"set",
"visibility",
"(",
"view",
"visible",
")",
";",
"binding",
"screen",
"rotation",
"button",
"set",
"visibility",
"(",
"view",
"gone",
")",
";",
"binding",
"resize",
"text",
"view",
"set",
"visibility",
"(",
"view",
"gone",
")",
";",
"binding",
"get",
"root",
"(",
")",
"find",
"view",
"by",
"id",
"(",
"r",
"id",
"metadata",
"view",
")",
"set",
"visibility",
"(",
"view",
"gone",
")",
";",
"binding",
"queue",
"button",
"set",
"visibility",
"(",
"view",
"gone",
")",
";",
"binding",
"more",
"options",
"button",
"set",
"visibility",
"(",
"view",
"gone",
")",
";",
"binding",
"top",
"controls",
"set",
"orientation",
"(",
"linear",
"layout",
"horizontal",
")",
";",
"binding",
"primary",
"controls",
"get",
"layout",
"params",
"(",
")",
"width",
"=",
"linear",
"layout",
"layout",
"params",
"wrap",
"content",
";",
"binding",
"secondary",
"controls",
"set",
"alpha",
"(",
"1",
"0f",
")",
";",
"binding",
"secondary",
"controls",
"set",
"visibility",
"(",
"view",
"visible",
")",
";",
"binding",
"secondary",
"controls",
"set",
"translation",
"y",
"(",
"0",
")",
";",
"binding",
"share",
"set",
"visibility",
"(",
"view",
"gone",
")",
";",
"binding",
"play",
"with",
"kodi",
"set",
"visibility",
"(",
"view",
"gone",
")",
";",
"binding",
"open",
"in",
"browser",
"set",
"visibility",
"(",
"view",
"gone",
")",
";",
"binding",
"switch",
"mute",
"set",
"visibility",
"(",
"view",
"gone",
")",
";",
"binding",
"player",
"close",
"button",
"set",
"visibility",
"(",
"view",
"gone",
")",
";",
"binding",
"top",
"controls",
"bring",
"to",
"front",
"(",
")",
";",
"binding",
"top",
"controls",
"set",
"clickable",
"(",
"false",
")",
";",
"binding",
"top",
"controls",
"set",
"focusable",
"(",
"false",
")",
";",
"binding",
"bottom",
"controls",
"bring",
"to",
"front",
"(",
")",
";",
"close",
"queue",
"(",
")",
";",
"}",
"else",
"if",
"(",
"video",
"player",
"selected",
"(",
")",
")",
"{",
"binding",
"full",
"screen",
"button",
"set",
"visibility",
"(",
"view",
"gone",
")",
";",
"setup",
"screen",
"rotation",
"button",
"(",
")",
";",
"binding",
"resize",
"text",
"view",
"set",
"visibility",
"(",
"view",
"visible",
")",
";",
"binding",
"get",
"root",
"(",
")",
"find",
"view",
"by",
"id",
"(",
"r",
"id",
"metadata",
"view",
")",
"set",
"visibility",
"(",
"view",
"visible",
")",
";",
"binding",
"more",
"options",
"button",
"set",
"visibility",
"(",
"view",
"visible",
")",
";",
"binding",
"top",
"controls",
"set",
"orientation",
"(",
"linear",
"layout",
"vertical",
")",
";",
"binding",
"primary",
"controls",
"get",
"layout",
"params",
"(",
")",
"width",
"=",
"linear",
"layout",
"layout",
"params",
"match",
"parent",
";",
"binding",
"secondary",
"controls",
"set",
"visibility",
"(",
"view",
"invisible",
")",
";",
"binding",
"more",
"options",
"button",
"set",
"image",
"drawable",
"(",
"app",
"compat",
"resources",
"get",
"drawable",
"(",
"context",
",",
"r",
"drawable",
"ic",
"expand",
"more",
"white",
"2",
"4dp",
")",
")",
";",
"binding",
"share",
"set",
"visibility",
"(",
"view",
"visible",
")",
";",
"binding",
"open",
"in",
"browser",
"set",
"visibility",
"(",
"view",
"visible",
")",
";",
"binding",
"switch",
"mute",
"set",
"visibility",
"(",
"view",
"visible",
")",
";",
"binding",
"player",
"close",
"button",
"set",
"visibility",
"(",
"is",
"fullscreen",
"?",
"view",
"gone",
":",
"view",
"visible",
")",
";",
"/",
"/",
"top",
"controls",
"have",
"a",
"large",
"min",
"height",
"which",
"is",
"allows",
"to",
"drag",
"the",
"player",
"/",
"/",
"down",
"in",
"fullscreen",
"mode",
"(",
"just",
"larger",
"area",
"to",
"make",
"easy",
"to",
"locate",
"by",
"finger",
")",
"binding",
"top",
"controls",
"set",
"clickable",
"(",
"true",
")",
";",
"binding",
"top",
"controls",
"set",
"focusable",
"(",
"true",
")",
";",
"}",
"show",
"hide",
"kodi",
"button",
"(",
")",
";",
"if",
"(",
"is",
"fullscreen",
")",
"{",
"binding",
"title",
"text",
"view",
"set",
"visibility",
"(",
"view",
"visible",
")",
";",
"binding",
"channel",
"text",
"view",
"set",
"visibility",
"(",
"view",
"visible",
")",
";",
"}",
"else",
"{",
"binding",
"title",
"text",
"view",
"set",
"visibility",
"(",
"view",
"gone",
")",
";",
"binding",
"channel",
"text",
"view",
"set",
"visibility",
"(",
"view",
"gone",
")",
";",
"}",
"set",
"mute",
"button",
"(",
"binding",
"switch",
"mute",
",",
"is",
"muted",
"(",
")",
")",
";",
"animate",
"rotation",
"(",
"binding",
"more",
"options",
"button",
",",
"default",
"controls",
"duration",
",",
"0",
")",
";",
"}"
]
|
[
"<",
"code",
">",
"optional",
"bytes",
"data",
"=",
"1",
";",
"<",
"code",
">"
]
| [
"public",
"boolean",
"has",
"data",
"(",
")",
"{",
"return",
"(",
"(",
"bit",
"field",
"0",
"&",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"1",
")",
"=",
"=",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"1",
")",
";",
"}"
]
|
[
"this",
"method",
"returns",
"empty",
"when",
"the",
"table",
"has",
"not",
"been",
"created",
"yet",
"(",
"i",
"e",
"for",
"create",
"table",
"as",
"select",
"queries",
")"
]
| [
"public",
"optional",
"<",
"table",
">",
"get",
"table",
"(",
")",
"{",
"return",
"table",
";",
"}"
]
|
[
"adds",
"a",
"data",
"set",
"as",
"a",
"broadcast",
"set",
"to",
"the",
"sum",
"function"
]
| [
"public",
"void",
"add",
"broadcast",
"set",
"for",
"sum",
"function",
"(",
"string",
"name",
",",
"data",
"set",
"<",
"?",
">",
"data",
")",
"{",
"this",
"bc",
"vars",
"sum",
"add",
"(",
"new",
"tuple",
"2",
"<",
">",
"(",
"name",
",",
"data",
")",
")",
";",
"}"
]
|
[
"operating",
"system",
"level",
"statistics"
]
| [
"public",
"os",
"stats",
"get",
"os",
"(",
")",
"{",
"return",
"this",
"os",
";",
"}"
]
|
[
"find",
"the",
"root",
"{",
"@",
"link",
"web",
"application",
"context",
"}",
"for",
"this",
"web",
"app",
",",
"typically",
"loaded",
"via",
"{",
"@",
"link",
"org",
"springframework",
"web",
"context",
"context",
"loader",
"listener",
"}",
"will",
"rethrow",
"an",
"exception",
"that",
"happened",
"on",
"root",
"context",
"startup",
",",
"to",
"differentiate",
"between",
"a",
"failed",
"context",
"startup",
"and",
"no",
"context",
"at",
"all"
]
| [
"public",
"static",
"web",
"application",
"context",
"get",
"required",
"web",
"application",
"context",
"(",
"faces",
"context",
"fc",
")",
"throws",
"illegal",
"state",
"exception",
"{",
"web",
"application",
"context",
"wac",
"=",
"get",
"web",
"application",
"context",
"(",
"fc",
")",
";",
"if",
"(",
"wac",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"no",
"web",
"application",
"context",
"found",
":",
"no",
"context",
"loader",
"listener",
"registered",
"?",
"\"",
")",
";",
"}",
"return",
"wac",
";",
"}"
]
|
[
"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",
"\"",
")",
";",
"}"
]
|
[
"weight",
"+",
"min",
"resources",
"=",
"=",
">",
"yarn",
"scheduler",
"capacity",
"&",
"lt",
";",
"queue",
"-",
"name",
"&",
"gt",
";",
"capacity"
]
| [
"private",
"void",
"emit",
"child",
"capacity",
"(",
"f",
"s",
"queue",
"queue",
")",
"{",
"capacity",
"converter",
"converter",
"=",
"capacity",
"converter",
"factory",
"get",
"converter",
"(",
"use",
"percentages",
")",
";",
"converter",
"convert",
"weights",
"for",
"child",
"queues",
"(",
"queue",
",",
"capacity",
"scheduler",
"config",
")",
";",
"if",
"(",
"resources",
"none",
"(",
")",
"compare",
"to",
"(",
"queue",
"get",
"min",
"share",
"(",
")",
")",
"!",
"=",
"0",
")",
"{",
"rule",
"handler",
"handle",
"min",
"resources",
"(",
")",
";",
"}",
"}"
]
|
[
"adds",
"the",
"specified",
"element",
"to",
"this",
"set",
"if",
"it",
"is",
"not",
"already",
"present",
"more",
"formally",
",",
"adds",
"the",
"specified",
"element",
"<",
"tt",
">",
"e",
"<",
"tt",
">",
"to",
"this",
"set",
"if",
"this",
"set",
"contains",
"no",
"element",
"<",
"tt",
">",
"e",
"2",
"<",
"tt",
">",
"such",
"that",
"<",
"tt",
">",
"(",
"e",
"=",
"=",
"null",
"&",
"nbsp",
";",
"?",
"&",
"nbsp",
";",
"e",
"2",
"=",
"=",
"null",
"&",
"nbsp",
";",
":",
"&",
"nbsp",
";",
"e",
"equals",
"(",
"e",
"2",
")",
")",
"<",
"tt",
">",
"if",
"this",
"set",
"already",
"contains",
"the",
"element",
",",
"the",
"call",
"leaves",
"the",
"set",
"unchanged",
"and",
"returns",
"<",
"tt",
">",
"false",
"<",
"tt",
">"
]
| [
"public",
"boolean",
"add",
"(",
"e",
"e",
")",
"{",
"return",
"map",
"put",
"(",
"e",
",",
"present",
")",
"=",
"=",
"null",
";",
"}"
]
|
[
"return",
"the",
"phase",
"in",
"which",
"this",
"container",
"will",
"be",
"started",
"and",
"stopped"
]
| [
"public",
"int",
"get",
"phase",
"(",
")",
"{",
"return",
"this",
"phase",
";",
"}"
]
|
[
"helper",
"to",
"deal",
"with",
"{",
"@",
"code",
"newarray",
"}"
]
| [
"private",
"int",
"parse",
"newarray",
"(",
"int",
"offset",
",",
"visitor",
"visitor",
")",
"{",
"int",
"value",
"=",
"bytes",
"get",
"unsigned",
"byte",
"(",
"offset",
"+",
"1",
")",
";",
"cst",
"type",
"type",
";",
"switch",
"(",
"value",
")",
"{",
"case",
"byte",
"ops",
"newarray",
"boolean",
":",
"{",
"type",
"=",
"cst",
"type",
"boolean",
"array",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"newarray",
"char",
":",
"{",
"type",
"=",
"cst",
"type",
"char",
"array",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"newarray",
"double",
":",
"{",
"type",
"=",
"cst",
"type",
"double",
"array",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"newarray",
"float",
":",
"{",
"type",
"=",
"cst",
"type",
"float",
"array",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"newarray",
"byte",
":",
"{",
"type",
"=",
"cst",
"type",
"byte",
"array",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"newarray",
"short",
":",
"{",
"type",
"=",
"cst",
"type",
"short",
"array",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"newarray",
"int",
":",
"{",
"type",
"=",
"cst",
"type",
"int",
"array",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"newarray",
"long",
":",
"{",
"type",
"=",
"cst",
"type",
"long",
"array",
";",
"break",
";",
"}",
"default",
":",
"{",
"throw",
"new",
"sim",
"exception",
"(",
"\"",
"bad",
"newarray",
"code",
"\"",
"+",
"hex",
"u",
"1",
"(",
"value",
")",
")",
";",
"}",
"}",
"/",
"/",
"revisit",
"the",
"previous",
"bytecode",
"to",
"find",
"out",
"the",
"length",
"of",
"the",
"array",
"int",
"previous",
"offset",
"=",
"visitor",
"get",
"previous",
"offset",
"(",
")",
";",
"constant",
"parser",
"visitor",
"constant",
"visitor",
"=",
"new",
"constant",
"parser",
"visitor",
"(",
")",
";",
"int",
"array",
"length",
"=",
"0",
";",
"/",
"*",
"*",
"for",
"visitors",
"that",
"don",
"'",
"t",
"record",
"the",
"previous",
"offset",
",",
"-",
"1",
"will",
"be",
"*",
"seen",
"here",
"*",
"/",
"if",
"(",
"previous",
"offset",
">",
"=",
"0",
")",
"{",
"parse",
"instruction",
"(",
"previous",
"offset",
",",
"constant",
"visitor",
")",
";",
"if",
"(",
"constant",
"visitor",
"cst",
"instanceof",
"cst",
"integer",
"&",
"&",
"constant",
"visitor",
"length",
"+",
"previous",
"offset",
"=",
"=",
"offset",
")",
"{",
"array",
"length",
"=",
"constant",
"visitor",
"value",
";",
"}",
"}",
"/",
"*",
"*",
"try",
"to",
"match",
"the",
"array",
"initialization",
"idiom",
"for",
"example",
",",
"if",
"the",
"*",
"subsequent",
"code",
"is",
"initializing",
"an",
"int",
"array",
",",
"we",
"are",
"expecting",
"the",
"*",
"following",
"pattern",
"repeatedly",
":",
"*",
"dup",
"*",
"push",
"index",
"*",
"push",
"value",
"*",
"*",
"astore",
"*",
"*",
"where",
"the",
"index",
"value",
"will",
"be",
"incrimented",
"sequentially",
"from",
"0",
"up",
"*",
"/",
"int",
"n",
"init",
"=",
"0",
";",
"int",
"cur",
"offset",
"=",
"offset",
"+",
"2",
";",
"int",
"last",
"offset",
"=",
"cur",
"offset",
";",
"array",
"list",
"<",
"constant",
">",
"init",
"vals",
"=",
"new",
"array",
"list",
"<",
"constant",
">",
"(",
")",
";",
"if",
"(",
"array",
"length",
"!",
"=",
"0",
")",
"{",
"while",
"(",
"true",
")",
"{",
"boolean",
"punt",
"=",
"false",
";",
"/",
"/",
"first",
",",
"check",
"if",
"the",
"next",
"bytecode",
"is",
"dup",
"int",
"next",
"byte",
"=",
"bytes",
"get",
"unsigned",
"byte",
"(",
"cur",
"offset",
"+",
"+",
")",
";",
"if",
"(",
"next",
"byte",
"!",
"=",
"byte",
"ops",
"dup",
")",
"break",
";",
"/",
"*",
"*",
"next",
",",
"check",
"if",
"the",
"expected",
"array",
"index",
"is",
"pushed",
"to",
"*",
"the",
"stack",
"*",
"/",
"parse",
"instruction",
"(",
"cur",
"offset",
",",
"constant",
"visitor",
")",
";",
"if",
"(",
"constant",
"visitor",
"length",
"=",
"=",
"0",
"|",
"|",
"!",
"(",
"constant",
"visitor",
"cst",
"instanceof",
"cst",
"integer",
")",
"|",
"|",
"constant",
"visitor",
"value",
"!",
"=",
"n",
"init",
")",
"break",
";",
"/",
"/",
"next",
",",
"fetch",
"the",
"init",
"value",
"and",
"record",
"it",
"cur",
"offset",
"+",
"=",
"constant",
"visitor",
"length",
";",
"/",
"*",
"*",
"next",
",",
"find",
"out",
"what",
"kind",
"of",
"constant",
"is",
"pushed",
"onto",
"*",
"the",
"stack",
"*",
"/",
"parse",
"instruction",
"(",
"cur",
"offset",
",",
"constant",
"visitor",
")",
";",
"if",
"(",
"constant",
"visitor",
"length",
"=",
"=",
"0",
"|",
"|",
"!",
"(",
"constant",
"visitor",
"cst",
"instanceof",
"cst",
"literal",
"bits",
")",
")",
"break",
";",
"cur",
"offset",
"+",
"=",
"constant",
"visitor",
"length",
";",
"init",
"vals",
"add",
"(",
"constant",
"visitor",
"cst",
")",
";",
"next",
"byte",
"=",
"bytes",
"get",
"unsigned",
"byte",
"(",
"cur",
"offset",
"+",
"+",
")",
";",
"/",
"/",
"now",
",",
"check",
"if",
"the",
"value",
"is",
"stored",
"to",
"the",
"array",
"properly",
"switch",
"(",
"value",
")",
"{",
"case",
"byte",
"ops",
"newarray",
"byte",
":",
"case",
"byte",
"ops",
"newarray",
"boolean",
":",
"{",
"if",
"(",
"next",
"byte",
"!",
"=",
"byte",
"ops",
"bastore",
")",
"{",
"punt",
"=",
"true",
";",
"}",
"break",
";",
"}",
"case",
"byte",
"ops",
"newarray",
"char",
":",
"{",
"if",
"(",
"next",
"byte",
"!",
"=",
"byte",
"ops",
"castore",
")",
"{",
"punt",
"=",
"true",
";",
"}",
"break",
";",
"}",
"case",
"byte",
"ops",
"newarray",
"double",
":",
"{",
"if",
"(",
"next",
"byte",
"!",
"=",
"byte",
"ops",
"dastore",
")",
"{",
"punt",
"=",
"true",
";",
"}",
"break",
";",
"}",
"case",
"byte",
"ops",
"newarray",
"float",
":",
"{",
"if",
"(",
"next",
"byte",
"!",
"=",
"byte",
"ops",
"fastore",
")",
"{",
"punt",
"=",
"true",
";",
"}",
"break",
";",
"}",
"case",
"byte",
"ops",
"newarray",
"short",
":",
"{",
"if",
"(",
"next",
"byte",
"!",
"=",
"byte",
"ops",
"sastore",
")",
"{",
"punt",
"=",
"true",
";",
"}",
"break",
";",
"}",
"case",
"byte",
"ops",
"newarray",
"int",
":",
"{",
"if",
"(",
"next",
"byte",
"!",
"=",
"byte",
"ops",
"iastore",
")",
"{",
"punt",
"=",
"true",
";",
"}",
"break",
";",
"}",
"case",
"byte",
"ops",
"newarray",
"long",
":",
"{",
"if",
"(",
"next",
"byte",
"!",
"=",
"byte",
"ops",
"lastore",
")",
"{",
"punt",
"=",
"true",
";",
"}",
"break",
";",
"}",
"default",
":",
"punt",
"=",
"true",
";",
"break",
";",
"}",
"if",
"(",
"punt",
")",
"{",
"break",
";",
"}",
"last",
"offset",
"=",
"cur",
"offset",
";",
"n",
"init",
"+",
"+",
";",
"}",
"}",
"/",
"*",
"*",
"for",
"singleton",
"arrays",
"it",
"is",
"still",
"more",
"economical",
"to",
"*",
"generate",
"the",
"aput",
"*",
"/",
"if",
"(",
"n",
"init",
"<",
"2",
"|",
"|",
"n",
"init",
"!",
"=",
"array",
"length",
")",
"{",
"visitor",
"visit",
"newarray",
"(",
"offset",
",",
"2",
",",
"type",
",",
"null",
")",
";",
"return",
"2",
";",
"}",
"else",
"{",
"visitor",
"visit",
"newarray",
"(",
"offset",
",",
"last",
"offset",
"-",
"offset",
",",
"type",
",",
"init",
"vals",
")",
";",
"return",
"last",
"offset",
"-",
"offset",
";",
"}",
"}"
]
|
[
"parses",
"and",
"returns",
"in",
"an",
"unsigned",
"int",
",",
"the",
"specified",
"-",
"size",
"unsigned",
"integer",
"type",
"value",
"(",
"8",
",",
"16",
",",
"or",
"32",
")"
]
| [
"public",
"long",
"parse",
"var",
"sized",
"u",
"int",
"(",
"int",
"size",
")",
"throws",
"pdb",
"exception",
"{",
"switch",
"(",
"size",
")",
"{",
"case",
"8",
":",
"return",
"parse",
"unsigned",
"byte",
"val",
"(",
")",
";",
"case",
"16",
":",
"return",
"parse",
"unsigned",
"short",
"val",
"(",
")",
";",
"case",
"32",
":",
"return",
"parse",
"unsigned",
"int",
"val",
"(",
")",
";",
"}",
"throw",
"new",
"pdb",
"exception",
"(",
"\"",
"bad",
"int",
"size",
"\"",
")",
";",
"}"
]
|
[
"create",
"a",
"new",
"index",
"on",
"the",
"singleton",
"node",
"with",
"empty",
"index",
"settings"
]
| [
"protected",
"index",
"service",
"create",
"index",
"(",
"string",
"index",
")",
"{",
"return",
"create",
"index",
"(",
"index",
",",
"settings",
"empty",
")",
";",
"}"
]
|
[
"the",
"used",
"space",
"by",
"the",
"block",
"pool",
"on",
"data",
"node"
]
| [
"public",
"long",
"get",
"block",
"pool",
"used",
"(",
")",
"{",
"return",
"block",
"pool",
"used",
";",
"}"
]
|
[
"get",
"fakejson",
"form",
"data",
":",
"test",
"json",
"serialization",
"of",
"form",
"data"
]
| [
"default",
"response",
"entity",
"<",
"void",
">",
"test",
"json",
"form",
"data",
"(",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"field",
"1",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"param",
"\"",
",",
"required",
"=",
"true",
")",
"string",
"param",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"field",
"2",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"param",
"2",
"\"",
",",
"required",
"=",
"true",
")",
"string",
"param",
"2",
")",
"{",
"return",
"new",
"response",
"entity",
"<",
">",
"(",
"http",
"status",
"not",
"implemented",
")",
";",
"}"
]
|
[
"returns",
"a",
"slice",
"of",
"this",
"buffer",
"'",
"s",
"readable",
"bytes",
"modifying",
"the",
"content",
"of",
"the",
"returned",
"buffer",
"or",
"this",
"buffer",
"affects",
"each",
"other",
"'",
"s",
"content",
"while",
"they",
"maintain",
"separate",
"indexes",
"and",
"marks",
"this",
"method",
"is",
"identical",
"to",
"{",
"@",
"code",
"buf",
"slice",
"(",
"buf",
"reader",
"index",
"(",
")",
",",
"buf",
"readable",
"bytes",
"(",
")",
")",
"}",
"this",
"method",
"does",
"not",
"modify",
"{",
"@",
"code",
"reader",
"index",
"}",
"or",
"{",
"@",
"code",
"writer",
"index",
"}",
"of",
"this",
"buffer",
"also",
"be",
"aware",
"that",
"this",
"method",
"will",
"not",
"call",
"{",
"@",
"link",
"#",
"retain",
"(",
")",
"}",
"and",
"so",
"the",
"reference",
"count",
"will",
"not",
"be",
"increased"
]
| [
"public",
"abstract",
"byte",
"buf",
"slice",
"(",
")",
";"
]
|
[
"date",
"to",
"the",
"formatted",
"time",
"string"
]
| [
"public",
"static",
"string",
"date",
"2",
"string",
"(",
"final",
"date",
"date",
",",
"@",
"non",
"null",
"final",
"string",
"pattern",
")",
"{",
"return",
"get",
"safe",
"date",
"format",
"(",
"pattern",
")",
"format",
"(",
"date",
")",
";",
"}"
]
|
[
"resolves",
"the",
"provided",
"cluster",
"expression",
"to",
"matching",
"cluster",
"names",
"supports",
"exact",
"or",
"wildcard",
"matches",
"throws",
"{",
"@",
"link",
"no",
"such",
"remote",
"cluster",
"exception",
"}",
"in",
"case",
"there",
"are",
"no",
"registered",
"remote",
"clusters",
"matching",
"the",
"provided",
"expression"
]
| [
"public",
"list",
"<",
"string",
">",
"resolve",
"cluster",
"names",
"(",
"set",
"<",
"string",
">",
"remote",
"clusters",
",",
"string",
"cluster",
"expression",
")",
"{",
"if",
"(",
"remote",
"clusters",
"contains",
"(",
"cluster",
"expression",
")",
")",
"{",
"return",
"collections",
"singleton",
"list",
"(",
"cluster",
"expression",
")",
";",
"}",
"else",
"if",
"(",
"regex",
"is",
"simple",
"match",
"pattern",
"(",
"cluster",
"expression",
")",
")",
"{",
"return",
"wildcard",
"resolver",
"resolve",
"(",
"remote",
"clusters",
",",
"cluster",
"expression",
")",
";",
"}",
"else",
"{",
"throw",
"new",
"no",
"such",
"remote",
"cluster",
"exception",
"(",
"cluster",
"expression",
")",
";",
"}",
"}"
]
|
[
"returns",
"true",
"if",
"field",
"arg",
"is",
"set",
"(",
"has",
"been",
"assigned",
"a",
"value",
")",
"and",
"false",
"otherwise"
]
| [
"public",
"boolean",
"is",
"set",
"arg",
"(",
")",
"{",
"return",
"this",
"arg",
"!",
"=",
"null",
";",
"}"
]
|
[
"delete",
"old",
"shards",
"and",
"old",
"deltas",
"for",
"call",
"from",
"replace",
"delta",
"uuids",
":",
"old",
"shards",
"and",
"old",
"deltas",
"are",
"not",
"necessarily",
"related",
",",
"see",
"the",
"comment",
"from",
"the",
"call"
]
| [
"private",
"shard",
"stats",
"delete",
"shards",
"and",
"index",
"(",
"long",
"table",
"id",
",",
"map",
"<",
"uuid",
",",
"optional",
"<",
"uuid",
">",
">",
"old",
"shard",
"uuids",
"map",
",",
"set",
"<",
"uuid",
">",
"old",
"delta",
"uuid",
"set",
",",
"handle",
"handle",
",",
"boolean",
"table",
"supports",
"delta",
"delete",
")",
"throws",
"s",
"q",
"l",
"exception",
"{",
"if",
"(",
"table",
"supports",
"delta",
"delete",
")",
"{",
"shard",
"stats",
"shard",
"stats",
"=",
"delete",
"shards",
"and",
"index",
"with",
"delta",
"(",
"table",
"id",
",",
"old",
"shard",
"uuids",
"map",
",",
"handle",
")",
";",
"long",
"row",
"count",
"=",
"shard",
"stats",
"get",
"row",
"count",
"(",
")",
";",
"long",
"compressed",
"size",
"=",
"shard",
"stats",
"get",
"compressed",
"size",
"(",
")",
";",
"long",
"uncompressed",
"size",
"=",
"shard",
"stats",
"get",
"uncompressed",
"size",
"(",
")",
";",
"shard",
"stats",
"delta",
"stats",
"=",
"delete",
"shards",
"and",
"index",
"simple",
"(",
"table",
"id",
",",
"old",
"delta",
"uuid",
"set",
",",
"handle",
",",
"true",
")",
";",
"row",
"count",
"-",
"=",
"delta",
"stats",
"get",
"row",
"count",
"(",
")",
";",
"/",
"/",
"delta",
"compressed",
"size",
"+",
"=",
"delta",
"stats",
"get",
"compressed",
"size",
"(",
")",
";",
"uncompressed",
"size",
"+",
"=",
"delta",
"stats",
"get",
"uncompressed",
"size",
"(",
")",
";",
"return",
"new",
"shard",
"stats",
"(",
"row",
"count",
",",
"compressed",
"size",
",",
"uncompressed",
"size",
")",
";",
"}",
"return",
"delete",
"shards",
"and",
"index",
"simple",
"(",
"table",
"id",
",",
"old",
"shard",
"uuids",
"map",
"key",
"set",
"(",
")",
",",
"handle",
",",
"false",
")",
";",
"}"
]
|
[
"send",
"the",
"calls",
"which",
"are",
"ready"
]
| [
"private",
"long",
"send",
"eligible",
"calls",
"(",
"long",
"now",
")",
"{",
"long",
"poll",
"timeout",
"=",
"long",
"max",
"value",
";",
"for",
"(",
"iterator",
"<",
"map",
"entry",
"<",
"node",
",",
"list",
"<",
"call",
">",
">",
">",
"iter",
"=",
"calls",
"to",
"send",
"entry",
"set",
"(",
")",
"iterator",
"(",
")",
";",
"iter",
"has",
"next",
"(",
")",
";",
")",
"{",
"map",
"entry",
"<",
"node",
",",
"list",
"<",
"call",
">",
">",
"entry",
"=",
"iter",
"next",
"(",
")",
";",
"list",
"<",
"call",
">",
"calls",
"=",
"entry",
"get",
"value",
"(",
")",
";",
"if",
"(",
"calls",
"is",
"empty",
"(",
")",
")",
"{",
"iter",
"remove",
"(",
")",
";",
"continue",
";",
"}",
"node",
"node",
"=",
"entry",
"get",
"key",
"(",
")",
";",
"if",
"(",
"!",
"client",
"ready",
"(",
"node",
",",
"now",
")",
")",
"{",
"long",
"node",
"timeout",
"=",
"client",
"poll",
"delay",
"ms",
"(",
"node",
",",
"now",
")",
";",
"poll",
"timeout",
"=",
"math",
"min",
"(",
"poll",
"timeout",
",",
"node",
"timeout",
")",
";",
"log",
"trace",
"(",
"\"",
"client",
"is",
"not",
"ready",
"to",
"send",
"to",
"{",
"}",
"must",
"delay",
"{",
"}",
"ms",
"\"",
",",
"node",
",",
"node",
"timeout",
")",
";",
"continue",
";",
"}",
"call",
"call",
"=",
"calls",
"remove",
"(",
"0",
")",
";",
"int",
"request",
"timeout",
"ms",
"=",
"math",
"min",
"(",
"kafka",
"admin",
"client",
"this",
"request",
"timeout",
"ms",
",",
"calc",
"timeout",
"ms",
"remaining",
"as",
"int",
"(",
"now",
",",
"call",
"deadline",
"ms",
")",
")",
";",
"abstract",
"request",
"builder",
"<",
"?",
">",
"request",
"builder",
";",
"try",
"{",
"request",
"builder",
"=",
"call",
"create",
"request",
"(",
"request",
"timeout",
"ms",
")",
";",
"}",
"catch",
"(",
"throwable",
"throwable",
")",
"{",
"call",
"fail",
"(",
"now",
",",
"new",
"kafka",
"exception",
"(",
"string",
"format",
"(",
"\"",
"internal",
"error",
"sending",
"%",
"s",
"to",
"%",
"s",
"\"",
",",
"call",
"call",
"name",
",",
"node",
")",
")",
")",
";",
"continue",
";",
"}",
"client",
"request",
"client",
"request",
"=",
"client",
"new",
"client",
"request",
"(",
"node",
"id",
"string",
"(",
")",
",",
"request",
"builder",
",",
"now",
",",
"true",
",",
"request",
"timeout",
"ms",
",",
"null",
")",
";",
"log",
"debug",
"(",
"\"",
"sending",
"{",
"}",
"to",
"{",
"}",
"correlation",
"id",
"=",
"{",
"}",
"\"",
",",
"request",
"builder",
",",
"node",
",",
"client",
"request",
"correlation",
"id",
"(",
")",
")",
";",
"client",
"send",
"(",
"client",
"request",
",",
"now",
")",
";",
"get",
"or",
"create",
"list",
"value",
"(",
"calls",
"in",
"flight",
",",
"node",
"id",
"string",
"(",
")",
")",
"add",
"(",
"call",
")",
";",
"correlation",
"id",
"to",
"calls",
"put",
"(",
"client",
"request",
"correlation",
"id",
"(",
")",
",",
"call",
")",
";",
"}",
"return",
"poll",
"timeout",
";",
"}"
]
|
[
"sets",
"{",
"@",
"link",
"format",
"#",
"average",
"bitrate",
"}",
"the",
"default",
"value",
"is",
"{",
"@",
"link",
"#",
"no",
"value",
"}"
]
| [
"public",
"builder",
"set",
"average",
"bitrate",
"(",
"int",
"average",
"bitrate",
")",
"{",
"this",
"average",
"bitrate",
"=",
"average",
"bitrate",
";",
"return",
"this",
";",
"}"
]
|
[
"set",
"the",
"annotation",
"metadata",
"of",
"the",
"importing",
"@",
"{",
"@",
"code",
"configuration",
"}",
"class"
]
| [
"void",
"set",
"import",
"metadata",
"(",
"annotation",
"metadata",
"import",
"metadata",
")",
";"
]
|
[
"make",
"a",
"call",
"and",
"canceling",
"it",
"as",
"soon",
"as",
"it",
"'",
"s",
"accepted",
"by",
"the",
"server"
]
| [
"private",
"void",
"call",
"and",
"cancel",
"(",
"int",
"expected",
"sequence",
"number",
",",
"count",
"down",
"latch",
"response",
"dequeued",
"latch",
",",
"count",
"down",
"latch",
"request",
"canceled",
"latch",
")",
"throws",
"exception",
"{",
"call",
"call",
"=",
"client",
"new",
"call",
"(",
"new",
"request",
"builder",
"(",
")",
"url",
"(",
"server",
"url",
"(",
"\"",
"/",
"\"",
")",
")",
"build",
"(",
")",
")",
";",
"count",
"down",
"latch",
"latch",
"=",
"new",
"count",
"down",
"latch",
"(",
"1",
")",
";",
"call",
"enqueue",
"(",
"new",
"callback",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"on",
"failure",
"(",
"call",
"call",
"1",
",",
"i",
"o",
"exception",
"e",
")",
"{",
"latch",
"count",
"down",
"(",
")",
";",
"}",
"@",
"override",
"public",
"void",
"on",
"response",
"(",
"call",
"call",
"1",
",",
"response",
"response",
")",
"{",
"fail",
"(",
")",
";",
"}",
"}",
")",
";",
"assert",
"that",
"(",
"server",
"take",
"request",
"(",
")",
"get",
"sequence",
"number",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"(",
"long",
")",
"expected",
"sequence",
"number",
")",
";",
"response",
"dequeued",
"latch",
"await",
"(",
")",
";",
"call",
"cancel",
"(",
")",
";",
"request",
"canceled",
"latch",
"count",
"down",
"(",
")",
";",
"latch",
"await",
"(",
")",
";",
"}"
]
|
[
"get",
"map",
"number"
]
| [
"public",
"map",
"<",
"string",
",",
"big",
"decimal",
">",
"get",
"map",
"number",
"(",
")",
"{",
"return",
"map",
"number",
";",
"}"
]
|
[
"test",
"inline",
"additional",
"properties"
]
| [
"public",
"void",
"test",
"inline",
"additional",
"properties",
"(",
"map",
"<",
"string",
",",
"string",
">",
"param",
")",
"{",
"/",
"/",
"todo",
":",
"implement",
"}"
]
|
[
"tests",
"that",
"reading",
"from",
"a",
"channel",
"when",
"after",
"the",
"partition",
"has",
"been",
"released",
"are",
"handled",
"and",
"don",
"'",
"t",
"lead",
"to",
"n",
"p",
"es"
]
| [
"public",
"void",
"test",
"get",
"next",
"after",
"partition",
"released",
"(",
")",
"throws",
"exception",
"{",
"result",
"subpartition",
"view",
"subpartition",
"view",
"=",
"create",
"result",
"subpartition",
"view",
"(",
"false",
")",
";",
"testing",
"result",
"partition",
"manager",
"partition",
"manager",
"=",
"new",
"testing",
"result",
"partition",
"manager",
"(",
"subpartition",
"view",
")",
";",
"local",
"input",
"channel",
"channel",
"=",
"create",
"local",
"input",
"channel",
"(",
"new",
"single",
"input",
"gate",
"builder",
"(",
")",
"build",
"(",
")",
",",
"partition",
"manager",
")",
";",
"channel",
"request",
"subpartition",
"(",
"0",
")",
";",
"assert",
"false",
"(",
"channel",
"get",
"next",
"buffer",
"(",
")",
"is",
"present",
"(",
")",
")",
";",
"/",
"/",
"release",
"the",
"subpartition",
"view",
"subpartition",
"view",
"release",
"all",
"resources",
"(",
")",
";",
"try",
"{",
"channel",
"get",
"next",
"buffer",
"(",
")",
";",
"fail",
"(",
"\"",
"did",
"not",
"throw",
"expected",
"cancel",
"task",
"exception",
"\"",
")",
";",
"}",
"catch",
"(",
"cancel",
"task",
"exception",
"ignored",
")",
"{",
"}",
"channel",
"release",
"all",
"resources",
"(",
")",
";",
"assert",
"false",
"(",
"channel",
"get",
"next",
"buffer",
"(",
")",
"is",
"present",
"(",
")",
")",
";",
"}"
]
|
[
"list",
"providers",
"you",
"can",
"use",
"jasypt"
]
| [
"public",
"void",
"list",
"providers",
"(",
"@",
"shell",
"option",
"(",
"value",
"=",
"{",
"\"",
"include",
"b",
"c",
"\"",
",",
"\"",
"-",
"-",
"include",
"b",
"c",
"\"",
"}",
",",
"help",
"=",
"\"",
"include",
"bouncy",
"castle",
"provider",
"\"",
")",
"final",
"boolean",
"include",
"b",
"c",
")",
"{",
"if",
"(",
"include",
"b",
"c",
")",
"{",
"if",
"(",
"security",
"get",
"provider",
"(",
"bouncy",
"castle",
"provider",
"provider",
"name",
")",
"=",
"=",
"null",
")",
"{",
"security",
"add",
"provider",
"(",
"new",
"bouncy",
"castle",
"provider",
"(",
")",
")",
";",
"}",
"}",
"else",
"{",
"security",
"remove",
"provider",
"(",
"bouncy",
"castle",
"provider",
"provider",
"name",
")",
";",
"}",
"val",
"providers",
"=",
"security",
"get",
"providers",
"(",
")",
";",
"for",
"(",
"val",
"provider",
":",
"providers",
")",
"{",
"val",
"services",
"=",
"provider",
"get",
"services",
"(",
")",
";",
"val",
"algorithms",
"=",
"services",
"stream",
"(",
")",
"filter",
"(",
"service",
"-",
">",
"\"",
"cipher",
"\"",
"equals",
"(",
"service",
"get",
"type",
"(",
")",
")",
"&",
"&",
"service",
"get",
"algorithm",
"(",
")",
"contains",
"(",
"\"",
"pbe",
"\"",
")",
")",
"map",
"(",
"provider",
"service",
":",
":",
"get",
"algorithm",
")",
"collect",
"(",
"collectors",
"to",
"list",
"(",
")",
")",
";",
"if",
"(",
"!",
"algorithms",
"is",
"empty",
"(",
")",
")",
"{",
"logger",
"info",
"(",
"\"",
"provider",
":",
"name",
":",
"[",
"{",
"}",
"]",
"class",
":",
"[",
"{",
"}",
"]",
"\"",
",",
"provider",
"get",
"name",
"(",
")",
",",
"provider",
"get",
"class",
"(",
")",
"get",
"name",
"(",
")",
")",
";",
"for",
"(",
"val",
"algorithm",
":",
"algorithms",
")",
"{",
"logger",
"info",
"(",
"\"",
"-",
"algorithm",
":",
"[",
"{",
"}",
"]",
"\"",
",",
"algorithm",
")",
";",
"}",
"}",
"}",
"}"
]
|
[
"returns",
"a",
"new",
"cache",
"context",
"based",
"on",
"the",
"combination"
]
| [
"private",
"cache",
"context",
"new",
"cache",
"context",
"(",
"list",
"<",
"object",
">",
"combination",
")",
"{",
"int",
"index",
"=",
"0",
";",
"return",
"new",
"cache",
"context",
"(",
"(",
"initial",
"capacity",
")",
"combination",
"get",
"(",
"index",
"+",
"+",
")",
",",
"(",
"stats",
")",
"combination",
"get",
"(",
"index",
"+",
"+",
")",
",",
"(",
"cache",
"weigher",
")",
"combination",
"get",
"(",
"index",
"+",
"+",
")",
",",
"(",
"maximum",
")",
"combination",
"get",
"(",
"index",
"+",
"+",
")",
",",
"(",
"cache",
"expiry",
")",
"combination",
"get",
"(",
"index",
"+",
"+",
")",
",",
"(",
"expire",
")",
"combination",
"get",
"(",
"index",
"+",
"+",
")",
",",
"(",
"expire",
")",
"combination",
"get",
"(",
"index",
"+",
"+",
")",
",",
"(",
"expire",
")",
"combination",
"get",
"(",
"index",
"+",
"+",
")",
",",
"(",
"advance",
")",
"combination",
"get",
"(",
"index",
"+",
"+",
")",
",",
"(",
"reference",
"type",
")",
"combination",
"get",
"(",
"index",
"+",
"+",
")",
",",
"(",
"reference",
"type",
")",
"combination",
"get",
"(",
"index",
"+",
"+",
")",
",",
"(",
"cache",
"executor",
")",
"combination",
"get",
"(",
"index",
"+",
"+",
")",
",",
"(",
"cache",
"scheduler",
")",
"combination",
"get",
"(",
"index",
"+",
"+",
")",
",",
"(",
"listener",
")",
"combination",
"get",
"(",
"index",
"+",
"+",
")",
",",
"(",
"population",
")",
"combination",
"get",
"(",
"index",
"+",
"+",
")",
",",
"(",
"boolean",
")",
"combination",
"get",
"(",
"index",
"+",
"+",
")",
",",
"(",
"boolean",
")",
"combination",
"get",
"(",
"index",
"+",
"+",
")",
",",
"(",
"compute",
")",
"combination",
"get",
"(",
"index",
"+",
"+",
")",
",",
"(",
"loader",
")",
"combination",
"get",
"(",
"index",
"+",
"+",
")",
",",
"(",
"writer",
")",
"combination",
"get",
"(",
"index",
"+",
"+",
")",
",",
"(",
"implementation",
")",
"combination",
"get",
"(",
"index",
"+",
"+",
")",
",",
"cache",
"spec",
")",
";",
"}"
]
|
[
"determine",
"if",
"a",
"datanode",
"is",
"good",
"for",
"placing",
"block"
]
| [
"boolean",
"is",
"good",
"datanode",
"(",
"datanode",
"descriptor",
"node",
",",
"int",
"max",
"target",
"per",
"rack",
",",
"boolean",
"consider",
"load",
",",
"list",
"<",
"datanode",
"storage",
"info",
">",
"results",
",",
"boolean",
"avoid",
"stale",
"nodes",
")",
"{",
"/",
"/",
"check",
"if",
"the",
"node",
"is",
"(",
"being",
")",
"decommissioned",
"if",
"(",
"!",
"node",
"is",
"in",
"service",
"(",
")",
")",
"{",
"log",
"node",
"is",
"not",
"chosen",
"(",
"node",
",",
"node",
"not",
"chosen",
"reason",
"not",
"in",
"service",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"avoid",
"stale",
"nodes",
")",
"{",
"if",
"(",
"node",
"is",
"stale",
"(",
"this",
"stale",
"interval",
")",
")",
"{",
"log",
"node",
"is",
"not",
"chosen",
"(",
"node",
",",
"node",
"not",
"chosen",
"reason",
"node",
"stale",
")",
";",
"return",
"false",
";",
"}",
"}",
"/",
"/",
"check",
"the",
"communication",
"traffic",
"of",
"the",
"target",
"machine",
"if",
"(",
"consider",
"load",
")",
"{",
"if",
"(",
"exclude",
"node",
"by",
"load",
"(",
"node",
")",
")",
"{",
"return",
"false",
";",
"}",
"}",
"/",
"/",
"check",
"if",
"the",
"target",
"rack",
"has",
"chosen",
"too",
"many",
"nodes",
"string",
"rackname",
"=",
"node",
"get",
"network",
"location",
"(",
")",
";",
"int",
"counter",
"=",
"1",
";",
"for",
"(",
"datanode",
"storage",
"info",
"result",
"storage",
":",
"results",
")",
"{",
"if",
"(",
"rackname",
"equals",
"(",
"result",
"storage",
"get",
"datanode",
"descriptor",
"(",
")",
"get",
"network",
"location",
"(",
")",
")",
")",
"{",
"counter",
"+",
"+",
";",
"}",
"}",
"if",
"(",
"counter",
">",
"max",
"target",
"per",
"rack",
")",
"{",
"log",
"node",
"is",
"not",
"chosen",
"(",
"node",
",",
"node",
"not",
"chosen",
"reason",
"too",
"many",
"nodes",
"on",
"rack",
")",
";",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}"
]
|
[
"customize",
"response",
"specification"
]
| [
"public",
"logout",
"user",
"oper",
"resp",
"spec",
"(",
"consumer",
"<",
"response",
"spec",
"builder",
">",
"resp",
"spec",
"customizer",
")",
"{",
"resp",
"spec",
"customizer",
"accept",
"(",
"resp",
"spec",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"attributes",
"of",
"type",
"{",
"@",
"link",
"build",
"type",
"#",
"output",
"list",
"}",
"are",
"not",
"configurable"
]
| [
"public",
"void",
"output",
"list",
"type",
"not",
"configurable",
"(",
")",
"throws",
"exception",
"{",
"write",
"config",
"rules",
"(",
")",
";",
"scratch",
"file",
"(",
"\"",
"foo",
"/",
"build",
"\"",
",",
"\"",
"genrule",
"(",
"\"",
",",
"\"",
"name",
"=",
"'",
"generator",
"'",
",",
"\"",
",",
"\"",
"srcs",
"=",
"[",
"]",
",",
"\"",
",",
"\"",
"outs",
"=",
"select",
"(",
"{",
"\"",
",",
"\"",
"'",
"/",
"/",
"conditions",
":",
"a",
"'",
":",
"[",
"'",
"a",
"out",
"'",
"]",
",",
"\"",
",",
"\"",
"'",
"\"",
"+",
"build",
"type",
"selector",
"default",
"condition",
"key",
"+",
"\"",
"'",
":",
"[",
"'",
"default",
"out",
"'",
"]",
"}",
")",
"\"",
",",
"\"",
")",
"\"",
")",
";",
"reporter",
"remove",
"handler",
"(",
"fail",
"fast",
"handler",
")",
";",
"/",
"/",
"expect",
"errors",
"get",
"configured",
"target",
"(",
"\"",
"/",
"/",
"foo",
":",
"generator",
"\"",
")",
";",
"assert",
"contains",
"event",
"(",
"\"",
"attribute",
"\\",
"\"",
"outs",
"\\",
"\"",
"is",
"not",
"configurable",
"\"",
")",
";",
"}"
]
|
[
"returns",
"the",
"length",
"of",
"the",
"string"
]
| [
"public",
"byte",
"get",
"length",
"(",
")",
"{",
"return",
"length",
";",
"}"
]
|
[
"activate",
"a",
"theme"
]
| [
"static",
"void",
"activate",
"l",
"a",
"f",
"(",
"@",
"non",
"nls",
"final",
"string",
"theme",
"id",
",",
"final",
"boolean",
"is",
"dark",
",",
"@",
"non",
"nls",
"final",
"string",
"name",
",",
"final",
"boolean",
"switch",
"color",
"scheme",
")",
"{",
"final",
"m",
"t",
"theme",
"facade",
"theme",
"for",
"=",
"m",
"t",
"themes",
"get",
"theme",
"for",
"(",
"theme",
"id",
")",
";",
"if",
"(",
"theme",
"for",
"!",
"=",
"null",
")",
"{",
"activate",
"(",
"theme",
"for",
",",
"switch",
"color",
"scheme",
")",
";",
"}",
"else",
"{",
"final",
"m",
"t",
"theme",
"facade",
"mt",
"theme",
"=",
"m",
"t",
"themes",
"native",
";",
"mt",
"theme",
"set",
"is",
"dark",
"(",
"is",
"dark",
")",
";",
"mt",
"theme",
"set",
"theme",
"name",
"(",
"name",
")",
";",
"activate",
"(",
"mt",
"theme",
",",
"switch",
"color",
"scheme",
")",
";",
"}",
"}"
]
|
[
"returns",
"the",
"character",
"at",
"position",
"<",
"tt",
">",
"pos",
"<",
"tt",
">",
"from",
"the",
"matched",
"text",
"it",
"is",
"equivalent",
"to",
"yytext",
"(",
")",
"char",
"at",
"(",
"pos",
")",
",",
"but",
"faster"
]
| [
"public",
"final",
"char",
"yycharat",
"(",
"int",
"pos",
")",
"{",
"return",
"zz",
"buffer",
"[",
"zz",
"start",
"read",
"+",
"pos",
"]",
";",
"}"
]
|
[
"this",
"method",
"does",
"not",
"log",
"as",
"it",
"does",
"not",
"support",
"backing",
"store",
"the",
"mutation",
"to",
"be",
"applied",
"on",
"top",
"of",
"sched",
"conf",
"will",
"be",
"directly",
"passed",
"in",
"confirm",
"mutation"
]
| [
"public",
"void",
"log",
"mutation",
"(",
"log",
"mutation",
"log",
"mutation",
")",
"{",
"}"
]
|
[
"(",
"try",
"to",
")",
"trim",
"the",
"pool",
"until",
"its",
"total",
"space",
"falls",
"below",
"the",
"max",
"size",
"(",
"soft",
"cap",
")",
"this",
"will",
"get",
"rid",
"of",
"values",
"on",
"the",
"free",
"list",
",",
"until",
"the",
"free",
"lists",
"are",
"empty",
",",
"or",
"we",
"fall",
"below",
"the",
"max",
"size",
";",
"whichever",
"comes",
"first",
"note",
":",
"it",
"is",
"not",
"an",
"error",
"if",
"we",
"have",
"eliminated",
"all",
"the",
"free",
"values",
",",
"but",
"the",
"pool",
"is",
"still",
"above",
"its",
"max",
"size",
"(",
"soft",
"cap",
")",
"the",
"approach",
"we",
"take",
"is",
"to",
"go",
"from",
"the",
"smallest",
"sized",
"bucket",
"down",
"to",
"the",
"largest",
"sized",
"bucket",
"this",
"may",
"seem",
"a",
"bit",
"counter",
"-",
"intuitive",
",",
"but",
"the",
"rationale",
"is",
"that",
"allocating",
"larger",
"-",
"sized",
"values",
"is",
"more",
"expensive",
"than",
"the",
"smaller",
"-",
"sized",
"ones",
",",
"so",
"we",
"want",
"to",
"keep",
"them",
"around",
"for",
"a",
"while"
]
| [
"synchronized",
"void",
"trim",
"to",
"size",
"(",
"int",
"target",
"size",
")",
"{",
"/",
"/",
"find",
"how",
"much",
"we",
"need",
"to",
"free",
"int",
"bytes",
"to",
"free",
"=",
"math",
"min",
"(",
"m",
"used",
"m",
"num",
"bytes",
"+",
"m",
"free",
"m",
"num",
"bytes",
"-",
"target",
"size",
",",
"m",
"free",
"m",
"num",
"bytes",
")",
";",
"if",
"(",
"bytes",
"to",
"free",
"<",
"=",
"0",
")",
"{",
"return",
";",
"}",
"if",
"(",
"f",
"log",
"is",
"loggable",
"(",
"f",
"log",
"verbose",
")",
")",
"{",
"f",
"log",
"v",
"(",
"tag",
",",
"\"",
"trim",
"to",
"size",
":",
"target",
"size",
"=",
"%",
"d",
";",
"initial",
"size",
"=",
"%",
"d",
";",
"bytes",
"to",
"free",
"=",
"%",
"d",
"\"",
",",
"target",
"size",
",",
"m",
"used",
"m",
"num",
"bytes",
"+",
"m",
"free",
"m",
"num",
"bytes",
",",
"bytes",
"to",
"free",
")",
";",
"}",
"log",
"stats",
"(",
")",
";",
"/",
"/",
"now",
"walk",
"through",
"the",
"buckets",
"from",
"the",
"smallest",
"to",
"the",
"largest",
"keep",
"freeing",
"things",
"/",
"/",
"until",
"we",
"'",
"ve",
"gotten",
"to",
"what",
"we",
"want",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"m",
"buckets",
"size",
"(",
")",
";",
"+",
"+",
"i",
")",
"{",
"if",
"(",
"bytes",
"to",
"free",
"<",
"=",
"0",
")",
"{",
"break",
";",
"}",
"bucket",
"<",
"v",
">",
"bucket",
"=",
"m",
"buckets",
"value",
"at",
"(",
"i",
")",
";",
"while",
"(",
"bytes",
"to",
"free",
">",
"0",
")",
"{",
"v",
"value",
"=",
"bucket",
"pop",
"(",
")",
";",
"if",
"(",
"value",
"=",
"=",
"null",
")",
"{",
"break",
";",
"}",
"free",
"(",
"value",
")",
";",
"bytes",
"to",
"free",
"-",
"=",
"bucket",
"m",
"item",
"size",
";",
"m",
"free",
"decrement",
"(",
"bucket",
"m",
"item",
"size",
")",
";",
"}",
"}",
"/",
"/",
"dump",
"stats",
"at",
"the",
"end",
"log",
"stats",
"(",
")",
";",
"if",
"(",
"f",
"log",
"is",
"loggable",
"(",
"f",
"log",
"verbose",
")",
")",
"{",
"f",
"log",
"v",
"(",
"tag",
",",
"\"",
"trim",
"to",
"size",
":",
"target",
"size",
"=",
"%",
"d",
";",
"final",
"size",
"=",
"%",
"d",
"\"",
",",
"target",
"size",
",",
"m",
"used",
"m",
"num",
"bytes",
"+",
"m",
"free",
"m",
"num",
"bytes",
")",
";",
"}",
"}"
]
|
[
"returns",
"the",
"binding",
"if",
"it",
"exists",
"immediately",
"otherwise",
"this",
"returns",
"null",
"if",
"the",
"returned",
"binding",
"didn",
"'",
"t",
"exist",
"or",
"was",
"unlinked",
",",
"it",
"will",
"be",
"enqueued",
"to",
"be",
"linked"
]
| [
"public",
"binding",
"<",
"?",
">",
"request",
"binding",
"(",
"string",
"key",
",",
"object",
"required",
"by",
",",
"class",
"loader",
"class",
"loader",
",",
"boolean",
"must",
"have",
"injections",
",",
"boolean",
"library",
")",
"{",
"assert",
"lock",
"held",
"(",
")",
";",
"binding",
"<",
"?",
">",
"binding",
"=",
"null",
";",
"for",
"(",
"linker",
"linker",
"=",
"this",
";",
"linker",
"!",
"=",
"null",
";",
"linker",
"=",
"linker",
"base",
")",
"{",
"binding",
"=",
"linker",
"bindings",
"get",
"(",
"key",
")",
";",
"if",
"(",
"binding",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"linker",
"!",
"=",
"this",
"&",
"&",
"!",
"binding",
"is",
"linked",
"(",
")",
")",
"throw",
"new",
"assertion",
"error",
"(",
")",
";",
"break",
";",
"}",
"}",
"if",
"(",
"binding",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"we",
"can",
"'",
"t",
"satisfy",
"this",
"binding",
"make",
"sure",
"it",
"'",
"ll",
"work",
"next",
"time",
"!",
"binding",
"<",
"?",
">",
"deferred",
"binding",
"=",
"new",
"deferred",
"binding",
"(",
"key",
",",
"class",
"loader",
",",
"required",
"by",
",",
"must",
"have",
"injections",
")",
";",
"deferred",
"binding",
"set",
"library",
"(",
"library",
")",
";",
"deferred",
"binding",
"set",
"depended",
"on",
"(",
"true",
")",
";",
"to",
"link",
"add",
"(",
"deferred",
"binding",
")",
";",
"attach",
"success",
"=",
"false",
";",
"return",
"null",
";",
"}",
"if",
"(",
"!",
"binding",
"is",
"linked",
"(",
")",
")",
"{",
"to",
"link",
"add",
"(",
"binding",
")",
";",
"/",
"/",
"this",
"binding",
"was",
"never",
"linked",
";",
"link",
"it",
"now",
"!",
"}",
"binding",
"set",
"library",
"(",
"library",
")",
";",
"binding",
"set",
"depended",
"on",
"(",
"true",
")",
";",
"return",
"binding",
";",
"}"
]
|
[
"close",
"the",
"scratch",
"-",
"pad",
"database",
"handle",
"if",
"it",
"open"
]
| [
"public",
"void",
"close",
"scratch",
"pad",
"(",
")",
"{",
"if",
"(",
"scratch",
"pad",
"!",
"=",
"null",
")",
"{",
"scratch",
"pad",
"close",
"(",
")",
";",
"scratch",
"pad",
"=",
"null",
";",
"}",
"}"
]
|
[
"sets",
"branch",
"id"
]
| [
"public",
"void",
"set",
"branch",
"id",
"(",
"long",
"branch",
"id",
")",
"{",
"this",
"branch",
"id",
"=",
"branch",
"id",
";",
"}"
]
|
[
"returns",
"a",
"fluent",
"iterable",
"whose",
"iterators",
"traverse",
"first",
"the",
"elements",
"of",
"this",
"fluent",
"iterable",
",",
"followed",
"by",
"those",
"of",
"{",
"@",
"code",
"other",
"}",
"the",
"iterators",
"are",
"not",
"polled",
"until",
"necessary",
"the",
"returned",
"iterable",
"'",
"s",
"{",
"@",
"code",
"iterator",
"}",
"supports",
"{",
"@",
"code",
"remove",
"(",
")",
"}",
"when",
"the",
"corresponding",
"{",
"@",
"code",
"iterator",
"}",
"supports",
"it",
"<",
"b",
">",
"{",
"@",
"code",
"stream",
"}",
"equivalent",
":",
"<",
"b",
">",
"{",
"@",
"link",
"stream",
"#",
"concat",
"}"
]
| [
"public",
"final",
"fluent",
"iterable",
"<",
"e",
">",
"append",
"(",
"iterable",
"<",
"?",
"extends",
"e",
">",
"other",
")",
"{",
"return",
"fluent",
"iterable",
"concat",
"(",
"get",
"delegate",
"(",
")",
",",
"other",
")",
";",
"}"
]
|
[
"specifies",
"the",
"{",
"@",
"link",
"network",
"policy",
"}",
"to",
"use",
"for",
"this",
"request",
"you",
"may",
"specify",
"additional",
"policy",
"options",
"using",
"the",
"varargs",
"parameter"
]
| [
"public",
"request",
"creator",
"network",
"policy",
"(",
"@",
"non",
"null",
"network",
"policy",
"policy",
",",
"@",
"non",
"null",
"network",
"policy",
"additional",
")",
"{",
"data",
"network",
"policy",
"(",
"policy",
",",
"additional",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"get",
"an",
"instance",
"of",
"leader",
"election"
]
| [
"public",
"election",
"get",
"election",
"alg",
"(",
")",
"{",
"return",
"election",
"alg",
";",
"}"
]
|
[
"get",
"predicted",
"{",
"code",
"resource",
"}",
"allocation",
"for",
"the",
"pipeline",
"if",
"the",
"prediction",
"for",
"the",
"pipeline",
"already",
"exists",
"in",
"the",
"{",
"@",
"link",
"skyline",
"store",
"}",
",",
"it",
"will",
"directly",
"get",
"the",
"prediction",
"from",
"{",
"@",
"link",
"skyline",
"store",
"}",
",",
"otherwise",
"it",
"will",
"call",
"the",
"{",
"@",
"link",
"solver",
"}",
"to",
"make",
"prediction",
",",
"and",
"store",
"the",
"predicted",
"{",
"code",
"resource",
"}",
"allocation",
"to",
"the",
"{",
"@",
"link",
"skyline",
"store",
"}",
"note",
"that",
"invoking",
"{",
"@",
"link",
"solver",
"}",
"could",
"be",
"a",
"time",
"-",
"consuming",
"operation"
]
| [
"public",
"string",
"get",
"prediction",
"(",
"@",
"path",
"param",
"(",
"value",
"=",
"\"",
"pipeline",
"id",
"\"",
")",
"string",
"pipeline",
"id",
")",
"throws",
"solver",
"exception",
",",
"skyline",
"store",
"exception",
"{",
"/",
"/",
"first",
",",
"try",
"to",
"grab",
"the",
"predicted",
"resource",
"allocation",
"from",
"the",
"skyline",
"/",
"/",
"store",
"r",
"l",
"e",
"sparse",
"resource",
"allocation",
"result",
"=",
"skyline",
"store",
"get",
"estimation",
"(",
"pipeline",
"id",
")",
";",
"/",
"/",
"if",
"received",
"resource",
"allocation",
"is",
"null",
",",
"then",
"run",
"the",
"solver",
"if",
"(",
"result",
"=",
"=",
"null",
")",
"{",
"recurrence",
"id",
"recurrence",
"id",
"=",
"new",
"recurrence",
"id",
"(",
"pipeline",
"id",
",",
"\"",
"*",
"\"",
")",
";",
"map",
"<",
"recurrence",
"id",
",",
"list",
"<",
"resource",
"skyline",
">",
">",
"job",
"history",
"=",
"skyline",
"store",
"get",
"history",
"(",
"recurrence",
"id",
")",
";",
"result",
"=",
"solver",
"solve",
"(",
"job",
"history",
")",
";",
"}",
"final",
"string",
"prediction",
"=",
"gson",
"to",
"json",
"(",
"result",
",",
"rle",
"type",
")",
";",
"logger",
"debug",
"(",
"\"",
"predict",
"resource",
"requests",
"for",
"pipeline",
"id",
":",
"{",
"}",
"\"",
"+",
"pipeline",
"id",
")",
";",
"return",
"prediction",
";",
"}"
]
|
[
"adds",
"device",
"information",
"for",
"newer",
"i",
"o",
"s",
"devices",
",",
"or",
"overrides",
"information",
"for",
"given",
"ones"
]
| [
"public",
"void",
"add",
"ios",
"device",
"(",
"string",
"classifier",
",",
"string",
"machine",
"string",
",",
"int",
"ppi",
")",
"{",
"i",
"o",
"s",
"device",
"add",
"device",
"to",
"map",
"(",
"known",
"devices",
",",
"classifier",
",",
"machine",
"string",
",",
"ppi",
")",
";",
"}"
]
|
[
"returns",
"a",
"new",
",",
"empty",
"list",
"with",
"the",
"specified",
"mutability"
]
| [
"public",
"static",
"<",
"t",
">",
"starlark",
"list",
"<",
"t",
">",
"new",
"list",
"(",
"mutability",
"mutability",
")",
"{",
"return",
"wrap",
"(",
"mutability",
",",
"empty",
"array",
")",
";",
"}"
]
|
[
"creates",
"default",
"implementation",
"of",
"task",
"distributor"
]
| [
"public",
"static",
"executor",
"create",
"task",
"distributor",
"(",
")",
"{",
"return",
"executors",
"new",
"cached",
"thread",
"pool",
"(",
"create",
"thread",
"factory",
"(",
"thread",
"norm",
"priority",
",",
"\"",
"uil",
"-",
"pool",
"-",
"d",
"-",
"\"",
")",
")",
";",
"}"
]
|
[
"wait",
"the",
"block",
"to",
"have",
"the",
"exact",
"number",
"of",
"replicas",
"as",
"expected"
]
| [
"private",
"static",
"void",
"wait",
"replication",
"(",
"file",
"system",
"fs",
",",
"path",
"file",
",",
"int",
"block",
"idx",
",",
"int",
"num",
"replicas",
")",
"throws",
"i",
"o",
"exception",
",",
"timeout",
"exception",
",",
"interrupted",
"exception",
"{",
"int",
"attempts",
"=",
"50",
";",
"/",
"/",
"wait",
"5",
"seconds",
"while",
"(",
"attempts",
">",
"0",
")",
"{",
"int",
"actual",
"replicas",
"=",
"get",
"num",
"replicas",
"(",
"fs",
",",
"file",
",",
"block",
"idx",
")",
";",
"if",
"(",
"actual",
"replicas",
"=",
"=",
"num",
"replicas",
")",
"{",
"return",
";",
"}",
"system",
"out",
"printf",
"(",
"\"",
"block",
"%",
"d",
"of",
"file",
"%",
"s",
"has",
"%",
"d",
"replicas",
"(",
"desired",
"%",
"d",
")",
"\\",
"n",
"\"",
",",
"block",
"idx",
",",
"file",
"to",
"string",
"(",
")",
",",
"actual",
"replicas",
",",
"num",
"replicas",
")",
";",
"thread",
"sleep",
"(",
"100",
")",
";",
"attempts",
"-",
"-",
";",
"}",
"throw",
"new",
"timeout",
"exception",
"(",
"\"",
"timed",
"out",
"waiting",
"the",
"\"",
"+",
"block",
"idx",
"+",
"\"",
"-",
"th",
"block",
"\"",
"+",
"\"",
"of",
"\"",
"+",
"file",
"+",
"\"",
"to",
"have",
"\"",
"+",
"num",
"replicas",
"+",
"\"",
"replicas",
"\"",
")",
";",
"}"
]
|
[
"pruning",
"is",
"an",
"optional",
"feature",
"for",
"metadata",
"store",
"implementations",
"tests",
"will",
"only",
"check",
"that",
"functionality",
"if",
"it",
"is",
"expected",
"to",
"work"
]
| [
"public",
"boolean",
"supports",
"pruning",
"(",
")",
"{",
"return",
"true",
";",
"}"
]
|
[
"create",
"a",
"root",
"-",
"level",
"generic",
"element",
"mostly",
"for",
"testing",
"purpose"
]
| [
"public",
"<",
"t",
"extends",
">",
"generic",
"<",
"t",
">",
"root",
"(",
"string",
"name",
",",
"enum",
"set",
"<",
"e",
"opt",
">",
"opts",
")",
"{",
"return",
"new",
"generic",
"<",
"t",
">",
"(",
"name",
",",
"null",
",",
"opts",
")",
";",
"}"
]
|
[
"if",
"the",
"plugin",
"is",
"already",
"installed",
",",
"and",
"the",
"new",
"version",
"of",
"the",
"plugin",
"has",
"a",
"\"",
"compatible",
"since",
"version",
"\"",
"value",
"(",
"i",
"e",
",",
"it",
"'",
"s",
"only",
"directly",
"compatible",
"with",
"that",
"version",
"or",
"later",
")",
",",
"this",
"will",
"check",
"to",
"see",
"if",
"the",
"installed",
"version",
"is",
"older",
"than",
"the",
"compatible",
"-",
"since",
"version",
"if",
"it",
"is",
"older",
",",
"it",
"'",
"ll",
"return",
"false",
"if",
"it",
"'",
"s",
"not",
"older",
",",
"or",
"it",
"'",
"s",
"not",
"installed",
",",
"or",
"it",
"'",
"s",
"installed",
"but",
"there",
"'",
"s",
"no",
"compatible",
"since",
"version",
"specified",
",",
"it",
"'",
"ll",
"return",
"true"
]
| [
"public",
"boolean",
"is",
"compatible",
"with",
"installed",
"version",
"(",
")",
"{",
"plugin",
"wrapper",
"installed",
"version",
"=",
"get",
"installed",
"(",
")",
";",
"if",
"(",
"installed",
"version",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"compatible",
"since",
"version",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"new",
"version",
"number",
"(",
"installed",
"version",
"get",
"version",
"(",
")",
")",
"is",
"older",
"than",
"(",
"new",
"version",
"number",
"(",
"compatible",
"since",
"version",
")",
")",
")",
"{",
"return",
"false",
";",
"}",
"}",
"}",
"return",
"true",
";",
"}"
]
|
[
"returns",
":",
"0",
"if",
"the",
"two",
"conditions",
"contain",
"the",
"same",
"number",
"of",
"http",
"request",
"methods",
"less",
"than",
"0",
"if",
"\"",
"this",
"\"",
"instance",
"has",
"an",
"http",
"request",
"method",
"but",
"\"",
"other",
"\"",
"doesn",
"'",
"t",
"greater",
"than",
"0",
"\"",
"other",
"\"",
"has",
"an",
"http",
"request",
"method",
"but",
"\"",
"this",
"\"",
"doesn",
"'",
"t",
"it",
"is",
"assumed",
"that",
"both",
"instances",
"have",
"been",
"obtained",
"via",
"{",
"@",
"link",
"#",
"get",
"matching",
"condition",
"(",
"server",
"web",
"exchange",
")",
"}",
"and",
"therefore",
"each",
"instance",
"contains",
"the",
"matching",
"http",
"request",
"method",
"only",
"or",
"is",
"otherwise",
"empty"
]
| [
"public",
"int",
"compare",
"to",
"(",
"request",
"methods",
"request",
"condition",
"other",
",",
"server",
"web",
"exchange",
"exchange",
")",
"{",
"if",
"(",
"other",
"methods",
"size",
"(",
")",
"!",
"=",
"this",
"methods",
"size",
"(",
")",
")",
"{",
"return",
"other",
"methods",
"size",
"(",
")",
"-",
"this",
"methods",
"size",
"(",
")",
";",
"}",
"else",
"if",
"(",
"this",
"methods",
"size",
"(",
")",
"=",
"=",
"1",
")",
"{",
"if",
"(",
"this",
"methods",
"contains",
"(",
"request",
"method",
"head",
")",
"&",
"&",
"other",
"methods",
"contains",
"(",
"request",
"method",
"get",
")",
")",
"{",
"return",
"-",
"1",
";",
"}",
"else",
"if",
"(",
"this",
"methods",
"contains",
"(",
"request",
"method",
"get",
")",
"&",
"&",
"other",
"methods",
"contains",
"(",
"request",
"method",
"head",
")",
")",
"{",
"return",
"1",
";",
"}",
"}",
"return",
"0",
";",
"}"
]
|
[
"see",
"original",
"{",
"@",
"link",
"ongoing",
"stubbing",
"#",
"then",
"return",
"(",
"object",
",",
"object",
"[",
"]",
")",
"}"
]
| [
"b",
"d",
"d",
"my",
"ongoing",
"stubbing",
"<",
"t",
">",
"will",
"return",
"(",
"t",
"value",
",",
"t",
"values",
")",
";"
]
|
[
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"and",
"only",
"if",
"the",
"specified",
"message",
"is",
"a",
"content",
"message",
"typically",
",",
"this",
"method",
"is",
"implemented",
"as",
"a",
"single",
"{",
"@",
"code",
"return",
"}",
"statement",
"with",
"{",
"@",
"code",
"instanceof",
"}",
":",
"return",
"msg",
"instanceof",
"my",
"content",
"message",
";"
]
| [
"protected",
"abstract",
"boolean",
"is",
"content",
"message",
"(",
"i",
"msg",
")",
"throws",
"exception",
";"
]
|
[
"constructs",
"an",
"{",
"@",
"code",
"array",
"list",
"multimap",
"}",
"with",
"the",
"same",
"mappings",
"as",
"the",
"specified",
"multimap",
"this",
"method",
"will",
"soon",
"be",
"deprecated",
"in",
"favor",
"of",
"{",
"@",
"code",
"multimap",
"builder",
"hash",
"keys",
"(",
")",
"array",
"list",
"values",
"(",
")",
"build",
"(",
"multimap",
")",
"}"
]
| [
"public",
"static",
"<",
"k",
",",
"v",
">",
"array",
"list",
"multimap",
"<",
"k",
",",
"v",
">",
"create",
"(",
"multimap",
"<",
"?",
"extends",
"k",
",",
"?",
"extends",
"v",
">",
"multimap",
")",
"{",
"return",
"new",
"array",
"list",
"multimap",
"<",
">",
"(",
"multimap",
")",
";",
"}"
]
|
[
"returns",
"the",
"downstream",
"tls",
"context",
"in",
"this",
"ssl",
"context",
"provider",
"if",
"this",
"is",
"server",
"side"
]
| [
"public",
"downstream",
"tls",
"context",
"get",
"downstream",
"tls",
"context",
"(",
")",
"{",
"check",
"state",
"(",
"tls",
"context",
"instanceof",
"downstream",
"tls",
"context",
",",
"\"",
"expected",
"downstream",
"tls",
"context",
"\"",
")",
";",
"return",
"(",
"(",
"downstream",
"tls",
"context",
")",
"tls",
"context",
")",
";",
"}"
]
|
[
"this",
"field",
"should",
"be",
"0",
"when",
"the",
"loaded",
"program",
"is",
"being",
"debugged",
",",
"the",
"memory",
"image",
"of",
"this",
"field",
"may",
"be",
"modified",
"by",
"the",
"debugger",
"to",
"insert",
"a",
"trap",
"instruction"
]
| [
"public",
"long",
"get",
"debugger",
"(",
")",
"{",
"return",
"o",
"debugger",
";",
"}"
]
|
[
"decode",
"an",
"indexed",
"id",
"back",
"to",
"its",
"original",
"form"
]
| [
"public",
"static",
"string",
"decode",
"id",
"(",
"byte",
"[",
"]",
"id",
"bytes",
",",
"int",
"offset",
",",
"int",
"length",
")",
"{",
"if",
"(",
"length",
"=",
"=",
"0",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"ids",
"can",
"'",
"t",
"be",
"empty",
"\"",
")",
";",
"}",
"final",
"int",
"magic",
"char",
"=",
"byte",
"to",
"unsigned",
"int",
"(",
"id",
"bytes",
"[",
"offset",
"]",
")",
";",
"switch",
"(",
"magic",
"char",
")",
"{",
"case",
"numeric",
":",
"return",
"decode",
"numeric",
"id",
"(",
"id",
"bytes",
",",
"offset",
",",
"length",
")",
";",
"case",
"utf8",
":",
"return",
"decode",
"utf",
"8",
"id",
"(",
"id",
"bytes",
",",
"offset",
",",
"length",
")",
";",
"default",
":",
"return",
"decode",
"base",
"6",
"4",
"id",
"(",
"id",
"bytes",
",",
"offset",
",",
"length",
")",
";",
"}",
"}"
]
|
[
"this",
"method",
"retrieves",
"the",
"events",
"for",
"a",
"list",
"of",
"entities",
"all",
"of",
"the",
"same",
"entity",
"type",
"the",
"events",
"for",
"each",
"entity",
"are",
"sorted",
"in",
"order",
"of",
"their",
"timestamps",
",",
"descending"
]
| [
"timeline",
"events",
"get",
"entity",
"timelines",
"(",
"string",
"entity",
"type",
",",
"sorted",
"set",
"<",
"string",
">",
"entity",
"ids",
",",
"long",
"limit",
",",
"long",
"window",
"start",
",",
"long",
"window",
"end",
",",
"set",
"<",
"string",
">",
"event",
"types",
")",
"throws",
"i",
"o",
"exception",
";"
]
|
[
"returns",
"true",
"if",
"field",
"corresponding",
"to",
"field",
"i",
"d",
"is",
"set",
"(",
"has",
"been",
"assigned",
"a",
"value",
")",
"and",
"false",
"otherwise"
]
| [
"public",
"boolean",
"is",
"set",
"(",
"fields",
"field",
")",
"{",
"if",
"(",
"field",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
")",
";",
"}",
"switch",
"(",
"field",
")",
"{",
"case",
"msg",
":",
"return",
"is",
"set",
"msg",
"(",
")",
";",
"}",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
")",
";",
"}"
]
|
[
"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",
"\"",
")",
";",
"}"
]
|
[
"get",
"events",
"indicating",
"completion",
"(",
"successfailure",
")",
"of",
"component",
"tasks"
]
| [
"public",
"task",
"completion",
"event",
"[",
"]",
"get",
"task",
"completion",
"events",
"(",
"final",
"int",
"start",
"from",
",",
"final",
"int",
"num",
"events",
")",
"throws",
"i",
"o",
"exception",
",",
"interrupted",
"exception",
"{",
"ensure",
"state",
"(",
"job",
"state",
"running",
")",
";",
"return",
"ugi",
"do",
"as",
"(",
"new",
"privileged",
"exception",
"action",
"<",
"task",
"completion",
"event",
"[",
"]",
">",
"(",
")",
"{",
"@",
"override",
"public",
"task",
"completion",
"event",
"[",
"]",
"run",
"(",
")",
"throws",
"i",
"o",
"exception",
",",
"interrupted",
"exception",
"{",
"return",
"cluster",
"get",
"client",
"(",
")",
"get",
"task",
"completion",
"events",
"(",
"get",
"job",
"i",
"d",
"(",
")",
",",
"start",
"from",
",",
"num",
"events",
")",
";",
"}",
"}",
")",
";",
"}"
]
|
[
"tests",
"the",
"checkpoint",
"restoration",
"with",
"changing",
"parallelism",
"of",
"job",
"vertex",
"with",
"partitioned",
"state"
]
| [
"private",
"void",
"test",
"restore",
"latest",
"checkpointed",
"state",
"with",
"changing",
"parallelism",
"(",
"boolean",
"scale",
"out",
")",
"throws",
"exception",
"{",
"final",
"job",
"i",
"d",
"jid",
"=",
"new",
"job",
"i",
"d",
"(",
")",
";",
"final",
"job",
"vertex",
"i",
"d",
"job",
"vertex",
"i",
"d",
"1",
"=",
"new",
"job",
"vertex",
"i",
"d",
"(",
")",
";",
"final",
"job",
"vertex",
"i",
"d",
"job",
"vertex",
"i",
"d",
"2",
"=",
"new",
"job",
"vertex",
"i",
"d",
"(",
")",
";",
"int",
"parallelism",
"1",
"=",
"3",
";",
"int",
"parallelism",
"2",
"=",
"scale",
"out",
"?",
"2",
":",
"13",
";",
"int",
"max",
"parallelism",
"1",
"=",
"42",
";",
"int",
"max",
"parallelism",
"2",
"=",
"13",
";",
"int",
"new",
"parallelism",
"2",
"=",
"scale",
"out",
"?",
"13",
":",
"2",
";",
"final",
"execution",
"job",
"vertex",
"job",
"vertex",
"1",
"=",
"mock",
"execution",
"job",
"vertex",
"(",
"job",
"vertex",
"i",
"d",
"1",
",",
"parallelism",
"1",
",",
"max",
"parallelism",
"1",
")",
";",
"final",
"execution",
"job",
"vertex",
"job",
"vertex",
"2",
"=",
"mock",
"execution",
"job",
"vertex",
"(",
"job",
"vertex",
"i",
"d",
"2",
",",
"parallelism",
"2",
",",
"max",
"parallelism",
"2",
")",
";",
"list",
"<",
"execution",
"vertex",
">",
"all",
"execution",
"vertices",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"parallelism",
"1",
"+",
"parallelism",
"2",
")",
";",
"all",
"execution",
"vertices",
"add",
"all",
"(",
"arrays",
"as",
"list",
"(",
"job",
"vertex",
"1",
"get",
"task",
"vertices",
"(",
")",
")",
")",
";",
"all",
"execution",
"vertices",
"add",
"all",
"(",
"arrays",
"as",
"list",
"(",
"job",
"vertex",
"2",
"get",
"task",
"vertices",
"(",
")",
")",
")",
";",
"execution",
"vertex",
"[",
"]",
"array",
"execution",
"vertices",
"=",
"all",
"execution",
"vertices",
"to",
"array",
"(",
"new",
"execution",
"vertex",
"[",
"all",
"execution",
"vertices",
"size",
"(",
")",
"]",
")",
";",
"/",
"/",
"set",
"up",
"the",
"coordinator",
"and",
"validate",
"the",
"initial",
"state",
"checkpoint",
"coordinator",
"coord",
"=",
"new",
"checkpoint",
"coordinator",
"builder",
"(",
")",
"set",
"job",
"id",
"(",
"jid",
")",
"set",
"tasks",
"(",
"array",
"execution",
"vertices",
")",
"set",
"timer",
"(",
"manually",
"triggered",
"scheduled",
"executor",
")",
"build",
"(",
")",
";",
"/",
"/",
"trigger",
"the",
"checkpoint",
"coord",
"trigger",
"checkpoint",
"(",
"false",
")",
";",
"manually",
"triggered",
"scheduled",
"executor",
"trigger",
"all",
"(",
")",
";",
"assert",
"equals",
"(",
"1",
",",
"coord",
"get",
"pending",
"checkpoints",
"(",
")",
"size",
"(",
")",
")",
";",
"long",
"checkpoint",
"id",
"=",
"iterables",
"get",
"only",
"element",
"(",
"coord",
"get",
"pending",
"checkpoints",
"(",
")",
"key",
"set",
"(",
")",
")",
";",
"list",
"<",
"key",
"group",
"range",
">",
"key",
"group",
"partitions",
"1",
"=",
"state",
"assignment",
"operation",
"create",
"key",
"group",
"partitions",
"(",
"max",
"parallelism",
"1",
",",
"parallelism",
"1",
")",
";",
"list",
"<",
"key",
"group",
"range",
">",
"key",
"group",
"partitions",
"2",
"=",
"state",
"assignment",
"operation",
"create",
"key",
"group",
"partitions",
"(",
"max",
"parallelism",
"2",
",",
"parallelism",
"2",
")",
";",
"/",
"/",
"vertex",
"1",
"for",
"(",
"int",
"index",
"=",
"0",
";",
"index",
"<",
"job",
"vertex",
"1",
"get",
"parallelism",
"(",
")",
";",
"index",
"+",
"+",
")",
"{",
"operator",
"state",
"handle",
"op",
"state",
"backend",
"=",
"generate",
"partitionable",
"state",
"handle",
"(",
"job",
"vertex",
"i",
"d",
"1",
",",
"index",
",",
"2",
",",
"8",
",",
"false",
")",
";",
"key",
"groups",
"state",
"handle",
"keyed",
"state",
"backend",
"=",
"generate",
"key",
"group",
"state",
"(",
"job",
"vertex",
"i",
"d",
"1",
",",
"key",
"group",
"partitions",
"1",
"get",
"(",
"index",
")",
",",
"false",
")",
";",
"key",
"groups",
"state",
"handle",
"keyed",
"state",
"raw",
"=",
"generate",
"key",
"group",
"state",
"(",
"job",
"vertex",
"i",
"d",
"1",
",",
"key",
"group",
"partitions",
"1",
"get",
"(",
"index",
")",
",",
"true",
")",
";",
"operator",
"subtask",
"state",
"operator",
"subtask",
"state",
"=",
"operator",
"subtask",
"state",
"builder",
"(",
")",
"set",
"managed",
"operator",
"state",
"(",
"op",
"state",
"backend",
")",
"set",
"managed",
"keyed",
"state",
"(",
"keyed",
"state",
"backend",
")",
"set",
"raw",
"keyed",
"state",
"(",
"keyed",
"state",
"raw",
")",
"build",
"(",
")",
";",
"task",
"state",
"snapshot",
"task",
"operator",
"subtask",
"states",
"=",
"new",
"task",
"state",
"snapshot",
"(",
")",
";",
"task",
"operator",
"subtask",
"states",
"put",
"subtask",
"state",
"by",
"operator",
"i",
"d",
"(",
"operator",
"i",
"d",
"from",
"job",
"vertex",
"i",
"d",
"(",
"job",
"vertex",
"i",
"d",
"1",
")",
",",
"operator",
"subtask",
"state",
")",
";",
"acknowledge",
"checkpoint",
"acknowledge",
"checkpoint",
"=",
"new",
"acknowledge",
"checkpoint",
"(",
"jid",
",",
"job",
"vertex",
"1",
"get",
"task",
"vertices",
"(",
")",
"[",
"index",
"]",
"get",
"current",
"execution",
"attempt",
"(",
")",
"get",
"attempt",
"id",
"(",
")",
",",
"checkpoint",
"id",
",",
"new",
"checkpoint",
"metrics",
"(",
")",
",",
"task",
"operator",
"subtask",
"states",
")",
";",
"coord",
"receive",
"acknowledge",
"message",
"(",
"acknowledge",
"checkpoint",
",",
"task",
"manager",
"location",
"info",
")",
";",
"}",
"/",
"/",
"vertex",
"2",
"final",
"list",
"<",
"chained",
"state",
"handle",
"<",
"operator",
"state",
"handle",
">",
">",
"expected",
"op",
"states",
"backend",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"job",
"vertex",
"2",
"get",
"parallelism",
"(",
")",
")",
";",
"final",
"list",
"<",
"chained",
"state",
"handle",
"<",
"operator",
"state",
"handle",
">",
">",
"expected",
"op",
"states",
"raw",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"job",
"vertex",
"2",
"get",
"parallelism",
"(",
")",
")",
";",
"for",
"(",
"int",
"index",
"=",
"0",
";",
"index",
"<",
"job",
"vertex",
"2",
"get",
"parallelism",
"(",
")",
";",
"index",
"+",
"+",
")",
"{",
"key",
"groups",
"state",
"handle",
"keyed",
"state",
"backend",
"=",
"generate",
"key",
"group",
"state",
"(",
"job",
"vertex",
"i",
"d",
"2",
",",
"key",
"group",
"partitions",
"2",
"get",
"(",
"index",
")",
",",
"false",
")",
";",
"key",
"groups",
"state",
"handle",
"keyed",
"state",
"raw",
"=",
"generate",
"key",
"group",
"state",
"(",
"job",
"vertex",
"i",
"d",
"2",
",",
"key",
"group",
"partitions",
"2",
"get",
"(",
"index",
")",
",",
"true",
")",
";",
"operator",
"state",
"handle",
"op",
"state",
"backend",
"=",
"generate",
"partitionable",
"state",
"handle",
"(",
"job",
"vertex",
"i",
"d",
"2",
",",
"index",
",",
"2",
",",
"8",
",",
"false",
")",
";",
"operator",
"state",
"handle",
"op",
"state",
"raw",
"=",
"generate",
"partitionable",
"state",
"handle",
"(",
"job",
"vertex",
"i",
"d",
"2",
",",
"index",
",",
"2",
",",
"8",
",",
"true",
")",
";",
"expected",
"op",
"states",
"backend",
"add",
"(",
"new",
"chained",
"state",
"handle",
"<",
">",
"(",
"collections",
"singleton",
"list",
"(",
"op",
"state",
"backend",
")",
")",
")",
";",
"expected",
"op",
"states",
"raw",
"add",
"(",
"new",
"chained",
"state",
"handle",
"<",
">",
"(",
"collections",
"singleton",
"list",
"(",
"op",
"state",
"raw",
")",
")",
")",
";",
"operator",
"subtask",
"state",
"operator",
"subtask",
"state",
"=",
"operator",
"subtask",
"state",
"builder",
"(",
")",
"set",
"managed",
"operator",
"state",
"(",
"op",
"state",
"backend",
")",
"set",
"raw",
"operator",
"state",
"(",
"op",
"state",
"raw",
")",
"set",
"managed",
"keyed",
"state",
"(",
"keyed",
"state",
"backend",
")",
"set",
"raw",
"keyed",
"state",
"(",
"keyed",
"state",
"raw",
")",
"build",
"(",
")",
";",
"task",
"state",
"snapshot",
"task",
"operator",
"subtask",
"states",
"=",
"new",
"task",
"state",
"snapshot",
"(",
")",
";",
"task",
"operator",
"subtask",
"states",
"put",
"subtask",
"state",
"by",
"operator",
"i",
"d",
"(",
"operator",
"i",
"d",
"from",
"job",
"vertex",
"i",
"d",
"(",
"job",
"vertex",
"i",
"d",
"2",
")",
",",
"operator",
"subtask",
"state",
")",
";",
"acknowledge",
"checkpoint",
"acknowledge",
"checkpoint",
"=",
"new",
"acknowledge",
"checkpoint",
"(",
"jid",
",",
"job",
"vertex",
"2",
"get",
"task",
"vertices",
"(",
")",
"[",
"index",
"]",
"get",
"current",
"execution",
"attempt",
"(",
")",
"get",
"attempt",
"id",
"(",
")",
",",
"checkpoint",
"id",
",",
"new",
"checkpoint",
"metrics",
"(",
")",
",",
"task",
"operator",
"subtask",
"states",
")",
";",
"coord",
"receive",
"acknowledge",
"message",
"(",
"acknowledge",
"checkpoint",
",",
"task",
"manager",
"location",
"info",
")",
";",
"}",
"list",
"<",
"completed",
"checkpoint",
">",
"completed",
"checkpoints",
"=",
"coord",
"get",
"successful",
"checkpoints",
"(",
")",
";",
"assert",
"equals",
"(",
"1",
",",
"completed",
"checkpoints",
"size",
"(",
")",
")",
";",
"set",
"<",
"execution",
"job",
"vertex",
">",
"tasks",
"=",
"new",
"hash",
"set",
"<",
">",
"(",
")",
";",
"list",
"<",
"key",
"group",
"range",
">",
"new",
"key",
"group",
"partitions",
"2",
"=",
"state",
"assignment",
"operation",
"create",
"key",
"group",
"partitions",
"(",
"max",
"parallelism",
"2",
",",
"new",
"parallelism",
"2",
")",
";",
"final",
"execution",
"job",
"vertex",
"new",
"job",
"vertex",
"1",
"=",
"mock",
"execution",
"job",
"vertex",
"(",
"job",
"vertex",
"i",
"d",
"1",
",",
"parallelism",
"1",
",",
"max",
"parallelism",
"1",
")",
";",
"/",
"/",
"rescale",
"vertex",
"2",
"final",
"execution",
"job",
"vertex",
"new",
"job",
"vertex",
"2",
"=",
"mock",
"execution",
"job",
"vertex",
"(",
"job",
"vertex",
"i",
"d",
"2",
",",
"new",
"parallelism",
"2",
",",
"max",
"parallelism",
"2",
")",
";",
"tasks",
"add",
"(",
"new",
"job",
"vertex",
"1",
")",
";",
"tasks",
"add",
"(",
"new",
"job",
"vertex",
"2",
")",
";",
"assert",
"true",
"(",
"coord",
"restore",
"latest",
"checkpointed",
"state",
"to",
"all",
"(",
"tasks",
",",
"false",
")",
")",
";",
"/",
"/",
"verify",
"the",
"restored",
"state",
"verify",
"state",
"restore",
"(",
"job",
"vertex",
"i",
"d",
"1",
",",
"new",
"job",
"vertex",
"1",
",",
"key",
"group",
"partitions",
"1",
")",
";",
"list",
"<",
"list",
"<",
"collection",
"<",
"operator",
"state",
"handle",
">",
">",
">",
"actual",
"op",
"states",
"backend",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"new",
"job",
"vertex",
"2",
"get",
"parallelism",
"(",
")",
")",
";",
"list",
"<",
"list",
"<",
"collection",
"<",
"operator",
"state",
"handle",
">",
">",
">",
"actual",
"op",
"states",
"raw",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"new",
"job",
"vertex",
"2",
"get",
"parallelism",
"(",
")",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"new",
"job",
"vertex",
"2",
"get",
"parallelism",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"list",
"<",
"operator",
"i",
"d",
"pair",
">",
"operator",
"i",
"ds",
"=",
"new",
"job",
"vertex",
"2",
"get",
"operator",
"i",
"ds",
"(",
")",
";",
"key",
"groups",
"state",
"handle",
"original",
"keyed",
"state",
"backend",
"=",
"generate",
"key",
"group",
"state",
"(",
"job",
"vertex",
"i",
"d",
"2",
",",
"new",
"key",
"group",
"partitions",
"2",
"get",
"(",
"i",
")",
",",
"false",
")",
";",
"key",
"groups",
"state",
"handle",
"original",
"keyed",
"state",
"raw",
"=",
"generate",
"key",
"group",
"state",
"(",
"job",
"vertex",
"i",
"d",
"2",
",",
"new",
"key",
"group",
"partitions",
"2",
"get",
"(",
"i",
")",
",",
"true",
")",
";",
"job",
"manager",
"task",
"restore",
"task",
"restore",
"=",
"new",
"job",
"vertex",
"2",
"get",
"task",
"vertices",
"(",
")",
"[",
"i",
"]",
"get",
"current",
"execution",
"attempt",
"(",
")",
"get",
"task",
"restore",
"(",
")",
";",
"assert",
"assert",
"equals",
"(",
"1l",
",",
"task",
"restore",
"get",
"restore",
"checkpoint",
"id",
"(",
")",
")",
";",
"task",
"state",
"snapshot",
"task",
"state",
"handles",
"=",
"task",
"restore",
"get",
"task",
"state",
"snapshot",
"(",
")",
";",
"final",
"int",
"head",
"op",
"index",
"=",
"operator",
"i",
"ds",
"size",
"(",
")",
"-",
"1",
";",
"list",
"<",
"collection",
"<",
"operator",
"state",
"handle",
">",
">",
"all",
"parallel",
"managed",
"op",
"states",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"operator",
"i",
"ds",
"size",
"(",
")",
")",
";",
"list",
"<",
"collection",
"<",
"operator",
"state",
"handle",
">",
">",
"all",
"parallel",
"raw",
"op",
"states",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"operator",
"i",
"ds",
"size",
"(",
")",
")",
";",
"for",
"(",
"int",
"idx",
"=",
"0",
";",
"idx",
"<",
"operator",
"i",
"ds",
"size",
"(",
")",
";",
"+",
"+",
"idx",
")",
"{",
"operator",
"i",
"d",
"operator",
"i",
"d",
"=",
"operator",
"i",
"ds",
"get",
"(",
"idx",
")",
"get",
"generated",
"operator",
"i",
"d",
"(",
")",
";",
"operator",
"subtask",
"state",
"op",
"state",
"=",
"task",
"state",
"handles",
"get",
"subtask",
"state",
"by",
"operator",
"i",
"d",
"(",
"operator",
"i",
"d",
")",
";",
"collection",
"<",
"operator",
"state",
"handle",
">",
"op",
"state",
"backend",
"=",
"op",
"state",
"get",
"managed",
"operator",
"state",
"(",
")",
";",
"collection",
"<",
"operator",
"state",
"handle",
">",
"op",
"state",
"raw",
"=",
"op",
"state",
"get",
"raw",
"operator",
"state",
"(",
")",
";",
"all",
"parallel",
"managed",
"op",
"states",
"add",
"(",
"op",
"state",
"backend",
")",
";",
"all",
"parallel",
"raw",
"op",
"states",
"add",
"(",
"op",
"state",
"raw",
")",
";",
"if",
"(",
"idx",
"=",
"=",
"head",
"op",
"index",
")",
"{",
"collection",
"<",
"keyed",
"state",
"handle",
">",
"keyed",
"state",
"backend",
"=",
"op",
"state",
"get",
"managed",
"keyed",
"state",
"(",
")",
";",
"collection",
"<",
"keyed",
"state",
"handle",
">",
"key",
"group",
"state",
"raw",
"=",
"op",
"state",
"get",
"raw",
"keyed",
"state",
"(",
")",
";",
"compare",
"keyed",
"state",
"(",
"collections",
"singleton",
"list",
"(",
"original",
"keyed",
"state",
"backend",
")",
",",
"keyed",
"state",
"backend",
")",
";",
"compare",
"keyed",
"state",
"(",
"collections",
"singleton",
"list",
"(",
"original",
"keyed",
"state",
"raw",
")",
",",
"key",
"group",
"state",
"raw",
")",
";",
"}",
"}",
"actual",
"op",
"states",
"backend",
"add",
"(",
"all",
"parallel",
"managed",
"op",
"states",
")",
";",
"actual",
"op",
"states",
"raw",
"add",
"(",
"all",
"parallel",
"raw",
"op",
"states",
")",
";",
"}",
"compare",
"partitionable",
"state",
"(",
"expected",
"op",
"states",
"backend",
",",
"actual",
"op",
"states",
"backend",
")",
";",
"compare",
"partitionable",
"state",
"(",
"expected",
"op",
"states",
"raw",
",",
"actual",
"op",
"states",
"raw",
")",
";",
"}"
]
|
[
"query",
"the",
"stream",
"for",
"a",
"specific",
"capability"
]
| [
"boolean",
"has",
"capability",
"(",
"string",
"capability",
")",
";"
]
|
[
"the",
"get",
"function",
"to",
"get",
"load",
"more"
]
| [
"public",
"final",
"boolean",
"enable",
"load",
"more",
"(",
")",
"{",
"return",
"enabled",
"custom",
"load",
"more",
"view",
";",
"}"
]
|
[
"user",
"not",
"found"
]
| [
"public",
"void",
"should",
"see",
"4",
"0",
"4",
"after",
"update",
"user",
"(",
")",
"{",
"string",
"username",
"=",
"null",
";",
"user",
"body",
"=",
"null",
";",
"api",
"update",
"user",
"(",
")",
"username",
"path",
"(",
"username",
")",
"body",
"(",
"body",
")",
"execute",
"(",
"r",
"-",
">",
"r",
"pretty",
"peek",
"(",
")",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
]
|
[
"specify",
"a",
"non",
"existent",
"file",
"test",
"for",
"inclusion",
"should",
"be",
"true",
"as",
"if",
"the",
"feature",
"is",
"turned",
"off"
]
| [
"public",
"void",
"test",
"file",
"missing",
"(",
")",
"{",
"i",
"p",
"list",
"ipl",
"=",
"new",
"file",
"based",
"i",
"p",
"list",
"(",
"\"",
"missingips",
"txt",
"\"",
")",
";",
"assert",
"false",
"(",
"\"",
"110",
"113",
"221",
"222",
"is",
"in",
"the",
"list",
"\"",
",",
"ipl",
"is",
"in",
"(",
"\"",
"110",
"113",
"221",
"222",
"\"",
")",
")",
";",
"}"
]
|
[
"return",
"a",
"{",
"@",
"code",
"response",
"entity",
"}",
"with",
"the",
"body",
"decoded",
"to",
"a",
"{",
"@",
"code",
"list",
"}",
"of",
"elements",
"of",
"the",
"given",
"type",
"for",
"an",
"error",
"response",
"(",
"status",
"code",
"of",
"4xx",
"or",
"5xx",
")",
",",
"the",
"{",
"@",
"code",
"mono",
"}",
"emits",
"a",
"{",
"@",
"link",
"web",
"client",
"exception",
"}",
"use",
"{",
"@",
"link",
"#",
"on",
"status",
"(",
"predicate",
",",
"function",
")",
"}",
"to",
"customize",
"error",
"response",
"handling"
]
| [
"<",
"t",
">",
"mono",
"<",
"response",
"entity",
"<",
"list",
"<",
"t",
">",
">",
">",
"to",
"entity",
"list",
"(",
"class",
"<",
"t",
">",
"element",
"class",
")",
";"
]
|
[
"specify",
"omitted",
"fields",
",",
"as",
"a",
"map",
"consisting",
"of",
"{",
"@",
"code",
"class",
"}",
"instances",
"mapped",
"to",
"comma",
"separated",
"field",
"names"
]
| [
"public",
"void",
"set",
"omitted",
"fields",
"(",
"map",
"<",
"class",
"<",
"?",
">",
",",
"string",
">",
"omitted",
"fields",
")",
"{",
"this",
"omitted",
"fields",
"=",
"omitted",
"fields",
";",
"}"
]
|
[
"retrieves",
"and",
"removes",
"the",
"head",
"of",
"the",
"queue",
"represented",
"by",
"this",
"deque",
"(",
"in",
"other",
"words",
",",
"the",
"first",
"element",
"of",
"this",
"deque",
")",
",",
"or",
"returns",
"<",
"tt",
">",
"null",
"<",
"tt",
">",
"if",
"this",
"deque",
"is",
"empty",
"this",
"method",
"is",
"equivalent",
"to",
"{",
"@",
"link",
"#",
"poll",
"first",
"(",
")",
"}"
]
| [
"e",
"poll",
"(",
")",
";"
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.