docstring_tokens
list | code_tokens
list |
|---|---|
[
"same",
"test",
"but",
"the",
"client",
"should",
"use",
"dn",
"hostnames"
]
| [
"public",
"void",
"test",
"file",
"creation",
"using",
"hostname",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"assume",
"true",
"(",
"system",
"get",
"property",
"(",
"\"",
"os",
"name",
"\"",
")",
"starts",
"with",
"(",
"\"",
"linux",
"\"",
")",
")",
";",
"check",
"file",
"creation",
"(",
"null",
",",
"true",
")",
";",
"}"
]
|
[
"set",
"the",
"token",
"all",
"error",
"-",
"related",
"values",
"are",
"cleared"
]
| [
"public",
"void",
"token",
"(",
"o",
"auth",
"bearer",
"token",
"token",
")",
"{",
"this",
"token",
"=",
"token",
";",
"this",
"error",
"code",
"=",
"null",
";",
"this",
"error",
"description",
"=",
"null",
";",
"this",
"error",
"uri",
"=",
"null",
";",
"}"
]
|
[
"build",
"a",
"resolvable",
"wrapper",
"for",
"the",
"specified",
"field",
",",
"allowing",
"to",
"resolve",
"the",
"field",
"'",
"s",
"name",
"in",
"a",
"{",
"@",
"code",
"message",
"source",
"}",
"the",
"default",
"implementation",
"returns",
"a",
"first",
"argument",
"indicating",
"the",
"field",
":",
"of",
"type",
"{",
"@",
"code",
"default",
"message",
"source",
"resolvable",
"}",
",",
"with",
"\"",
"object",
"name",
"field",
"\"",
"and",
"\"",
"field",
"\"",
"as",
"codes",
",",
"and",
"with",
"the",
"plain",
"field",
"name",
"as",
"default",
"message"
]
| [
"protected",
"message",
"source",
"resolvable",
"get",
"resolvable",
"field",
"(",
"string",
"object",
"name",
",",
"string",
"field",
")",
"{",
"string",
"[",
"]",
"codes",
"=",
"new",
"string",
"[",
"]",
"{",
"object",
"name",
"+",
"errors",
"nested",
"path",
"separator",
"+",
"field",
",",
"field",
"}",
";",
"return",
"new",
"default",
"message",
"source",
"resolvable",
"(",
"codes",
",",
"field",
")",
";",
"}"
]
|
[
"this",
"takes",
"the",
"a",
"{",
"@",
"code",
"map",
"<",
"string",
",",
"string",
">",
"}",
"of",
"the",
"type",
"\"",
"fieldname",
":",
"fieldtype",
"\"",
"and",
"transforms",
"it",
"into",
"the",
"typical",
"mapping",
"format",
"example",
":",
"input",
":",
"{",
"\"",
"field",
"1",
"sub",
"field",
"1",
"\"",
":",
"\"",
"long",
"\"",
",",
"\"",
"field",
"2",
"\"",
":",
"\"",
"keyword",
"\"",
"}",
"output",
":",
"{",
"\"",
"field",
"1",
"sub",
"field",
"1",
"\"",
":",
"{",
"\"",
"type",
"\"",
":",
"\"",
"long",
"\"",
"}",
",",
"\"",
"field",
"2",
"\"",
":",
"{",
"\"",
"type",
"\"",
":",
"\"",
"keyword",
"\"",
"}",
"}"
]
| [
"static",
"map",
"<",
"string",
",",
"object",
">",
"create",
"mappings",
"from",
"string",
"map",
"(",
"map",
"<",
"string",
",",
"string",
">",
"mappings",
")",
"{",
"return",
"mappings",
"entry",
"set",
"(",
")",
"stream",
"(",
")",
"collect",
"(",
"to",
"map",
"(",
"e",
"-",
">",
"e",
"get",
"key",
"(",
")",
",",
"e",
"-",
">",
"singleton",
"map",
"(",
"\"",
"type",
"\"",
",",
"e",
"get",
"value",
"(",
")",
")",
")",
")",
";",
"}"
]
|
[
"the",
"class",
"holding",
"records",
"for",
"this",
"type"
]
| [
"public",
"class",
"<",
"record",
">",
"get",
"record",
"type",
"(",
")",
"{",
"return",
"record",
"class",
";",
"}"
]
|
[
"insert",
"a",
"fixed",
",",
"prefix",
"-",
"based",
"version",
"in",
"resource",
"u",
"r",
"ls",
"that",
"match",
"the",
"given",
"path",
"patterns",
",",
"for",
"example",
":",
"<",
"code",
">",
"\"",
"{",
"version",
"}",
"jsmain",
"js",
"\"",
"<",
"code",
">",
"this",
"is",
"useful",
"(",
"vs",
"content",
"-",
"based",
"versions",
")",
"when",
"using",
"java",
"script",
"module",
"loaders",
"the",
"version",
"may",
"be",
"a",
"random",
"number",
",",
"the",
"current",
"date",
",",
"or",
"a",
"value",
"fetched",
"from",
"a",
"git",
"commit",
"sha",
",",
"a",
"property",
"file",
",",
"or",
"environment",
"variable",
"and",
"set",
"with",
"sp",
"e",
"l",
"expressions",
"in",
"the",
"configuration",
"(",
"e",
"g",
"see",
"{",
"@",
"code",
"@",
"value",
"}",
"in",
"java",
"config",
")",
"if",
"not",
"done",
"already",
",",
"variants",
"of",
"the",
"given",
"{",
"@",
"code",
"path",
"patterns",
"}",
",",
"prefixed",
"with",
"the",
"{",
"@",
"code",
"version",
"}",
"will",
"be",
"also",
"configured",
"for",
"example",
",",
"adding",
"a",
"{",
"@",
"code",
"\"",
"js",
"\"",
"}",
"path",
"pattern",
"will",
"also",
"cofigure",
"automatically",
"a",
"{",
"@",
"code",
"\"",
"v",
"1",
"0",
"0js",
"\"",
"}",
"with",
"{",
"@",
"code",
"\"",
"v",
"1",
"0",
"0",
"\"",
"}",
"the",
"{",
"@",
"code",
"version",
"}",
"string",
"given",
"as",
"an",
"argument"
]
| [
"public",
"version",
"resource",
"resolver",
"add",
"fixed",
"version",
"strategy",
"(",
"string",
"version",
",",
"string",
"path",
"patterns",
")",
"{",
"list",
"<",
"string",
">",
"patterns",
"list",
"=",
"arrays",
"as",
"list",
"(",
"path",
"patterns",
")",
";",
"list",
"<",
"string",
">",
"prefixed",
"patterns",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"path",
"patterns",
"length",
")",
";",
"string",
"version",
"prefix",
"=",
"\"",
"/",
"\"",
"+",
"version",
";",
"for",
"(",
"string",
"pattern",
":",
"patterns",
"list",
")",
"{",
"prefixed",
"patterns",
"add",
"(",
"pattern",
")",
";",
"if",
"(",
"!",
"pattern",
"starts",
"with",
"(",
"version",
"prefix",
")",
"&",
"&",
"!",
"patterns",
"list",
"contains",
"(",
"version",
"prefix",
"+",
"pattern",
")",
")",
"{",
"prefixed",
"patterns",
"add",
"(",
"version",
"prefix",
"+",
"pattern",
")",
";",
"}",
"}",
"return",
"add",
"version",
"strategy",
"(",
"new",
"fixed",
"version",
"strategy",
"(",
"version",
")",
",",
"string",
"utils",
"to",
"string",
"array",
"(",
"prefixed",
"patterns",
")",
")",
";",
"}"
]
|
[
"submit",
"the",
"job"
]
| [
"public",
"synchronized",
"void",
"submit",
"(",
"balance",
"job",
"job",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"!",
"running",
"get",
"(",
")",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"scheduler",
"is",
"shutdown",
"\"",
")",
";",
"}",
"string",
"job",
"id",
"=",
"allocate",
"job",
"id",
"(",
")",
";",
"job",
"set",
"id",
"(",
"job",
"id",
")",
";",
"job",
"set",
"scheduler",
"(",
"this",
")",
";",
"journal",
"save",
"job",
"(",
"job",
")",
";",
"job",
"set",
"put",
"(",
"job",
",",
"job",
")",
";",
"running",
"queue",
"add",
"(",
"job",
")",
";",
"log",
"info",
"(",
"\"",
"add",
"new",
"job",
"=",
"{",
"}",
"\"",
",",
"job",
")",
";",
"}"
]
|
[
"tests",
"that",
"bitcode",
"is",
"disabled",
"for",
"simulator",
"builds",
"even",
"if",
"enabled",
"by",
"flag"
]
| [
"public",
"void",
"test",
"compilation",
"actions",
"with",
"bitcode",
"simulator",
"(",
")",
"throws",
"exception",
"{",
"use",
"configuration",
"(",
"\"",
"-",
"-",
"crosstool",
"top",
"=",
"\"",
"+",
"mock",
"objc",
"support",
"default",
"osx",
"crosstool",
",",
"\"",
"-",
"-",
"ios",
"multi",
"cpus",
"=",
"x",
"8",
"6",
"64",
"\"",
",",
"\"",
"-",
"-",
"apple",
"bitcode",
"=",
"embedded",
"\"",
")",
";",
"create",
"library",
"target",
"writer",
"(",
"\"",
"/",
"/",
"objc",
":",
"lib",
"\"",
")",
"set",
"and",
"create",
"files",
"(",
"\"",
"srcs",
"\"",
",",
"\"",
"a",
"m",
"\"",
",",
"\"",
"b",
"m",
"\"",
",",
"\"",
"private",
"h",
"\"",
")",
"set",
"and",
"create",
"files",
"(",
"\"",
"hdrs",
"\"",
",",
"\"",
"c",
"h",
"\"",
")",
"write",
"(",
")",
";",
"command",
"action",
"compile",
"action",
"a",
"=",
"compile",
"action",
"(",
"\"",
"/",
"/",
"objc",
":",
"lib",
"\"",
",",
"\"",
"a",
"o",
"\"",
")",
";",
"assert",
"that",
"(",
"compile",
"action",
"a",
"get",
"arguments",
"(",
")",
")",
"does",
"not",
"contain",
"(",
"\"",
"-",
"fembed",
"-",
"bitcode",
"\"",
")",
";",
"assert",
"that",
"(",
"compile",
"action",
"a",
"get",
"arguments",
"(",
")",
")",
"does",
"not",
"contain",
"(",
"\"",
"-",
"fembed",
"-",
"bitcode",
"-",
"marker",
"\"",
")",
";",
"}"
]
|
[
"keep",
"checking",
"queue",
"for",
"message"
]
| [
"public",
"void",
"run",
"(",
")",
"throws",
"exception",
"{",
"while",
"(",
"true",
")",
"{",
"var",
"message",
"=",
"queue",
"manager",
"receive",
"message",
"(",
")",
";",
"if",
"(",
"message",
"=",
"=",
"null",
")",
"{",
"logger",
"info",
"(",
"\"",
"no",
"message",
"waiting",
"\"",
")",
";",
"thread",
"sleep",
"(",
"200",
")",
";",
"}",
"else",
"{",
"process",
"message",
"(",
"message",
")",
";",
"}",
"}",
"}"
]
|
[
"extract",
"the",
"login",
"details",
"from",
"a",
"uri",
",",
"raising",
"an",
"exception",
"if",
"the",
"uri",
"contains",
"them"
]
| [
"public",
"static",
"void",
"reject",
"secrets",
"in",
"u",
"r",
"is",
"(",
"uri",
"name",
")",
"{",
"login",
"login",
"=",
"extract",
"login",
"details",
"(",
"name",
")",
";",
"preconditions",
"check",
"argument",
"(",
"!",
"login",
"has",
"login",
"(",
")",
",",
"login",
"warning",
")",
";",
"}"
]
|
[
"branch",
"on",
"separate",
"images",
"-",
">",
"thumbnail",
"resize",
"and",
"rotate",
"-",
">",
"thumbnail",
"producers",
"as",
"provided",
"-",
">",
"local",
"image",
"resize",
"and",
"rotate",
"-",
">",
"add",
"meta",
"data",
"producer"
]
| [
"private",
"producer",
"<",
"encoded",
"image",
">",
"new",
"local",
"transformations",
"sequence",
"(",
"producer",
"<",
"encoded",
"image",
">",
"input",
"producer",
",",
"thumbnail",
"producer",
"<",
"encoded",
"image",
">",
"[",
"]",
"thumbnail",
"producers",
")",
"{",
"producer",
"<",
"encoded",
"image",
">",
"local",
"image",
"producer",
"=",
"producer",
"factory",
"new",
"add",
"image",
"transform",
"meta",
"data",
"producer",
"(",
"input",
"producer",
")",
";",
"local",
"image",
"producer",
"=",
"m",
"producer",
"factory",
"new",
"resize",
"and",
"rotate",
"producer",
"(",
"local",
"image",
"producer",
",",
"true",
",",
"m",
"image",
"transcoder",
"factory",
")",
";",
"throttling",
"producer",
"<",
"encoded",
"image",
">",
"local",
"image",
"throttling",
"producer",
"=",
"m",
"producer",
"factory",
"new",
"throttling",
"producer",
"(",
"local",
"image",
"producer",
")",
";",
"return",
"m",
"producer",
"factory",
"new",
"branch",
"on",
"separate",
"images",
"producer",
"(",
"new",
"local",
"thumbnail",
"producer",
"(",
"thumbnail",
"producers",
")",
",",
"local",
"image",
"throttling",
"producer",
")",
";",
"}"
]
|
[
"appends",
"the",
"string",
"representation",
"of",
"each",
"entry",
"in",
"{",
"@",
"code",
"entries",
"}",
",",
"using",
"the",
"previously",
"configured",
"separator",
"and",
"key",
"-",
"value",
"separator",
",",
"to",
"{",
"@",
"code",
"appendable",
"}"
]
| [
"public",
"<",
"a",
"extends",
"appendable",
">",
"a",
"append",
"to",
"(",
"a",
"appendable",
",",
"iterator",
"<",
"?",
"extends",
"entry",
"<",
"?",
",",
"?",
">",
">",
"parts",
")",
"throws",
"i",
"o",
"exception",
"{",
"check",
"not",
"null",
"(",
"appendable",
")",
";",
"if",
"(",
"parts",
"has",
"next",
"(",
")",
")",
"{",
"entry",
"<",
"?",
",",
"?",
">",
"entry",
"=",
"parts",
"next",
"(",
")",
";",
"appendable",
"append",
"(",
"joiner",
"to",
"string",
"(",
"entry",
"get",
"key",
"(",
")",
")",
")",
";",
"appendable",
"append",
"(",
"key",
"value",
"separator",
")",
";",
"appendable",
"append",
"(",
"joiner",
"to",
"string",
"(",
"entry",
"get",
"value",
"(",
")",
")",
")",
";",
"while",
"(",
"parts",
"has",
"next",
"(",
")",
")",
"{",
"appendable",
"append",
"(",
"joiner",
"separator",
")",
";",
"entry",
"<",
"?",
",",
"?",
">",
"e",
"=",
"parts",
"next",
"(",
")",
";",
"appendable",
"append",
"(",
"joiner",
"to",
"string",
"(",
"e",
"get",
"key",
"(",
")",
")",
")",
";",
"appendable",
"append",
"(",
"key",
"value",
"separator",
")",
";",
"appendable",
"append",
"(",
"joiner",
"to",
"string",
"(",
"e",
"get",
"value",
"(",
")",
")",
")",
";",
"}",
"}",
"return",
"appendable",
";",
"}"
]
|
[
"build",
"the",
"uri",
"for",
"the",
"request",
"with",
"a",
"{",
"@",
"link",
"uri",
"builder",
"}",
"obtained",
"through",
"the",
"{",
"@",
"link",
"uri",
"builder",
"factory",
"}",
"configured",
"for",
"this",
"client"
]
| [
"s",
"uri",
"(",
"function",
"<",
"uri",
"builder",
",",
"uri",
">",
"uri",
"function",
")",
";"
]
|
[
"create",
"a",
"new",
"{",
"@",
"link",
"default",
"node",
"}",
"as",
"tree",
"node"
]
| [
"default",
"node",
"build",
"tree",
"node",
"(",
"resource",
"wrapper",
"id",
",",
"cluster",
"node",
"cluster",
"node",
")",
";"
]
|
[
"adds",
"symbols",
"to",
"the",
"\"",
"to",
"\"",
"program",
"that",
"are",
"not",
"in",
"the",
"\"",
"to",
"\"",
"program",
",",
"but",
"are",
"in",
"the",
"\"",
"from",
"\"",
"program"
]
| [
"private",
"void",
"add",
"from",
"symbols",
"(",
"address",
"from",
"address",
",",
"boolean",
"replace",
",",
"long",
"long",
"hashtable",
"conflict",
"symbol",
"i",
"d",
"map",
",",
"task",
"monitor",
"monitor",
")",
"throws",
"cancelled",
"exception",
",",
"invalid",
"input",
"exception",
",",
"duplicate",
"name",
"exception",
"{",
"address",
"to",
"address",
"=",
"origin",
"to",
"result",
"translator",
"get",
"address",
"(",
"from",
"address",
")",
";",
"symbol",
"[",
"]",
"from",
"symbols",
"=",
"from",
"symbol",
"table",
"get",
"user",
"symbols",
"(",
"from",
"address",
")",
";",
"for",
"(",
"symbol",
"from",
"symbol",
":",
"from",
"symbols",
")",
"{",
"monitor",
"check",
"canceled",
"(",
")",
";",
"if",
"(",
"from",
"symbol",
"get",
"symbol",
"type",
"(",
")",
"equals",
"(",
"symbol",
"type",
"function",
")",
")",
"{",
"continue",
";",
"/",
"/",
"handle",
"function",
"symbols",
"separately",
"}",
"source",
"type",
"from",
"source",
"=",
"from",
"symbol",
"get",
"source",
"(",
")",
";",
"string",
"from",
"name",
"=",
"from",
"symbol",
"get",
"name",
"(",
")",
";",
"namespace",
"from",
"namespace",
"=",
"from",
"symbol",
"get",
"parent",
"namespace",
"(",
")",
";",
"namespace",
"desired",
"to",
"namespace",
"=",
"determine",
"to",
"namespace",
"(",
"to",
"address",
",",
"from",
"namespace",
",",
"conflict",
"symbol",
"i",
"d",
"map",
")",
";",
"symbol",
"to",
"symbol",
"=",
"to",
"symbol",
"table",
"get",
"symbol",
"(",
"from",
"name",
",",
"to",
"address",
",",
"desired",
"to",
"namespace",
")",
";",
"if",
"(",
"to",
"symbol",
"=",
"=",
"null",
")",
"{",
"to",
"symbol",
"=",
"to",
"symbol",
"table",
"create",
"label",
"(",
"to",
"address",
",",
"from",
"name",
",",
"desired",
"to",
"namespace",
",",
"from",
"source",
")",
";",
"}",
"else",
"if",
"(",
"replace",
"&",
"&",
"to",
"symbol",
"get",
"source",
"(",
")",
"!",
"=",
"from",
"source",
")",
"{",
"try",
"{",
"to",
"symbol",
"set",
"source",
"(",
"from",
"source",
")",
";",
"}",
"catch",
"(",
"illegal",
"argument",
"exception",
"e",
")",
"{",
"msg",
"warn",
"(",
"this",
",",
"e",
"get",
"message",
"(",
")",
")",
";",
"}",
"}",
"boolean",
"pinned",
"=",
"from",
"symbol",
"is",
"pinned",
"(",
")",
";",
"if",
"(",
"replace",
"&",
"&",
"to",
"symbol",
"is",
"pinned",
"(",
")",
"!",
"=",
"pinned",
")",
"{",
"to",
"symbol",
"set",
"pinned",
"(",
"pinned",
")",
";",
"}",
"/",
"/",
"string",
"from",
"comment",
"=",
"from",
"symbol",
"get",
"symbol",
"data",
"3",
"(",
")",
";",
"/",
"/",
"string",
"to",
"comment",
"=",
"to",
"symbol",
"get",
"symbol",
"data",
"3",
"(",
")",
";",
"/",
"/",
"if",
"(",
"!",
"system",
"utilities",
"is",
"equal",
"(",
"from",
"comment",
",",
"to",
"comment",
")",
")",
"{",
"/",
"/",
"string",
"new",
"comment",
";",
"/",
"/",
"if",
"(",
"replace",
")",
"{",
"/",
"/",
"new",
"comment",
"=",
"from",
"comment",
";",
"/",
"/",
"}",
"/",
"/",
"else",
"{",
"/",
"/",
"new",
"comment",
"=",
"string",
"utilities",
"merge",
"strings",
"(",
"from",
"comment",
",",
"to",
"comment",
")",
";",
"/",
"/",
"}",
"/",
"/",
"to",
"symbol",
"set",
"symbol",
"data",
"3",
"(",
"new",
"comment",
")",
";",
"/",
"/",
"}",
"}",
"}"
]
|
[
"place",
"an",
"order",
"for",
"a",
"pet"
]
| [
"public",
"order",
"place",
"order",
"(",
"order",
"order",
")",
"throws",
"api",
"exception",
"{",
"object",
"local",
"var",
"post",
"body",
"=",
"order",
";",
"/",
"/",
"verify",
"the",
"required",
"parameter",
"'",
"order",
"'",
"is",
"set",
"if",
"(",
"order",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"api",
"exception",
"(",
"400",
",",
"\"",
"missing",
"the",
"required",
"parameter",
"'",
"order",
"'",
"when",
"calling",
"place",
"order",
"\"",
")",
";",
"}",
"/",
"/",
"create",
"path",
"and",
"map",
"variables",
"string",
"local",
"var",
"path",
"=",
"\"",
"/",
"store",
"/",
"order",
"\"",
"replace",
"all",
"(",
"\"",
"\\",
"\\",
"{",
"format",
"\\",
"\\",
"}",
"\"",
",",
"\"",
"json",
"\"",
")",
";",
"/",
"/",
"query",
"params",
"list",
"<",
"pair",
">",
"local",
"var",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
"pair",
">",
"(",
")",
";",
"/",
"/",
"header",
"params",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"header",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"/",
"/",
"form",
"params",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"form",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"string",
"[",
"]",
"local",
"var",
"content",
"types",
"=",
"{",
"}",
";",
"string",
"local",
"var",
"content",
"type",
"=",
"local",
"var",
"content",
"types",
"length",
">",
"0",
"?",
"local",
"var",
"content",
"types",
"[",
"0",
"]",
":",
"\"",
"application",
"/",
"json",
"\"",
";",
"if",
"(",
"local",
"var",
"content",
"type",
"starts",
"with",
"(",
"\"",
"multipart",
"/",
"form",
"-",
"data",
"\"",
")",
")",
"{",
"/",
"/",
"file",
"uploading",
"multipart",
"entity",
"builder",
"local",
"var",
"builder",
"=",
"multipart",
"entity",
"builder",
"create",
"(",
")",
";",
"local",
"var",
"post",
"body",
"=",
"local",
"var",
"builder",
"build",
"(",
")",
";",
"}",
"else",
"{",
"/",
"/",
"normal",
"form",
"params",
"}",
"try",
"{",
"string",
"local",
"var",
"response",
"=",
"api",
"invoker",
"invoke",
"a",
"p",
"i",
"(",
"base",
"path",
",",
"local",
"var",
"path",
",",
"\"",
"post",
"\"",
",",
"local",
"var",
"query",
"params",
",",
"local",
"var",
"post",
"body",
",",
"local",
"var",
"header",
"params",
",",
"local",
"var",
"form",
"params",
",",
"local",
"var",
"content",
"type",
")",
";",
"if",
"(",
"local",
"var",
"response",
"!",
"=",
"null",
")",
"{",
"return",
"(",
"order",
")",
"api",
"invoker",
"deserialize",
"(",
"local",
"var",
"response",
",",
"\"",
"\"",
",",
"order",
"class",
")",
";",
"}",
"else",
"{",
"return",
"null",
";",
"}",
"}",
"catch",
"(",
"api",
"exception",
"ex",
")",
"{",
"throw",
"ex",
";",
"}",
"}"
]
|
[
"parse",
"the",
"timeout",
"key",
"in",
"the",
"spawn",
"execution",
"info",
",",
"if",
"it",
"exists",
"otherwise",
",",
"return",
"default",
"timeout",
",",
"or",
"{",
"@",
"code",
"duration",
"zero",
"}",
"if",
"that",
"is",
"null"
]
| [
"public",
"static",
"duration",
"get",
"timeout",
"(",
"spawn",
"spawn",
",",
"duration",
"default",
"timeout",
")",
"throws",
"exec",
"exception",
"{",
"string",
"timeout",
"str",
"=",
"spawn",
"get",
"execution",
"info",
"(",
")",
"get",
"(",
"execution",
"requirements",
"timeout",
")",
";",
"if",
"(",
"timeout",
"str",
"=",
"=",
"null",
")",
"{",
"return",
"default",
"timeout",
"=",
"=",
"null",
"?",
"duration",
"zero",
":",
"default",
"timeout",
";",
"}",
"try",
"{",
"return",
"duration",
"of",
"seconds",
"(",
"integer",
"parse",
"int",
"(",
"timeout",
"str",
")",
")",
";",
"}",
"catch",
"(",
"number",
"format",
"exception",
"e",
")",
"{",
"throw",
"new",
"user",
"exec",
"exception",
"(",
"e",
",",
"failure",
"detail",
"new",
"builder",
"(",
")",
"set",
"message",
"(",
"\"",
"could",
"not",
"parse",
"timeout",
"\"",
")",
"set",
"spawn",
"(",
"failure",
"details",
"spawn",
"new",
"builder",
"(",
")",
"set",
"code",
"(",
"code",
"invalid",
"timeout",
")",
")",
"build",
"(",
")",
")",
";",
"}",
"}"
]
|
[
"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",
")",
";",
"}"
]
|
[
"creates",
"a",
"new",
"(",
"statistically",
")",
"random",
"job",
"i",
"d"
]
| [
"public",
"static",
"job",
"i",
"d",
"generate",
"(",
")",
"{",
"return",
"new",
"job",
"i",
"d",
"(",
")",
";",
"}"
]
|
[
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"and",
"only",
"if",
"the",
"specified",
"message",
"can",
"be",
"encoded",
"by",
"this",
"codec"
]
| [
"public",
"boolean",
"accept",
"outbound",
"message",
"(",
"object",
"msg",
")",
"throws",
"exception",
"{",
"return",
"outbound",
"msg",
"matcher",
"match",
"(",
"msg",
")",
";",
"}"
]
|
[
"merges",
"this",
"rectangle",
"with",
"a",
"list",
"of",
"points",
"the",
"rectangle",
"should",
"not",
"have",
"negative",
"width",
"or",
"negative",
"height"
]
| [
"public",
"rectangle",
"merge",
"(",
"vector",
"2",
"[",
"]",
"vecs",
")",
"{",
"float",
"min",
"x",
"=",
"x",
";",
"float",
"max",
"x",
"=",
"x",
"+",
"width",
";",
"float",
"min",
"y",
"=",
"y",
";",
"float",
"max",
"y",
"=",
"y",
"+",
"height",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"vecs",
"length",
";",
"+",
"+",
"i",
")",
"{",
"vector",
"2",
"v",
"=",
"vecs",
"[",
"i",
"]",
";",
"min",
"x",
"=",
"math",
"min",
"(",
"min",
"x",
",",
"v",
"x",
")",
";",
"max",
"x",
"=",
"math",
"max",
"(",
"max",
"x",
",",
"v",
"x",
")",
";",
"min",
"y",
"=",
"math",
"min",
"(",
"min",
"y",
",",
"v",
"y",
")",
";",
"max",
"y",
"=",
"math",
"max",
"(",
"max",
"y",
",",
"v",
"y",
")",
";",
"}",
"x",
"=",
"min",
"x",
";",
"width",
"=",
"max",
"x",
"-",
"min",
"x",
";",
"y",
"=",
"min",
"y",
";",
"height",
"=",
"max",
"y",
"-",
"min",
"y",
";",
"return",
"this",
";",
"}"
]
|
[
"add",
"a",
"metadata",
"entry",
"if",
"called",
"more",
"than",
"once",
"or",
"in",
"addition",
"to",
"route",
",",
"composite",
"metadata",
"must",
"be",
"in",
"use"
]
| [
"public",
"metadata",
"encoder",
"metadata",
"(",
"object",
"metadata",
",",
"@",
"nullable",
"mime",
"type",
"mime",
"type",
")",
"{",
"if",
"(",
"this",
"is",
"composite",
")",
"{",
"assert",
"not",
"null",
"(",
"mime",
"type",
",",
"\"",
"mime",
"type",
"is",
"required",
"for",
"composite",
"metadata",
"entries",
"\"",
")",
";",
"}",
"else",
"if",
"(",
"mime",
"type",
"=",
"=",
"null",
")",
"{",
"mime",
"type",
"=",
"this",
"metadata",
"mime",
"type",
";",
"}",
"else",
"if",
"(",
"!",
"this",
"metadata",
"mime",
"type",
"equals",
"(",
"mime",
"type",
")",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"mime",
"type",
"is",
"optional",
"when",
"not",
"using",
"composite",
"metadata",
",",
"but",
"it",
"was",
"provided",
"\"",
"+",
"\"",
"and",
"does",
"not",
"match",
"the",
"connection",
"metadata",
"mime",
"type",
"'",
"\"",
"+",
"this",
"metadata",
"mime",
"type",
"+",
"\"",
"'",
"\"",
")",
";",
"}",
"reactive",
"adapter",
"adapter",
"=",
"this",
"strategies",
"reactive",
"adapter",
"registry",
"(",
")",
"get",
"adapter",
"(",
"metadata",
"get",
"class",
"(",
")",
")",
";",
"if",
"(",
"adapter",
"!",
"=",
"null",
")",
"{",
"assert",
"is",
"true",
"(",
"!",
"adapter",
"is",
"multi",
"value",
"(",
")",
",",
"\"",
"expected",
"single",
"value",
":",
"\"",
"+",
"metadata",
")",
";",
"metadata",
"=",
"mono",
"from",
"(",
"adapter",
"to",
"publisher",
"(",
"metadata",
")",
")",
"default",
"if",
"empty",
"(",
"no",
"value",
")",
";",
"this",
"has",
"async",
"values",
"=",
"true",
";",
"}",
"this",
"metadata",
"entries",
"add",
"(",
"new",
"metadata",
"entry",
"(",
"metadata",
",",
"mime",
"type",
")",
")",
";",
"assert",
"metadata",
"entry",
"count",
"(",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"this",
"method",
"is",
"not",
"implemented",
";",
"can",
"'",
"t",
"set",
"the",
"end",
"address",
"for",
"expanding",
"up"
]
| [
"void",
"set",
"end",
"address",
"(",
"address",
"addr",
")",
"{",
"}"
]
|
[
"resets",
"the",
"state",
"of",
"search",
"processor"
]
| [
"void",
"reset",
"(",
")",
";"
]
|
[
"checks",
"that",
"a",
"certain",
"event",
"sequence",
"is",
"recognized",
"with",
"an",
"or",
"filter"
]
| [
"public",
"void",
"test",
"simple",
"or",
"filter",
"pattern",
"c",
"e",
"p",
"(",
")",
"throws",
"exception",
"{",
"stream",
"execution",
"environment",
"env",
"=",
"stream",
"execution",
"environment",
"get",
"execution",
"environment",
"(",
")",
";",
"data",
"stream",
"<",
"event",
">",
"input",
"=",
"env",
"from",
"elements",
"(",
"new",
"event",
"(",
"1",
",",
"\"",
"start",
"\"",
",",
"1",
"0",
")",
",",
"new",
"event",
"(",
"2",
",",
"\"",
"middle",
"\"",
",",
"2",
"0",
")",
",",
"new",
"event",
"(",
"3",
",",
"\"",
"end",
"\"",
",",
"3",
"0",
")",
",",
"new",
"event",
"(",
"4",
",",
"\"",
"start",
"\"",
",",
"4",
"0",
")",
",",
"new",
"event",
"(",
"5",
",",
"\"",
"middle",
"\"",
",",
"5",
"0",
")",
",",
"new",
"event",
"(",
"6",
",",
"\"",
"end",
"\"",
",",
"6",
"0",
")",
")",
";",
"pattern",
"<",
"event",
",",
"?",
">",
"pattern",
"=",
"pattern",
"<",
"event",
">",
"begin",
"(",
"\"",
"start",
"\"",
")",
"where",
"(",
"new",
"simple",
"condition",
"<",
"event",
">",
"(",
")",
"{",
"@",
"override",
"public",
"boolean",
"filter",
"(",
"event",
"value",
")",
"throws",
"exception",
"{",
"return",
"value",
"get",
"name",
"(",
")",
"equals",
"(",
"\"",
"start",
"\"",
")",
";",
"}",
"}",
")",
"followed",
"by",
"any",
"(",
"\"",
"middle",
"\"",
")",
"where",
"(",
"new",
"simple",
"condition",
"<",
"event",
">",
"(",
")",
"{",
"@",
"override",
"public",
"boolean",
"filter",
"(",
"event",
"value",
")",
"throws",
"exception",
"{",
"return",
"value",
"get",
"price",
"(",
")",
"=",
"=",
"2",
"0",
";",
"}",
"}",
")",
"or",
"(",
"new",
"simple",
"condition",
"<",
"event",
">",
"(",
")",
"{",
"@",
"override",
"public",
"boolean",
"filter",
"(",
"event",
"value",
")",
"throws",
"exception",
"{",
"return",
"value",
"get",
"price",
"(",
")",
"=",
"=",
"5",
"0",
";",
"}",
"}",
")",
"followed",
"by",
"any",
"(",
"\"",
"end",
"\"",
")",
"where",
"(",
"new",
"simple",
"condition",
"<",
"event",
">",
"(",
")",
"{",
"@",
"override",
"public",
"boolean",
"filter",
"(",
"event",
"value",
")",
"throws",
"exception",
"{",
"return",
"value",
"get",
"name",
"(",
")",
"equals",
"(",
"\"",
"end",
"\"",
")",
";",
"}",
"}",
")",
";",
"data",
"stream",
"<",
"string",
">",
"result",
"=",
"cep",
"pattern",
"(",
"input",
",",
"pattern",
")",
"in",
"processing",
"time",
"(",
")",
"select",
"(",
"new",
"pattern",
"select",
"function",
"<",
"event",
",",
"string",
">",
"(",
")",
"{",
"@",
"override",
"public",
"string",
"select",
"(",
"map",
"<",
"string",
",",
"list",
"<",
"event",
">",
">",
"pattern",
")",
"{",
"string",
"builder",
"builder",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"builder",
"append",
"(",
"pattern",
"get",
"(",
"\"",
"start",
"\"",
")",
"get",
"(",
"0",
")",
"get",
"id",
"(",
")",
")",
"append",
"(",
"\"",
",",
"\"",
")",
"append",
"(",
"pattern",
"get",
"(",
"\"",
"middle",
"\"",
")",
"get",
"(",
"0",
")",
"get",
"id",
"(",
")",
")",
"append",
"(",
"\"",
",",
"\"",
")",
"append",
"(",
"pattern",
"get",
"(",
"\"",
"end",
"\"",
")",
"get",
"(",
"0",
")",
"get",
"id",
"(",
")",
")",
";",
"return",
"builder",
"to",
"string",
"(",
")",
";",
"}",
"}",
")",
";",
"list",
"<",
"string",
">",
"result",
"list",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"data",
"stream",
"utils",
"collect",
"(",
"result",
")",
"for",
"each",
"remaining",
"(",
"result",
"list",
":",
":",
"add",
")",
";",
"list",
"<",
"string",
">",
"expected",
"=",
"arrays",
"as",
"list",
"(",
"\"",
"1",
",",
"5",
",",
"6",
"\"",
",",
"\"",
"1",
",",
"2",
",",
"3",
"\"",
",",
"\"",
"4",
",",
"5",
",",
"6",
"\"",
",",
"\"",
"1",
",",
"2",
",",
"6",
"\"",
")",
";",
"expected",
"sort",
"(",
"string",
":",
":",
"compare",
"to",
")",
";",
"result",
"list",
"sort",
"(",
"string",
":",
":",
"compare",
"to",
")",
";",
"assert",
"equals",
"(",
"expected",
",",
"result",
"list",
")",
";",
"}"
]
|
[
"verify",
"the",
"access",
"for",
"logs",
",",
"stacks",
",",
"conf",
",",
"and",
"log",
"level",
"servlets",
",",
"when",
"authentication",
"filters",
"are",
"set",
",",
"but",
"authorization",
"is",
"not",
"enabled"
]
| [
"public",
"void",
"test",
"disabled",
"authorization",
"of",
"default",
"servlets",
"(",
")",
"throws",
"exception",
"{",
"configuration",
"conf",
"=",
"new",
"configuration",
"(",
")",
";",
"/",
"/",
"authorization",
"is",
"disabled",
"by",
"default",
"conf",
"set",
"(",
"http",
"server",
"2",
"filter",
"initializer",
"property",
",",
"dummy",
"filter",
"initializer",
"class",
"get",
"name",
"(",
")",
")",
";",
"conf",
"set",
"(",
"common",
"configuration",
"keys",
"hadoop",
"security",
"group",
"mapping",
",",
"my",
"groups",
"provider",
"class",
"get",
"name",
"(",
")",
")",
";",
"groups",
"get",
"user",
"to",
"groups",
"mapping",
"service",
"(",
"conf",
")",
";",
"my",
"groups",
"provider",
"clear",
"mapping",
"(",
")",
";",
"my",
"groups",
"provider",
"mapping",
"put",
"(",
"\"",
"user",
"a",
"\"",
",",
"arrays",
"as",
"list",
"(",
"\"",
"group",
"a",
"\"",
")",
")",
";",
"my",
"groups",
"provider",
"mapping",
"put",
"(",
"\"",
"user",
"b",
"\"",
",",
"arrays",
"as",
"list",
"(",
"\"",
"group",
"b",
"\"",
")",
")",
";",
"http",
"server",
"2",
"my",
"server",
"=",
"new",
"http",
"server",
"2",
"builder",
"(",
")",
"set",
"name",
"(",
"\"",
"test",
"\"",
")",
"add",
"endpoint",
"(",
"new",
"uri",
"(",
"\"",
"http",
":",
"/",
"/",
"localhost",
":",
"0",
"\"",
")",
")",
"set",
"find",
"port",
"(",
"true",
")",
"build",
"(",
")",
";",
"my",
"server",
"set",
"attribute",
"(",
"http",
"server",
"2",
"conf",
"context",
"attribute",
",",
"conf",
")",
";",
"my",
"server",
"start",
"(",
")",
";",
"string",
"server",
"u",
"r",
"l",
"=",
"\"",
"http",
":",
"/",
"/",
"\"",
"+",
"net",
"utils",
"get",
"host",
"port",
"string",
"(",
"my",
"server",
"get",
"connector",
"address",
"(",
"0",
")",
")",
"+",
"\"",
"/",
"\"",
";",
"for",
"(",
"string",
"servlet",
":",
"new",
"string",
"[",
"]",
"{",
"\"",
"conf",
"\"",
",",
"\"",
"logs",
"\"",
",",
"\"",
"stacks",
"\"",
",",
"\"",
"log",
"level",
"\"",
"}",
")",
"{",
"for",
"(",
"string",
"user",
":",
"new",
"string",
"[",
"]",
"{",
"\"",
"user",
"a",
"\"",
",",
"\"",
"user",
"b",
"\"",
"}",
")",
"{",
"assert",
"equals",
"(",
"http",
"u",
"r",
"l",
"connection",
"http",
"ok",
",",
"get",
"http",
"status",
"code",
"(",
"server",
"u",
"r",
"l",
"+",
"servlet",
",",
"user",
")",
")",
";",
"}",
"}",
"my",
"server",
"stop",
"(",
")",
";",
"}"
]
|
[
"skip",
"bypass",
"and",
"support",
"event",
"based",
"on",
"authentication",
"attributes"
]
| [
"protected",
"static",
"boolean",
"locate",
"matching",
"attribute",
"based",
"on",
"authentication",
"attributes",
"(",
"final",
"multifactor",
"authentication",
"provider",
"bypass",
"properties",
"bypass",
",",
"final",
"authentication",
"authn",
")",
"{",
"return",
"locate",
"matching",
"attribute",
"value",
"(",
"bypass",
"get",
"authentication",
"attribute",
"name",
"(",
")",
",",
"bypass",
"get",
"authentication",
"attribute",
"value",
"(",
")",
",",
"authn",
"get",
"attributes",
"(",
")",
",",
"false",
")",
";",
"}"
]
|
[
"test",
"method",
"'",
"tasks",
"'",
"should",
"set",
"tasks",
"page",
"class",
"for",
"rendering"
]
| [
"public",
"void",
"test",
"tasks",
"(",
")",
"{",
"app",
"controller",
"tasks",
"(",
")",
";",
"assert",
"equals",
"(",
"tasks",
"page",
"class",
",",
"app",
"controller",
"get",
"clazz",
"(",
")",
")",
";",
"}"
]
|
[
"creates",
"an",
"instance",
"of",
"a",
"scalar",
"or",
"table",
"function",
"during",
"translation"
]
| [
"public",
"static",
"bridging",
"sql",
"function",
"of",
"(",
"rel",
"opt",
"cluster",
"cluster",
",",
"@",
"nullable",
"function",
"identifier",
"identifier",
",",
"function",
"definition",
"definition",
")",
"{",
"final",
"flink",
"context",
"context",
"=",
"shortcut",
"utils",
"unwrap",
"context",
"(",
"cluster",
")",
";",
"final",
"flink",
"type",
"factory",
"type",
"factory",
"=",
"shortcut",
"utils",
"unwrap",
"type",
"factory",
"(",
"cluster",
")",
";",
"return",
"of",
"(",
"context",
",",
"type",
"factory",
",",
"identifier",
",",
"definition",
")",
";",
"}"
]
|
[
"this",
"telemetry",
"is",
"only",
"enabled",
"when",
"running",
"on",
"java",
"versions",
"newer",
"than",
"java",
"8"
]
| [
"public",
"static",
"boolean",
"enabled",
"(",
")",
"{",
"return",
"java",
"utils",
"get",
"current",
"java",
"runtime",
"version",
"number",
"(",
")",
"is",
"newer",
"than",
"(",
"java",
"specification",
"version",
"java",
"8",
")",
";",
"}"
]
|
[
"is",
"the",
"background",
"thread",
"running"
]
| [
"boolean",
"running",
"(",
")",
"{",
"return",
"running",
"get",
"(",
")",
";",
"}"
]
|
[
"get",
"property",
"class"
]
| [
"public",
"string",
"get",
"property",
"class",
"(",
")",
"{",
"return",
"property",
"class",
";",
"}"
]
|
[
"build",
"call",
"for",
"delete",
"user"
]
| [
"public",
"okhttp",
"3",
"call",
"delete",
"user",
"call",
"(",
"string",
"username",
",",
"final",
"api",
"callback",
"callback",
")",
"throws",
"api",
"exception",
"{",
"object",
"local",
"var",
"post",
"body",
"=",
"null",
";",
"/",
"/",
"create",
"path",
"and",
"map",
"variables",
"api",
"operation",
"api",
"operation",
"=",
"local",
"var",
"api",
"client",
"get",
"operation",
"lookup",
"map",
"(",
")",
"get",
"(",
"\"",
"delete",
"user",
"\"",
")",
";",
"if",
"(",
"api",
"operation",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"api",
"exception",
"(",
"\"",
"operation",
"not",
"found",
"in",
"oas",
"\"",
")",
";",
"}",
"operation",
"operation",
"=",
"api",
"operation",
"get",
"operation",
"(",
")",
";",
"string",
"local",
"var",
"path",
"=",
"api",
"operation",
"get",
"path",
"(",
")",
";",
"map",
"<",
"string",
",",
"object",
">",
"param",
"map",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"param",
"map",
"put",
"(",
"\"",
"username",
"\"",
",",
"username",
")",
";",
"list",
"<",
"pair",
">",
"local",
"var",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
"pair",
">",
"(",
")",
";",
"list",
"<",
"pair",
">",
"local",
"var",
"collection",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
"pair",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"header",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"cookie",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"object",
">",
"local",
"var",
"form",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"object",
">",
"(",
")",
";",
"local",
"var",
"path",
"=",
"local",
"var",
"api",
"client",
"fill",
"parameters",
"from",
"operation",
"(",
"operation",
",",
"param",
"map",
",",
"local",
"var",
"path",
",",
"local",
"var",
"query",
"params",
",",
"local",
"var",
"collection",
"query",
"params",
",",
"local",
"var",
"header",
"params",
",",
"local",
"var",
"cookie",
"params",
")",
";",
"final",
"string",
"[",
"]",
"local",
"var",
"accepts",
"=",
"{",
"}",
";",
"final",
"string",
"local",
"var",
"accept",
"=",
"local",
"var",
"api",
"client",
"select",
"header",
"accept",
"(",
"local",
"var",
"accepts",
")",
";",
"if",
"(",
"local",
"var",
"accept",
"!",
"=",
"null",
")",
"{",
"local",
"var",
"header",
"params",
"put",
"(",
"\"",
"accept",
"\"",
",",
"local",
"var",
"accept",
")",
";",
"}",
"final",
"string",
"[",
"]",
"local",
"var",
"content",
"types",
"=",
"{",
"}",
";",
"final",
"string",
"local",
"var",
"content",
"type",
"=",
"local",
"var",
"api",
"client",
"select",
"header",
"content",
"type",
"(",
"local",
"var",
"content",
"types",
")",
";",
"local",
"var",
"header",
"params",
"put",
"(",
"\"",
"content",
"-",
"type",
"\"",
",",
"local",
"var",
"content",
"type",
")",
";",
"string",
"[",
"]",
"local",
"var",
"auth",
"names",
"=",
"new",
"string",
"[",
"]",
"{",
"}",
";",
"return",
"local",
"var",
"api",
"client",
"build",
"call",
"(",
"local",
"var",
"path",
",",
"api",
"operation",
"get",
"method",
"(",
")",
",",
"local",
"var",
"query",
"params",
",",
"local",
"var",
"collection",
"query",
"params",
",",
"local",
"var",
"post",
"body",
",",
"local",
"var",
"header",
"params",
",",
"local",
"var",
"cookie",
"params",
",",
"local",
"var",
"form",
"params",
",",
"local",
"var",
"auth",
"names",
",",
"callback",
")",
";",
"}"
]
|
[
"constructs",
"an",
"error",
"message",
"for",
"license",
"incompatibility"
]
| [
"public",
"static",
"string",
"build",
"error",
"message",
"(",
"final",
"string",
"feature",
",",
"final",
"remote",
"cluster",
"license",
"info",
"remote",
"cluster",
"license",
"info",
",",
"final",
"predicate",
"<",
"x",
"pack",
"info",
"response",
"license",
"info",
">",
"predicate",
")",
"{",
"final",
"string",
"builder",
"error",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"if",
"(",
"remote",
"cluster",
"license",
"info",
"license",
"info",
"(",
")",
"get",
"status",
"(",
")",
"!",
"=",
"license",
"status",
"active",
")",
"{",
"error",
"append",
"(",
"string",
"format",
"(",
"locale",
"root",
",",
"\"",
"the",
"license",
"on",
"cluster",
"[",
"%",
"s",
"]",
"is",
"not",
"active",
"\"",
",",
"remote",
"cluster",
"license",
"info",
"cluster",
"alias",
"(",
")",
")",
")",
";",
"}",
"else",
"{",
"assert",
"predicate",
"test",
"(",
"remote",
"cluster",
"license",
"info",
"license",
"info",
"(",
")",
")",
"=",
"=",
"false",
":",
"\"",
"license",
"must",
"be",
"incompatible",
"to",
"build",
"error",
"message",
"\"",
";",
"final",
"string",
"message",
"=",
"string",
"format",
"(",
"locale",
"root",
",",
"\"",
"the",
"license",
"mode",
"[",
"%",
"s",
"]",
"on",
"cluster",
"[",
"%",
"s",
"]",
"does",
"not",
"enable",
"[",
"%",
"s",
"]",
"\"",
",",
"license",
"operation",
"mode",
"parse",
"(",
"remote",
"cluster",
"license",
"info",
"license",
"info",
"(",
")",
"get",
"mode",
"(",
")",
")",
",",
"remote",
"cluster",
"license",
"info",
"cluster",
"alias",
"(",
")",
",",
"feature",
")",
";",
"error",
"append",
"(",
"message",
")",
";",
"}",
"return",
"error",
"to",
"string",
"(",
")",
";",
"}"
]
|
[
"{",
"@",
"inherit",
"doc",
"}"
]
| [
"public",
"int",
"execute",
"update",
"(",
"string",
"sql",
")",
"throws",
"s",
"q",
"l",
"exception",
"{",
"check",
"closed",
"(",
")",
";",
"return",
"0",
";",
"}"
]
|
[
"get",
"prefix",
"integer"
]
| [
"public",
"integer",
"get",
"prefix",
"integer",
"(",
")",
"{",
"return",
"prefix",
"integer",
";",
"}"
]
|
[
"a",
"notify",
"method",
"to",
"take",
"the",
"listens",
"to",
"notify",
",",
"along",
"with",
"the",
"method",
"that",
"should",
"be",
"called",
"on",
"each",
"listener"
]
| [
"protected",
"<",
"t",
">",
"void",
"notify",
"(",
"list",
"<",
"t",
">",
"listeners",
",",
"consumer",
"<",
"t",
">",
"method",
")",
"{",
"swing",
"(",
"(",
")",
"-",
">",
"{",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"listeners",
"size",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"t",
"listener",
"=",
"listeners",
"get",
"(",
"i",
")",
";",
"method",
"accept",
"(",
"listener",
")",
";",
"}",
"}",
")",
";",
"}"
]
|
[
"adds",
"machine",
"learning",
"job",
"(",
"s",
")",
"to",
"a",
"calendar",
",",
"notifies",
"listener",
"when",
"completed",
"for",
"additional",
"info",
"see",
"<",
"a",
"href",
"=",
"\"",
"https",
":",
"www",
"elastic",
"coguideenelasticsearchreferencecurrentml",
"-",
"put",
"-",
"calendar",
"-",
"job",
"html",
"\"",
">",
"ml",
"put",
"calendar",
"job",
"documentation"
]
| [
"public",
"cancellable",
"put",
"calendar",
"job",
"async",
"(",
"put",
"calendar",
"job",
"request",
"request",
",",
"request",
"options",
"options",
",",
"action",
"listener",
"<",
"put",
"calendar",
"response",
">",
"listener",
")",
"{",
"return",
"rest",
"high",
"level",
"client",
"perform",
"request",
"async",
"and",
"parse",
"entity",
"(",
"request",
",",
"m",
"l",
"request",
"converters",
":",
":",
"put",
"calendar",
"job",
",",
"options",
",",
"put",
"calendar",
"response",
":",
":",
"from",
"x",
"content",
",",
"listener",
",",
"collections",
"empty",
"set",
"(",
")",
")",
";",
"}"
]
|
[
"merging",
"the",
"\"",
"field",
"names",
"\"",
"enabled",
"setting",
"is",
"forbidden",
"in",
"8",
"0",
",",
"but",
"we",
"still",
"want",
"to",
"tests",
"the",
"behavior",
"on",
"pre",
"-",
"8",
"indices"
]
| [
"public",
"void",
"test",
"merging",
"mappings",
"before",
"8",
"(",
")",
"throws",
"exception",
"{",
"mapper",
"service",
"mapper",
"service",
"=",
"create",
"mapper",
"service",
"(",
"version",
"utils",
"random",
"previous",
"compatible",
"version",
"(",
"random",
"(",
")",
",",
"version",
"v",
"8",
"0",
"0",
")",
",",
"mapping",
"(",
"b",
"-",
">",
"{",
"}",
")",
")",
";",
"merge",
"(",
"mapper",
"service",
",",
"top",
"mapping",
"(",
"b",
"-",
">",
"b",
"start",
"object",
"(",
"\"",
"field",
"names",
"\"",
")",
"field",
"(",
"\"",
"enabled",
"\"",
",",
"false",
")",
"end",
"object",
"(",
")",
")",
")",
";",
"assert",
"false",
"(",
"mapper",
"service",
"document",
"mapper",
"(",
")",
"metadata",
"mapper",
"(",
"field",
"names",
"field",
"mapper",
"class",
")",
"field",
"type",
"(",
")",
"is",
"enabled",
"(",
")",
")",
";",
"assert",
"warnings",
"(",
"field",
"names",
"field",
"mapper",
"enabled",
"deprecation",
"message",
")",
";",
"merge",
"(",
"mapper",
"service",
",",
"top",
"mapping",
"(",
"b",
"-",
">",
"b",
"start",
"object",
"(",
"\"",
"field",
"names",
"\"",
")",
"field",
"(",
"\"",
"enabled",
"\"",
",",
"true",
")",
"end",
"object",
"(",
")",
")",
")",
";",
"assert",
"true",
"(",
"mapper",
"service",
"document",
"mapper",
"(",
")",
"metadata",
"mapper",
"(",
"field",
"names",
"field",
"mapper",
"class",
")",
"field",
"type",
"(",
")",
"is",
"enabled",
"(",
")",
")",
";",
"assert",
"warnings",
"(",
"field",
"names",
"field",
"mapper",
"enabled",
"deprecation",
"message",
")",
";",
"}"
]
|
[
"split",
"a",
"range",
"record",
"and",
"all",
"related",
"map",
"entries",
"at",
"a",
"new",
"end",
"index",
"a",
"new",
"range",
"record",
"is",
"created",
"at",
"new",
"end",
"+",
"1",
"to",
"the",
"end",
"of",
"the",
"original",
"range",
"new",
"map",
"entries",
"are",
"created",
"for",
"this",
"new",
"range"
]
| [
"private",
"d",
"b",
"record",
"split",
"range",
"(",
"d",
"b",
"record",
"range",
"record",
",",
"long",
"new",
"end",
")",
"throws",
"i",
"o",
"exception",
"{",
"/",
"/",
"split",
"range",
"record",
"d",
"b",
"record",
"new",
"range",
"=",
"ranges",
"schema",
"create",
"record",
"(",
"new",
"end",
"+",
"1",
")",
";",
"new",
"range",
"set",
"field",
"(",
"range",
"to",
"col",
",",
"range",
"record",
"get",
"field",
"value",
"(",
"range",
"to",
"col",
")",
")",
";",
"range",
"record",
"set",
"long",
"value",
"(",
"range",
"to",
"col",
",",
"new",
"end",
")",
";",
"range",
"table",
"put",
"record",
"(",
"range",
"record",
")",
";",
"range",
"table",
"put",
"record",
"(",
"new",
"range",
")",
";",
"/",
"/",
"split",
"related",
"map",
"records",
"field",
"[",
"]",
"map",
"keys",
"=",
"map",
"table",
"find",
"records",
"(",
"range",
"record",
"get",
"key",
"field",
"(",
")",
",",
"map",
"range",
"key",
"col",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"map",
"keys",
"length",
";",
"i",
"+",
"+",
")",
"{",
"d",
"b",
"record",
"map",
"rec",
"=",
"map",
"table",
"get",
"record",
"(",
"map",
"keys",
"[",
"i",
"]",
")",
";",
"map",
"rec",
"set",
"key",
"(",
"map",
"table",
"get",
"max",
"key",
"(",
")",
"+",
"1",
")",
";",
"map",
"rec",
"set",
"field",
"(",
"map",
"range",
"key",
"col",
",",
"new",
"range",
"get",
"key",
"field",
"(",
")",
")",
";",
"map",
"table",
"put",
"record",
"(",
"map",
"rec",
")",
";",
"}",
"return",
"new",
"range",
";",
"}"
]
|
[
"test",
"if",
"a",
"i",
"node",
"file",
"under",
"construction",
"with",
"block",
"info",
"striped",
"can",
"be",
"saved",
"and",
"loaded",
"by",
"f",
"s",
"image",
"serialization"
]
| [
"public",
"void",
"test",
"save",
"and",
"load",
"striped",
"i",
"node",
"file",
"u",
"c",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"/",
"/",
"construct",
"a",
"i",
"node",
"with",
"striped",
"block",
"for",
"saving",
"and",
"loading",
"configuration",
"conf",
"=",
"new",
"configuration",
"(",
")",
";",
"mini",
"d",
"f",
"s",
"cluster",
"cluster",
"=",
"null",
";",
"try",
"{",
"cluster",
"=",
"new",
"mini",
"d",
"f",
"s",
"cluster",
"builder",
"(",
"conf",
")",
"build",
"(",
")",
";",
"cluster",
"wait",
"active",
"(",
")",
";",
"d",
"f",
"s",
"test",
"util",
"enable",
"all",
"e",
"c",
"policies",
"(",
"cluster",
"get",
"file",
"system",
"(",
")",
")",
";",
"test",
"save",
"and",
"load",
"striped",
"i",
"node",
"file",
"(",
"cluster",
"get",
"namesystem",
"(",
")",
",",
"conf",
",",
"true",
")",
";",
"}",
"finally",
"{",
"if",
"(",
"cluster",
"!",
"=",
"null",
")",
"{",
"cluster",
"shutdown",
"(",
")",
";",
"}",
"}",
"}"
]
|
[
"raising",
"error",
"in",
"a",
"thread",
"doesn",
"'",
"t",
"seem",
"to",
"fail",
"the",
"test",
"so",
"check",
"afterwards"
]
| [
"public",
"boolean",
"has",
"error",
"(",
")",
"{",
"return",
"error",
";",
"}"
]
|
[
"lists",
"all",
"blobs",
"in",
"the",
"container",
"that",
"match",
"the",
"specified",
"prefix"
]
| [
"map",
"<",
"string",
",",
"blob",
"metadata",
">",
"list",
"blobs",
"by",
"prefix",
"(",
"string",
"blob",
"name",
"prefix",
")",
"throws",
"i",
"o",
"exception",
";"
]
|
[
"route",
"to",
"a",
"built",
"router",
"function",
"if",
"the",
"given",
"path",
"prefix",
"pattern",
"applies",
"this",
"method",
"can",
"be",
"used",
"to",
"create",
"nested",
"routes",
",",
"where",
"a",
"group",
"of",
"routes",
"share",
"a",
"common",
"path",
"prefix",
"for",
"instance",
",",
"the",
"following",
"example",
"creates",
"a",
"nested",
"route",
"with",
"a",
"\"",
"user",
"\"",
"path",
"predicate",
",",
"so",
"that",
"get",
"requests",
"for",
"\"",
"user",
"\"",
"will",
"list",
"users",
",",
"and",
"post",
"request",
"for",
"\"",
"user",
"\"",
"will",
"create",
"a",
"new",
"user",
"<",
"pre",
"class",
"=",
"\"",
"code",
"\"",
">",
"router",
"function",
"&",
"lt",
";",
"server",
"response",
"&",
"gt",
";",
"nested",
"route",
"=",
"router",
"functions",
"route",
"(",
")",
"path",
"(",
"\"",
"user",
"\"",
",",
"builder",
"-",
">",
"builder",
"get",
"(",
"this",
":",
":",
"list",
"users",
")",
"post",
"(",
"this",
":",
":",
"create",
"user",
")",
")",
"build",
"(",
")",
";"
]
| [
"builder",
"path",
"(",
"string",
"pattern",
",",
"consumer",
"<",
"builder",
">",
"builder",
"consumer",
")",
";"
]
|
[
"it",
"writes",
"the",
"primitive",
"value",
"to",
"the",
"parquet",
"record",
"consumer"
]
| [
"private",
"void",
"write",
"primitive",
"(",
"final",
"object",
"value",
",",
"final",
"primitive",
"object",
"inspector",
"inspector",
")",
"{",
"if",
"(",
"value",
"=",
"=",
"null",
")",
"{",
"return",
";",
"}",
"switch",
"(",
"inspector",
"get",
"primitive",
"category",
"(",
")",
")",
"{",
"case",
"void",
":",
"return",
";",
"case",
"double",
":",
"record",
"consumer",
"add",
"double",
"(",
"(",
"(",
"double",
"object",
"inspector",
")",
"inspector",
")",
"get",
"(",
"value",
")",
")",
";",
"break",
";",
"case",
"boolean",
":",
"record",
"consumer",
"add",
"boolean",
"(",
"(",
"(",
"boolean",
"object",
"inspector",
")",
"inspector",
")",
"get",
"(",
"value",
")",
")",
";",
"break",
";",
"case",
"float",
":",
"record",
"consumer",
"add",
"float",
"(",
"(",
"(",
"float",
"object",
"inspector",
")",
"inspector",
")",
"get",
"(",
"value",
")",
")",
";",
"break",
";",
"case",
"byte",
":",
"record",
"consumer",
"add",
"integer",
"(",
"(",
"(",
"byte",
"object",
"inspector",
")",
"inspector",
")",
"get",
"(",
"value",
")",
")",
";",
"break",
";",
"case",
"int",
":",
"record",
"consumer",
"add",
"integer",
"(",
"(",
"(",
"int",
"object",
"inspector",
")",
"inspector",
")",
"get",
"(",
"value",
")",
")",
";",
"break",
";",
"case",
"long",
":",
"record",
"consumer",
"add",
"long",
"(",
"(",
"(",
"long",
"object",
"inspector",
")",
"inspector",
")",
"get",
"(",
"value",
")",
")",
";",
"break",
";",
"case",
"short",
":",
"record",
"consumer",
"add",
"integer",
"(",
"(",
"(",
"short",
"object",
"inspector",
")",
"inspector",
")",
"get",
"(",
"value",
")",
")",
";",
"break",
";",
"case",
"string",
":",
"string",
"v",
"=",
"(",
"(",
"string",
"object",
"inspector",
")",
"inspector",
")",
"get",
"primitive",
"java",
"object",
"(",
"value",
")",
";",
"record",
"consumer",
"add",
"binary",
"(",
"binary",
"from",
"string",
"(",
"v",
")",
")",
";",
"break",
";",
"case",
"char",
":",
"string",
"v",
"char",
"=",
"(",
"(",
"hive",
"char",
"object",
"inspector",
")",
"inspector",
")",
"get",
"primitive",
"java",
"object",
"(",
"value",
")",
"get",
"stripped",
"value",
"(",
")",
";",
"record",
"consumer",
"add",
"binary",
"(",
"binary",
"from",
"string",
"(",
"v",
"char",
")",
")",
";",
"break",
";",
"case",
"varchar",
":",
"string",
"v",
"varchar",
"=",
"(",
"(",
"hive",
"varchar",
"object",
"inspector",
")",
"inspector",
")",
"get",
"primitive",
"java",
"object",
"(",
"value",
")",
"get",
"value",
"(",
")",
";",
"record",
"consumer",
"add",
"binary",
"(",
"binary",
"from",
"string",
"(",
"v",
"varchar",
")",
")",
";",
"break",
";",
"case",
"binary",
":",
"byte",
"[",
"]",
"v",
"binary",
"=",
"(",
"(",
"binary",
"object",
"inspector",
")",
"inspector",
")",
"get",
"primitive",
"java",
"object",
"(",
"value",
")",
";",
"record",
"consumer",
"add",
"binary",
"(",
"binary",
"from",
"byte",
"array",
"(",
"v",
"binary",
")",
")",
";",
"break",
";",
"case",
"timestamp",
":",
"timestamp",
"ts",
"=",
"(",
"(",
"timestamp",
"object",
"inspector",
")",
"inspector",
")",
"get",
"primitive",
"java",
"object",
"(",
"value",
")",
";",
"record",
"consumer",
"add",
"binary",
"(",
"nano",
"time",
"utils",
"get",
"nano",
"time",
"(",
"ts",
",",
"false",
")",
"to",
"binary",
"(",
")",
")",
";",
"break",
";",
"case",
"decimal",
":",
"hive",
"decimal",
"v",
"decimal",
"=",
"(",
"(",
"hive",
"decimal",
")",
"inspector",
"get",
"primitive",
"java",
"object",
"(",
"value",
")",
")",
";",
"decimal",
"type",
"info",
"dec",
"type",
"info",
"=",
"(",
"decimal",
"type",
"info",
")",
"inspector",
"get",
"type",
"info",
"(",
")",
";",
"record",
"consumer",
"add",
"binary",
"(",
"decimal",
"to",
"binary",
"(",
"v",
"decimal",
",",
"dec",
"type",
"info",
")",
")",
";",
"break",
";",
"case",
"date",
":",
"date",
"v",
"date",
"=",
"(",
"(",
"date",
"object",
"inspector",
")",
"inspector",
")",
"get",
"primitive",
"java",
"object",
"(",
"value",
")",
";",
"record",
"consumer",
"add",
"integer",
"(",
"date",
"writable",
"date",
"to",
"days",
"(",
"v",
"date",
")",
")",
";",
"break",
";",
"default",
":",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"unsupported",
"primitive",
"data",
"type",
":",
"\"",
"+",
"inspector",
"get",
"primitive",
"category",
"(",
")",
")",
";",
"}",
"}"
]
|
[
"returns",
"an",
"iterator",
"for",
"the",
"vertex",
"set",
"of",
"this",
"graph"
]
| [
"public",
"graph",
"iterator",
"<",
"vertex",
">",
"vertex",
"iterator",
"(",
")",
"{",
"return",
"vertices",
"iterator",
"(",
")",
";",
"}",
"/",
"/"
]
|
[
"to",
"test",
"special",
"tags",
"to",
"test",
"special",
"tags",
"and",
"operation",
"id",
"starting",
"with",
"number"
]
| [
"public",
"void",
"call",
"1",
"2",
"3test",
"special",
"tags",
"test",
"(",
")",
"{",
"client",
"body",
"=",
"null",
";",
"/",
"/",
"client",
"response",
"=",
"api",
"call",
"1",
"2",
"3test",
"special",
"tags",
"(",
"body",
")",
";",
"/",
"/",
"assert",
"not",
"null",
"(",
"response",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
]
|
[
"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",
"\"",
")",
";",
"}"
]
|
[
"checks",
"that",
"from",
"index",
"and",
"to",
"index",
"are",
"in",
"range",
",",
"and",
"throws",
"an",
"appropriate",
"exception",
"if",
"they",
"aren",
"'",
"t"
]
| [
"private",
"static",
"void",
"range",
"check",
"(",
"int",
"array",
"len",
",",
"int",
"from",
"index",
",",
"int",
"to",
"index",
")",
"{",
"if",
"(",
"from",
"index",
">",
"to",
"index",
")",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"from",
"index",
"(",
"\"",
"+",
"from",
"index",
"+",
"\"",
")",
">",
"to",
"index",
"(",
"\"",
"+",
"to",
"index",
"+",
"\"",
")",
"\"",
")",
";",
"if",
"(",
"from",
"index",
"<",
"0",
")",
"throw",
"new",
"array",
"index",
"out",
"of",
"bounds",
"exception",
"(",
"from",
"index",
")",
";",
"if",
"(",
"to",
"index",
">",
"array",
"len",
")",
"throw",
"new",
"array",
"index",
"out",
"of",
"bounds",
"exception",
"(",
"to",
"index",
")",
";",
"}"
]
|
[
"decrease",
"resource",
"usage",
"for",
"this",
"queue",
"and",
"all",
"parent",
"queues"
]
| [
"protected",
"void",
"dec",
"used",
"resource",
"(",
"resource",
"res",
")",
"{",
"synchronized",
"(",
"resource",
"usage",
")",
"{",
"resources",
"subtract",
"from",
"(",
"resource",
"usage",
",",
"res",
")",
";",
"if",
"(",
"parent",
"!",
"=",
"null",
")",
"{",
"parent",
"dec",
"used",
"resource",
"(",
"res",
")",
";",
"}",
"}",
"}"
]
|
[
"called",
"when",
"a",
"custom",
"action",
"provided",
"by",
"this",
"provider",
"is",
"sent",
"to",
"the",
"media",
"session"
]
| [
"void",
"on",
"custom",
"action",
"(",
"player",
"player",
",",
"control",
"dispatcher",
"control",
"dispatcher",
",",
"string",
"action",
",",
"@",
"nullable",
"bundle",
"extras",
")",
";"
]
|
[
"uploads",
"an",
"image",
"(",
"required",
")"
]
| [
"public",
"model",
"api",
"response",
"upload",
"file",
"with",
"required",
"file",
"(",
"long",
"pet",
"id",
",",
"attachment",
"required",
"file",
"detail",
",",
"string",
"additional",
"metadata",
")",
"{",
"/",
"/",
"todo",
":",
"implement",
"return",
"null",
";",
"}"
]
|
[
"sets",
"a",
"factory",
"to",
"create",
"{",
"@",
"link",
"resolved",
"addresses",
"}",
"for",
"child",
"load",
"balancer"
]
| [
"builder",
"set",
"resolved",
"addresses",
"factory",
"(",
"resolved",
"address",
"factory",
"resolved",
"address",
"factory",
")",
"{",
"this",
"resolved",
"address",
"factory",
"=",
"check",
"not",
"null",
"(",
"resolved",
"address",
"factory",
",",
"\"",
"resolved",
"address",
"factory",
"\"",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
]
| [
"private",
"string",
"to",
"indented",
"string",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
]
|
[
"gets",
"current",
"theme"
]
| [
"protected",
"string",
"get",
"current",
"theme",
"(",
")",
"{",
"return",
"theme",
"utils",
"get",
"current",
"theme",
"(",
"cas",
"properties",
")",
";",
"}"
]
|
[
"returns",
"the",
"extension",
"encoder",
"filter"
]
| [
"protected",
"web",
"socket",
"extension",
"filter",
"extension",
"encoder",
"filter",
"(",
")",
"{",
"return",
"extension",
"encoder",
"filter",
";",
"}"
]
|
[
"if",
"an",
"application",
"is",
"submitted",
"without",
"any",
"priority",
",",
"and",
"submitted",
"user",
"has",
"a",
"default",
"priority",
",",
"this",
"method",
"helps",
"to",
"update",
"this",
"default",
"priority",
"as",
"app",
"'",
"s",
"priority"
]
| [
"public",
"priority",
"get",
"default",
"priority",
"(",
"string",
"queue",
"name",
",",
"user",
"group",
"information",
"user",
")",
"{",
"if",
"(",
"!",
"is",
"a",
"c",
"ls",
"enable",
")",
"{",
"return",
"null",
";",
"}",
"list",
"<",
"priority",
"a",
"c",
"l",
">",
"acls",
"=",
"all",
"acls",
"get",
"(",
"queue",
"name",
")",
";",
"if",
"(",
"acls",
"=",
"=",
"null",
"|",
"|",
"acls",
"is",
"empty",
"(",
")",
")",
"{",
"return",
"null",
";",
"}",
"priority",
"a",
"c",
"l",
"approved",
"priority",
"a",
"c",
"l",
"=",
"get",
"mapped",
"priority",
"acl",
"for",
"u",
"g",
"i",
"(",
"acls",
",",
"user",
",",
"null",
")",
";",
"if",
"(",
"approved",
"priority",
"a",
"c",
"l",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"priority",
"default",
"priority",
"=",
"priority",
"new",
"instance",
"(",
"approved",
"priority",
"a",
"c",
"l",
"get",
"default",
"priority",
"(",
")",
"get",
"priority",
"(",
")",
")",
";",
"return",
"default",
"priority",
";",
"}"
]
|
[
"flush",
"the",
"underlying",
"producer",
"to",
"ensure",
"that",
"all",
"pending",
"writes",
"have",
"been",
"sent"
]
| [
"public",
"void",
"flush",
"(",
")",
"{",
"producer",
"flush",
"(",
")",
";",
"}"
]
|
[
"test",
"the",
"property",
"'",
"map",
"'"
]
| [
"public",
"void",
"map",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"map",
"}"
]
|
[
"gets",
"the",
"state",
"backend",
"that",
"this",
"rocks",
"d",
"b",
"state",
"backend",
"uses",
"to",
"persist",
"its",
"bytes",
"to",
"this",
"rocks",
"d",
"b",
"state",
"backend",
"only",
"implements",
"the",
"rocks",
"d",
"b",
"specific",
"parts",
",",
"it",
"relies",
"on",
"the",
"'",
"checkpoint",
"backend",
"'",
"to",
"persist",
"the",
"checkpoint",
"and",
"savepoint",
"bytes",
"streams"
]
| [
"public",
"state",
"backend",
"get",
"checkpoint",
"backend",
"(",
")",
"{",
"return",
"checkpoint",
"stream",
"backend",
";",
"}"
]
|
[
"verifies",
"that",
"the",
"{",
"@",
"code",
"set",
"}",
"returned",
"by",
"{",
"@",
"code",
"out",
"edges",
"}",
"has",
"the",
"expected",
"mutability",
"property",
"(",
"see",
"the",
"{",
"@",
"code",
"network",
"}",
"documentation",
"for",
"more",
"information",
")"
]
| [
"public",
"abstract",
"void",
"out",
"edges",
"check",
"returned",
"set",
"mutability",
"(",
")",
";"
]
|
[
"report",
"that",
"the",
"task",
"encounted",
"a",
"fatal",
"error"
]
| [
"void",
"fatal",
"error",
"(",
"task",
"attempt",
"i",
"d",
"task",
"id",
",",
"string",
"message",
",",
"boolean",
"fast",
"fail",
")",
"throws",
"i",
"o",
"exception",
";"
]
|
[
"the",
"value",
"of",
"the",
"enumflag",
"<",
"code",
">",
"optional",
"uint",
"3",
"2",
"value",
"=",
"4",
";",
"<",
"code",
">"
]
| [
"public",
"boolean",
"has",
"value",
"(",
")",
"{",
"return",
"(",
"(",
"bit",
"field",
"0",
"&",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"8",
")",
"=",
"=",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"8",
")",
";",
"}"
]
|
[
"build",
"execution",
"slot",
"sharing",
"groups",
"for",
"all",
"vertices",
"in",
"the",
"topology",
"the",
"execution",
"slot",
"sharing",
"group",
"of",
"a",
"vertex",
"is",
"determined",
"in",
"order",
"below",
":",
"1",
"try",
"finding",
"an",
"existing",
"group",
"of",
"the",
"corresponding",
"co",
"-",
"location",
"constraint",
"2",
"try",
"finding",
"an",
"available",
"group",
"of",
"its",
"producer",
"vertex",
"if",
"the",
"producer",
"is",
"in",
"the",
"same",
"slot",
"sharing",
"group",
"3",
"try",
"finding",
"any",
"available",
"group",
"4",
"create",
"a",
"new",
"group"
]
| [
"private",
"map",
"<",
"execution",
"vertex",
"i",
"d",
",",
"execution",
"slot",
"sharing",
"group",
">",
"build",
"(",
")",
"{",
"final",
"linked",
"hash",
"map",
"<",
"job",
"vertex",
"i",
"d",
",",
"list",
"<",
"scheduling",
"execution",
"vertex",
">",
">",
"all",
"vertices",
"=",
"get",
"execution",
"vertices",
"(",
")",
";",
"/",
"/",
"loop",
"on",
"job",
"vertices",
"so",
"that",
"an",
"execution",
"vertex",
"will",
"not",
"be",
"added",
"into",
"a",
"group",
"/",
"/",
"if",
"that",
"group",
"better",
"fits",
"another",
"execution",
"vertex",
"for",
"(",
"list",
"<",
"scheduling",
"execution",
"vertex",
">",
"execution",
"vertices",
":",
"all",
"vertices",
"values",
"(",
")",
")",
"{",
"final",
"list",
"<",
"scheduling",
"execution",
"vertex",
">",
"remaining",
"=",
"try",
"find",
"optimal",
"available",
"execution",
"slot",
"sharing",
"group",
"for",
"(",
"execution",
"vertices",
")",
";",
"find",
"available",
"or",
"create",
"new",
"execution",
"slot",
"sharing",
"group",
"for",
"(",
"remaining",
")",
";",
"update",
"constraint",
"to",
"execution",
"slot",
"sharing",
"group",
"map",
"(",
"execution",
"vertices",
")",
";",
"}",
"return",
"execution",
"slot",
"sharing",
"group",
"map",
";",
"}"
]
|
[
"draws",
"a",
"rectangle",
"outline",
"starting",
"at",
"x",
",",
"y",
"extending",
"by",
"width",
"to",
"the",
"right",
"and",
"by",
"height",
"downwards",
"(",
"y",
"-",
"axis",
"points",
"downwards",
")",
"using",
"the",
"current",
"color"
]
| [
"public",
"void",
"draw",
"rectangle",
"(",
"int",
"x",
",",
"int",
"y",
",",
"int",
"width",
",",
"int",
"height",
")",
"{",
"pixmap",
"draw",
"rect",
"(",
"x",
",",
"y",
",",
"width",
",",
"height",
",",
"color",
")",
";",
"}"
]
|
[
"returns",
"whether",
"the",
"instruction",
"is",
"a",
"category",
"2",
"instruction",
"this",
"means",
"that",
"it",
"operates",
"on",
"long",
"or",
"double",
"arguments"
]
| [
"public",
"boolean",
"is",
"category",
"2",
"(",
")",
"{",
"return",
"is",
"category2",
"[",
"opcode",
"&",
"0xff",
"]",
";",
"}"
]
|
[
"model",
"tests",
"for",
"file",
"schema",
"test",
"class"
]
| [
"public",
"void",
"test",
"file",
"schema",
"test",
"class",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"file",
"schema",
"test",
"class",
"}"
]
|
[
"when",
"partial",
"message",
"support",
"is",
"available",
"and",
"requested",
"via",
"{",
"@",
"link",
"org",
"springframework",
"web",
"socket",
"web",
"socket",
"handler",
"#",
"supports",
"partial",
"messages",
"(",
")",
"}",
",",
"this",
"method",
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"the",
"current",
"message",
"is",
"the",
"last",
"part",
"of",
"the",
"complete",
"web",
"socket",
"message",
"sent",
"by",
"the",
"client",
"otherwise",
"{",
"@",
"code",
"false",
"}",
"is",
"returned",
"if",
"partial",
"message",
"support",
"is",
"either",
"not",
"available",
"or",
"not",
"enabled"
]
| [
"boolean",
"is",
"last",
"(",
")",
";"
]
|
[
"returns",
"whether",
"collection",
"within",
"the",
"provided",
"<",
"code",
">",
"reader",
"<",
"code",
">",
"can",
"be",
"early",
"-",
"terminated",
"if",
"it",
"sorts",
"with",
"<",
"code",
">",
"sort",
"and",
"formats",
"<",
"code",
">"
]
| [
"private",
"static",
"boolean",
"can",
"early",
"terminate",
"(",
"index",
"reader",
"reader",
",",
"sort",
"and",
"formats",
"sort",
"and",
"formats",
")",
"{",
"if",
"(",
"sort",
"and",
"formats",
"=",
"=",
"null",
"|",
"|",
"sort",
"and",
"formats",
"sort",
"=",
"=",
"null",
")",
"{",
"return",
"false",
";",
"}",
"final",
"sort",
"sort",
"=",
"sort",
"and",
"formats",
"sort",
";",
"for",
"(",
"leaf",
"reader",
"context",
"ctx",
":",
"reader",
"leaves",
"(",
")",
")",
"{",
"sort",
"index",
"sort",
"=",
"ctx",
"reader",
"(",
")",
"get",
"meta",
"data",
"(",
")",
"get",
"sort",
"(",
")",
";",
"if",
"(",
"index",
"sort",
"=",
"=",
"null",
"|",
"|",
"lucene",
"can",
"early",
"terminate",
"(",
"sort",
",",
"index",
"sort",
")",
"=",
"=",
"false",
")",
"{",
"return",
"false",
";",
"}",
"}",
"return",
"true",
";",
"}"
]
|
[
"transports",
"with",
"no",
"native",
"cross",
"-",
"domain",
"communication",
"(",
"e",
"g",
"\"",
"eventsource",
"\"",
",",
"\"",
"htmlfile",
"\"",
")",
"must",
"get",
"a",
"simple",
"page",
"from",
"the",
"\"",
"foreign",
"\"",
"domain",
"in",
"an",
"invisible",
"iframe",
"so",
"that",
"code",
"in",
"the",
"iframe",
"can",
"run",
"from",
"a",
"domain",
"local",
"to",
"the",
"sock",
"j",
"s",
"server",
"since",
"the",
"iframe",
"needs",
"to",
"load",
"the",
"sock",
"j",
"s",
"javascript",
"client",
"library",
",",
"this",
"property",
"allows",
"specifying",
"where",
"to",
"load",
"it",
"from",
"by",
"default",
"this",
"is",
"set",
"to",
"point",
"to",
"\"",
"https",
":",
"cdn",
"jsdelivr",
"netsockjs",
"0",
"3",
"4sockjs",
"min",
"js",
"\"",
"however",
"it",
"can",
"also",
"be",
"set",
"to",
"point",
"to",
"a",
"url",
"served",
"by",
"the",
"application",
"note",
"that",
"it",
"'",
"s",
"possible",
"to",
"specify",
"a",
"relative",
"url",
"in",
"which",
"case",
"the",
"url",
"must",
"be",
"relative",
"to",
"the",
"iframe",
"url",
"for",
"example",
"assuming",
"a",
"sock",
"j",
"s",
"endpoint",
"mapped",
"to",
"\"",
"sockjs",
"\"",
",",
"and",
"resulting",
"iframe",
"url",
"\"",
"sockjsiframe",
"html",
"\"",
",",
"then",
"the",
"the",
"relative",
"url",
"must",
"start",
"with",
"\"",
"\"",
"to",
"traverse",
"up",
"to",
"the",
"location",
"above",
"the",
"sock",
"j",
"s",
"mapping",
"in",
"case",
"of",
"a",
"prefix",
"-",
"based",
"servlet",
"mapping",
"one",
"more",
"traversal",
"may",
"be",
"needed"
]
| [
"public",
"sock",
"js",
"service",
"registration",
"set",
"client",
"library",
"url",
"(",
"string",
"client",
"library",
"url",
")",
"{",
"this",
"client",
"library",
"url",
"=",
"client",
"library",
"url",
";",
"return",
"this",
";",
"}"
]
|
[
"set",
"the",
"value",
"of",
"the",
"'",
"{",
"@",
"code",
"onmouseover",
"}",
"'",
"attribute",
"may",
"be",
"a",
"runtime",
"expression"
]
| [
"public",
"void",
"set",
"onmouseover",
"(",
"string",
"onmouseover",
")",
"{",
"this",
"onmouseover",
"=",
"onmouseover",
";",
"}"
]
|
[
"does",
"resource",
"exist",
"?"
]
| [
"public",
"static",
"boolean",
"does",
"resource",
"exist",
"(",
"final",
"string",
"resource",
",",
"final",
"resource",
"loader",
"resource",
"loader",
")",
"{",
"try",
"{",
"if",
"(",
"string",
"utils",
"is",
"not",
"blank",
"(",
"resource",
")",
")",
"{",
"val",
"res",
"=",
"resource",
"loader",
"get",
"resource",
"(",
"resource",
")",
";",
"return",
"does",
"resource",
"exist",
"(",
"res",
")",
";",
"}",
"}",
"catch",
"(",
"final",
"exception",
"e",
")",
"{",
"logging",
"utils",
"warn",
"(",
"logger",
",",
"e",
")",
";",
"}",
"return",
"false",
";",
"}"
]
|
[
"registers",
"{",
"@",
"code",
"type",
"}",
"identified",
"by",
"its",
"{",
"@",
"link",
"class",
"#",
"get",
"simple",
"name",
"simple",
"name",
"}",
"labels",
"are",
"case",
"sensitive"
]
| [
"public",
"runtime",
"type",
"adapter",
"factory",
"<",
"t",
">",
"register",
"subtype",
"(",
"class",
"<",
"?",
"extends",
"t",
">",
"type",
")",
"{",
"return",
"register",
"subtype",
"(",
"type",
",",
"type",
"get",
"simple",
"name",
"(",
")",
")",
";",
"}"
]
|
[
"summary",
"of",
"emit",
"queues",
"that",
"can",
"be",
"used",
"for",
"logging"
]
| [
"public",
"string",
"print",
"info",
"(",
")",
"{",
"string",
"buffer",
"sb",
"=",
"new",
"string",
"buffer",
"(",
")",
";",
"sb",
"append",
"(",
"string",
"format",
"(",
"\"",
"queues",
":",
"%",
"d",
",",
"empty",
":",
"%",
"d",
"\"",
",",
"queues",
"size",
"(",
")",
",",
"empty",
"queues",
"size",
"(",
")",
")",
")",
";",
"for",
"(",
"map",
"entry",
"<",
"integer",
",",
"async",
"record",
"queue",
"<",
"t",
">",
">",
"e",
":",
"queues",
"entry",
"set",
"(",
")",
")",
"{",
"async",
"record",
"queue",
"q",
"=",
"e",
"get",
"value",
"(",
")",
";",
"sb",
"append",
"(",
"string",
"format",
"(",
"\"",
"\\",
"n",
"%",
"d",
"timestamp",
":",
"%",
"s",
"size",
":",
"%",
"d",
"\"",
",",
"e",
"get",
"value",
"(",
")",
"queue",
"id",
",",
"q",
"head",
"timestamp",
",",
"q",
"queue",
"size",
"(",
")",
")",
")",
";",
"}",
"return",
"sb",
"to",
"string",
"(",
")",
";",
"}"
]
|
[
"returns",
"the",
"class",
"path",
"currently",
"represented",
"in",
"this",
"panel"
]
| [
"public",
"class",
"path",
"get",
"class",
"path",
"(",
")",
"{",
"int",
"size",
"=",
"list",
"model",
"size",
"(",
")",
";",
"if",
"(",
"size",
"=",
"=",
"0",
")",
"{",
"return",
"null",
";",
"}",
"class",
"path",
"class",
"path",
"=",
"new",
"class",
"path",
"(",
")",
";",
"for",
"(",
"int",
"index",
"=",
"0",
";",
"index",
"<",
"size",
";",
"index",
"+",
"+",
")",
"{",
"class",
"path",
"add",
"(",
"(",
"class",
"path",
"entry",
")",
"list",
"model",
"get",
"(",
"index",
")",
")",
";",
"}",
"return",
"class",
"path",
";",
"}"
]
|
[
"allow",
"all",
"files",
"for",
"legacy",
"compatibility",
"all",
"uses",
"of",
"this",
"method",
"should",
"be",
"audited",
"and",
"then",
"removed",
"in",
"some",
"cases",
",",
"it",
"'",
"s",
"correct",
"to",
"allow",
"any",
"file",
",",
"but",
"mostly",
"the",
"set",
"of",
"files",
"should",
"be",
"restricted",
"to",
"a",
"reasonable",
"set"
]
| [
"public",
"builder",
"<",
"type",
">",
"legacy",
"allow",
"any",
"file",
"type",
"(",
")",
"{",
"return",
"allowed",
"file",
"types",
"(",
"file",
"type",
"set",
"any",
"file",
")",
";",
"}"
]
|
[
"this",
"test",
"shows",
"that",
"we",
"do",
"not",
"load",
"the",
"geo",
"-",
"ip",
"databases",
"on",
"non",
"-",
"ingest",
"nodes",
",",
"and",
"only",
"load",
"on",
"ingest",
"nodes",
"on",
"first",
"use"
]
| [
"public",
"void",
"test",
"lazy",
"loading",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"assume",
"false",
"(",
"\"",
"https",
":",
"/",
"/",
"github",
"com",
"/",
"elastic",
"/",
"elasticsearch",
"/",
"issues",
"/",
"37342",
"\"",
",",
"constants",
"windows",
")",
";",
"final",
"bytes",
"reference",
"bytes",
";",
"try",
"(",
"x",
"content",
"builder",
"builder",
"=",
"json",
"x",
"content",
"content",
"builder",
"(",
")",
")",
"{",
"builder",
"start",
"object",
"(",
")",
";",
"{",
"builder",
"field",
"(",
"\"",
"description",
"\"",
",",
"\"",
"test",
"\"",
")",
";",
"builder",
"start",
"array",
"(",
"\"",
"processors",
"\"",
")",
";",
"{",
"builder",
"start",
"object",
"(",
")",
";",
"{",
"builder",
"start",
"object",
"(",
"\"",
"geoip",
"\"",
")",
";",
"{",
"builder",
"field",
"(",
"\"",
"field",
"\"",
",",
"\"",
"ip",
"\"",
")",
";",
"builder",
"field",
"(",
"\"",
"target",
"field",
"\"",
",",
"\"",
"ip",
"-",
"city",
"\"",
")",
";",
"builder",
"field",
"(",
"\"",
"database",
"file",
"\"",
",",
"\"",
"geo",
"lite",
"2",
"-",
"city",
"mmdb",
"\"",
")",
";",
"}",
"builder",
"end",
"object",
"(",
")",
";",
"}",
"builder",
"end",
"object",
"(",
")",
";",
"builder",
"start",
"object",
"(",
")",
";",
"{",
"builder",
"start",
"object",
"(",
"\"",
"geoip",
"\"",
")",
";",
"{",
"builder",
"field",
"(",
"\"",
"field",
"\"",
",",
"\"",
"ip",
"\"",
")",
";",
"builder",
"field",
"(",
"\"",
"target",
"field",
"\"",
",",
"\"",
"ip",
"-",
"country",
"\"",
")",
";",
"builder",
"field",
"(",
"\"",
"database",
"file",
"\"",
",",
"\"",
"geo",
"lite",
"2",
"-",
"country",
"mmdb",
"\"",
")",
";",
"}",
"builder",
"end",
"object",
"(",
")",
";",
"}",
"builder",
"end",
"object",
"(",
")",
";",
"builder",
"start",
"object",
"(",
")",
";",
"{",
"builder",
"start",
"object",
"(",
"\"",
"geoip",
"\"",
")",
";",
"{",
"builder",
"field",
"(",
"\"",
"field",
"\"",
",",
"\"",
"ip",
"\"",
")",
";",
"builder",
"field",
"(",
"\"",
"target",
"field",
"\"",
",",
"\"",
"ip",
"-",
"asn",
"\"",
")",
";",
"builder",
"field",
"(",
"\"",
"database",
"file",
"\"",
",",
"\"",
"geo",
"lite",
"2",
"-",
"asn",
"mmdb",
"\"",
")",
";",
"}",
"builder",
"end",
"object",
"(",
")",
";",
"}",
"builder",
"end",
"object",
"(",
")",
";",
"}",
"builder",
"end",
"array",
"(",
")",
";",
"}",
"builder",
"end",
"object",
"(",
")",
";",
"bytes",
"=",
"bytes",
"reference",
"bytes",
"(",
"builder",
")",
";",
"}",
"assert",
"acked",
"(",
"client",
"(",
")",
"admin",
"(",
")",
"cluster",
"(",
")",
"put",
"pipeline",
"(",
"new",
"put",
"pipeline",
"request",
"(",
"\"",
"geoip",
"\"",
",",
"bytes",
",",
"x",
"content",
"type",
"json",
")",
")",
"action",
"get",
"(",
")",
")",
";",
"/",
"/",
"the",
"geo",
"-",
"ip",
"databases",
"should",
"not",
"be",
"loaded",
"on",
"any",
"nodes",
"as",
"they",
"are",
"all",
"non",
"-",
"ingest",
"nodes",
"arrays",
"stream",
"(",
"internal",
"cluster",
"(",
")",
"get",
"node",
"names",
"(",
")",
")",
"for",
"each",
"(",
"node",
"-",
">",
"assert",
"database",
"load",
"status",
"(",
"node",
",",
"false",
")",
")",
";",
"/",
"/",
"start",
"an",
"ingest",
"node",
"final",
"string",
"ingest",
"node",
"=",
"internal",
"cluster",
"(",
")",
"start",
"node",
"(",
"node",
"roles",
"ingest",
"node",
"(",
")",
")",
";",
"internal",
"cluster",
"(",
")",
"get",
"instance",
"(",
"ingest",
"service",
"class",
",",
"ingest",
"node",
")",
";",
"/",
"/",
"the",
"geo",
"-",
"ip",
"database",
"should",
"not",
"be",
"loaded",
"yet",
"as",
"we",
"have",
"no",
"indexed",
"any",
"documents",
"using",
"a",
"pipeline",
"that",
"has",
"a",
"geo",
"-",
"ip",
"processor",
"assert",
"database",
"load",
"status",
"(",
"ingest",
"node",
",",
"false",
")",
";",
"final",
"index",
"request",
"index",
"request",
"=",
"new",
"index",
"request",
"(",
"\"",
"index",
"\"",
")",
";",
"index",
"request",
"set",
"pipeline",
"(",
"\"",
"geoip",
"\"",
")",
";",
"index",
"request",
"source",
"(",
"collections",
"singleton",
"map",
"(",
"\"",
"ip",
"\"",
",",
"\"",
"1",
"1",
"1",
"1",
"\"",
")",
")",
";",
"final",
"index",
"response",
"index",
"response",
"=",
"client",
"(",
")",
"index",
"(",
"index",
"request",
")",
"action",
"get",
"(",
")",
";",
"assert",
"that",
"(",
"index",
"response",
"status",
"(",
")",
",",
"equal",
"to",
"(",
"rest",
"status",
"created",
")",
")",
";",
"/",
"/",
"now",
"the",
"geo",
"-",
"ip",
"database",
"should",
"be",
"loaded",
"on",
"the",
"ingest",
"node",
"assert",
"database",
"load",
"status",
"(",
"ingest",
"node",
",",
"true",
")",
";",
"/",
"/",
"the",
"geo",
"-",
"ip",
"database",
"should",
"still",
"not",
"be",
"loaded",
"on",
"the",
"non",
"-",
"ingest",
"nodes",
"arrays",
"stream",
"(",
"internal",
"cluster",
"(",
")",
"get",
"node",
"names",
"(",
")",
")",
"filter",
"(",
"node",
"-",
">",
"node",
"equals",
"(",
"ingest",
"node",
")",
"=",
"=",
"false",
")",
"for",
"each",
"(",
"node",
"-",
">",
"assert",
"database",
"load",
"status",
"(",
"node",
",",
"false",
")",
")",
";",
"}"
]
|
[
"returns",
"the",
"zero",
"-",
"relative",
"index",
"of",
"the",
"item",
"which",
"is",
"currently",
"at",
"the",
"top",
"of",
"the",
"receiver",
"this",
"index",
"can",
"change",
"when",
"items",
"are",
"scrolled",
"or",
"new",
"items",
"are",
"added",
"or",
"removed"
]
| [
"public",
"int",
"get",
"top",
"index",
"(",
")",
"{",
"if",
"(",
"top",
"index",
"!",
"=",
"-",
"1",
")",
"return",
"top",
"index",
";",
"if",
"(",
"!",
"v",
"scroll",
"get",
"visible",
"(",
")",
")",
"{",
"top",
"index",
"=",
"0",
";",
"}",
"else",
"{",
"/",
"/",
"figure",
"out",
"first",
"visible",
"row",
"and",
"last",
"visible",
"row",
"top",
"index",
"=",
"v",
"scroll",
"get",
"selection",
"(",
")",
";",
"}",
"return",
"top",
"index",
";",
"}"
]
|
[
"get",
"the",
"list",
"of",
"snapshottable",
"directories",
"that",
"are",
"owned",
"by",
"the",
"current",
"user",
"return",
"all",
"the",
"snapshottable",
"directories",
"if",
"the",
"current",
"user",
"is",
"a",
"super",
"user"
]
| [
"public",
"snapshottable",
"directory",
"status",
"[",
"]",
"get",
"snapshottable",
"dir",
"listing",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"statistics",
"increment",
"read",
"ops",
"(",
"1",
")",
";",
"storage",
"statistics",
"increment",
"op",
"counter",
"(",
"op",
"type",
"get",
"snapshottable",
"directory",
"list",
")",
";",
"return",
"dfs",
"get",
"snapshottable",
"dir",
"listing",
"(",
")",
";",
"}"
]
|
[
"create",
"a",
"server",
"-",
"sent",
"event",
"response",
"the",
"{",
"@",
"link",
"sse",
"builder",
"}",
"provided",
"to",
"{",
"@",
"code",
"consumer",
"}",
"can",
"be",
"used",
"to",
"build",
"and",
"send",
"events",
"for",
"example",
":",
"<",
"pre",
"class",
"=",
"\"",
"code",
"\"",
">",
"public",
"server",
"response",
"handle",
"sse",
"(",
"server",
"request",
"request",
")",
"{",
"return",
"server",
"response",
"sse",
"(",
"sse",
"-",
">",
"sse",
"send",
"(",
"\"",
"hello",
"world",
"!",
"\"",
")",
")",
";",
"}",
"or",
",",
"to",
"set",
"both",
"the",
"id",
"and",
"event",
"type",
":",
"<",
"pre",
"class",
"=",
"\"",
"code",
"\"",
">",
"public",
"server",
"response",
"handle",
"sse",
"(",
"server",
"request",
"request",
")",
"{",
"return",
"server",
"response",
"sse",
"(",
"sse",
"-",
">",
"sse",
"id",
"(",
"\"",
"42",
")",
"event",
"(",
"\"",
"event",
"\"",
")",
"send",
"(",
"\"",
"hello",
"world",
"!",
"\"",
")",
")",
";",
"}"
]
| [
"static",
"server",
"response",
"sse",
"(",
"consumer",
"<",
"sse",
"builder",
">",
"consumer",
",",
"duration",
"timeout",
")",
"{",
"return",
"sse",
"server",
"response",
"create",
"(",
"consumer",
",",
"timeout",
")",
";",
"}"
]
|
[
"get",
"user",
"by",
"user",
"name"
]
| [
"public",
"completable",
"future",
"<",
"api",
"response",
"<",
"user",
">",
">",
"get",
"user",
"by",
"name",
"with",
"http",
"info",
"(",
"string",
"username",
")",
"throws",
"api",
"exception",
"{",
"try",
"{",
"http",
"request",
"builder",
"local",
"var",
"request",
"builder",
"=",
"get",
"user",
"by",
"name",
"request",
"builder",
"(",
"username",
")",
";",
"return",
"member",
"var",
"http",
"client",
"send",
"async",
"(",
"local",
"var",
"request",
"builder",
"build",
"(",
")",
",",
"http",
"response",
"body",
"handlers",
"of",
"string",
"(",
")",
")",
"then",
"compose",
"async",
"(",
"local",
"var",
"response",
"-",
">",
"{",
"if",
"(",
"local",
"var",
"response",
"status",
"code",
"(",
")",
"/",
"100",
"!",
"=",
"2",
")",
"{",
"return",
"completable",
"future",
"failed",
"future",
"(",
"get",
"api",
"exception",
"(",
"\"",
"get",
"user",
"by",
"name",
"\"",
",",
"local",
"var",
"response",
")",
")",
";",
"}",
"try",
"{",
"return",
"completable",
"future",
"completed",
"future",
"(",
"new",
"api",
"response",
"<",
"user",
">",
"(",
"local",
"var",
"response",
"status",
"code",
"(",
")",
",",
"local",
"var",
"response",
"headers",
"(",
")",
"map",
"(",
")",
",",
"member",
"var",
"object",
"mapper",
"read",
"value",
"(",
"local",
"var",
"response",
"body",
"(",
")",
",",
"new",
"type",
"reference",
"<",
"user",
">",
"(",
")",
"{",
"}",
")",
")",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"return",
"completable",
"future",
"failed",
"future",
"(",
"new",
"api",
"exception",
"(",
"e",
")",
")",
";",
"}",
"}",
")",
";",
"}",
"catch",
"(",
"api",
"exception",
"e",
")",
"{",
"return",
"completable",
"future",
"failed",
"future",
"(",
"e",
")",
";",
"}",
"}"
]
|
[
"returns",
"a",
"range",
"that",
"contains",
"all",
"values",
"greater",
"than",
"or",
"equal",
"to",
"{",
"@",
"code",
"endpoint",
"}"
]
| [
"public",
"static",
"<",
"c",
"extends",
"comparable",
"<",
"?",
">",
">",
"range",
"<",
"c",
">",
"at",
"least",
"(",
"c",
"endpoint",
")",
"{",
"return",
"create",
"(",
"cut",
"below",
"value",
"(",
"endpoint",
")",
",",
"cut",
"<",
"c",
">",
"above",
"all",
"(",
")",
")",
";",
"}"
]
|
[
"compares",
"two",
"{",
"@",
"code",
"int",
"}",
"values",
"as",
"specified",
"by",
"{",
"@",
"link",
"ints",
"#",
"compare",
"}",
",",
"if",
"the",
"result",
"of",
"this",
"comparison",
"chain",
"has",
"not",
"already",
"been",
"determined"
]
| [
"public",
"abstract",
"comparison",
"chain",
"compare",
"(",
"int",
"left",
",",
"int",
"right",
")",
";"
]
|
[
"model",
"tests",
"for",
"type",
"holder",
"default"
]
| [
"public",
"void",
"test",
"type",
"holder",
"default",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"type",
"holder",
"default",
"}"
]
|
[
"get",
"the",
"maximum",
"triplets"
]
| [
"public",
"long",
"get",
"maximum",
"triplets",
"(",
")",
"{",
"return",
"maximum",
"triplets",
";",
"}"
]
|
[
"used",
"to",
"register",
"a",
"service",
"dynamically",
",",
"during",
"runtime",
",",
"instead",
"of",
"during",
"the",
"plugin",
"'",
"s",
"constructor"
]
| [
"protected",
"final",
"<",
"t",
">",
"void",
"register",
"dynamic",
"service",
"provided",
"(",
"class",
"<",
"?",
"super",
"t",
">",
"interface",
"class",
",",
"t",
"service",
")",
"{",
"do",
"register",
"service",
"provided",
"(",
"interface",
"class",
",",
"service",
",",
"true",
")",
";",
"}"
]
|
[
"compute",
"a",
"target",
"state",
"for",
"an",
"edge",
"in",
"the",
"dfa",
",",
"and",
"attempt",
"to",
"add",
"the",
"computed",
"state",
"and",
"corresponding",
"edge",
"to",
"the",
"dfa"
]
| [
"protected",
"d",
"f",
"a",
"state",
"compute",
"target",
"state",
"(",
"char",
"stream",
"input",
",",
"d",
"f",
"a",
"state",
"s",
",",
"int",
"t",
")",
"{",
"a",
"t",
"n",
"config",
"set",
"reach",
"=",
"new",
"ordered",
"a",
"t",
"n",
"config",
"set",
"(",
")",
";",
"/",
"/",
"if",
"we",
"don",
"'",
"t",
"find",
"an",
"existing",
"dfa",
"state",
"/",
"/",
"fill",
"reach",
"starting",
"from",
"closure",
",",
"following",
"t",
"transitions",
"get",
"reachable",
"config",
"set",
"(",
"input",
",",
"s",
"configs",
",",
"reach",
",",
"t",
")",
";",
"if",
"(",
"reach",
"is",
"empty",
"(",
")",
")",
"{",
"/",
"/",
"we",
"got",
"nowhere",
"on",
"t",
"from",
"s",
"if",
"(",
"!",
"reach",
"has",
"semantic",
"context",
")",
"{",
"/",
"/",
"we",
"got",
"nowhere",
"on",
"t",
",",
"don",
"'",
"t",
"throw",
"out",
"this",
"knowledge",
";",
"it",
"'",
"d",
"/",
"/",
"cause",
"a",
"failover",
"from",
"dfa",
"later",
"add",
"d",
"f",
"a",
"edge",
"(",
"s",
",",
"t",
",",
"error",
")",
";",
"}",
"/",
"/",
"stop",
"when",
"we",
"can",
"'",
"t",
"match",
"any",
"more",
"char",
"return",
"error",
";",
"}",
"/",
"/",
"add",
"an",
"edge",
"from",
"s",
"to",
"target",
"dfa",
"found",
"/",
"created",
"for",
"reach",
"return",
"add",
"d",
"f",
"a",
"edge",
"(",
"s",
",",
"t",
",",
"reach",
")",
";",
"}"
]
|
[
"java",
"io",
"thinks",
"that",
"a",
"read",
"at",
"eof",
"is",
"an",
"error",
"and",
"should",
"return",
"-",
"1",
",",
"contrary",
"to",
"traditional",
"unix",
"practice",
"where",
"you",
"'",
"d",
"read",
"until",
"you",
"got",
"0",
"bytes",
"(",
"and",
"any",
"future",
"read",
"would",
"return",
"-",
"1",
")"
]
| [
"public",
"static",
"int",
"read",
"(",
"file",
"descriptor",
"fd",
",",
"byte",
"[",
"]",
"bytes",
",",
"int",
"byte",
"offset",
",",
"int",
"byte",
"count",
")",
"throws",
"i",
"o",
"exception",
"{",
"array",
"utils",
"check",
"offset",
"and",
"count",
"(",
"bytes",
"length",
",",
"byte",
"offset",
",",
"byte",
"count",
")",
";",
"if",
"(",
"byte",
"count",
"=",
"=",
"0",
")",
"{",
"return",
"0",
";",
"}",
"try",
"{",
"int",
"read",
"count",
"=",
"os",
"read",
"(",
"fd",
",",
"bytes",
",",
"byte",
"offset",
",",
"byte",
"count",
")",
";",
"if",
"(",
"read",
"count",
"=",
"=",
"0",
")",
"{",
"return",
"-",
"1",
";",
"}",
"return",
"read",
"count",
";",
"}",
"catch",
"(",
"errno",
"exception",
"errno",
"exception",
")",
"{",
"if",
"(",
"errno",
"exception",
"errno",
"=",
"=",
"os",
"constants",
"eagain",
")",
"{",
"/",
"/",
"we",
"return",
"0",
"rather",
"than",
"throw",
"if",
"we",
"try",
"to",
"read",
"from",
"an",
"empty",
"non",
"-",
"blocking",
"pipe",
"return",
"0",
";",
"}",
"throw",
"new",
"i",
"o",
"exception",
"(",
"errno",
"exception",
")",
";",
"}",
"}"
]
|
[
"creates",
"an",
"empty",
"{",
"@",
"code",
"hash",
"based",
"table",
"}",
"with",
"the",
"specified",
"map",
"sizes"
]
| [
"public",
"static",
"<",
"r",
",",
"c",
",",
"v",
">",
"hash",
"based",
"table",
"<",
"r",
",",
"c",
",",
"v",
">",
"create",
"(",
"int",
"expected",
"rows",
",",
"int",
"expected",
"cells",
"per",
"row",
")",
"{",
"check",
"nonnegative",
"(",
"expected",
"cells",
"per",
"row",
",",
"\"",
"expected",
"cells",
"per",
"row",
"\"",
")",
";",
"map",
"<",
"r",
",",
"map",
"<",
"c",
",",
"v",
">",
">",
"backing",
"map",
"=",
"maps",
"new",
"linked",
"hash",
"map",
"with",
"expected",
"size",
"(",
"expected",
"rows",
")",
";",
"return",
"new",
"hash",
"based",
"table",
"<",
">",
"(",
"backing",
"map",
",",
"new",
"factory",
"<",
"c",
",",
"v",
">",
"(",
"expected",
"cells",
"per",
"row",
")",
")",
";",
"}"
]
|
[
"determine",
"how",
"many",
"leading",
"bytes",
"of",
"a",
"specified",
"page",
"region",
"is",
"marked",
"as",
"initialized",
"valid",
"page",
"region",
"defined",
"by",
"page",
"offset",
"and",
"size",
"is",
"assumed"
]
| [
"public",
"static",
"int",
"get",
"initialized",
"byte",
"count",
"(",
"byte",
"[",
"]",
"initialized",
"mask",
",",
"int",
"page",
"offset",
",",
"int",
"size",
")",
"{",
"if",
"(",
"initialized",
"mask",
"=",
"=",
"null",
")",
"{",
"return",
"size",
";",
"}",
"int",
"initialized",
"size",
"=",
"0",
";",
"int",
"mask",
"offset",
"=",
"page",
"offset",
"/",
"8",
";",
"int",
"first",
"bit",
"=",
"page",
"offset",
"%",
"8",
";",
"while",
"(",
"size",
">",
"0",
")",
"{",
"int",
"s",
"=",
"math",
"min",
"(",
"size",
",",
"8",
"-",
"first",
"bit",
")",
";",
"/",
"/",
"number",
"of",
"bytes",
"represented",
"by",
"mask",
"size",
"-",
"=",
"s",
";",
"int",
"mask",
"=",
"(",
"0xff",
"<",
"<",
"first",
"bit",
")",
"&",
"(",
"(",
"1",
"<",
"<",
"(",
"first",
"bit",
"+",
"s",
")",
")",
"-",
"1",
")",
";",
"int",
"result",
"=",
"initialized",
"mask",
"[",
"mask",
"offset",
"]",
"&",
"mask",
";",
"if",
"(",
"result",
"!",
"=",
"mask",
")",
"{",
"/",
"/",
"count",
"leading",
"bits",
"for",
"(",
"result",
">",
">",
"=",
"first",
"bit",
";",
"(",
"result",
"&",
"1",
")",
"!",
"=",
"0",
";",
"result",
">",
">",
"=",
"1",
")",
"{",
"+",
"+",
"initialized",
"size",
";",
"}",
"return",
"initialized",
"size",
";",
"}",
"initialized",
"size",
"+",
"=",
"s",
";",
"+",
"+",
"mask",
"offset",
";",
"first",
"bit",
"=",
"0",
";",
"}",
"return",
"initialized",
"size",
";",
"}"
]
|
[
"{",
"@",
"inherit",
"doc",
"}"
]
| [
"public",
"void",
"add",
"contents",
"(",
"dex",
"file",
"file",
")",
"{",
"if",
"(",
"!",
"static",
"fields",
"is",
"empty",
"(",
")",
")",
"{",
"get",
"static",
"values",
"constant",
"(",
")",
";",
"/",
"/",
"force",
"the",
"fields",
"to",
"be",
"sorted",
"for",
"(",
"encoded",
"field",
"field",
":",
"static",
"fields",
")",
"{",
"field",
"add",
"contents",
"(",
"file",
")",
";",
"}",
"}",
"if",
"(",
"!",
"instance",
"fields",
"is",
"empty",
"(",
")",
")",
"{",
"collections",
"sort",
"(",
"instance",
"fields",
")",
";",
"for",
"(",
"encoded",
"field",
"field",
":",
"instance",
"fields",
")",
"{",
"field",
"add",
"contents",
"(",
"file",
")",
";",
"}",
"}",
"if",
"(",
"!",
"direct",
"methods",
"is",
"empty",
"(",
")",
")",
"{",
"collections",
"sort",
"(",
"direct",
"methods",
")",
";",
"for",
"(",
"encoded",
"method",
"method",
":",
"direct",
"methods",
")",
"{",
"method",
"add",
"contents",
"(",
"file",
")",
";",
"}",
"}",
"if",
"(",
"!",
"virtual",
"methods",
"is",
"empty",
"(",
")",
")",
"{",
"collections",
"sort",
"(",
"virtual",
"methods",
")",
";",
"for",
"(",
"encoded",
"method",
"method",
":",
"virtual",
"methods",
")",
"{",
"method",
"add",
"contents",
"(",
"file",
")",
";",
"}",
"}",
"}"
]
|
[
"returns",
"the",
"number",
"of",
"vertices",
"with",
"in",
"valence",
"zero"
]
| [
"public",
"int",
"num",
"sources",
"(",
")",
"{",
"return",
"this",
"vertices",
"(",
")",
"num",
"sources",
"(",
")",
";",
"}"
]
|
[
"return",
"the",
"bit",
"set",
"for",
"the",
"provided",
"sequence",
"number",
",",
"possibly",
"allocating",
"a",
"new",
"set",
"if",
"needed"
]
| [
"private",
"static",
"long",
"get",
"bit",
"set",
"key",
"(",
"final",
"long",
"seq",
"no",
")",
"{",
"return",
"seq",
"no",
"/",
"bit",
"set",
"size",
";",
"}"
]
|
[
"find",
"a",
"{",
"@",
"link",
"generic",
"converter",
"}",
"given",
"a",
"source",
"and",
"target",
"type",
"this",
"method",
"will",
"attempt",
"to",
"match",
"all",
"possible",
"converters",
"by",
"working",
"through",
"the",
"class",
"and",
"interface",
"hierarchy",
"of",
"the",
"types"
]
| [
"public",
"generic",
"converter",
"find",
"(",
"type",
"descriptor",
"source",
"type",
",",
"type",
"descriptor",
"target",
"type",
")",
"{",
"/",
"/",
"search",
"the",
"full",
"type",
"hierarchy",
"list",
"<",
"class",
"<",
"?",
">",
">",
"source",
"candidates",
"=",
"get",
"class",
"hierarchy",
"(",
"source",
"type",
"get",
"type",
"(",
")",
")",
";",
"list",
"<",
"class",
"<",
"?",
">",
">",
"target",
"candidates",
"=",
"get",
"class",
"hierarchy",
"(",
"target",
"type",
"get",
"type",
"(",
")",
")",
";",
"for",
"(",
"class",
"<",
"?",
">",
"source",
"candidate",
":",
"source",
"candidates",
")",
"{",
"for",
"(",
"class",
"<",
"?",
">",
"target",
"candidate",
":",
"target",
"candidates",
")",
"{",
"convertible",
"pair",
"convertible",
"pair",
"=",
"new",
"convertible",
"pair",
"(",
"source",
"candidate",
",",
"target",
"candidate",
")",
";",
"generic",
"converter",
"converter",
"=",
"get",
"registered",
"converter",
"(",
"source",
"type",
",",
"target",
"type",
",",
"convertible",
"pair",
")",
";",
"if",
"(",
"converter",
"!",
"=",
"null",
")",
"{",
"return",
"converter",
";",
"}",
"}",
"}",
"return",
"null",
";",
"}"
]
|
[
"helper",
"method",
"to",
"build",
"upstream",
"tls",
"context",
"for",
"above",
"tests",
"called",
"from",
"other",
"classes",
"as",
"well"
]
| [
"public",
"static",
"envoy",
"server",
"proto",
"data",
"upstream",
"tls",
"context",
"build",
"upstream",
"tls",
"context",
"from",
"filenames",
"(",
"@",
"nullable",
"string",
"private",
"key",
",",
"@",
"nullable",
"string",
"cert",
"chain",
",",
"@",
"nullable",
"string",
"trust",
"ca",
")",
"{",
"try",
"{",
"if",
"(",
"cert",
"chain",
"!",
"=",
"null",
")",
"{",
"cert",
"chain",
"=",
"get",
"temp",
"file",
"name",
"for",
"resources",
"file",
"(",
"cert",
"chain",
")",
";",
"}",
"if",
"(",
"private",
"key",
"!",
"=",
"null",
")",
"{",
"private",
"key",
"=",
"get",
"temp",
"file",
"name",
"for",
"resources",
"file",
"(",
"private",
"key",
")",
";",
"}",
"if",
"(",
"trust",
"ca",
"!",
"=",
"null",
")",
"{",
"trust",
"ca",
"=",
"get",
"temp",
"file",
"name",
"for",
"resources",
"file",
"(",
"trust",
"ca",
")",
";",
"}",
"}",
"catch",
"(",
"i",
"o",
"exception",
"ioe",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"ioe",
")",
";",
"}",
"return",
"build",
"upstream",
"tls",
"context",
"(",
"build",
"common",
"tls",
"context",
"from",
"filenames",
"(",
"private",
"key",
",",
"cert",
"chain",
",",
"trust",
"ca",
")",
")",
";",
"}"
]
|
[
"move",
"the",
"window",
"while",
"advancing",
"the",
"query",
"base"
]
| [
"private",
"void",
"rebase",
"window",
"(",
"int",
"next",
"stage",
",",
"action",
"listener",
"<",
"payload",
">",
"listener",
")",
"{",
"log",
"trace",
"(",
"\"",
"rebasing",
"window",
"\"",
")",
";",
"advance",
"(",
"next",
"stage",
",",
"listener",
")",
";",
"}"
]
|
[
"verify",
"that",
"on",
"a",
"partial",
"delete",
",",
"the",
"s",
"3",
"guard",
"tables",
"are",
"updated",
"with",
"deleted",
"items",
"and",
"only",
"them"
]
| [
"public",
"void",
"test",
"process",
"delete",
"failure",
"(",
")",
"throws",
"throwable",
"{",
"string",
"key",
"a",
"=",
"\"",
"/",
"a",
"/",
"\"",
";",
"string",
"key",
"a",
"b",
"=",
"\"",
"/",
"a",
"/",
"b",
"\"",
";",
"string",
"key",
"a",
"c",
"=",
"\"",
"/",
"a",
"/",
"c",
"\"",
";",
"path",
"path",
"a",
"=",
"qualify",
"key",
"(",
"key",
"a",
")",
";",
"path",
"path",
"a",
"b",
"=",
"qualify",
"key",
"(",
"key",
"a",
"b",
")",
";",
"path",
"path",
"a",
"c",
"=",
"qualify",
"key",
"(",
"key",
"a",
"c",
")",
";",
"list",
"<",
"string",
">",
"src",
"keys",
"=",
"lists",
"new",
"array",
"list",
"(",
"key",
"a",
",",
"key",
"a",
"b",
",",
"key",
"a",
"c",
")",
";",
"list",
"<",
"path",
">",
"src",
"=",
"lists",
"new",
"array",
"list",
"(",
"path",
"a",
",",
"path",
"a",
"b",
",",
"path",
"a",
"c",
")",
";",
"list",
"<",
"delete",
"objects",
"request",
"key",
"version",
">",
"key",
"list",
"=",
"to",
"delete",
"requests",
"(",
"src",
"keys",
")",
";",
"list",
"<",
"path",
">",
"delete",
"forbidden",
"=",
"lists",
"new",
"array",
"list",
"(",
"path",
"a",
"b",
")",
";",
"final",
"list",
"<",
"path",
">",
"delete",
"allowed",
"=",
"lists",
"new",
"array",
"list",
"(",
"path",
"a",
",",
"path",
"a",
"c",
")",
";",
"list",
"<",
"multi",
"object",
"delete",
"support",
"key",
"path",
">",
"forbidden",
"k",
"p",
"=",
"lists",
"new",
"array",
"list",
"(",
"new",
"multi",
"object",
"delete",
"support",
"key",
"path",
"(",
"key",
"a",
"b",
",",
"path",
"a",
"b",
",",
"true",
")",
")",
";",
"multi",
"object",
"delete",
"exception",
"ex",
"=",
"create",
"delete",
"exception",
"(",
"access",
"denied",
",",
"forbidden",
"k",
"p",
")",
";",
"operation",
"tracking",
"store",
"store",
"=",
"new",
"operation",
"tracking",
"store",
"(",
")",
";",
"store",
"context",
"store",
"context",
"=",
"s",
"3",
"a",
"test",
"utils",
"create",
"mock",
"store",
"context",
"(",
"true",
",",
"store",
",",
"context",
"accessors",
")",
";",
"multi",
"object",
"delete",
"support",
"delete",
"support",
"=",
"new",
"multi",
"object",
"delete",
"support",
"(",
"store",
"context",
",",
"null",
")",
";",
"list",
"<",
"path",
">",
"retained",
"markers",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"triple",
"<",
"list",
"<",
"path",
">",
",",
"list",
"<",
"path",
">",
",",
"list",
"<",
"pair",
"<",
"path",
",",
"i",
"o",
"exception",
">",
">",
">",
"triple",
"=",
"delete",
"support",
"process",
"delete",
"failure",
"(",
"ex",
",",
"key",
"list",
",",
"retained",
"markers",
")",
";",
"assertions",
"assert",
"that",
"(",
"triple",
"get",
"right",
"(",
")",
")",
"as",
"(",
"\"",
"failure",
"list",
"\"",
")",
"is",
"empty",
"(",
")",
";",
"list",
"<",
"path",
">",
"undeleted",
"=",
"triple",
"get",
"left",
"(",
")",
";",
"list",
"<",
"path",
">",
"deleted",
"=",
"triple",
"get",
"middle",
"(",
")",
";",
"assertions",
"assert",
"that",
"(",
"deleted",
")",
"as",
"(",
"\"",
"deleted",
"files",
"\"",
")",
"contains",
"all",
"(",
"delete",
"allowed",
")",
"does",
"not",
"contain",
"any",
"elements",
"of",
"(",
"delete",
"forbidden",
")",
";",
"assertions",
"assert",
"that",
"(",
"undeleted",
")",
"as",
"(",
"\"",
"undeleted",
"store",
"entries",
"\"",
")",
"contains",
"all",
"(",
"delete",
"forbidden",
")",
"does",
"not",
"contain",
"any",
"elements",
"of",
"(",
"delete",
"allowed",
")",
";",
"/",
"/",
"because",
"dir",
"marker",
"retention",
"is",
"on",
",",
"we",
"expect",
"at",
"least",
"one",
"retained",
"/",
"/",
"marker",
"assertions",
"assert",
"that",
"(",
"retained",
"markers",
")",
"as",
"(",
"\"",
"retained",
"markers",
"\"",
")",
"contains",
"exactly",
"(",
"path",
"a",
")",
";",
"assertions",
"assert",
"that",
"(",
"store",
"get",
"deleted",
"(",
")",
")",
"as",
"(",
"\"",
"list",
"of",
"tombstoned",
"records",
"\"",
")",
"does",
"not",
"contain",
"(",
"path",
"a",
")",
";",
"}"
]
|
[
"return",
"the",
"request",
"uri",
"for",
"the",
"given",
"request",
",",
"detecting",
"an",
"include",
"request",
"url",
"if",
"called",
"within",
"a",
"request",
"dispatcher",
"include",
"as",
"the",
"value",
"returned",
"by",
"{",
"@",
"code",
"request",
"get",
"request",
"u",
"r",
"i",
"(",
")",
"}",
"is",
"not",
"decoded",
"by",
"the",
"servlet",
"container",
",",
"this",
"method",
"will",
"decode",
"it",
"the",
"uri",
"that",
"the",
"web",
"container",
"resolves",
"should",
"be",
"correct",
",",
"but",
"some",
"containers",
"like",
"j",
"boss",
"jetty",
"incorrectly",
"include",
"\"",
";",
"\"",
"strings",
"like",
"\"",
";",
"jsessionid",
"\"",
"in",
"the",
"uri",
"this",
"method",
"cuts",
"off",
"such",
"incorrect",
"appendices"
]
| [
"public",
"string",
"get",
"request",
"uri",
"(",
"http",
"servlet",
"request",
"request",
")",
"{",
"string",
"uri",
"=",
"(",
"string",
")",
"request",
"get",
"attribute",
"(",
"web",
"utils",
"include",
"request",
"uri",
"attribute",
")",
";",
"if",
"(",
"uri",
"=",
"=",
"null",
")",
"{",
"uri",
"=",
"request",
"get",
"request",
"u",
"r",
"i",
"(",
")",
";",
"}",
"return",
"decode",
"and",
"clean",
"uri",
"string",
"(",
"request",
",",
"uri",
")",
";",
"}"
]
|
[
"set",
"the",
"environment",
"of",
"the",
"subprocess",
"to",
"be",
"the",
"configuration",
",",
"with",
"'",
"'",
"s",
"replaced",
"by",
"'",
"'",
"s"
]
| [
"private",
"void",
"set",
"conf",
"as",
"env",
"vars",
"(",
"map",
"<",
"string",
",",
"string",
">",
"env",
")",
"{",
"for",
"(",
"map",
"entry",
"<",
"string",
",",
"string",
">",
"pair",
":",
"get",
"conf",
"(",
")",
")",
"{",
"env",
"put",
"(",
"pair",
"get",
"key",
"(",
")",
"replace",
"(",
"'",
"'",
",",
"'",
"'",
")",
",",
"pair",
"get",
"value",
"(",
")",
")",
";",
"}",
"}"
]
|
[
"create",
"a",
"file",
"output",
"stream",
"using",
"{",
"@",
"link",
"file",
"output",
"stream",
"#",
"file",
"output",
"stream",
"(",
"file",
"descriptor",
")",
"}",
"wraps",
"the",
"created",
"output",
"stream",
"to",
"intercept",
"write",
"calls",
"before",
"delegating",
"to",
"the",
"wrapped",
"stream"
]
| [
"public",
"file",
"output",
"stream",
"get",
"file",
"output",
"stream",
"(",
"@",
"nullable",
"fs",
"volume",
"spi",
"volume",
",",
"file",
"descriptor",
"fd",
")",
"{",
"return",
"new",
"wrapped",
"file",
"output",
"stream",
"(",
"volume",
",",
"fd",
")",
";",
"}"
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.