docstring_tokens
list | code_tokens
list |
|---|---|
[
"reset",
"all",
"values",
"this",
"method",
"is",
"optional",
"and",
"can",
"be",
"noop",
",",
"depending",
"on",
"the",
"underlying",
"implementation"
]
| [
"void",
"reset",
"all",
"values",
"(",
")",
";"
]
|
[
"builds",
"and",
"returns",
"an",
"automaton",
"that",
"represents",
"the",
"given",
"pattern"
]
| [
"static",
"automaton",
"wildcard",
"(",
"string",
"text",
")",
"{",
"list",
"<",
"automaton",
">",
"automata",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"text",
"length",
"(",
")",
";",
")",
"{",
"final",
"char",
"c",
"=",
"text",
"char",
"at",
"(",
"i",
")",
";",
"int",
"length",
"=",
"1",
";",
"switch",
"(",
"c",
")",
"{",
"case",
"wildcard",
"string",
":",
"automata",
"add",
"(",
"automata",
"make",
"any",
"string",
"(",
")",
")",
";",
"break",
";",
"case",
"wildcard",
"char",
":",
"automata",
"add",
"(",
"automata",
"make",
"any",
"char",
"(",
")",
")",
";",
"break",
";",
"case",
"wildcard",
"escape",
":",
"/",
"/",
"add",
"the",
"next",
"codepoint",
"instead",
",",
"if",
"it",
"exists",
"if",
"(",
"i",
"+",
"length",
"<",
"text",
"length",
"(",
")",
")",
"{",
"final",
"char",
"next",
"char",
"=",
"text",
"char",
"at",
"(",
"i",
"+",
"length",
")",
";",
"length",
"+",
"=",
"1",
";",
"automata",
"add",
"(",
"automata",
"make",
"char",
"(",
"next",
"char",
")",
")",
";",
"break",
";",
"}",
"/",
"/",
"else",
"fallthru",
",",
"lenient",
"parsing",
"with",
"a",
"trailing",
"\\",
"default",
":",
"automata",
"add",
"(",
"automata",
"make",
"char",
"(",
"c",
")",
")",
";",
"}",
"i",
"+",
"=",
"length",
";",
"}",
"return",
"concatenate",
"(",
"automata",
")",
";",
"}"
]
|
[
"attempt",
"to",
"convert",
"a",
"typed",
"value",
"to",
"a",
"byte",
"using",
"the",
"supplied",
"type",
"converter"
]
| [
"public",
"static",
"byte",
"to",
"byte",
"(",
"type",
"converter",
"type",
"converter",
",",
"typed",
"value",
"typed",
"value",
")",
"{",
"return",
"convert",
"value",
"(",
"type",
"converter",
",",
"typed",
"value",
",",
"byte",
"class",
")",
";",
"}"
]
|
[
"patch",
"another",
"-",
"fakedummy",
":",
"to",
"test",
"special",
"tags",
"to",
"test",
"special",
"tags",
"and",
"operation",
"id",
"starting",
"with",
"number"
]
| [
"default",
"response",
"entity",
"<",
"client",
">",
"call",
"1",
"2",
"3test",
"special",
"tags",
"(",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"client",
"model",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"valid",
"@",
"request",
"body",
"client",
"body",
")",
"{",
"get",
"request",
"(",
")",
"if",
"present",
"(",
"request",
"-",
">",
"{",
"for",
"(",
"media",
"type",
"media",
"type",
":",
"media",
"type",
"parse",
"media",
"types",
"(",
"request",
"get",
"header",
"(",
"\"",
"accept",
"\"",
")",
")",
")",
"{",
"if",
"(",
"media",
"type",
"is",
"compatible",
"with",
"(",
"media",
"type",
"value",
"of",
"(",
"\"",
"application",
"/",
"json",
"\"",
")",
")",
")",
"{",
"string",
"example",
"string",
"=",
"\"",
"{",
"\\",
"\"",
"client",
"\\",
"\"",
":",
"\\",
"\"",
"client",
"\\",
"\"",
"}",
"\"",
";",
"api",
"util",
"set",
"example",
"response",
"(",
"request",
",",
"\"",
"application",
"/",
"json",
"\"",
",",
"example",
"string",
")",
";",
"break",
";",
"}",
"}",
"}",
")",
";",
"return",
"new",
"response",
"entity",
"<",
">",
"(",
"http",
"status",
"not",
"implemented",
")",
";",
"}"
]
|
[
"returns",
"this",
"value",
"as",
"a",
"double"
]
| [
"public",
"double",
"as",
"double",
"(",
")",
"{",
"switch",
"(",
"type",
")",
"{",
"case",
"string",
"value",
":",
"return",
"double",
"parse",
"double",
"(",
"string",
"value",
")",
";",
"case",
"double",
"value",
":",
"return",
"double",
"value",
";",
"case",
"long",
"value",
":",
"return",
"long",
"value",
";",
"case",
"boolean",
"value",
":",
"return",
"long",
"value",
"!",
"=",
"0",
"?",
"1",
":",
"0",
";",
"}",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"value",
"cannot",
"be",
"converted",
"to",
"double",
":",
"\"",
"+",
"type",
")",
";",
"}"
]
|
[
"if",
"enabled",
",",
"the",
"explanation",
"of",
"the",
"search",
"hit"
]
| [
"public",
"explanation",
"get",
"explanation",
"(",
")",
"{",
"return",
"explanation",
";",
"}"
]
|
[
"tests",
"that",
"we",
"never",
"get",
"an",
"optimal",
"hashes",
"number",
"of",
"zero"
]
| [
"public",
"void",
"test",
"optimal",
"hashes",
"(",
")",
"{",
"for",
"(",
"int",
"n",
"=",
"1",
";",
"n",
"<",
"1000",
";",
"n",
"+",
"+",
")",
"{",
"for",
"(",
"int",
"m",
"=",
"0",
";",
"m",
"<",
"1000",
";",
"m",
"+",
"+",
")",
"{",
"assert",
"true",
"(",
"bloom",
"filter",
"optimal",
"num",
"of",
"hash",
"functions",
"(",
"n",
",",
"m",
")",
">",
"0",
")",
";",
"}",
"}",
"}"
]
|
[
"serialize",
"the",
"actual",
"read",
"result",
"on",
"the",
"wire"
]
| [
"static",
"void",
"write",
"read",
"result",
"(",
"output",
"stream",
"out",
",",
"status",
"status",
"code",
")",
"throws",
"i",
"o",
"exception",
"{",
"client",
"read",
"status",
"proto",
"new",
"builder",
"(",
")",
"set",
"status",
"(",
"status",
"code",
")",
"build",
"(",
")",
"write",
"delimited",
"to",
"(",
"out",
")",
";",
"out",
"flush",
"(",
")",
";",
"}"
]
|
[
"sets",
"a",
"new",
"placeholder",
"drawable",
"with",
"scale",
"type"
]
| [
"public",
"void",
"set",
"placeholder",
"image",
"(",
"int",
"resource",
"id",
",",
"scaling",
"utils",
"scale",
"type",
"scale",
"type",
")",
"{",
"set",
"placeholder",
"image",
"(",
"m",
"resources",
"get",
"drawable",
"(",
"resource",
"id",
")",
",",
"scale",
"type",
")",
";",
"}"
]
|
[
"the",
"minimum",
"angle",
"slices",
"on",
"the",
"chart",
"are",
"rendered",
"with",
",",
"default",
"is",
"0f"
]
| [
"public",
"float",
"get",
"min",
"angle",
"for",
"slices",
"(",
")",
"{",
"return",
"m",
"min",
"angle",
"for",
"slices",
";",
"}"
]
|
[
"output",
"the",
"error",
"message",
"to",
"the",
"log",
"and",
"as",
"a",
"status",
"message",
"for",
"this",
"command"
]
| [
"protected",
"void",
"handle",
"error",
"(",
"string",
"message",
")",
"{",
"msg",
"error",
"(",
"this",
",",
"message",
")",
";",
"set",
"status",
"msg",
"(",
"message",
")",
";",
"}"
]
|
[
"if",
"this",
"hashcode",
"has",
"enough",
"bits",
",",
"returns",
"{",
"@",
"code",
"as",
"long",
"(",
")",
"}",
",",
"otherwise",
"returns",
"a",
"{",
"@",
"code",
"long",
"}",
"value",
"with",
"{",
"@",
"code",
"as",
"bytes",
"(",
")",
"}",
"as",
"the",
"least",
"-",
"significant",
"bytes",
"and",
"{",
"@",
"code",
"0x",
"0",
"0",
"}",
"as",
"the",
"remaining",
"most",
"-",
"significant",
"bytes"
]
| [
"public",
"abstract",
"long",
"pad",
"to",
"long",
"(",
")",
";"
]
|
[
"get",
"bundle",
"diff",
"dex",
"file"
]
| [
"public",
"list",
"<",
"file",
">",
"create",
"bundle",
"dex",
"patch",
"(",
"file",
"new",
"apk",
"unzip",
"folder",
",",
"file",
"base",
"apk",
"unzip",
"folder",
",",
"file",
"diff",
"dex",
"folder",
",",
"boolean",
"main",
"dex",
")",
"throws",
"exception",
"{",
"list",
"<",
"file",
">",
"dexs",
"=",
"lists",
"new",
"array",
"list",
"(",
")",
";",
"/",
"/",
"/",
"/",
"if",
"(",
"!",
"tmp",
"dex",
"file",
"exists",
"(",
")",
")",
"{",
"/",
"/",
"tmp",
"dex",
"file",
"mkdirs",
"(",
")",
";",
"/",
"/",
"}",
"list",
"<",
"file",
">",
"base",
"dex",
"files",
"=",
"get",
"folder",
"dex",
"files",
"(",
"base",
"apk",
"unzip",
"folder",
")",
";",
"list",
"<",
"file",
">",
"new",
"dex",
"files",
"=",
"get",
"folder",
"dex",
"files",
"(",
"new",
"apk",
"unzip",
"folder",
")",
";",
"patch",
"dex",
"tool",
"dex",
"tool",
"=",
"new",
"tpatch",
"dex",
"tool",
"(",
"base",
"dex",
"files",
",",
"new",
"dex",
"files",
",",
"default",
"api",
"level",
",",
"bundle",
"class",
"map",
"get",
"(",
"diff",
"dex",
"folder",
"get",
"name",
"(",
")",
")",
",",
"main",
"dex",
")",
";",
"dex",
"tool",
"set",
"new",
"patch",
"(",
"(",
"(",
"tpatch",
"input",
")",
"input",
")",
"new",
"patch",
")",
";",
"dex",
"diff",
"info",
"dex",
"diff",
"info",
"=",
"dex",
"tool",
"create",
"patch",
"dex",
"(",
"diff",
"dex",
"folder",
")",
";",
"if",
"(",
"diff",
"dex",
"folder",
"list",
"files",
"(",
")",
"!",
"=",
"null",
"&",
"&",
"diff",
"dex",
"folder",
"list",
"files",
"(",
")",
"length",
">",
"0",
")",
"{",
"dexs",
"add",
"all",
"(",
"file",
"utils",
"list",
"files",
"(",
"diff",
"dex",
"folder",
",",
"new",
"string",
"[",
"]",
"{",
"\"",
"dex",
"\"",
"}",
",",
"true",
")",
")",
";",
"bundle",
"diff",
"result",
"bundle",
"diff",
"result",
"=",
"new",
"bundle",
"diff",
"result",
"(",
")",
";",
"if",
"(",
"main",
"dex",
")",
"{",
"bundle",
"diff",
"result",
"set",
"bundle",
"name",
"(",
"\"",
"com",
"taobao",
"maindex",
"\"",
")",
";",
"}",
"else",
"{",
"bundle",
"diff",
"result",
"set",
"bundle",
"name",
"(",
"base",
"apk",
"unzip",
"folder",
"get",
"name",
"(",
")",
"substring",
"(",
"3",
")",
"replace",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
")",
";",
"}",
"bundle",
"diff",
"results",
"add",
"(",
"bundle",
"diff",
"result",
")",
";",
"diff",
"patch",
"infos",
"add",
"(",
"bundle",
"diff",
"result",
")",
";",
"dex",
"diff",
"info",
"save",
"(",
"bundle",
"diff",
"result",
")",
";",
"}",
"/",
"/",
"if",
"(",
"dexs",
"size",
"(",
")",
">",
"0",
")",
"{",
"/",
"/",
"/",
"/",
"file",
"utils",
"copy",
"file",
"(",
"dexs",
"get",
"(",
"0",
")",
",",
"dest",
"dex",
")",
";",
"/",
"/",
"}",
"/",
"/",
"/",
"/",
"file",
"utils",
"delete",
"directory",
"(",
"tmp",
"dex",
"file",
")",
";",
"/",
"/",
"if",
"(",
"main",
"dex",
")",
"{",
"/",
"/",
"try",
"{",
"/",
"/",
"/",
"/",
"bundle",
"infos",
"put",
"(",
"input",
"new",
"apk",
"bo",
"get",
"version",
"name",
"(",
")",
",",
"new",
"atlas",
"framework",
"properties",
"reader",
"(",
"/",
"/",
"new",
"method",
"reader",
"(",
"/",
"/",
"new",
"class",
"reader",
"(",
"/",
"/",
"new",
"dex",
"reader",
"(",
"dest",
"dex",
")",
")",
")",
",",
"null",
")",
"read",
"(",
"\"",
"landroid",
"/",
"taobao",
"/",
"atlas",
"/",
"framework",
"/",
"framework",
"properties",
";",
"\"",
",",
"\"",
"<",
"clinit",
">",
"\"",
")",
")",
";",
"/",
"/",
"bundle",
"infos",
"put",
"(",
"input",
"base",
"apk",
"bo",
"get",
"version",
"name",
"(",
")",
",",
"new",
"atlas",
"framework",
"properties",
"reader",
"(",
"/",
"/",
"new",
"method",
"reader",
"(",
"/",
"/",
"new",
"class",
"reader",
"(",
"/",
"/",
"new",
"dex",
"reader",
"(",
"base",
"dex",
"files",
")",
")",
")",
",",
"bundle",
"infos",
"get",
"(",
"input",
"new",
"apk",
"bo",
"get",
"version",
"name",
"(",
")",
")",
")",
"read",
"(",
"\"",
"landroid",
"/",
"taobao",
"/",
"atlas",
"/",
"framework",
"/",
"framework",
"properties",
";",
"\"",
",",
"\"",
"<",
"clinit",
">",
"\"",
")",
")",
";",
"/",
"/",
"}",
"catch",
"(",
"throwable",
"e",
")",
"{",
"/",
"/",
"e",
"print",
"stack",
"trace",
"(",
")",
";",
"/",
"/",
"}",
"/",
"/",
"/",
"/",
"}",
"return",
"dexs",
";",
"}"
]
|
[
"returns",
"the",
"single",
"instance",
"of",
"the",
"old",
"language",
"factory"
]
| [
"public",
"static",
"language",
"translator",
"factory",
"get",
"language",
"translator",
"factory",
"(",
")",
"{",
"if",
"(",
"language",
"translator",
"factory",
"=",
"=",
"null",
")",
"{",
"language",
"translator",
"factory",
"=",
"new",
"language",
"translator",
"factory",
"(",
")",
";",
"}",
"return",
"language",
"translator",
"factory",
";",
"}"
]
|
[
"build",
"call",
"for",
"logout",
"user"
]
| [
"public",
"okhttp",
"3",
"call",
"logout",
"user",
"call",
"(",
"final",
"api",
"callback",
"callback",
")",
"throws",
"api",
"exception",
"{",
"object",
"local",
"var",
"post",
"body",
"=",
"null",
";",
"/",
"/",
"create",
"path",
"and",
"map",
"variables",
"string",
"local",
"var",
"path",
"=",
"\"",
"/",
"user",
"/",
"logout",
"\"",
";",
"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",
">",
"(",
")",
";",
"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",
",",
"\"",
"get",
"\"",
",",
"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",
")",
";",
"}"
]
|
[
"get",
"the",
"data",
"types",
"in",
"this",
"group"
]
| [
"public",
"data",
"type",
"[",
"]",
"get",
"data",
"types",
"(",
")",
"{",
"data",
"type",
"[",
"]",
"dt",
"=",
"new",
"data",
"type",
"[",
"data",
"list",
"size",
"(",
")",
"]",
";",
"return",
"data",
"list",
"to",
"array",
"(",
"dt",
")",
";",
"}"
]
|
[
"if",
"the",
"provided",
"throwable",
"is",
"an",
"error",
"this",
"method",
"throws",
"it",
",",
"otherwise",
"returns",
"a",
"runtime",
"exception",
"wrapping",
"the",
"error",
"if",
"that",
"error",
"is",
"a",
"checked",
"exception"
]
| [
"public",
"static",
"runtime",
"exception",
"wrap",
"or",
"throw",
"(",
"throwable",
"error",
")",
"{",
"if",
"(",
"error",
"instanceof",
"error",
")",
"{",
"throw",
"(",
"error",
")",
"error",
";",
"}",
"if",
"(",
"error",
"instanceof",
"runtime",
"exception",
")",
"{",
"return",
"(",
"runtime",
"exception",
")",
"error",
";",
"}",
"return",
"new",
"runtime",
"exception",
"(",
"error",
")",
";",
"}"
]
|
[
"queues",
"execution",
"of",
"the",
"given",
"spawn",
"with",
"the",
"{",
"@",
"linkplain",
"spawn",
"strategy",
"registry",
"highest",
"priority",
"strategy",
"}",
"that",
"can",
"be",
"found",
"for",
"it"
]
| [
"public",
"spawn",
"continuation",
"begin",
"execution",
"(",
"spawn",
"spawn",
",",
"action",
"execution",
"context",
"action",
"execution",
"context",
")",
"throws",
"interrupted",
"exception",
"{",
"spawn",
"strategy",
"resolved",
"strategy",
";",
"try",
"{",
"resolved",
"strategy",
"=",
"resolve",
"one",
"(",
"spawn",
",",
"action",
"execution",
"context",
")",
";",
"}",
"catch",
"(",
"exec",
"exception",
"e",
")",
"{",
"return",
"spawn",
"continuation",
"failed",
"with",
"exec",
"exception",
"(",
"e",
")",
";",
"}",
"return",
"resolved",
"strategy",
"begin",
"execution",
"(",
"spawn",
",",
"action",
"execution",
"context",
")",
";",
"}"
]
|
[
"wait",
"for",
"a",
"namenode",
"to",
"be",
"registered",
"with",
"a",
"particular",
"state"
]
| [
"public",
"static",
"void",
"wait",
"namenode",
"registered",
"(",
"final",
"active",
"namenode",
"resolver",
"resolver",
",",
"final",
"string",
"ns",
"id",
",",
"final",
"string",
"nn",
"id",
",",
"final",
"federation",
"namenode",
"service",
"state",
"state",
")",
"throws",
"exception",
"{",
"generic",
"test",
"utils",
"wait",
"for",
"(",
"new",
"supplier",
"<",
"boolean",
">",
"(",
")",
"{",
"@",
"override",
"public",
"boolean",
"get",
"(",
")",
"{",
"try",
"{",
"list",
"<",
"?",
"extends",
"federation",
"namenode",
"context",
">",
"namenodes",
"=",
"resolver",
"get",
"namenodes",
"for",
"nameservice",
"id",
"(",
"ns",
"id",
")",
";",
"if",
"(",
"namenodes",
"!",
"=",
"null",
")",
"{",
"for",
"(",
"federation",
"namenode",
"context",
"namenode",
":",
"namenodes",
")",
"{",
"/",
"/",
"check",
"if",
"this",
"is",
"the",
"namenode",
"we",
"are",
"checking",
"if",
"(",
"namenode",
"get",
"namenode",
"id",
"(",
")",
"=",
"=",
"nn",
"id",
"|",
"|",
"namenode",
"get",
"namenode",
"id",
"(",
")",
"equals",
"(",
"nn",
"id",
")",
")",
"{",
"return",
"state",
"=",
"=",
"null",
"|",
"|",
"namenode",
"get",
"state",
"(",
")",
"equals",
"(",
"state",
")",
";",
"}",
"}",
"}",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"/",
"/",
"ignore",
"}",
"return",
"false",
";",
"}",
"}",
",",
"1000",
",",
"60",
"*",
"1000",
")",
";",
"}"
]
|
[
"map",
"the",
"route",
"for",
"http",
"delete",
"requests"
]
| [
"public",
"static",
"void",
"delete",
"(",
"string",
"path",
",",
"string",
"accept",
"type",
",",
"template",
"view",
"route",
"route",
",",
"template",
"engine",
"engine",
")",
"{",
"get",
"instance",
"(",
")",
"delete",
"(",
"path",
",",
"accept",
"type",
",",
"route",
",",
"engine",
")",
";",
"}"
]
|
[
"this",
"method",
"is",
"used",
"instead",
"of",
"put",
"by",
"constructors",
"and",
"pseudoconstructors",
"(",
"clone",
",",
"read",
"object",
")",
"it",
"does",
"not",
"resize",
"the",
"table",
",",
"check",
"for",
"comodification",
",",
"etc",
"it",
"calls",
"create",
"entry",
"rather",
"than",
"add",
"entry"
]
| [
"private",
"void",
"put",
"for",
"create",
"(",
"int",
"key",
",",
"value",
"value",
")",
"{",
"int",
"hash",
"=",
"hash",
"(",
"key",
")",
";",
"int",
"i",
"=",
"index",
"for",
"(",
"hash",
",",
"table",
"length",
")",
";"
]
|
[
"creates",
"a",
"builder",
"to",
"build",
"{",
"@",
"link",
"message",
"subscription",
"impl",
"}"
]
| [
"public",
"static",
"builder",
"builder",
"(",
")",
"{",
"return",
"new",
"builder",
"(",
")",
";",
"}"
]
|
[
"returns",
"an",
"iterator",
"for",
"the",
"keys",
"in",
"the",
"set",
"remove",
"is",
"supported",
"if",
"{",
"@",
"link",
"collections",
"#",
"allocate",
"iterators",
"}",
"is",
"false",
",",
"the",
"same",
"iterator",
"instance",
"is",
"returned",
"each",
"time",
"this",
"method",
"is",
"called",
"use",
"the",
"{",
"@",
"link",
"int",
"set",
"iterator",
"}",
"constructor",
"for",
"nested",
"or",
"multithreaded",
"iteration"
]
| [
"public",
"int",
"set",
"iterator",
"iterator",
"(",
")",
"{",
"if",
"(",
"collections",
"allocate",
"iterators",
")",
"return",
"new",
"int",
"set",
"iterator",
"(",
"this",
")",
";",
"if",
"(",
"iterator",
"1",
"=",
"=",
"null",
")",
"{",
"iterator",
"1",
"=",
"new",
"int",
"set",
"iterator",
"(",
"this",
")",
";",
"iterator",
"2",
"=",
"new",
"int",
"set",
"iterator",
"(",
"this",
")",
";",
"}",
"if",
"(",
"!",
"iterator",
"1",
"valid",
")",
"{",
"iterator",
"1",
"reset",
"(",
")",
";",
"iterator",
"1",
"valid",
"=",
"true",
";",
"iterator",
"2",
"valid",
"=",
"false",
";",
"return",
"iterator",
"1",
";",
"}",
"iterator",
"2",
"reset",
"(",
")",
";",
"iterator",
"2",
"valid",
"=",
"true",
";",
"iterator",
"1",
"valid",
"=",
"false",
";",
"return",
"iterator",
"2",
";",
"}"
]
|
[
"wrap",
"the",
"given",
"netty",
"{",
"@",
"link",
"byte",
"buf",
"}",
"in",
"a",
"{",
"@",
"code",
"netty",
"data",
"buffer",
"}"
]
| [
"public",
"netty",
"data",
"buffer",
"wrap",
"(",
"byte",
"buf",
"byte",
"buf",
")",
"{",
"byte",
"buf",
"touch",
"(",
")",
";",
"return",
"new",
"netty",
"data",
"buffer",
"(",
"byte",
"buf",
",",
"this",
")",
";",
"}"
]
|
[
"generate",
"a",
"new",
"id",
",",
"combined",
"by",
"three",
"parts",
"the",
"first",
"one",
"represents",
"application",
"instance",
"id",
"the",
"second",
"one",
"represents",
"thread",
"id",
"the",
"third",
"one",
"also",
"has",
"two",
"parts",
",",
"1",
")",
"a",
"timestamp",
",",
"measured",
"in",
"milliseconds",
"2",
")",
"a",
"seq",
",",
"in",
"current",
"thread",
",",
"between",
"0",
"(",
"included",
")",
"and",
"9999",
"(",
"included",
")"
]
| [
"public",
"static",
"string",
"generate",
"(",
")",
"{",
"return",
"string",
"util",
"join",
"(",
"'",
"'",
",",
"process",
"id",
",",
"string",
"value",
"of",
"(",
"thread",
"current",
"thread",
"(",
")",
"get",
"id",
"(",
")",
")",
",",
"string",
"value",
"of",
"(",
"thread",
"id",
"sequence",
"get",
"(",
")",
"next",
"seq",
"(",
")",
")",
")",
";",
"}"
]
|
[
"add",
"the",
"header",
"field",
"to",
"the",
"dynamic",
"table",
"entries",
"are",
"evicted",
"from",
"the",
"dynamic",
"table",
"until",
"the",
"size",
"of",
"the",
"table",
"and",
"the",
"new",
"header",
"field",
"is",
"less",
"than",
"or",
"equal",
"to",
"the",
"table",
"'",
"s",
"capacity",
"if",
"the",
"size",
"of",
"the",
"new",
"entry",
"is",
"larger",
"than",
"the",
"table",
"'",
"s",
"capacity",
",",
"the",
"dynamic",
"table",
"will",
"be",
"cleared"
]
| [
"public",
"void",
"add",
"(",
"hpack",
"header",
"field",
"header",
")",
"{",
"int",
"header",
"size",
"=",
"header",
"size",
"(",
")",
";",
"if",
"(",
"header",
"size",
">",
"capacity",
")",
"{",
"clear",
"(",
")",
";",
"return",
";",
"}",
"while",
"(",
"capacity",
"-",
"size",
"<",
"header",
"size",
")",
"{",
"remove",
"(",
")",
";",
"}",
"hpack",
"header",
"fields",
"[",
"head",
"+",
"+",
"]",
"=",
"header",
";",
"size",
"+",
"=",
"header",
"size",
";",
"if",
"(",
"head",
"=",
"=",
"hpack",
"header",
"fields",
"length",
")",
"{",
"head",
"=",
"0",
";",
"}",
"}"
]
|
[
"the",
"usage",
"of",
"capacity",
"table",
"for",
"counting",
"module",
"will",
"subtracte",
"one",
"whether",
"open",
"the",
"limination",
"check",
"of",
"capacity",
"management"
]
| [
"public",
"object",
"around",
"delete",
"config",
"(",
"proceeding",
"join",
"point",
"pjp",
",",
"http",
"servlet",
"request",
"request",
",",
"http",
"servlet",
"response",
"response",
",",
"string",
"data",
"id",
",",
"string",
"group",
",",
"string",
"tenant",
")",
"throws",
"throwable",
"{",
"if",
"(",
"!",
"property",
"util",
"is",
"manage",
"capacity",
"(",
")",
")",
"{",
"return",
"pjp",
"proceed",
"(",
")",
";",
"}",
"logger",
"info",
"(",
"\"",
"[",
"capacity",
"management",
"]",
"around",
"delete",
"config",
"\"",
")",
";",
"config",
"info",
"config",
"info",
"=",
"persist",
"service",
"find",
"config",
"info",
"(",
"data",
"id",
",",
"group",
",",
"tenant",
")",
";",
"if",
"(",
"config",
"info",
"=",
"=",
"null",
")",
"{",
"return",
"pjp",
"proceed",
"(",
")",
";",
"}",
"return",
"do",
"4",
"delete",
"(",
"pjp",
",",
"response",
",",
"group",
",",
"tenant",
",",
"config",
"info",
")",
";",
"}"
]
|
[
"creates",
"a",
"a",
"{",
"@",
"link",
"run",
"list",
"}",
"combining",
"all",
"the",
"runs",
"of",
"the",
"supplied",
"jobs"
]
| [
"public",
"static",
"<",
"j",
"extends",
"job",
"<",
"j",
",",
"r",
">",
",",
"r",
"extends",
"run",
"<",
"j",
",",
"r",
">",
">",
"run",
"list",
"<",
"r",
">",
"from",
"jobs",
"(",
"iterable",
"<",
"?",
"extends",
"j",
">",
"jobs",
")",
"{",
"list",
"<",
"iterable",
"<",
"r",
">",
">",
"run",
"lists",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"for",
"(",
"job",
"j",
":",
"jobs",
")",
"run",
"lists",
"add",
"(",
"j",
"get",
"builds",
"(",
")",
")",
";",
"return",
"new",
"run",
"list",
"<",
">",
"(",
"combine",
"(",
"run",
"lists",
")",
")",
";",
"}"
]
|
[
"rewrites",
"the",
"modifiers",
",",
"name",
"and",
"descriptor",
"of",
"a",
"declared",
"interface",
"static",
"method",
"for",
"example",
",",
"the",
"visitor",
"converts",
"<",
"code",
">",
"package",
"path",
"a",
"b",
";",
"interface",
"foo",
"{",
"private",
"static",
"x",
"execute",
"(",
"a",
"a",
")",
"{",
"}",
"}",
"<",
"code",
">",
"to",
"<",
"code",
">",
"package",
"path",
"a",
"b",
";",
"interface",
"foo",
"{",
"the",
"package",
"path",
"is",
"mangled",
"to",
"the",
"new",
"method",
"name",
"to",
"avoid",
"name",
"clashing",
"for",
"interfaces",
"with",
"inheritance",
"static",
"x",
"execute",
"(",
"a",
"a",
")",
"{",
"}",
"}",
"<",
"code",
">",
"note",
":",
"the",
"desugared",
"method",
"will",
"be",
"subsequently",
"moved",
"to",
"the",
"interface",
"'",
"s",
"companion",
"class",
"by",
"{",
"@",
"link",
"com",
"google",
"devtools",
"build",
"android",
"desugar",
"interface",
"desugaring",
"}"
]
| [
"public",
"method",
"visitor",
"visit",
"interface",
"static",
"method",
"(",
"method",
"decl",
"info",
"method",
"decl",
"info",
",",
"class",
"visitor",
"cv",
")",
"{",
"return",
"method",
"decl",
"info",
"substitute",
"of",
"interface",
"static",
"method",
"(",
")",
"accept",
"(",
"cv",
")",
";",
"}"
]
|
[
"should",
"this",
"request",
"trigger",
"a",
"refresh",
"(",
"{",
"@",
"linkplain",
"refresh",
"policy",
"#",
"immediate",
"}",
",",
"the",
"default",
")",
",",
"wait",
"for",
"a",
"refresh",
"(",
"{",
"@",
"linkplain",
"refresh",
"policy",
"#",
"wait",
"until",
"}",
")",
",",
"or",
"proceed",
"ignore",
"refreshes",
"entirely",
"(",
"{",
"@",
"linkplain",
"refresh",
"policy",
"#",
"none",
"}",
")"
]
| [
"public",
"refresh",
"policy",
"get",
"refresh",
"policy",
"(",
")",
"{",
"return",
"refresh",
"policy",
";",
"}"
]
|
[
"get",
"array",
"item"
]
| [
"public",
"list",
"<",
"integer",
">",
"get",
"array",
"item",
"(",
")",
"{",
"return",
"array",
"item",
";",
"}"
]
|
[
"generate",
"the",
"bean",
"name",
"that",
"is",
"used",
"within",
"the",
"scoped",
"proxy",
"to",
"reference",
"the",
"target",
"bean"
]
| [
"public",
"static",
"string",
"get",
"target",
"bean",
"name",
"(",
"string",
"original",
"bean",
"name",
")",
"{",
"return",
"target",
"name",
"prefix",
"+",
"original",
"bean",
"name",
";",
"}"
]
|
[
"copies",
"all",
"header",
"key",
",",
"value",
"pairs",
"into",
"the",
"current",
"context"
]
| [
"public",
"void",
"copy",
"headers",
"(",
"iterable",
"<",
"map",
"entry",
"<",
"string",
",",
"string",
">",
">",
"headers",
")",
"{",
"thread",
"local",
"set",
"(",
"thread",
"local",
"get",
"(",
")",
"copy",
"headers",
"(",
"headers",
")",
")",
";",
"}"
]
|
[
"10",
":",
"nfctx",
"#",
"3",
"(",
"start",
")",
"-",
"-",
"writes",
"no",
"-",
"flow",
"context",
"=",
"3",
"@",
"30",
"+",
"-",
"-",
"14",
":",
"br",
"22",
"|",
"|",
"20",
":",
"nop",
"<",
"-",
"+",
"+",
"-",
">",
"22",
":",
"breq",
"30",
"-",
"|",
"-",
"+",
"24",
":",
"br",
"20",
"-",
"-",
"+",
"|",
"|",
"30",
":",
"cop",
"3",
"<",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"+",
"32",
":",
"ret",
"limit",
"size",
":",
"4",
"instruction",
"set",
"order",
":",
"10",
",",
"14",
",",
"22",
",",
"2420",
",",
"(",
"22",
")",
",",
"(",
"24",
")",
",",
"(",
"30",
")",
"30",
",",
"32",
"(",
")",
"-",
"indicates",
"instructions",
"blocked",
"by",
"those",
"already",
"added",
"to",
"program",
"test",
"fragmented",
"disassembly",
"with",
"instruction",
"set",
"size",
"limit",
"of",
"4",
"and",
"flow",
"priority",
"given",
"to",
"code",
"blocks",
"already",
"added",
"to",
"program",
"flow",
"priority",
"is",
"needed",
"to",
"ensure",
"that",
"block",
"which",
"consumes",
"context",
"is",
"assured",
"of",
"being",
"added"
]
| [
"public",
"void",
"test",
"disassembler",
"flow",
"priority",
"(",
")",
"throws",
"exception",
"{",
"/",
"/",
"override",
"instruction",
"set",
"limit",
"disassembler",
"set",
"instruction",
"set",
"size",
"limit",
"(",
"4",
")",
";",
"program",
"builder",
"add",
"bytes",
"fallthrough",
"set",
"no",
"flow",
"context",
"(",
"10",
",",
"3",
",",
"30",
")",
";",
"program",
"builder",
"add",
"bytes",
"branch",
"(",
"14",
",",
"22",
")",
";",
"program",
"builder",
"add",
"bytes",
"fallthrough",
"(",
"20",
")",
";",
"program",
"builder",
"add",
"bytes",
"branch",
"conditional",
"(",
"22",
",",
"30",
")",
";",
"program",
"builder",
"add",
"bytes",
"branch",
"(",
"24",
",",
"20",
")",
";",
"program",
"builder",
"add",
"bytes",
"cop",
"instruction",
"(",
"30",
")",
";",
"program",
"builder",
"add",
"bytes",
"return",
"(",
"32",
")",
";",
"address",
"set",
"view",
"dis",
"addrs",
"=",
"disassembler",
"disassemble",
"(",
"addr",
"(",
"10",
")",
",",
"null",
")",
";",
"/",
"/",
"open",
"program",
"in",
"tool",
"(",
")",
";",
"assert",
"equals",
"(",
"addrset",
"(",
"range",
"(",
"10",
",",
"15",
")",
",",
"range",
"(",
"20",
",",
"25",
")",
",",
"range",
"(",
"30",
",",
"33",
")",
")",
",",
"dis",
"addrs",
")",
";",
"verify",
"context",
"ranges",
"(",
"30",
",",
"30",
",",
"\"",
"nfctx",
"\"",
",",
"new",
"context",
"range",
"value",
"(",
"30",
",",
"30",
",",
"3",
")",
")",
";",
"verify",
"instruction",
"presence",
"(",
")",
";",
"verify",
"no",
"bookmarks",
"(",
")",
";",
"}"
]
|
[
"return",
"the",
"{",
"@",
"link",
"timer",
"}",
"registered",
"under",
"this",
"name",
";",
"or",
"create",
"and",
"register",
"a",
"new",
"{",
"@",
"link",
"timer",
"}",
"if",
"none",
"is",
"registered"
]
| [
"public",
"timer",
"timer",
"(",
"string",
"name",
")",
"{",
"return",
"get",
"or",
"add",
"(",
"name",
",",
"metric",
"builder",
"timers",
")",
";",
"}"
]
|
[
"test",
"the",
"property",
"'",
"float",
"'"
]
| [
"public",
"void",
"float",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"float",
"}"
]
|
[
"the",
"image",
"won",
"'",
"t",
"be",
"kept",
"in",
"-",
"memory",
"during",
"packing",
"if",
"{",
"@",
"link",
"settings",
"#",
"limit",
"memory",
"}",
"is",
"true"
]
| [
"public",
"rect",
"add",
"image",
"(",
"file",
"file",
",",
"string",
"root",
"path",
")",
"{",
"buffered",
"image",
"image",
";",
"try",
"{",
"image",
"=",
"image",
"i",
"o",
"read",
"(",
"file",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"ex",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"error",
"reading",
"image",
":",
"\"",
"+",
"file",
",",
"ex",
")",
";",
"}",
"if",
"(",
"image",
"=",
"=",
"null",
")",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"unable",
"to",
"read",
"image",
":",
"\"",
"+",
"file",
")",
";",
"string",
"name",
";",
"try",
"{",
"name",
"=",
"file",
"get",
"canonical",
"path",
"(",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"ex",
")",
"{",
"name",
"=",
"file",
"get",
"absolute",
"path",
"(",
")",
";",
"}",
"name",
"=",
"name",
"replace",
"(",
"'",
"\\",
"\\",
"'",
",",
"'",
"/",
"'",
")",
";",
"/",
"/",
"strip",
"root",
"dir",
"off",
"front",
"of",
"image",
"path",
"if",
"(",
"root",
"path",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"!",
"name",
"starts",
"with",
"(",
"root",
"path",
")",
")",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"path",
"'",
"\"",
"+",
"name",
"+",
"\"",
"'",
"does",
"not",
"start",
"with",
"root",
":",
"\"",
"+",
"root",
"path",
")",
";",
"name",
"=",
"name",
"substring",
"(",
"root",
"path",
"length",
"(",
")",
")",
";",
"}",
"/",
"/",
"strip",
"extension",
"int",
"dot",
"index",
"=",
"name",
"last",
"index",
"of",
"(",
"'",
"'",
")",
";",
"if",
"(",
"dot",
"index",
"!",
"=",
"-",
"1",
")",
"name",
"=",
"name",
"substring",
"(",
"0",
",",
"dot",
"index",
")",
";",
"rect",
"rect",
"=",
"add",
"image",
"(",
"image",
",",
"name",
")",
";",
"if",
"(",
"rect",
"!",
"=",
"null",
"&",
"&",
"settings",
"limit",
"memory",
")",
"rect",
"unload",
"image",
"(",
"file",
")",
";",
"return",
"rect",
";",
"}"
]
|
[
"create",
"a",
"chain",
"with",
"isolated",
"end",
"vertices"
]
| [
"public",
"void",
"create",
"chain",
"(",
"float",
"[",
"]",
"vertices",
")",
"{",
"jni",
"create",
"chain",
"(",
"addr",
",",
"vertices",
",",
"0",
",",
"vertices",
"length",
"/",
"2",
")",
";",
"is",
"looped",
"=",
"false",
";",
"}"
]
|
[
"in",
"federation",
",",
"the",
"heart",
"beat",
"request",
"needs",
"to",
"be",
"sent",
"to",
"all",
"the",
"sub",
"clusters",
"from",
"which",
"the",
"am",
"has",
"requested",
"containers",
"this",
"method",
"splits",
"the",
"specified",
"allocate",
"request",
"from",
"the",
"am",
"and",
"creates",
"a",
"new",
"request",
"for",
"each",
"sub",
"-",
"cluster",
"rm"
]
| [
"private",
"map",
"<",
"sub",
"cluster",
"id",
",",
"allocate",
"request",
">",
"split",
"allocate",
"request",
"(",
"allocate",
"request",
"request",
")",
"throws",
"yarn",
"exception",
"{",
"map",
"<",
"sub",
"cluster",
"id",
",",
"allocate",
"request",
">",
"request",
"map",
"=",
"new",
"hash",
"map",
"<",
"sub",
"cluster",
"id",
",",
"allocate",
"request",
">",
"(",
")",
";",
"/",
"/",
"create",
"heart",
"beat",
"request",
"for",
"home",
"sub",
"-",
"cluster",
"resource",
"manager",
"find",
"or",
"create",
"allocate",
"request",
"for",
"sub",
"cluster",
"(",
"this",
"home",
"sub",
"cluster",
"id",
",",
"request",
",",
"request",
"map",
")",
";",
"/",
"/",
"create",
"heart",
"beat",
"request",
"instances",
"for",
"all",
"other",
"already",
"registered",
"/",
"/",
"sub",
"-",
"cluster",
"resource",
"managers",
"set",
"<",
"string",
">",
"sub",
"cluster",
"ids",
"=",
"this",
"uam",
"pool",
"get",
"all",
"u",
"a",
"m",
"ids",
"(",
")",
";",
"for",
"(",
"string",
"sub",
"cluster",
"id",
":",
"sub",
"cluster",
"ids",
")",
"{",
"find",
"or",
"create",
"allocate",
"request",
"for",
"sub",
"cluster",
"(",
"sub",
"cluster",
"id",
"new",
"instance",
"(",
"sub",
"cluster",
"id",
")",
",",
"request",
",",
"request",
"map",
")",
";",
"}",
"if",
"(",
"!",
"is",
"null",
"or",
"empty",
"(",
"request",
"get",
"ask",
"list",
"(",
")",
")",
")",
"{",
"/",
"/",
"ask",
"the",
"federation",
"policy",
"interpreter",
"to",
"split",
"the",
"ask",
"list",
"for",
"/",
"/",
"sending",
"it",
"to",
"all",
"the",
"sub",
"-",
"cluster",
"resource",
"managers",
"map",
"<",
"sub",
"cluster",
"id",
",",
"list",
"<",
"resource",
"request",
">",
">",
"asks",
"=",
"split",
"resource",
"requests",
"(",
"request",
"get",
"ask",
"list",
"(",
")",
")",
";",
"/",
"/",
"add",
"the",
"ask",
"lists",
"to",
"the",
"corresponding",
"sub",
"-",
"cluster",
"requests",
"for",
"(",
"entry",
"<",
"sub",
"cluster",
"id",
",",
"list",
"<",
"resource",
"request",
">",
">",
"entry",
":",
"asks",
"entry",
"set",
"(",
")",
")",
"{",
"allocate",
"request",
"new",
"request",
"=",
"find",
"or",
"create",
"allocate",
"request",
"for",
"sub",
"cluster",
"(",
"entry",
"get",
"key",
"(",
")",
",",
"request",
",",
"request",
"map",
")",
";",
"new",
"request",
"get",
"ask",
"list",
"(",
")",
"add",
"all",
"(",
"entry",
"get",
"value",
"(",
")",
")",
";",
"}",
"}",
"if",
"(",
"request",
"get",
"resource",
"blacklist",
"request",
"(",
")",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"!",
"is",
"null",
"or",
"empty",
"(",
"request",
"get",
"resource",
"blacklist",
"request",
"(",
")",
"get",
"blacklist",
"additions",
"(",
")",
")",
")",
"{",
"for",
"(",
"string",
"resource",
"name",
":",
"request",
"get",
"resource",
"blacklist",
"request",
"(",
")",
"get",
"blacklist",
"additions",
"(",
")",
")",
"{",
"sub",
"cluster",
"id",
"sub",
"cluster",
"id",
"=",
"get",
"sub",
"cluster",
"for",
"node",
"(",
"resource",
"name",
")",
";",
"if",
"(",
"sub",
"cluster",
"id",
"!",
"=",
"null",
")",
"{",
"allocate",
"request",
"new",
"request",
"=",
"find",
"or",
"create",
"allocate",
"request",
"for",
"sub",
"cluster",
"(",
"sub",
"cluster",
"id",
",",
"request",
",",
"request",
"map",
")",
";",
"new",
"request",
"get",
"resource",
"blacklist",
"request",
"(",
")",
"get",
"blacklist",
"additions",
"(",
")",
"add",
"(",
"resource",
"name",
")",
";",
"}",
"}",
"}",
"if",
"(",
"!",
"is",
"null",
"or",
"empty",
"(",
"request",
"get",
"resource",
"blacklist",
"request",
"(",
")",
"get",
"blacklist",
"removals",
"(",
")",
")",
")",
"{",
"for",
"(",
"string",
"resource",
"name",
":",
"request",
"get",
"resource",
"blacklist",
"request",
"(",
")",
"get",
"blacklist",
"removals",
"(",
")",
")",
"{",
"sub",
"cluster",
"id",
"sub",
"cluster",
"id",
"=",
"get",
"sub",
"cluster",
"for",
"node",
"(",
"resource",
"name",
")",
";",
"if",
"(",
"sub",
"cluster",
"id",
"!",
"=",
"null",
")",
"{",
"allocate",
"request",
"new",
"request",
"=",
"find",
"or",
"create",
"allocate",
"request",
"for",
"sub",
"cluster",
"(",
"sub",
"cluster",
"id",
",",
"request",
",",
"request",
"map",
")",
";",
"new",
"request",
"get",
"resource",
"blacklist",
"request",
"(",
")",
"get",
"blacklist",
"removals",
"(",
")",
"add",
"(",
"resource",
"name",
")",
";",
"}",
"}",
"}",
"}",
"if",
"(",
"!",
"is",
"null",
"or",
"empty",
"(",
"request",
"get",
"release",
"list",
"(",
")",
")",
")",
"{",
"for",
"(",
"container",
"id",
"cid",
":",
"request",
"get",
"release",
"list",
"(",
")",
")",
"{",
"if",
"(",
"warn",
"if",
"not",
"exists",
"(",
"cid",
",",
"\"",
"release",
"\"",
")",
")",
"{",
"sub",
"cluster",
"id",
"sub",
"cluster",
"id",
"=",
"this",
"container",
"id",
"to",
"sub",
"cluster",
"id",
"map",
"get",
"(",
"cid",
")",
";",
"allocate",
"request",
"new",
"request",
"=",
"request",
"map",
"get",
"(",
"sub",
"cluster",
"id",
")",
";",
"new",
"request",
"get",
"release",
"list",
"(",
")",
"add",
"(",
"cid",
")",
";",
"}",
"}",
"}",
"if",
"(",
"!",
"is",
"null",
"or",
"empty",
"(",
"request",
"get",
"update",
"requests",
"(",
")",
")",
")",
"{",
"for",
"(",
"update",
"container",
"request",
"ucr",
":",
"request",
"get",
"update",
"requests",
"(",
")",
")",
"{",
"if",
"(",
"warn",
"if",
"not",
"exists",
"(",
"ucr",
"get",
"container",
"id",
"(",
")",
",",
"\"",
"update",
"\"",
")",
")",
"{",
"sub",
"cluster",
"id",
"sub",
"cluster",
"id",
"=",
"this",
"container",
"id",
"to",
"sub",
"cluster",
"id",
"map",
"get",
"(",
"ucr",
"get",
"container",
"id",
"(",
")",
")",
";",
"allocate",
"request",
"new",
"request",
"=",
"request",
"map",
"get",
"(",
"sub",
"cluster",
"id",
")",
";",
"new",
"request",
"get",
"update",
"requests",
"(",
")",
"add",
"(",
"ucr",
")",
";",
"}",
"}",
"}",
"return",
"request",
"map",
";",
"}"
]
|
[
"returns",
"an",
"instance",
"with",
"a",
"single",
"trivial",
"command",
"line"
]
| [
"public",
"static",
"command",
"lines",
"of",
"(",
"iterable",
"<",
"string",
">",
"args",
")",
"{",
"return",
"new",
"command",
"lines",
"(",
"command",
"line",
"of",
"(",
"args",
")",
")",
";",
"}"
]
|
[
"set",
"the",
"jpa",
"dialect",
"to",
"use",
"for",
"this",
"transaction",
"manager",
"used",
"for",
"vendor",
"-",
"specific",
"transaction",
"management",
"and",
"jdbc",
"connection",
"exposure",
"if",
"the",
"entity",
"manager",
"factory",
"uses",
"a",
"known",
"jpa",
"dialect",
",",
"it",
"will",
"be",
"autodetected",
":",
"you",
"can",
"still",
"explicitly",
"specify",
"the",
"data",
"source",
",",
"but",
"you",
"don",
"'",
"t",
"need",
"to",
"in",
"this",
"case",
"the",
"dialect",
"object",
"can",
"be",
"used",
"to",
"retrieve",
"the",
"underlying",
"jdbc",
"connection",
"and",
"thus",
"allows",
"for",
"exposing",
"jpa",
"transactions",
"as",
"jdbc",
"transactions"
]
| [
"public",
"void",
"set",
"jpa",
"dialect",
"(",
"@",
"nullable",
"jpa",
"dialect",
"jpa",
"dialect",
")",
"{",
"this",
"jpa",
"dialect",
"=",
"(",
"jpa",
"dialect",
"!",
"=",
"null",
"?",
"jpa",
"dialect",
":",
"new",
"default",
"jpa",
"dialect",
"(",
")",
")",
";",
"}"
]
|
[
"asserts",
"the",
"queue",
"can",
"be",
"accessed",
"via",
"it",
"'",
"s",
"full",
"path",
"only",
",",
"using",
"it",
"'",
"s",
"short",
"name",
"supposed",
"to",
"return",
"something",
"else",
"this",
"is",
"a",
"result",
"of",
"forcefully",
"making",
"root",
"always",
"referencing",
"the",
"root",
"since",
"\"",
"root",
"\"",
"is",
"considered",
"a",
"full",
"path",
",",
"hence",
"no",
"other",
"queue",
"with",
"short",
"name",
"root",
"should",
"be",
"accessible",
"via",
"root"
]
| [
"public",
"void",
"assert",
"accessible",
"by",
"full",
"name",
"only",
"(",
"c",
"s",
"queue",
"store",
"store",
",",
"c",
"s",
"queue",
"queue",
")",
"{",
"assert",
"false",
"(",
"store",
"is",
"ambiguous",
"(",
"queue",
"get",
"queue",
"short",
"name",
"(",
")",
")",
")",
";",
"assert",
"not",
"equals",
"(",
"queue",
",",
"store",
"get",
"(",
"queue",
"get",
"queue",
"short",
"name",
"(",
")",
")",
")",
";",
"assert",
"equals",
"(",
"queue",
",",
"store",
"get",
"(",
"queue",
"get",
"queue",
"path",
"(",
")",
")",
")",
";",
"}"
]
|
[
"returns",
"the",
"number",
"of",
"segments",
"in",
"the",
"segment",
"table"
]
| [
"short",
"get",
"segment",
"count",
"(",
")",
"{",
"return",
"ne",
"cseg",
";",
"}"
]
|
[
"runs",
"task",
"in",
"eclipse",
"progress",
"service",
"note",
":",
"this",
"call",
"can",
"'",
"t",
"be",
"canceled",
"if",
"it",
"will",
"block",
"in",
"io"
]
| [
"public",
"static",
"void",
"run",
"in",
"progress",
"service",
"(",
"final",
"d",
"b",
"r",
"runnable",
"with",
"progress",
"runnable",
")",
"throws",
"invocation",
"target",
"exception",
",",
"interrupted",
"exception",
"{",
"get",
"default",
"runnable",
"context",
"(",
")",
"run",
"(",
"true",
",",
"true",
",",
"runnable",
")",
";",
"}"
]
|
[
"get",
"the",
"list",
"of",
"all",
"plugins",
"-",
"available",
"and",
"installed"
]
| [
"public",
"http",
"response",
"do",
"plugins",
"(",
")",
"{",
"jenkins",
"get",
"(",
")",
"check",
"permission",
"(",
"jenkins",
"administer",
")",
";",
"j",
"s",
"o",
"n",
"array",
"response",
"=",
"new",
"j",
"s",
"o",
"n",
"array",
"(",
")",
";",
"map",
"<",
"string",
",",
"j",
"s",
"o",
"n",
"object",
">",
"all",
"plugins",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"for",
"(",
"plugin",
"wrapper",
"plugin",
":",
"plugins",
")",
"{",
"j",
"s",
"o",
"n",
"object",
"plugin",
"info",
"=",
"new",
"j",
"s",
"o",
"n",
"object",
"(",
")",
";",
"plugin",
"info",
"put",
"(",
"\"",
"installed",
"\"",
",",
"true",
")",
";",
"plugin",
"info",
"put",
"(",
"\"",
"name",
"\"",
",",
"plugin",
"get",
"short",
"name",
"(",
")",
")",
";",
"plugin",
"info",
"put",
"(",
"\"",
"title",
"\"",
",",
"plugin",
"get",
"display",
"name",
"(",
")",
")",
";",
"plugin",
"info",
"put",
"(",
"\"",
"active",
"\"",
",",
"plugin",
"is",
"active",
"(",
")",
")",
";",
"plugin",
"info",
"put",
"(",
"\"",
"enabled",
"\"",
",",
"plugin",
"is",
"enabled",
"(",
")",
")",
";",
"plugin",
"info",
"put",
"(",
"\"",
"bundled",
"\"",
",",
"plugin",
"is",
"bundled",
")",
";",
"plugin",
"info",
"put",
"(",
"\"",
"deleted",
"\"",
",",
"plugin",
"is",
"deleted",
"(",
")",
")",
";",
"plugin",
"info",
"put",
"(",
"\"",
"downgradable",
"\"",
",",
"plugin",
"is",
"downgradable",
"(",
")",
")",
";",
"plugin",
"info",
"put",
"(",
"\"",
"website",
"\"",
",",
"plugin",
"get",
"url",
"(",
")",
")",
";",
"list",
"<",
"dependency",
">",
"dependencies",
"=",
"plugin",
"get",
"dependencies",
"(",
")",
";",
"if",
"(",
"dependencies",
"!",
"=",
"null",
"&",
"&",
"!",
"dependencies",
"is",
"empty",
"(",
")",
")",
"{",
"map",
"<",
"string",
",",
"string",
">",
"dependency",
"map",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"for",
"(",
"dependency",
"dependency",
":",
"dependencies",
")",
"{",
"dependency",
"map",
"put",
"(",
"dependency",
"short",
"name",
",",
"dependency",
"version",
")",
";",
"}",
"plugin",
"info",
"put",
"(",
"\"",
"dependencies",
"\"",
",",
"dependency",
"map",
")",
";",
"}",
"else",
"{",
"plugin",
"info",
"put",
"(",
"\"",
"dependencies",
"\"",
",",
"collections",
"empty",
"map",
"(",
")",
")",
";",
"}",
"response",
"add",
"(",
"plugin",
"info",
")",
";",
"}",
"for",
"(",
"update",
"site",
"site",
":",
"jenkins",
"get",
"(",
")",
"get",
"update",
"center",
"(",
")",
"get",
"site",
"list",
"(",
")",
")",
"{",
"for",
"(",
"update",
"site",
"plugin",
"plugin",
":",
"site",
"get",
"availables",
"(",
")",
")",
"{",
"j",
"s",
"o",
"n",
"object",
"plugin",
"info",
"=",
"all",
"plugins",
"get",
"(",
"plugin",
"name",
")",
";",
"if",
"(",
"plugin",
"info",
"=",
"=",
"null",
")",
"{",
"plugin",
"info",
"=",
"new",
"j",
"s",
"o",
"n",
"object",
"(",
")",
";",
"plugin",
"info",
"put",
"(",
"\"",
"installed",
"\"",
",",
"false",
")",
";",
"}",
"plugin",
"info",
"put",
"(",
"\"",
"name",
"\"",
",",
"plugin",
"name",
")",
";",
"plugin",
"info",
"put",
"(",
"\"",
"title",
"\"",
",",
"plugin",
"get",
"display",
"name",
"(",
")",
")",
";",
"plugin",
"info",
"put",
"(",
"\"",
"excerpt",
"\"",
",",
"plugin",
"excerpt",
")",
";",
"plugin",
"info",
"put",
"(",
"\"",
"site",
"\"",
",",
"site",
"get",
"id",
"(",
")",
")",
";",
"plugin",
"info",
"put",
"(",
"\"",
"dependencies",
"\"",
",",
"plugin",
"dependencies",
")",
";",
"plugin",
"info",
"put",
"(",
"\"",
"website",
"\"",
",",
"plugin",
"wiki",
")",
";",
"response",
"add",
"(",
"plugin",
"info",
")",
";",
"}",
"}",
"return",
"hudson",
"util",
"http",
"responses",
"ok",
"j",
"s",
"o",
"n",
"(",
"response",
")",
";",
"}"
]
|
[
"pre",
"-",
"processes",
"a",
"test",
"immediately",
"before",
"execution",
"of",
"the",
"{",
"@",
"link",
"java",
"lang",
"reflect",
"method",
"test",
"method",
"}",
"in",
"the",
"supplied",
"{",
"@",
"link",
"test",
"context",
"test",
"context",
"}",
"&",
"mdash",
";",
"for",
"example",
",",
"for",
"timing",
"or",
"logging",
"purposes",
"this",
"method",
"must",
"be",
"called",
"after",
"framework",
"-",
"specific",
"before",
"lifecycle",
"callbacks",
"the",
"default",
"implementation",
"is",
"empty",
"can",
"be",
"overridden",
"by",
"concrete",
"classes",
"as",
"necessary"
]
| [
"default",
"void",
"before",
"test",
"execution",
"(",
"test",
"context",
"test",
"context",
")",
"throws",
"exception",
"{",
"}"
]
|
[
"generate",
"a",
"text",
"representation",
"of",
"the",
"vuid",
",",
"breaking",
"out",
"its",
"individual",
"components",
"-",
"-",
"user",
",",
"app",
",",
"isolated",
",",
"etc",
"@",
"hide"
]
| [
"public",
"static",
"void",
"format",
"uid",
"(",
"print",
"writer",
"pw",
",",
"int",
"uid",
")",
"{",
"if",
"(",
"uid",
"<",
"process",
"first",
"application",
"uid",
")",
"{",
"pw",
"print",
"(",
"uid",
")",
";",
"}",
"else",
"{",
"pw",
"print",
"(",
"'",
"u",
"'",
")",
";",
"pw",
"print",
"(",
"get",
"user",
"id",
"(",
"uid",
")",
")",
";",
"final",
"int",
"app",
"id",
"=",
"get",
"app",
"id",
"(",
"uid",
")",
";",
"if",
"(",
"app",
"id",
">",
"=",
"first",
"isolated",
"uid",
"&",
"&",
"app",
"id",
"<",
"=",
"last",
"isolated",
"uid",
")",
"{",
"pw",
"print",
"(",
"'",
"i",
"'",
")",
";",
"pw",
"print",
"(",
"app",
"id",
"-",
"first",
"isolated",
"uid",
")",
";",
"}",
"else",
"if",
"(",
"app",
"id",
">",
"=",
"process",
"first",
"application",
"uid",
")",
"{",
"pw",
"print",
"(",
"'",
"a",
"'",
")",
";",
"pw",
"print",
"(",
"app",
"id",
"-",
"process",
"first",
"application",
"uid",
")",
";",
"}",
"else",
"{",
"pw",
"print",
"(",
"'",
"s",
"'",
")",
";",
"pw",
"print",
"(",
"app",
"id",
")",
";",
"}",
"}",
"}"
]
|
[
"returns",
"a",
"recyclable",
"m",
"p",
"point",
"d",
"instance",
"returns",
"the",
"x",
"and",
"y",
"coordinates",
"(",
"pixels",
")",
"for",
"a",
"given",
"x",
"and",
"y",
"value",
"in",
"the",
"chart"
]
| [
"public",
"m",
"p",
"point",
"d",
"get",
"pixel",
"for",
"values",
"(",
"float",
"x",
",",
"float",
"y",
")",
"{",
"pts",
"buffer",
"[",
"0",
"]",
"=",
"x",
";",
"pts",
"buffer",
"[",
"1",
"]",
"=",
"y",
";",
"point",
"values",
"to",
"pixel",
"(",
"pts",
"buffer",
")",
";",
"double",
"x",
"px",
"=",
"pts",
"buffer",
"[",
"0",
"]",
";",
"double",
"y",
"px",
"=",
"pts",
"buffer",
"[",
"1",
"]",
";",
"return",
"m",
"p",
"point",
"d",
"get",
"instance",
"(",
"x",
"px",
",",
"y",
"px",
")",
";",
"}"
]
|
[
"usually",
",",
"the",
"{",
"@",
"link",
"class",
"loader",
"}",
"calls",
"its",
"parent",
"and",
"finally",
"this",
"method",
"so",
"if",
"we",
"are",
"here",
",",
"it",
"'",
"s",
"the",
"last",
"element",
"of",
"the",
"chain",
"it",
"doesn",
"'",
"t",
"happen",
"in",
"{",
"@",
"link",
"jenkins",
"util",
"ant",
"class",
"loader",
"}",
"so",
"it",
"has",
"an",
"special",
"management",
"on",
"{",
"@",
"link",
"hudson",
"classic",
"plugin",
"strategy",
"}"
]
| [
"protected",
"class",
"<",
"?",
">",
"find",
"class",
"(",
"string",
"name",
")",
"throws",
"class",
"not",
"found",
"exception",
"{",
"class",
"not",
"found",
"exception",
"e",
"=",
"new",
"class",
"not",
"found",
"exception",
"(",
"name",
")",
";",
"missing",
"class",
"telemetry",
"report",
"exception",
"(",
"name",
",",
"e",
")",
";",
"throw",
"e",
";",
"}"
]
|
[
"returns",
"an",
"{",
"@",
"link",
"executor",
"}",
"that",
"runs",
"each",
"task",
"executed",
"sequentially",
",",
"such",
"that",
"no",
"two",
"tasks",
"are",
"running",
"concurrently",
"submitted",
"tasks",
"have",
"a",
"happens",
"-",
"before",
"order",
"as",
"defined",
"in",
"the",
"java",
"language",
"specification",
"the",
"executor",
"uses",
"{",
"@",
"code",
"delegate",
"}",
"in",
"order",
"to",
"{",
"@",
"link",
"executor",
"#",
"execute",
"execute",
"}",
"each",
"task",
"in",
"turn",
",",
"and",
"does",
"not",
"create",
"any",
"threads",
"of",
"its",
"own",
"after",
"execution",
"begins",
"on",
"a",
"thread",
"from",
"the",
"{",
"@",
"code",
"delegate",
"}",
"{",
"@",
"link",
"executor",
"}",
",",
"tasks",
"are",
"polled",
"and",
"executed",
"from",
"a",
"task",
"queue",
"until",
"there",
"are",
"no",
"more",
"tasks",
"the",
"thread",
"will",
"not",
"be",
"released",
"until",
"there",
"are",
"no",
"more",
"tasks",
"to",
"run",
"if",
"a",
"task",
"is",
"submitted",
"while",
"a",
"thread",
"is",
"executing",
"tasks",
"from",
"the",
"task",
"queue",
",",
"the",
"thread",
"will",
"not",
"be",
"released",
"until",
"that",
"submitted",
"task",
"is",
"also",
"complete",
"if",
"a",
"task",
"is",
"{",
"@",
"linkplain",
"thread",
"#",
"interrupt",
"interrupted",
"}",
"while",
"a",
"task",
"is",
"running",
":",
"execution",
"will",
"not",
"stop",
"until",
"the",
"task",
"queue",
"is",
"empty",
"tasks",
"will",
"begin",
"execution",
"with",
"the",
"thread",
"marked",
"as",
"not",
"interrupted",
"-",
"any",
"interruption",
"applies",
"only",
"to",
"the",
"task",
"that",
"was",
"running",
"at",
"the",
"point",
"of",
"interruption",
"if",
"the",
"thread",
"was",
"interrupted",
"before",
"the",
"sequential",
"executor",
"'",
"s",
"worker",
"begins",
"execution",
",",
"the",
"interrupt",
"will",
"be",
"restored",
"to",
"the",
"thread",
"after",
"it",
"completes",
"so",
"that",
"its",
"{",
"@",
"code",
"delegate",
"}",
"executor",
"may",
"process",
"the",
"interrupt",
"subtasks",
"are",
"run",
"with",
"the",
"thread",
"uninterrupted",
"and",
"interrupts",
"received",
"during",
"execution",
"of",
"a",
"task",
"are",
"ignored",
"{",
"@",
"code",
"runtime",
"exception",
"}",
"s",
"thrown",
"by",
"tasks",
"are",
"simply",
"logged",
"and",
"the",
"executor",
"keeps",
"trucking",
"if",
"an",
"{",
"@",
"code",
"error",
"}",
"is",
"thrown",
",",
"the",
"error",
"will",
"propagate",
"and",
"execution",
"will",
"stop",
"until",
"the",
"next",
"time",
"a",
"task",
"is",
"submitted",
"when",
"an",
"{",
"@",
"code",
"error",
"}",
"is",
"thrown",
"by",
"an",
"executed",
"task",
",",
"previously",
"submitted",
"tasks",
"may",
"never",
"run",
"an",
"attempt",
"will",
"be",
"made",
"to",
"restart",
"execution",
"on",
"the",
"next",
"call",
"to",
"{",
"@",
"code",
"execute",
"}",
"if",
"the",
"{",
"@",
"code",
"delegate",
"}",
"has",
"begun",
"to",
"reject",
"execution",
",",
"the",
"previously",
"submitted",
"tasks",
"may",
"never",
"run",
",",
"despite",
"not",
"throwing",
"a",
"rejected",
"execution",
"exception",
"synchronously",
"with",
"the",
"call",
"to",
"{",
"@",
"code",
"execute",
"}",
"if",
"this",
"behaviour",
"is",
"problematic",
",",
"use",
"an",
"executor",
"with",
"a",
"single",
"thread",
"(",
"e",
"g",
"{",
"@",
"link",
"executors",
"#",
"new",
"single",
"thread",
"executor",
"}",
")"
]
| [
"public",
"static",
"executor",
"new",
"sequential",
"executor",
"(",
"executor",
"delegate",
")",
"{",
"return",
"new",
"sequential",
"executor",
"(",
"delegate",
")",
";",
"}"
]
|
[
"adds",
"all",
"elements",
"in",
"{",
"@",
"code",
"iterable",
"}",
"to",
"{",
"@",
"code",
"collection",
"}"
]
| [
"public",
"static",
"<",
"t",
">",
"boolean",
"add",
"all",
"(",
"collection",
"<",
"t",
">",
"add",
"to",
",",
"iterable",
"<",
"?",
"extends",
"t",
">",
"elements",
"to",
"add",
")",
"{",
"if",
"(",
"elements",
"to",
"add",
"instanceof",
"collection",
")",
"{",
"collection",
"<",
"?",
"extends",
"t",
">",
"c",
"=",
"(",
"collection",
"<",
"?",
"extends",
"t",
">",
")",
"elements",
"to",
"add",
";",
"return",
"add",
"to",
"add",
"all",
"(",
"c",
")",
";",
"}",
"return",
"iterators",
"add",
"all",
"(",
"add",
"to",
",",
"check",
"not",
"null",
"(",
"elements",
"to",
"add",
")",
"iterator",
"(",
")",
")",
";",
"}"
]
|
[
"<",
"code",
">",
"optional",
"string",
"product",
"=",
"2",
";",
"<",
"code",
">"
]
| [
"public",
"builder",
"set",
"product",
"(",
"java",
"lang",
"string",
"value",
")",
"{",
"copy",
"on",
"write",
"(",
")",
";",
"instance",
"set",
"product",
"(",
"value",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"specifies",
"the",
"ordering",
"of",
"the",
"generated",
"multimap",
"'",
"s",
"values",
"for",
"each",
"key"
]
| [
"public",
"builder",
"<",
"k",
",",
"v",
">",
"order",
"values",
"by",
"(",
"comparator",
"<",
"?",
"super",
"v",
">",
"value",
"comparator",
")",
"{",
"this",
"value",
"comparator",
"=",
"check",
"not",
"null",
"(",
"value",
"comparator",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"verify",
"if",
"the",
"weather",
"has",
"the",
"expected",
"influence",
"on",
"the",
"observer"
]
| [
"public",
"void",
"test",
"observer",
"(",
"weather",
"type",
"weather",
",",
"string",
"response",
")",
"{",
"final",
"var",
"observer",
"=",
"this",
"factory",
"get",
"(",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"appender",
"get",
"log",
"size",
"(",
")",
")",
";",
"observer",
"update",
"(",
"weather",
")",
";",
"assert",
"equals",
"(",
"response",
",",
"appender",
"get",
"last",
"message",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"1",
",",
"appender",
"get",
"log",
"size",
"(",
")",
")",
";",
"}"
]
|
[
"get",
"number",
"minimum",
":",
"32",
"1",
"maximum",
":",
"543",
"2"
]
| [
"public",
"big",
"decimal",
"get",
"number",
"(",
")",
"{",
"return",
"number",
";",
"}"
]
|
[
"get",
"{",
"@",
"link",
"content",
"summary",
"}",
"rooted",
"at",
"the",
"specified",
"directory"
]
| [
"content",
"summary",
"get",
"content",
"summary",
"(",
"string",
"path",
")",
"throws",
"i",
"o",
"exception",
";"
]
|
[
"read",
"messages",
"into",
"the",
"given",
"array",
"and",
"return",
"the",
"amount",
"which",
"was",
"read"
]
| [
"protected",
"abstract",
"int",
"do",
"read",
"messages",
"(",
"list",
"<",
"object",
">",
"msgs",
")",
"throws",
"exception",
";"
]
|
[
"get",
"the",
"cpu",
"units",
"to",
"use",
"for",
"the",
"task",
"manager",
"process"
]
| [
"public",
"double",
"cpus",
"(",
")",
"{",
"return",
"containered",
"parameters",
"get",
"task",
"executor",
"process",
"spec",
"(",
")",
"get",
"cpu",
"cores",
"(",
")",
"get",
"value",
"(",
")",
"double",
"value",
"(",
")",
";",
"}"
]
|
[
"synchronize",
"check",
"sums"
]
| [
"public",
"static",
"void",
"sync",
"check",
"sums",
"(",
"byte",
"[",
"]",
"checksums",
",",
"string",
"server",
")",
"{",
"try",
"{",
"map",
"<",
"string",
",",
"string",
">",
"headers",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
"128",
")",
";",
"headers",
"put",
"(",
"http",
"header",
"consts",
"client",
"version",
"header",
",",
"version",
"utils",
"version",
")",
";",
"headers",
"put",
"(",
"http",
"header",
"consts",
"user",
"agent",
"header",
",",
"utils",
"and",
"commons",
"server",
"version",
")",
";",
"headers",
"put",
"(",
"http",
"header",
"consts",
"connection",
",",
"\"",
"keep",
"-",
"alive",
"\"",
")",
";",
"http",
"client",
"async",
"http",
"put",
"large",
"(",
"\"",
"http",
":",
"/",
"/",
"\"",
"+",
"server",
"+",
"env",
"util",
"get",
"context",
"path",
"(",
")",
"+",
"utils",
"and",
"commons",
"nacos",
"naming",
"context",
"+",
"timestamp",
"sync",
"url",
"+",
"\"",
"?",
"source",
"=",
"\"",
"+",
"net",
"utils",
"local",
"server",
"(",
")",
",",
"headers",
",",
"checksums",
",",
"new",
"callback",
"<",
"string",
">",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"on",
"receive",
"(",
"rest",
"result",
"<",
"string",
">",
"result",
")",
"{",
"if",
"(",
"!",
"result",
"ok",
"(",
")",
")",
"{",
"loggers",
"distro",
"error",
"(",
"\"",
"failed",
"to",
"req",
"api",
":",
"{",
"}",
",",
"code",
":",
"{",
"}",
",",
"msg",
":",
"{",
"}",
"\"",
",",
"\"",
"http",
":",
"/",
"/",
"\"",
"+",
"server",
"+",
"env",
"util",
"get",
"context",
"path",
"(",
")",
"+",
"utils",
"and",
"commons",
"nacos",
"naming",
"context",
"+",
"timestamp",
"sync",
"url",
",",
"result",
"get",
"code",
"(",
")",
",",
"result",
"get",
"message",
"(",
")",
")",
";",
"}",
"}",
"@",
"override",
"public",
"void",
"on",
"error",
"(",
"throwable",
"throwable",
")",
"{",
"loggers",
"distro",
"error",
"(",
"\"",
"failed",
"to",
"req",
"api",
":",
"\"",
"+",
"\"",
"http",
":",
"/",
"/",
"\"",
"+",
"server",
"+",
"env",
"util",
"get",
"context",
"path",
"(",
")",
"+",
"utils",
"and",
"commons",
"nacos",
"naming",
"context",
"+",
"timestamp",
"sync",
"url",
",",
"throwable",
")",
";",
"}",
"@",
"override",
"public",
"void",
"on",
"cancel",
"(",
")",
"{",
"}",
"}",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"loggers",
"distro",
"warn",
"(",
"\"",
"naming",
"proxy",
"\"",
",",
"e",
")",
";",
"}",
"}"
]
|
[
"used",
"for",
"handling",
"output",
"of",
"callable",
"statements"
]
| [
"public",
"class",
"<",
"?",
">",
"get",
"java",
"type",
"(",
")",
"{",
"return",
"java",
"type",
";",
"}"
]
|
[
"test",
"the",
"property",
"'",
"namespace",
"number",
"'"
]
| [
"public",
"void",
"namespace",
"number",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"namespace",
"number",
"}"
]
|
[
"content",
"of",
"the",
"element"
]
| [
"content",
"(",
"object",
"lines",
")",
";"
]
|
[
"builds",
"an",
"option",
"dialog",
"based",
"on",
"the",
"values",
"set",
"in",
"this",
"builder"
]
| [
"public",
"option",
"dialog",
"build",
"(",
")",
"{",
"return",
"swing",
"run",
"now",
"(",
"(",
")",
"-",
">",
"{",
"return",
"new",
"option",
"dialog",
"(",
"title",
",",
"message",
",",
"message",
"type",
",",
"icon",
",",
"add",
"cancel",
"button",
",",
"remember",
"option",
",",
"options",
",",
"default",
"option",
")",
";",
"}",
")",
";",
"}"
]
|
[
"given",
"an",
"index",
"pattern",
",",
"checks",
"whether",
"it",
"matches",
"against",
"the",
"current",
"shard",
"the",
"pattern",
"may",
"represent",
"a",
"fully",
"qualified",
"index",
"name",
"if",
"the",
"search",
"targets",
"remote",
"shards"
]
| [
"public",
"boolean",
"index",
"matches",
"(",
"string",
"pattern",
")",
"{",
"return",
"index",
"name",
"matcher",
"test",
"(",
"pattern",
")",
";",
"}"
]
|
[
"called",
"by",
"transport",
"implementations",
"when",
"they",
"receive",
"headers"
]
| [
"protected",
"void",
"inbound",
"headers",
"received",
"(",
"metadata",
"headers",
")",
"{",
"check",
"state",
"(",
"!",
"status",
"reported",
",",
"\"",
"received",
"headers",
"on",
"closed",
"stream",
"\"",
")",
";",
"stats",
"trace",
"ctx",
"client",
"inbound",
"headers",
"(",
")",
";",
"boolean",
"compressed",
"stream",
"=",
"false",
";",
"string",
"stream",
"encoding",
"=",
"headers",
"get",
"(",
"content",
"encoding",
"key",
")",
";",
"if",
"(",
"full",
"stream",
"decompression",
"&",
"&",
"stream",
"encoding",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"stream",
"encoding",
"equals",
"ignore",
"case",
"(",
"\"",
"gzip",
"\"",
")",
")",
"{",
"set",
"full",
"stream",
"decompressor",
"(",
"new",
"gzip",
"inflating",
"buffer",
"(",
")",
")",
";",
"compressed",
"stream",
"=",
"true",
";",
"}",
"else",
"if",
"(",
"!",
"stream",
"encoding",
"equals",
"ignore",
"case",
"(",
"\"",
"identity",
"\"",
")",
")",
"{",
"deframe",
"failed",
"(",
"status",
"internal",
"with",
"description",
"(",
"string",
"format",
"(",
"\"",
"can",
"'",
"t",
"find",
"full",
"stream",
"decompressor",
"for",
"%",
"s",
"\"",
",",
"stream",
"encoding",
")",
")",
"as",
"runtime",
"exception",
"(",
")",
")",
";",
"return",
";",
"}",
"}",
"string",
"message",
"encoding",
"=",
"headers",
"get",
"(",
"message",
"encoding",
"key",
")",
";",
"if",
"(",
"message",
"encoding",
"!",
"=",
"null",
")",
"{",
"decompressor",
"decompressor",
"=",
"decompressor",
"registry",
"lookup",
"decompressor",
"(",
"message",
"encoding",
")",
";",
"if",
"(",
"decompressor",
"=",
"=",
"null",
")",
"{",
"deframe",
"failed",
"(",
"status",
"internal",
"with",
"description",
"(",
"string",
"format",
"(",
"\"",
"can",
"'",
"t",
"find",
"decompressor",
"for",
"%",
"s",
"\"",
",",
"message",
"encoding",
")",
")",
"as",
"runtime",
"exception",
"(",
")",
")",
";",
"return",
";",
"}",
"else",
"if",
"(",
"decompressor",
"!",
"=",
"codec",
"identity",
"none",
")",
"{",
"if",
"(",
"compressed",
"stream",
")",
"{",
"deframe",
"failed",
"(",
"status",
"internal",
"with",
"description",
"(",
"string",
"format",
"(",
"\"",
"full",
"stream",
"and",
"g",
"r",
"p",
"c",
"message",
"encoding",
"cannot",
"both",
"be",
"set",
"\"",
")",
")",
"as",
"runtime",
"exception",
"(",
")",
")",
";",
"return",
";",
"}",
"set",
"decompressor",
"(",
"decompressor",
")",
";",
"}",
"}",
"listener",
"(",
")",
"headers",
"read",
"(",
"headers",
")",
";",
"}"
]
|
[
"returns",
"the",
"logarithm",
"of",
"\"",
"x",
"\"",
"with",
"base",
"\"",
"base",
"\""
]
| [
"public",
"static",
"double",
"log",
"(",
"double",
"base",
",",
"double",
"x",
")",
"{",
"return",
"math",
"log",
"(",
"x",
")",
"/",
"math",
"log",
"(",
"base",
")",
";",
"}"
]
|
[
"test",
"of",
"entry",
"with",
"method",
",",
"of",
"class",
"zip",
"in"
]
| [
"public",
"void",
"test",
"entry",
"with",
"(",
")",
"throws",
"exception",
"{",
"int",
"count",
"=",
"entry",
"count",
";",
"string",
"filename",
"=",
"\"",
"test",
"jar",
"\"",
";",
"zip",
"file",
"builder",
"builder",
"=",
"new",
"zip",
"file",
"builder",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"count",
";",
"i",
"+",
"+",
")",
"{",
"builder",
"add",
"(",
"\"",
"pkg",
"/",
"f",
"\"",
"+",
"i",
"+",
"\"",
"class",
"\"",
",",
"\"",
"all",
"day",
"long",
"\"",
")",
";",
"}",
"builder",
"create",
"(",
"filename",
")",
";",
"final",
"zip",
"in",
"zip",
"in",
"=",
"new",
"zip",
"in",
"(",
"filename",
")",
";",
"zip",
"in",
"central",
"directory",
"(",
")",
";",
"count",
"=",
"0",
";",
"int",
"offset",
"=",
"0",
";",
"local",
"file",
"header",
"header",
";",
"do",
"{",
"header",
"=",
"zip",
"in",
"next",
"header",
"from",
"(",
"offset",
")",
";",
"string",
"name",
"=",
"\"",
"pkg",
"/",
"f",
"\"",
"+",
"count",
"+",
"\"",
"class",
"\"",
";",
"if",
"(",
"header",
"!",
"=",
"null",
")",
"{",
"zip",
"entry",
"zip",
"entry",
"=",
"zip",
"in",
"entry",
"with",
"(",
"header",
")",
";",
"assert",
"that",
"(",
"zip",
"entry",
"get",
"dir",
"entry",
"(",
")",
")",
"is",
"not",
"null",
"(",
")",
";",
"assert",
"that",
"(",
"zip",
"entry",
"get",
"header",
"(",
")",
")",
"is",
"same",
"instance",
"as",
"(",
"header",
")",
";",
"assert",
"that",
"(",
"zip",
"entry",
"get",
"header",
"(",
")",
"get",
"filename",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"name",
")",
";",
"assert",
"that",
"(",
"zip",
"entry",
"get",
"dir",
"entry",
"(",
")",
"get",
"filename",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"name",
")",
";",
"assert",
"that",
"(",
"header",
"get",
"filename",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"name",
")",
";",
"count",
"+",
"+",
";",
"offset",
"=",
"(",
"int",
")",
"header",
"file",
"offset",
"(",
")",
"+",
"4",
";",
"}",
"}",
"while",
"(",
"header",
"!",
"=",
"null",
")",
";",
"assert",
"that",
"(",
"count",
")",
"is",
"equal",
"to",
"(",
"entry",
"count",
")",
";",
"}"
]
|
[
"uploads",
"an",
"image"
]
| [
"model",
"api",
"response",
"upload",
"file",
"(",
"@",
"param",
"(",
"\"",
"pet",
"id",
"\"",
")",
"long",
"pet",
"id",
",",
"@",
"param",
"(",
"\"",
"additional",
"metadata",
"\"",
")",
"string",
"additional",
"metadata",
",",
"@",
"param",
"(",
"\"",
"file",
"\"",
")",
"file",
"file",
")",
";"
]
|
[
"given",
"a",
"reference",
"for",
"a",
"specified",
"program",
",",
"get",
"the",
"corresponding",
"reference",
"from",
"the",
"specified",
"other",
"program",
"a",
"non",
"-",
"memory",
"reference",
"is",
"considered",
"a",
"suitable",
"reference",
"for",
"returning",
"if",
"its",
"destination",
"address",
"is",
"from",
"the",
"same",
"address",
"space",
"(",
"i",
"e",
",",
"stack",
",",
"register",
",",
"etc",
")"
]
| [
"public",
"static",
"reference",
"get",
"reference",
"(",
"program",
"program",
",",
"reference",
"ref",
",",
"program",
"other",
"program",
")",
"{",
"address",
"from",
"addr",
"=",
"get",
"compatible",
"address",
"(",
"program",
",",
"ref",
"get",
"from",
"address",
"(",
")",
",",
"other",
"program",
")",
";",
"if",
"(",
"from",
"addr",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"if",
"(",
"ref",
"is",
"memory",
"reference",
"(",
")",
")",
"{",
"address",
"to",
"addr",
"=",
"get",
"compatible",
"address",
"(",
"program",
",",
"ref",
"get",
"to",
"address",
"(",
")",
",",
"other",
"program",
")",
";",
"if",
"(",
"to",
"addr",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"return",
"other",
"program",
"get",
"reference",
"manager",
"(",
")",
"get",
"reference",
"(",
"from",
"addr",
",",
"to",
"addr",
",",
"ref",
"get",
"operand",
"index",
"(",
")",
")",
";",
"}",
"reference",
"other",
"ref",
"=",
"other",
"program",
"get",
"reference",
"manager",
"(",
")",
"get",
"primary",
"reference",
"from",
"(",
"from",
"addr",
",",
"ref",
"get",
"operand",
"index",
"(",
")",
")",
";",
"if",
"(",
"other",
"ref",
"!",
"=",
"null",
"&",
"&",
"ref",
"get",
"to",
"address",
"(",
")",
"has",
"same",
"address",
"space",
"(",
"other",
"ref",
"get",
"to",
"address",
"(",
")",
")",
")",
"{",
"return",
"other",
"ref",
";",
"}",
"return",
"null",
";",
"}"
]
|
[
"steps",
"through",
"the",
"instruction",
"list",
"checking",
"if",
"the",
"current",
"instruction",
"ended",
"a",
"successful",
"pattern",
"-",
"match",
"sequence"
]
| [
"public",
"boolean",
"accept",
"(",
"abstract",
"insn",
"node",
"ain",
")",
"{",
"if",
"(",
"pointer",
">",
"=",
"filters",
"length",
")",
"reset",
"(",
")",
";",
"instruction",
"filter",
"filter",
"=",
"filters",
"[",
"pointer",
"]",
";",
"if",
"(",
"filter",
"accept",
"(",
"ain",
")",
")",
"{",
"last",
"match",
"[",
"pointer",
"]",
"=",
"ain",
";",
"if",
"(",
"pointer",
">",
"=",
"(",
"filters",
"length",
"-",
"1",
")",
")",
"{",
"return",
"true",
";",
"}",
"pointer",
"+",
"+",
";",
"}",
"else",
"{",
"reset",
"(",
")",
";",
"}",
"return",
"false",
";",
"}"
]
|
[
"model",
"tests",
"for",
"file",
"schema",
"test",
"class"
]
| [
"public",
"void",
"test",
"file",
"schema",
"test",
"class",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"file",
"schema",
"test",
"class",
"}"
]
|
[
"creates",
"a",
"{",
"@",
"link",
"timing",
"transition",
"}",
"with",
"the",
"given",
"duration"
]
| [
"public",
"static",
"transition",
"animator",
"timing",
"(",
"final",
"int",
"duration",
"ms",
")",
"{",
"return",
"new",
"timing",
"transition",
"animator",
"(",
"duration",
"ms",
")",
";",
"}"
]
|
[
"get",
"the",
"vertex",
"degree"
]
| [
"public",
"long",
"value",
"get",
"degree",
"(",
")",
"{",
"return",
"degree",
";",
"}"
]
|
[
"sign",
"saml",
"response"
]
| [
"public",
"static",
"string",
"sign",
"saml",
"response",
"(",
"final",
"string",
"saml",
"response",
",",
"final",
"private",
"key",
"private",
"key",
",",
"final",
"public",
"key",
"public",
"key",
")",
"{",
"val",
"doc",
"=",
"construct",
"document",
"from",
"xml",
"(",
"saml",
"response",
")",
";",
"if",
"(",
"doc",
"!",
"=",
"null",
")",
"{",
"val",
"signed",
"element",
"=",
"sign",
"saml",
"element",
"(",
"doc",
"get",
"root",
"element",
"(",
")",
",",
"private",
"key",
",",
"public",
"key",
")",
";",
"doc",
"set",
"root",
"element",
"(",
"signed",
"element",
"detach",
"(",
")",
")",
";",
"return",
"new",
"x",
"m",
"l",
"outputter",
"(",
")",
"output",
"string",
"(",
"doc",
")",
";",
"}",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"error",
"signing",
"saml",
"response",
":",
"null",
"document",
"\"",
")",
";",
"}"
]
|
[
"parametrizes",
"the",
"ship",
"strategy",
"fields",
"of",
"a",
"channel",
"such",
"that",
"the",
"channel",
"produces",
"the",
"desired",
"global",
"properties"
]
| [
"public",
"void",
"parameterize",
"channel",
"(",
"channel",
"channel",
",",
"boolean",
"global",
"dop",
"change",
",",
"execution",
"mode",
"exchange",
"mode",
",",
"boolean",
"break",
"pipeline",
")",
"{",
"/",
"/",
"safety",
"check",
"fully",
"replicated",
"input",
"must",
"be",
"preserved",
"if",
"(",
"channel",
"get",
"source",
"(",
")",
"get",
"global",
"properties",
"(",
")",
"is",
"fully",
"replicated",
"(",
")",
"&",
"&",
"!",
"(",
"this",
"partitioning",
"=",
"=",
"partitioning",
"property",
"full",
"replication",
"|",
"|",
"this",
"partitioning",
"=",
"=",
"partitioning",
"property",
"any",
"distribution",
")",
")",
"{",
"throw",
"new",
"compiler",
"exception",
"(",
"\"",
"fully",
"replicated",
"input",
"must",
"be",
"preserved",
"\"",
"+",
"\"",
"and",
"may",
"not",
"be",
"converted",
"into",
"another",
"global",
"property",
"\"",
")",
";",
"}",
"/",
"/",
"if",
"we",
"request",
"nothing",
",",
"then",
"we",
"need",
"no",
"special",
"strategy",
"forward",
",",
"if",
"the",
"number",
"of",
"/",
"/",
"instances",
"remains",
"/",
"/",
"the",
"same",
",",
"randomly",
"repartition",
"otherwise",
"if",
"(",
"is",
"trivial",
"(",
")",
"|",
"|",
"this",
"partitioning",
"=",
"=",
"partitioning",
"property",
"any",
"distribution",
")",
"{",
"ship",
"strategy",
"type",
"ship",
"strategy",
"=",
"global",
"dop",
"change",
"?",
"ship",
"strategy",
"type",
"partition",
"random",
":",
"ship",
"strategy",
"type",
"forward",
";",
"data",
"exchange",
"mode",
"em",
"=",
"data",
"exchange",
"mode",
"select",
"(",
"exchange",
"mode",
",",
"ship",
"strategy",
",",
"break",
"pipeline",
")",
";",
"channel",
"set",
"ship",
"strategy",
"(",
"ship",
"strategy",
",",
"em",
")",
";",
"return",
";",
"}",
"final",
"global",
"properties",
"in",
"globals",
"=",
"channel",
"get",
"source",
"(",
")",
"get",
"global",
"properties",
"(",
")",
";",
"/",
"/",
"if",
"we",
"have",
"no",
"global",
"parallelism",
"change",
",",
"check",
"if",
"we",
"have",
"already",
"compatible",
"global",
"/",
"/",
"properties",
"if",
"(",
"!",
"global",
"dop",
"change",
"&",
"&",
"is",
"met",
"by",
"(",
"in",
"globals",
")",
")",
"{",
"data",
"exchange",
"mode",
"em",
"=",
"data",
"exchange",
"mode",
"select",
"(",
"exchange",
"mode",
",",
"ship",
"strategy",
"type",
"forward",
",",
"break",
"pipeline",
")",
";",
"channel",
"set",
"ship",
"strategy",
"(",
"ship",
"strategy",
"type",
"forward",
",",
"em",
")",
";",
"return",
";",
"}",
"/",
"/",
"if",
"we",
"fall",
"through",
"the",
"conditions",
"until",
"here",
",",
"we",
"need",
"to",
"re",
"-",
"establish",
"ship",
"strategy",
"type",
"ship",
"type",
";",
"field",
"list",
"partition",
"keys",
";",
"boolean",
"[",
"]",
"sort",
"direction",
";",
"partitioner",
"<",
"?",
">",
"partitioner",
";",
"switch",
"(",
"this",
"partitioning",
")",
"{",
"case",
"full",
"replication",
":",
"ship",
"type",
"=",
"ship",
"strategy",
"type",
"broadcast",
";",
"partition",
"keys",
"=",
"null",
";",
"sort",
"direction",
"=",
"null",
";",
"partitioner",
"=",
"null",
";",
"break",
";",
"case",
"any",
"partitioning",
":",
"case",
"hash",
"partitioned",
":",
"ship",
"type",
"=",
"ship",
"strategy",
"type",
"partition",
"hash",
";",
"partition",
"keys",
"=",
"utils",
"create",
"ordered",
"from",
"set",
"(",
"this",
"partitioning",
"fields",
")",
";",
"sort",
"direction",
"=",
"null",
";",
"partitioner",
"=",
"null",
";",
"break",
";",
"case",
"range",
"partitioned",
":",
"ship",
"type",
"=",
"ship",
"strategy",
"type",
"partition",
"range",
";",
"partition",
"keys",
"=",
"this",
"ordering",
"get",
"involved",
"indexes",
"(",
")",
";",
"sort",
"direction",
"=",
"this",
"ordering",
"get",
"field",
"sort",
"directions",
"(",
")",
";",
"partitioner",
"=",
"null",
";",
"if",
"(",
"this",
"data",
"distribution",
"!",
"=",
"null",
")",
"{",
"channel",
"set",
"data",
"distribution",
"(",
"this",
"data",
"distribution",
")",
";",
"}",
"break",
";",
"case",
"forced",
"rebalanced",
":",
"ship",
"type",
"=",
"ship",
"strategy",
"type",
"partition",
"forced",
"rebalance",
";",
"partition",
"keys",
"=",
"null",
";",
"sort",
"direction",
"=",
"null",
";",
"partitioner",
"=",
"null",
";",
"break",
";",
"case",
"custom",
"partitioning",
":",
"ship",
"type",
"=",
"ship",
"strategy",
"type",
"partition",
"custom",
";",
"partition",
"keys",
"=",
"utils",
"create",
"ordered",
"from",
"set",
"(",
"this",
"partitioning",
"fields",
")",
";",
"sort",
"direction",
"=",
"null",
";",
"partitioner",
"=",
"this",
"custom",
"partitioner",
";",
"break",
";",
"default",
":",
"throw",
"new",
"compiler",
"exception",
"(",
"\"",
"invalid",
"partitioning",
"to",
"create",
"through",
"a",
"data",
"exchange",
":",
"\"",
"+",
"this",
"partitioning",
"name",
"(",
")",
")",
";",
"}",
"data",
"exchange",
"mode",
"ex",
"mode",
"=",
"data",
"exchange",
"mode",
"select",
"(",
"exchange",
"mode",
",",
"ship",
"type",
",",
"break",
"pipeline",
")",
";",
"channel",
"set",
"ship",
"strategy",
"(",
"ship",
"type",
",",
"partition",
"keys",
",",
"sort",
"direction",
",",
"partitioner",
",",
"ex",
"mode",
")",
";",
"}"
]
|
[
"keep",
"calling",
"this",
"till",
"you",
"get",
"a",
"{",
"@",
"link",
"e",
"o",
"f",
"exception",
"}",
"for",
"getting",
"logs",
"of",
"the",
"specific",
"types",
"for",
"a",
"single",
"container"
]
| [
"public",
"static",
"int",
"read",
"container",
"logs",
"for",
"a",
"log",
"type",
"(",
"data",
"input",
"stream",
"value",
"stream",
",",
"print",
"stream",
"out",
",",
"long",
"log",
"uploaded",
"time",
",",
"list",
"<",
"string",
">",
"log",
"type",
",",
"long",
"bytes",
")",
"throws",
"i",
"o",
"exception",
"{",
"byte",
"[",
"]",
"buf",
"=",
"new",
"byte",
"[",
"65535",
"]",
";",
"string",
"file",
"type",
"=",
"value",
"stream",
"read",
"u",
"t",
"f",
"(",
")",
";",
"string",
"file",
"length",
"str",
"=",
"value",
"stream",
"read",
"u",
"t",
"f",
"(",
")",
";",
"long",
"file",
"length",
"=",
"long",
"parse",
"long",
"(",
"file",
"length",
"str",
")",
";",
"if",
"(",
"log",
"type",
"contains",
"(",
"file",
"type",
")",
")",
"{",
"out",
"print",
"(",
"\"",
"log",
"type",
":",
"\"",
")",
";",
"out",
"println",
"(",
"file",
"type",
")",
";",
"if",
"(",
"log",
"uploaded",
"time",
"!",
"=",
"-",
"1",
")",
"{",
"out",
"print",
"(",
"\"",
"log",
"upload",
"time",
":",
"\"",
")",
";",
"out",
"println",
"(",
"times",
"format",
"(",
"log",
"uploaded",
"time",
")",
")",
";",
"}",
"out",
"print",
"(",
"\"",
"log",
"length",
":",
"\"",
")",
";",
"out",
"println",
"(",
"file",
"length",
"str",
")",
";",
"out",
"println",
"(",
"\"",
"log",
"contents",
":",
"\"",
")",
";",
"long",
"to",
"skip",
"=",
"0",
";",
"long",
"total",
"bytes",
"to",
"read",
"=",
"file",
"length",
";",
"long",
"skip",
"after",
"read",
"=",
"0",
";",
"if",
"(",
"bytes",
"<",
"0",
")",
"{",
"long",
"abs",
"bytes",
"=",
"math",
"abs",
"(",
"bytes",
")",
";",
"if",
"(",
"abs",
"bytes",
"<",
"file",
"length",
")",
"{",
"to",
"skip",
"=",
"file",
"length",
"-",
"abs",
"bytes",
";",
"total",
"bytes",
"to",
"read",
"=",
"abs",
"bytes",
";",
"}",
"org",
"apache",
"hadoop",
"io",
"i",
"o",
"utils",
"skip",
"fully",
"(",
"value",
"stream",
",",
"to",
"skip",
")",
";",
"}",
"else",
"{",
"if",
"(",
"bytes",
"<",
"file",
"length",
")",
"{",
"total",
"bytes",
"to",
"read",
"=",
"bytes",
";",
"skip",
"after",
"read",
"=",
"file",
"length",
"-",
"bytes",
";",
"}",
"}",
"long",
"cur",
"read",
"=",
"0",
";",
"long",
"pending",
"read",
"=",
"total",
"bytes",
"to",
"read",
"-",
"cur",
"read",
";",
"int",
"to",
"read",
"=",
"pending",
"read",
">",
"buf",
"length",
"?",
"buf",
"length",
":",
"(",
"int",
")",
"pending",
"read",
";",
"int",
"len",
"=",
"value",
"stream",
"read",
"(",
"buf",
",",
"0",
",",
"to",
"read",
")",
";",
"while",
"(",
"len",
"!",
"=",
"-",
"1",
"&",
"&",
"cur",
"read",
"<",
"total",
"bytes",
"to",
"read",
")",
"{",
"out",
"write",
"(",
"buf",
",",
"0",
",",
"len",
")",
";",
"cur",
"read",
"+",
"=",
"len",
";",
"pending",
"read",
"=",
"total",
"bytes",
"to",
"read",
"-",
"cur",
"read",
";",
"to",
"read",
"=",
"pending",
"read",
">",
"buf",
"length",
"?",
"buf",
"length",
":",
"(",
"int",
")",
"pending",
"read",
";",
"len",
"=",
"value",
"stream",
"read",
"(",
"buf",
",",
"0",
",",
"to",
"read",
")",
";",
"}",
"org",
"apache",
"hadoop",
"io",
"i",
"o",
"utils",
"skip",
"fully",
"(",
"value",
"stream",
",",
"skip",
"after",
"read",
")",
";",
"out",
"println",
"(",
"\"",
"\\",
"n",
"end",
"of",
"log",
"type",
":",
"\"",
"+",
"file",
"type",
")",
";",
"out",
"println",
"(",
"\"",
"\"",
")",
";",
"return",
"0",
";",
"}",
"else",
"{",
"long",
"total",
"skipped",
"=",
"0",
";",
"long",
"curr",
"skipped",
"=",
"0",
";",
"while",
"(",
"curr",
"skipped",
"!",
"=",
"-",
"1",
"&",
"&",
"total",
"skipped",
"<",
"file",
"length",
")",
"{",
"curr",
"skipped",
"=",
"value",
"stream",
"skip",
"(",
"file",
"length",
"-",
"total",
"skipped",
")",
";",
"total",
"skipped",
"+",
"=",
"curr",
"skipped",
";",
"}",
"return",
"-",
"1",
";",
"}",
"}"
]
|
[
"program",
"entry",
"point"
]
| [
"public",
"static",
"void",
"main",
"(",
"string",
"[",
"]",
"args",
")",
"{",
"var",
"context",
"=",
"new",
"class",
"path",
"xml",
"application",
"context",
"(",
"\"",
"application",
"context",
"xml",
"\"",
")",
";",
"var",
"repository",
"=",
"context",
"get",
"bean",
"(",
"person",
"repository",
"class",
")",
";",
"var",
"peter",
"=",
"new",
"person",
"(",
"\"",
"peter",
"\"",
",",
"\"",
"sagan",
"\"",
",",
"17",
")",
";",
"var",
"nasta",
"=",
"new",
"person",
"(",
"\"",
"nasta",
"\"",
",",
"\"",
"kuzminova",
"\"",
",",
"25",
")",
";",
"var",
"john",
"=",
"new",
"person",
"(",
"\"",
"john",
"\"",
",",
"\"",
"lawrence",
"\"",
",",
"35",
")",
";",
"var",
"terry",
"=",
"new",
"person",
"(",
"\"",
"terry",
"\"",
",",
"\"",
"law",
"\"",
",",
"36",
")",
";",
"/",
"/",
"add",
"new",
"person",
"records",
"repository",
"save",
"(",
"peter",
")",
";",
"repository",
"save",
"(",
"nasta",
")",
";",
"repository",
"save",
"(",
"john",
")",
";",
"repository",
"save",
"(",
"terry",
")",
";",
"/",
"/",
"count",
"person",
"records",
"logger",
"info",
"(",
"\"",
"count",
"person",
"records",
":",
"{",
"}",
"\"",
",",
"repository",
"count",
"(",
")",
")",
";",
"/",
"/",
"print",
"all",
"records",
"var",
"persons",
"=",
"(",
"list",
"<",
"person",
">",
")",
"repository",
"find",
"all",
"(",
")",
";",
"persons",
"stream",
"(",
")",
"map",
"(",
"person",
":",
":",
"to",
"string",
")",
"for",
"each",
"(",
"logger",
":",
":",
"info",
")",
";",
"/",
"/",
"update",
"person",
"nasta",
"set",
"name",
"(",
"\"",
"barbora",
"\"",
")",
";",
"nasta",
"set",
"surname",
"(",
"\"",
"spotakova",
"\"",
")",
";",
"repository",
"save",
"(",
"nasta",
")",
";",
"repository",
"find",
"by",
"id",
"(",
"2l",
")",
"if",
"present",
"(",
"p",
"-",
">",
"logger",
"info",
"(",
"\"",
"find",
"by",
"id",
"2",
":",
"{",
"}",
"\"",
",",
"p",
")",
")",
";",
"/",
"/",
"remove",
"record",
"from",
"person",
"repository",
"delete",
"by",
"id",
"(",
"2l",
")",
";",
"/",
"/",
"count",
"records",
"logger",
"info",
"(",
"\"",
"count",
"person",
"records",
":",
"{",
"}",
"\"",
",",
"repository",
"count",
"(",
")",
")",
";",
"/",
"/",
"find",
"by",
"name",
"repository",
"find",
"one",
"(",
"new",
"person",
"specifications",
"name",
"equal",
"spec",
"(",
"\"",
"john",
"\"",
")",
")",
"if",
"present",
"(",
"p",
"-",
">",
"logger",
"info",
"(",
"\"",
"find",
"by",
"john",
"is",
"{",
"}",
"\"",
",",
"p",
")",
")",
";",
"/",
"/",
"find",
"by",
"age",
"persons",
"=",
"repository",
"find",
"all",
"(",
"new",
"person",
"specifications",
"age",
"between",
"spec",
"(",
"20",
",",
"40",
")",
")",
";",
"logger",
"info",
"(",
"\"",
"find",
"person",
"with",
"age",
"between",
"20",
",",
"40",
":",
"\"",
")",
";",
"persons",
"stream",
"(",
")",
"map",
"(",
"person",
":",
":",
"to",
"string",
")",
"for",
"each",
"(",
"logger",
":",
":",
"info",
")",
";",
"repository",
"delete",
"all",
"(",
")",
";",
"context",
"close",
"(",
")",
";",
"}"
]
|
[
"called",
"when",
"the",
"node",
"is",
"started"
]
| [
"default",
"void",
"on",
"node",
"started",
"(",
")",
"{",
"}"
]
|
[
"schedules",
"the",
"given",
"runnable",
"periodically",
"on",
"the",
"underlying",
"executor",
"directly",
"and",
"returns",
"its",
"future",
"wrapped",
"into",
"a",
"disposable"
]
| [
"public",
"disposable",
"schedule",
"periodically",
"direct",
"(",
"runnable",
"run",
",",
"long",
"initial",
"delay",
",",
"long",
"period",
",",
"time",
"unit",
"unit",
")",
"{",
"final",
"runnable",
"decorated",
"run",
"=",
"rx",
"java",
"plugins",
"on",
"schedule",
"(",
"run",
")",
";",
"if",
"(",
"period",
"<",
"=",
"0l",
")",
"{",
"instant",
"periodic",
"task",
"periodic",
"wrapper",
"=",
"new",
"instant",
"periodic",
"task",
"(",
"decorated",
"run",
",",
"executor",
")",
";",
"try",
"{",
"future",
"<",
"?",
">",
"f",
";",
"if",
"(",
"initial",
"delay",
"<",
"=",
"0l",
")",
"{",
"f",
"=",
"executor",
"submit",
"(",
"periodic",
"wrapper",
")",
";",
"}",
"else",
"{",
"f",
"=",
"executor",
"schedule",
"(",
"periodic",
"wrapper",
",",
"initial",
"delay",
",",
"unit",
")",
";",
"}",
"periodic",
"wrapper",
"set",
"first",
"(",
"f",
")",
";",
"}",
"catch",
"(",
"rejected",
"execution",
"exception",
"ex",
")",
"{",
"rx",
"java",
"plugins",
"on",
"error",
"(",
"ex",
")",
";",
"return",
"empty",
"disposable",
"instance",
";",
"}",
"return",
"periodic",
"wrapper",
";",
"}",
"scheduled",
"direct",
"periodic",
"task",
"task",
"=",
"new",
"scheduled",
"direct",
"periodic",
"task",
"(",
"decorated",
"run",
")",
";",
"try",
"{",
"future",
"<",
"?",
">",
"f",
"=",
"executor",
"schedule",
"at",
"fixed",
"rate",
"(",
"task",
",",
"initial",
"delay",
",",
"period",
",",
"unit",
")",
";",
"task",
"set",
"future",
"(",
"f",
")",
";",
"return",
"task",
";",
"}",
"catch",
"(",
"rejected",
"execution",
"exception",
"ex",
")",
"{",
"rx",
"java",
"plugins",
"on",
"error",
"(",
"ex",
")",
";",
"return",
"empty",
"disposable",
"instance",
";",
"}",
"}"
]
|
[
"free",
"the",
"direct",
"{",
"@",
"link",
"byte",
"buffer",
"}"
]
| [
"public",
"static",
"void",
"free",
"(",
"byte",
"buffer",
"buffer",
")",
"{",
"platform",
"dependent",
"free",
"direct",
"buffer",
"(",
"buffer",
")",
";",
"}"
]
|
[
"returns",
"the",
"object",
"whose",
"integer",
"values",
"represent",
"various",
"interpretations",
"for",
"example",
",",
"if",
"d",
"tag",
"=",
"=",
"dt",
"symtab",
",",
"then",
"d",
"val",
"holds",
"the",
"address",
"of",
"the",
"symbol",
"table",
"but",
",",
"if",
"d",
"tag",
"=",
"=",
"dt",
"syment",
",",
"then",
"d",
"val",
"holds",
"the",
"size",
"of",
"each",
"symbol",
"entry"
]
| [
"public",
"long",
"get",
"value",
"(",
")",
"{",
"return",
"d",
"val",
";",
"}"
]
|
[
"set",
"the",
"domain",
"id"
]
| [
"public",
"void",
"set",
"id",
"(",
"string",
"id",
")",
"{",
"this",
"id",
"=",
"id",
";",
"}"
]
|
[
"sets",
"the",
"y",
"axis",
"phase",
"of",
"the",
"animation"
]
| [
"public",
"void",
"set",
"phase",
"y",
"(",
"float",
"phase",
")",
"{",
"if",
"(",
"phase",
">",
"1f",
")",
"{",
"phase",
"=",
"1f",
";",
"}",
"else",
"if",
"(",
"phase",
"<",
"0f",
")",
"{",
"phase",
"=",
"0f",
";",
"}",
"m",
"phase",
"y",
"=",
"phase",
";",
"}"
]
|
[
"traverses",
"the",
"resource",
"table",
"and",
"compiled",
"xml",
"resource",
"using",
"the",
"{",
"@",
"link",
"resource",
"visitor",
"}"
]
| [
"public",
"<",
"t",
"extends",
"resource",
"visitor",
">",
"t",
"visit",
"resources",
"(",
"t",
"visitor",
")",
"throws",
"i",
"o",
"exception",
"{",
"/",
"/",
"visit",
"manifest",
"visit",
"xml",
"resource",
"(",
"apk",
"file",
"system",
"get",
"path",
"(",
"manifest",
")",
",",
"visitor",
"entering",
"manifest",
"(",
")",
")",
";",
"/",
"/",
"visit",
"resource",
"table",
"and",
"associated",
"files",
"final",
"resource",
"table",
"resource",
"table",
"=",
"get",
"resource",
"table",
"(",
")",
";",
"final",
"list",
"<",
"string",
">",
"source",
"pool",
"=",
"resource",
"table",
"has",
"source",
"pool",
"(",
")",
"?",
"decode",
"source",
"pool",
"(",
"resource",
"table",
"get",
"source",
"pool",
"(",
")",
"get",
"data",
"(",
")",
"to",
"byte",
"array",
"(",
")",
")",
":",
"immutable",
"list",
"of",
"(",
")",
";",
"for",
"(",
"package",
"pkg",
":",
"resource",
"table",
"get",
"package",
"list",
"(",
")",
")",
"{",
"resource",
"package",
"visitor",
"pkg",
"visitor",
"=",
"visitor",
"entering",
"package",
"(",
"pkg",
"get",
"package",
"id",
"(",
")",
"get",
"id",
"(",
")",
",",
"pkg",
"get",
"package",
"name",
"(",
")",
")",
";",
"if",
"(",
"pkg",
"visitor",
"!",
"=",
"null",
")",
"{",
"for",
"(",
"resources",
"type",
"type",
":",
"pkg",
"get",
"type",
"list",
"(",
")",
")",
"{",
"resource",
"type",
"visitor",
"type",
"visitor",
"=",
"pkg",
"visitor",
"entering",
"resource",
"type",
"(",
"type",
"get",
"type",
"id",
"(",
")",
"get",
"id",
"(",
")",
",",
"resource",
"type",
"get",
"enum",
"(",
"type",
"get",
"name",
"(",
")",
")",
")",
";",
"if",
"(",
"type",
"visitor",
"!",
"=",
"null",
")",
"{",
"for",
"(",
"entry",
"entry",
":",
"type",
"get",
"entry",
"list",
"(",
")",
")",
"{",
"resource",
"value",
"visitor",
"entry",
"visitor",
"=",
"type",
"visitor",
"entering",
"declaration",
"(",
"entry",
"get",
"name",
"(",
")",
",",
"entry",
"get",
"entry",
"id",
"(",
")",
"get",
"id",
"(",
")",
")",
";",
"if",
"(",
"entry",
"visitor",
"!",
"=",
"null",
")",
"{",
"for",
"(",
"config",
"value",
"config",
"value",
":",
"entry",
"get",
"config",
"value",
"list",
"(",
")",
")",
"{",
"if",
"(",
"config",
"value",
"has",
"value",
"(",
")",
")",
"{",
"visit",
"value",
"(",
"entry",
"visitor",
",",
"config",
"value",
"get",
"value",
"(",
")",
",",
"source",
"pool",
")",
";",
"}",
"}",
"}",
"}",
"}",
"}",
"}",
"}",
"return",
"visitor",
";",
"}"
]
|
[
"atomically",
"sets",
"the",
"subscription",
"on",
"the",
"field",
"and",
"cancels",
"the",
"previous",
"subscription",
"if",
"any"
]
| [
"public",
"static",
"boolean",
"set",
"(",
"atomic",
"reference",
"<",
"subscription",
">",
"field",
",",
"subscription",
"s",
")",
"{",
"for",
"(",
";",
";",
")",
"{",
"subscription",
"current",
"=",
"field",
"get",
"(",
")",
";",
"if",
"(",
"current",
"=",
"=",
"cancelled",
")",
"{",
"if",
"(",
"s",
"!",
"=",
"null",
")",
"{",
"s",
"cancel",
"(",
")",
";",
"}",
"return",
"false",
";",
"}",
"if",
"(",
"field",
"compare",
"and",
"set",
"(",
"current",
",",
"s",
")",
")",
"{",
"if",
"(",
"current",
"!",
"=",
"null",
")",
"{",
"current",
"cancel",
"(",
")",
";",
"}",
"return",
"true",
";",
"}",
"}",
"}"
]
|
[
"initialize",
"this",
"container",
"creates",
"a",
"jms",
"connection",
",",
"starts",
"the",
"{",
"@",
"link",
"javax",
"jms",
"connection",
"}",
"(",
"if",
"{",
"@",
"link",
"#",
"set",
"auto",
"startup",
"(",
"boolean",
")",
"\"",
"auto",
"startup",
"\"",
"}",
"hasn",
"'",
"t",
"been",
"turned",
"off",
")",
",",
"and",
"calls",
"{",
"@",
"link",
"#",
"do",
"initialize",
"(",
")",
"}"
]
| [
"public",
"void",
"initialize",
"(",
")",
"throws",
"jms",
"exception",
"{",
"try",
"{",
"synchronized",
"(",
"this",
"lifecycle",
"monitor",
")",
"{",
"this",
"active",
"=",
"true",
";",
"this",
"lifecycle",
"monitor",
"notify",
"all",
"(",
")",
";",
"}",
"do",
"initialize",
"(",
")",
";",
"}",
"catch",
"(",
"j",
"m",
"s",
"exception",
"ex",
")",
"{",
"synchronized",
"(",
"this",
"shared",
"connection",
"monitor",
")",
"{",
"connection",
"factory",
"utils",
"release",
"connection",
"(",
"this",
"shared",
"connection",
",",
"get",
"connection",
"factory",
"(",
")",
",",
"this",
"auto",
"startup",
")",
";",
"this",
"shared",
"connection",
"=",
"null",
";",
"}",
"throw",
"convert",
"jms",
"access",
"exception",
"(",
"ex",
")",
";",
"}",
"}"
]
|
[
"initializes",
"the",
"buffer"
]
| [
"public",
"byte",
"buffer",
"init",
"(",
"long",
"time",
"us",
",",
"int",
"size",
")",
"{",
"this",
"time",
"us",
"=",
"time",
"us",
";",
"if",
"(",
"data",
"=",
"=",
"null",
"|",
"|",
"data",
"capacity",
"(",
")",
"<",
"size",
")",
"{",
"data",
"=",
"byte",
"buffer",
"allocate",
"direct",
"(",
"size",
")",
"order",
"(",
"byte",
"order",
"native",
"order",
"(",
")",
")",
";",
"}",
"data",
"position",
"(",
"0",
")",
";",
"data",
"limit",
"(",
"size",
")",
";",
"return",
"data",
";",
"}"
]
|
[
"the",
"result",
"of",
"a",
"call",
"to",
"this",
"method",
"is",
"equivalent",
"to",
"{",
"@",
"link",
"#",
"process",
"touch",
"event",
"(",
"android",
"view",
"motion",
"event",
")",
"}",
"receiving",
"an",
"action",
"cancel",
"event"
]
| [
"public",
"void",
"cancel",
"(",
")",
"{",
"m",
"active",
"pointer",
"id",
"=",
"invalid",
"pointer",
";",
"clear",
"motion",
"history",
"(",
")",
";",
"if",
"(",
"m",
"velocity",
"tracker",
"!",
"=",
"null",
")",
"{",
"m",
"velocity",
"tracker",
"recycle",
"(",
")",
";",
"m",
"velocity",
"tracker",
"=",
"null",
";",
"}",
"}"
]
|
[
"convenience",
"factory",
"for",
"{",
"@",
"link",
"kind",
"u",
"d",
"t",
"#",
"connector",
"}",
"channels"
]
| [
"static",
"socket",
"channel",
"u",
"d",
"t",
"new",
"connector",
"channel",
"u",
"d",
"t",
"(",
"final",
"type",
"u",
"d",
"t",
"type",
")",
"{",
"try",
"{",
"return",
"selector",
"provider",
"u",
"d",
"t",
"from",
"(",
"type",
")",
"open",
"socket",
"channel",
"(",
")",
";",
"}",
"catch",
"(",
"final",
"i",
"o",
"exception",
"e",
")",
"{",
"throw",
"new",
"channel",
"exception",
"(",
"\"",
"failed",
"to",
"open",
"a",
"socket",
"channel",
"\"",
",",
"e",
")",
";",
"}",
"}"
]
|
[
"sorts",
"the",
"elements",
"of",
"{",
"@",
"code",
"array",
"}",
"in",
"descending",
"order",
"note",
"that",
"this",
"method",
"uses",
"the",
"total",
"order",
"imposed",
"by",
"{",
"@",
"link",
"double",
"#",
"compare",
"}",
",",
"which",
"treats",
"all",
"na",
"n",
"values",
"as",
"equal",
"and",
"0",
"0",
"as",
"greater",
"than",
"-",
"0",
"0"
]
| [
"public",
"static",
"void",
"sort",
"descending",
"(",
"double",
"[",
"]",
"array",
")",
"{",
"check",
"not",
"null",
"(",
"array",
")",
";",
"sort",
"descending",
"(",
"array",
",",
"0",
",",
"array",
"length",
")",
";",
"}"
]
|
[
"parses",
"the",
"optional",
"specified",
"string",
"as",
"a",
"decimal",
"number",
",",
"returning",
"its",
"integer",
"value"
]
| [
"public",
"static",
"int",
"parse",
"int",
"(",
"string",
"int",
"str",
",",
"int",
"default",
"value",
")",
"throws",
"number",
"format",
"exception",
"{",
"return",
"parse",
"optional",
"bounded",
"int",
"(",
"int",
"str",
",",
"default",
"value",
",",
"integer",
"min",
"value",
",",
"integer",
"max",
"value",
")",
";",
"}"
]
|
[
"sets",
"the",
"{",
"@",
"link",
"glide",
"executor",
"}",
"to",
"use",
"when",
"retrieving",
"{",
"@",
"link",
"com",
"bumptech",
"glide",
"load",
"engine",
"resource",
"}",
"s",
"that",
"are",
"not",
"already",
"in",
"the",
"cache",
"the",
"thread",
"count",
"defaults",
"to",
"the",
"number",
"of",
"cores",
"available",
"on",
"the",
"device",
",",
"with",
"a",
"maximum",
"of",
"4",
"use",
"the",
"{",
"@",
"link",
"glide",
"executor",
"#",
"new",
"source",
"executor",
"(",
")",
"}",
"methods",
"if",
"you",
"'",
"d",
"like",
"to",
"specify",
"options",
"for",
"the",
"source",
"executor"
]
| [
"public",
"glide",
"builder",
"set",
"resize",
"executor",
"(",
"@",
"nullable",
"glide",
"executor",
"service",
")",
"{",
"return",
"set",
"source",
"executor",
"(",
"service",
")",
";",
"}"
]
|
[
"change",
"the",
"start",
"symbol",
"for",
"the",
"grammar"
]
| [
"public",
"void",
"set",
"start",
"name",
"(",
"string",
"start",
"name",
")",
"{",
"this",
"start",
"name",
"=",
"start",
"name",
";",
"}"
]
|
[
"save",
"the",
"batch",
"'",
"s",
"edeks",
"to",
"file",
"xattrs"
]
| [
"static",
"void",
"save",
"file",
"x",
"attrs",
"for",
"batch",
"(",
"f",
"s",
"directory",
"fsd",
",",
"list",
"<",
"file",
"edek",
"info",
">",
"batch",
")",
"{",
"assert",
"fsd",
"get",
"f",
"s",
"namesystem",
"(",
")",
"has",
"write",
"lock",
"(",
")",
";",
"if",
"(",
"batch",
"!",
"=",
"null",
"&",
"&",
"!",
"batch",
"is",
"empty",
"(",
")",
")",
"{",
"for",
"(",
"file",
"edek",
"info",
"entry",
":",
"batch",
")",
"{",
"final",
"i",
"node",
"inode",
"=",
"fsd",
"get",
"inode",
"(",
"entry",
"get",
"inode",
"id",
"(",
")",
")",
";",
"/",
"/",
"no",
"dir",
"lock",
",",
"so",
"inode",
"could",
"be",
"removed",
"no",
"-",
"op",
"if",
"so",
"if",
"(",
"inode",
"=",
"=",
"null",
")",
"{",
"name",
"node",
"log",
"info",
"(",
"\"",
"cannot",
"find",
"inode",
"{",
"}",
",",
"skip",
"saving",
"xattr",
"for",
"\"",
"+",
"\"",
"re",
"-",
"encryption",
"\"",
",",
"entry",
"get",
"inode",
"id",
"(",
")",
")",
";",
"continue",
";",
"}",
"fsd",
"get",
"edit",
"log",
"(",
")",
"log",
"set",
"x",
"attrs",
"(",
"inode",
"get",
"full",
"path",
"name",
"(",
")",
",",
"inode",
"get",
"x",
"attr",
"feature",
"(",
")",
"get",
"x",
"attrs",
"(",
")",
",",
"false",
")",
";",
"}",
"}",
"}"
]
|
[
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"the",
"provided",
"reference",
"is",
"non",
"-",
"{",
"@",
"code",
"null",
"}",
"otherwise",
"returns",
"{",
"@",
"code",
"false",
"}"
]
| [
"public",
"static",
"boolean",
"non",
"null",
"(",
"object",
"obj",
")",
"{",
"return",
"obj",
"!",
"=",
"null",
";",
"}"
]
|
[
"when",
"mark",
"(",
")",
"is",
"used",
"on",
"buffered",
"input",
"stream",
",",
"the",
"request",
"size",
"on",
"the",
"checksum",
"file",
"system",
"can",
"be",
"small",
"however",
",",
"checksum",
"file",
"system",
"currently",
"depends",
"on",
"the",
"request",
"size",
">",
"=",
"bytes",
"per",
"sum",
"to",
"work",
"properly"
]
| [
"public",
"void",
"test",
"truncated",
"input",
"bug",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"int",
"io",
"buf",
"size",
"=",
"512",
";",
"final",
"int",
"file",
"size",
"=",
"io",
"buf",
"size",
"*",
"4",
";",
"int",
"file",
"pos",
"=",
"0",
";",
"configuration",
"conf",
"=",
"new",
"configuration",
"(",
")",
";",
"conf",
"set",
"int",
"(",
"\"",
"io",
"file",
"buffer",
"size",
"\"",
",",
"io",
"buf",
"size",
")",
";",
"file",
"system",
"file",
"sys",
"=",
"file",
"system",
"get",
"local",
"(",
"conf",
")",
";",
"try",
"{",
"/",
"/",
"first",
"create",
"a",
"test",
"input",
"file",
"path",
"test",
"file",
"=",
"new",
"path",
"(",
"test",
"root",
"dir",
",",
"\"",
"hadoop",
"-",
"1489",
"\"",
")",
";",
"write",
"file",
"(",
"file",
"sys",
",",
"test",
"file",
",",
"file",
"size",
")",
";",
"assert",
"true",
"(",
"file",
"sys",
"exists",
"(",
"test",
"file",
")",
")",
";",
"assert",
"true",
"(",
"file",
"sys",
"get",
"file",
"status",
"(",
"test",
"file",
")",
"get",
"len",
"(",
")",
"=",
"=",
"file",
"size",
")",
";",
"/",
"/",
"now",
"read",
"the",
"file",
"for",
"io",
"buf",
"size",
"bytes",
"f",
"s",
"data",
"input",
"stream",
"in",
"=",
"file",
"sys",
"open",
"(",
"test",
"file",
",",
"io",
"buf",
"size",
")",
";",
"/",
"/",
"seek",
"beyond",
"data",
"buffered",
"by",
"open",
"file",
"pos",
"+",
"=",
"io",
"buf",
"size",
"*",
"2",
"+",
"(",
"io",
"buf",
"size",
"-",
"10",
")",
";",
"in",
"seek",
"(",
"file",
"pos",
")",
";",
"/",
"/",
"read",
"4",
"more",
"bytes",
"before",
"marking",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"4",
";",
"+",
"+",
"i",
")",
"{",
"if",
"(",
"in",
"read",
"(",
")",
"=",
"=",
"-",
"1",
")",
"{",
"break",
";",
"}",
"+",
"+",
"file",
"pos",
";",
"}",
"/",
"/",
"now",
"set",
"mark",
"(",
")",
"to",
"trigger",
"the",
"bug",
"/",
"/",
"note",
":",
"in",
"the",
"fixed",
"code",
",",
"mark",
"(",
")",
"does",
"nothing",
"(",
"not",
"supported",
")",
"and",
"/",
"/",
"hence",
"won",
"'",
"t",
"trigger",
"this",
"bug",
"in",
"mark",
"(",
"1",
")",
";",
"system",
"out",
"println",
"(",
"\"",
"marked",
"\"",
")",
";",
"/",
"/",
"try",
"to",
"read",
"the",
"rest",
"while",
"(",
"file",
"pos",
"<",
"file",
"size",
")",
"{",
"if",
"(",
"in",
"read",
"(",
")",
"=",
"=",
"-",
"1",
")",
"{",
"break",
";",
"}",
"+",
"+",
"file",
"pos",
";",
"}",
"in",
"close",
"(",
")",
";",
"system",
"out",
"println",
"(",
"\"",
"read",
"\"",
"+",
"file",
"pos",
"+",
"\"",
"bytes",
"\"",
"+",
"\"",
"file",
"size",
"=",
"\"",
"+",
"file",
"size",
")",
";",
"assert",
"true",
"(",
"file",
"pos",
"=",
"=",
"file",
"size",
")",
";",
"}",
"finally",
"{",
"try",
"{",
"file",
"sys",
"close",
"(",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"/",
"/",
"noop",
"}",
"}",
"}"
]
|
[
"return",
"true",
"if",
"this",
"type",
"holder",
"example",
"object",
"is",
"equal",
"to",
"o"
]
| [
"public",
"boolean",
"equals",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"this",
"=",
"=",
"o",
")",
"{",
"return",
"true",
";",
"}",
"if",
"(",
"o",
"=",
"=",
"null",
"|",
"|",
"get",
"class",
"(",
")",
"!",
"=",
"o",
"get",
"class",
"(",
")",
")",
"{",
"return",
"false",
";",
"}",
"type",
"holder",
"example",
"type",
"holder",
"example",
"=",
"(",
"type",
"holder",
"example",
")",
"o",
";",
"return",
"objects",
"equals",
"(",
"this",
"string",
"item",
",",
"type",
"holder",
"example",
"string",
"item",
")",
"&",
"&",
"objects",
"equals",
"(",
"this",
"number",
"item",
",",
"type",
"holder",
"example",
"number",
"item",
")",
"&",
"&",
"objects",
"equals",
"(",
"this",
"float",
"item",
",",
"type",
"holder",
"example",
"float",
"item",
")",
"&",
"&",
"objects",
"equals",
"(",
"this",
"integer",
"item",
",",
"type",
"holder",
"example",
"integer",
"item",
")",
"&",
"&",
"objects",
"equals",
"(",
"this",
"bool",
"item",
",",
"type",
"holder",
"example",
"bool",
"item",
")",
"&",
"&",
"objects",
"equals",
"(",
"this",
"array",
"item",
",",
"type",
"holder",
"example",
"array",
"item",
")",
";",
"}"
]
|
[
"returns",
"whether",
"the",
"truncate",
"range",
"should",
"use",
"the",
"block",
"size",
"range"
]
| [
"boolean",
"should",
"truncate",
"use",
"block",
"size",
"(",
")",
"{",
"range",
"<",
"long",
">",
"truncate",
"range",
"=",
"get",
"truncate",
"size",
"(",
")",
";",
"if",
"(",
"truncate",
"range",
"=",
"=",
"null",
"|",
"|",
"(",
"truncate",
"range",
"get",
"lower",
"(",
")",
"=",
"=",
"truncate",
"range",
"get",
"upper",
"(",
")",
"&",
"&",
"(",
"truncate",
"range",
"get",
"upper",
"(",
")",
"=",
"=",
"long",
"max",
"value",
")",
")",
")",
"{",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}"
]
|
[
"returns",
"the",
"program",
"info",
"from",
"the",
"underlying",
"file",
"t",
"`",
"`",
"his",
"method",
"does",
"not",
"make",
"sense",
"to",
"invoke",
"if",
"a",
"write",
"is",
"being",
"performed",
"to",
"a",
"new",
"file"
]
| [
"public",
"program",
"info",
"get",
"program",
"info",
"(",
")",
"throws",
"s",
"a",
"x",
"exception",
",",
"i",
"o",
"exception",
"{",
"if",
"(",
"info",
"!",
"=",
"null",
")",
"{",
"return",
"info",
";",
"}",
"info",
"=",
"new",
"program",
"info",
"(",
")",
";",
"xml",
"pull",
"parser",
"parser",
"=",
"xml",
"pull",
"parser",
"factory",
"create",
"(",
"file",
",",
"new",
"my",
"error",
"handler",
"(",
"new",
"message",
"log",
"(",
")",
")",
",",
"false",
")",
";",
"boolean",
"is",
"file",
"valid",
"=",
"false",
";",
"string",
"ver",
"=",
"parser",
"get",
"processing",
"instruction",
"(",
"program",
"dtd",
",",
"\"",
"version",
"\"",
")",
";",
"if",
"(",
"ver",
"!",
"=",
"null",
")",
"{",
"try",
"{",
"dtd",
"version",
"=",
"integer",
"parse",
"int",
"(",
"ver",
")",
";",
"}",
"catch",
"(",
"number",
"format",
"exception",
"e",
")",
"{",
"msg",
"debug",
"(",
"this",
",",
"\"",
"unable",
"to",
"parse",
"dtd",
":",
"\"",
"+",
"ver",
")",
";",
"}",
"}",
"while",
"(",
"parser",
"has",
"next",
"(",
")",
")",
"{",
"xml",
"element",
"element",
"=",
"parser",
"next",
"(",
")",
";",
"string",
"name",
"=",
"element",
"get",
"name",
"(",
")",
";",
"if",
"(",
"name",
"equals",
"(",
"\"",
"program",
"\"",
")",
"&",
"&",
"element",
"is",
"start",
"(",
")",
")",
"{",
"is",
"file",
"valid",
"=",
"true",
";",
"info",
"program",
"name",
"=",
"element",
"get",
"attribute",
"(",
"\"",
"name",
"\"",
")",
";",
"info",
"exe",
"path",
"=",
"element",
"get",
"attribute",
"(",
"\"",
"exe",
"path",
"\"",
")",
";",
"info",
"exe",
"format",
"=",
"element",
"get",
"attribute",
"(",
"\"",
"exe",
"format",
"\"",
")",
";",
"info",
"image",
"base",
"=",
"element",
"get",
"attribute",
"(",
"\"",
"image",
"base",
"\"",
")",
";",
"}",
"else",
"if",
"(",
"name",
"equals",
"(",
"\"",
"info",
"source",
"\"",
")",
"&",
"&",
"element",
"is",
"start",
"(",
")",
")",
"{",
"info",
"user",
"=",
"element",
"get",
"attribute",
"(",
"\"",
"user",
"\"",
")",
";",
"info",
"set",
"tool",
"(",
"element",
"get",
"attribute",
"(",
"\"",
"tool",
"\"",
")",
")",
";",
"info",
"timestamp",
"=",
"element",
"get",
"attribute",
"(",
"\"",
"timestamp",
"\"",
")",
";",
"info",
"version",
"=",
"element",
"get",
"attribute",
"(",
"\"",
"version",
"\"",
")",
";",
"if",
"(",
"is",
"old",
"xml",
"(",
")",
"&",
"&",
"info",
"is",
"ghidra",
"(",
")",
")",
"{",
"info",
"program",
"name",
"=",
"element",
"get",
"attribute",
"(",
"\"",
"file",
"\"",
")",
";",
"}",
"}",
"else",
"if",
"(",
"name",
"equals",
"(",
"\"",
"processor",
"\"",
")",
"&",
"&",
"element",
"is",
"start",
"(",
")",
")",
"{",
"string",
"language",
"string",
"=",
"element",
"get",
"attribute",
"(",
"\"",
"language",
"provider",
"\"",
")",
";",
"language",
"compiler",
"spec",
"pair",
"pair",
"=",
"old",
"language",
"mapping",
"service",
"process",
"xml",
"language",
"string",
"(",
"language",
"string",
")",
";",
"if",
"(",
"pair",
"!",
"=",
"null",
")",
"{",
"info",
"language",
"i",
"d",
"=",
"pair",
"language",
"i",
"d",
";",
"info",
"compiler",
"spec",
"i",
"d",
"=",
"pair",
"compiler",
"spec",
"i",
"d",
";",
"}",
"else",
"{",
"info",
"set",
"compiler",
"spec",
"i",
"d",
"(",
"get",
"for",
"compiler",
"tag",
"(",
"parser",
")",
")",
";",
"}",
"info",
"processor",
"name",
"=",
"element",
"get",
"attribute",
"(",
"\"",
"name",
"\"",
")",
";",
"info",
"family",
"=",
"element",
"get",
"attribute",
"(",
"\"",
"family",
"\"",
")",
";",
"info",
"address",
"model",
"=",
"element",
"get",
"attribute",
"(",
"\"",
"address",
"model",
"\"",
")",
";",
"info",
"endian",
"=",
"element",
"get",
"attribute",
"(",
"\"",
"endian",
"\"",
")",
";",
"break",
";",
"}",
"}",
"parser",
"dispose",
"(",
")",
";",
"if",
"(",
"!",
"is",
"file",
"valid",
")",
"{",
"info",
"=",
"null",
";",
"}",
"return",
"info",
";",
"}"
]
|
[
"validate",
"the",
"abort",
"logic"
]
| [
"public",
"void",
"test",
"close",
"with",
"abort",
"(",
")",
"throws",
"throwable",
"{",
"describe",
"(",
"\"",
"close",
"the",
"stream",
"with",
"the",
"readahead",
"outstanding",
"\"",
")",
";",
"s",
"3",
"a",
"test",
"utils",
"metric",
"diff",
"read",
"ops",
"=",
"new",
"s",
"3",
"a",
"test",
"utils",
"metric",
"diff",
"(",
"get",
"file",
"system",
"(",
")",
",",
"statistic",
"stream",
"read",
"operations",
"incomplete",
")",
";",
"select",
"conf",
"set",
"int",
"(",
"readahead",
"range",
",",
"2",
")",
";",
"f",
"s",
"data",
"input",
"stream",
"stream",
"=",
"select",
"(",
"get",
"file",
"system",
"(",
")",
",",
"csv",
"path",
",",
"select",
"conf",
",",
"\"",
"select",
"*",
"from",
"s3object",
"s",
"\"",
")",
";",
"select",
"input",
"stream",
"sis",
"=",
"(",
"select",
"input",
"stream",
")",
"stream",
"get",
"wrapped",
"stream",
"(",
")",
";",
"assert",
"equals",
"(",
"\"",
"readahead",
"on",
"\"",
"+",
"sis",
",",
"2",
",",
"sis",
"get",
"readahead",
"(",
")",
")",
";",
"stream",
"set",
"readahead",
"(",
"1l",
")",
";",
"assert",
"equals",
"(",
"\"",
"readahead",
"on",
"\"",
"+",
"sis",
",",
"1",
",",
"sis",
"get",
"readahead",
"(",
")",
")",
";",
"stream",
"read",
"(",
")",
";",
"s",
"3",
"a",
"input",
"stream",
"statistics",
"stats",
"=",
"(",
"s",
"3",
"a",
"input",
"stream",
"statistics",
")",
"sis",
"get",
"s",
"3",
"a",
"stream",
"statistics",
"(",
")",
";",
"assert",
"equals",
"(",
"\"",
"read",
"count",
"in",
"\"",
"+",
"sis",
",",
"1",
",",
"stats",
"get",
"bytes",
"read",
"(",
")",
")",
";",
"stream",
"close",
"(",
")",
";",
"assert",
"equals",
"(",
"\"",
"abort",
"count",
"in",
"\"",
"+",
"sis",
",",
"1",
",",
"stats",
"get",
"aborted",
"(",
")",
")",
";",
"read",
"ops",
"assert",
"diff",
"equals",
"(",
"\"",
"read",
"operations",
"are",
"still",
"considered",
"active",
"\"",
",",
"0",
")",
";",
"intercept",
"(",
"path",
"i",
"o",
"exception",
"class",
",",
"f",
"s",
"exception",
"messages",
"stream",
"is",
"closed",
",",
"(",
")",
"-",
">",
"stream",
"read",
"(",
")",
")",
";",
"}"
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.