docstring_tokens
list | code_tokens
list |
|---|---|
[
"fires",
"off",
"the",
"given",
"{",
"@",
"link",
"f",
"v",
"event",
"}",
"using",
"the",
"appropriate",
"{",
"@",
"link",
"observer",
"}",
"methods"
] |
[
"public",
"void",
"send",
"(",
"f",
"v",
"event",
"evt",
")",
"{",
"set",
"changed",
"(",
")",
";",
"notify",
"observers",
"(",
"evt",
")",
";",
"}"
] |
[
"order",
"spec",
"to",
"be",
"used",
"in",
"generated",
"@",
"order",
"by",
"annotation"
] |
[
"public",
"string",
"get",
"order",
"spec",
"(",
")",
"{",
"if",
"(",
"property",
"order",
"list",
"is",
"empty",
"(",
")",
")",
"{",
"return",
"null",
";",
"}",
"else",
"{",
"return",
"property",
"order",
"list",
"get",
"order",
"spec",
"(",
")",
";",
"}",
"}"
] |
[
"we",
"store",
"the",
"counter",
"in",
"the",
"accumulator",
"if",
"the",
"counter",
"is",
"not",
"zero",
",",
"which",
"means",
"we",
"aggregated",
"at",
"least",
"one",
"record",
"for",
"current",
"key"
] |
[
"abstract",
"boolean",
"record",
"count",
"is",
"zero",
"(",
"row",
"data",
"acc",
")",
";"
] |
[
"create",
"a",
"{",
"@",
"link",
"secure",
"setting",
"#",
"secure",
"string",
"secure",
"string",
"}",
"{",
"@",
"link",
"setting",
"}",
"object",
"of",
"a",
"realm",
"of",
"with",
"the",
"provided",
"type",
"and",
"setting",
"suffix"
] |
[
"public",
"static",
"setting",
"affix",
"setting",
"<",
"secure",
"string",
">",
"secure",
"string",
"(",
"string",
"realm",
"type",
",",
"string",
"suffix",
")",
"{",
"return",
"setting",
"affix",
"key",
"setting",
"(",
"realm",
"setting",
"prefix",
"(",
"realm",
"type",
")",
",",
"suffix",
",",
"key",
"-",
">",
"secure",
"setting",
"secure",
"string",
"(",
"key",
",",
"null",
")",
")",
";",
"}"
] |
[
"increments",
"the",
"element",
"of",
"this",
"big",
"array",
"at",
"specified",
"index"
] |
[
"public",
"void",
"increment",
"(",
"long",
"index",
")",
"{",
"array",
"[",
"segment",
"(",
"index",
")",
"]",
"[",
"offset",
"(",
"index",
")",
"]",
"+",
"+",
";",
"}"
] |
[
"return",
"a",
"string",
"describing",
"internal",
"state",
"and",
"counters",
"effectively",
"{",
"@",
"code",
"to",
"string",
"(",
")",
"}",
"on",
"{",
"@",
"link",
"#",
"get",
"stats",
"(",
")",
"get",
"stats",
"(",
")",
"}"
] |
[
"public",
"string",
"get",
"stats",
"info",
"(",
")",
"{",
"return",
"this",
"stats",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"returns",
"true",
"if",
"the",
"array",
"has",
"one",
"or",
"more",
"items"
] |
[
"public",
"boolean",
"not",
"empty",
"(",
")",
"{",
"return",
"size",
">",
"0",
";",
"}"
] |
[
"iterate",
"over",
"registered",
"{",
"@",
"link",
"handler",
"method",
"argument",
"resolver",
"handler",
"method",
"argument",
"resolvers",
"}",
"and",
"invoke",
"the",
"one",
"that",
"supports",
"it"
] |
[
"public",
"mono",
"<",
"object",
">",
"resolve",
"argument",
"(",
"method",
"parameter",
"parameter",
",",
"message",
"<",
"?",
">",
"message",
")",
"{",
"handler",
"method",
"argument",
"resolver",
"resolver",
"=",
"get",
"argument",
"resolver",
"(",
"parameter",
")",
";",
"if",
"(",
"resolver",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"unsupported",
"parameter",
"type",
"[",
"\"",
"+",
"parameter",
"get",
"parameter",
"type",
"(",
")",
"get",
"name",
"(",
")",
"+",
"\"",
"]",
"supports",
"parameter",
"should",
"be",
"called",
"first",
"\"",
")",
";",
"}",
"return",
"resolver",
"resolve",
"argument",
"(",
"parameter",
",",
"message",
")",
";",
"}"
] |
[
"sets",
"the",
"attributes",
"for",
"audio",
"playback",
",",
"used",
"by",
"the",
"underlying",
"audio",
"track",
"if",
"not",
"set",
",",
"the",
"default",
"audio",
"attributes",
"will",
"be",
"used",
"they",
"are",
"suitable",
"for",
"general",
"media",
"playback",
"setting",
"the",
"audio",
"attributes",
"during",
"playback",
"may",
"introduce",
"a",
"short",
"gap",
"in",
"audio",
"output",
"as",
"the",
"audio",
"track",
"is",
"recreated",
"a",
"new",
"audio",
"session",
"id",
"will",
"also",
"be",
"generated",
"if",
"tunneling",
"is",
"enabled",
"by",
"the",
"track",
"selector",
",",
"the",
"specified",
"audio",
"attributes",
"will",
"be",
"ignored",
",",
"but",
"they",
"will",
"take",
"effect",
"if",
"audio",
"is",
"later",
"played",
"without",
"tunneling",
"if",
"the",
"device",
"is",
"running",
"a",
"build",
"before",
"platform",
"api",
"version",
"21",
",",
"audio",
"attributes",
"cannot",
"be",
"set",
"directly",
"on",
"the",
"underlying",
"audio",
"track",
"in",
"this",
"case",
",",
"the",
"usage",
"will",
"be",
"mapped",
"onto",
"an",
"equivalent",
"stream",
"type",
"using",
"{",
"@",
"link",
"util",
"#",
"get",
"stream",
"type",
"for",
"audio",
"usage",
"(",
"int",
")",
"}"
] |
[
"void",
"set",
"audio",
"attributes",
"(",
"audio",
"attributes",
"audio",
"attributes",
")",
";"
] |
[
"current",
"behavior",
"is",
"first",
"one",
"wins"
] |
[
"public",
"void",
"test",
"defacto",
"behavior",
"with",
"duplicate",
"entries",
"(",
")",
"throws",
"exception",
"{",
"list",
"<",
"fileset",
"output",
"symlink",
">",
"symlinks",
"=",
"immutable",
"list",
"of",
"(",
"fileset",
"symlink",
"(",
"\"",
"bar",
"\"",
",",
"\"",
"/",
"foo",
"/",
"bar",
"\"",
")",
",",
"fileset",
"symlink",
"(",
"\"",
"bar",
"\"",
",",
"\"",
"/",
"baz",
"\"",
")",
")",
";",
"fileset",
"manifest",
"manifest",
"=",
"fileset",
"manifest",
"construct",
"fileset",
"manifest",
"(",
"symlinks",
",",
"path",
"fragment",
"create",
"(",
"\"",
"out",
"/",
"foo",
"\"",
")",
",",
"behavior",
")",
";",
"assert",
"that",
"(",
"manifest",
"get",
"entries",
"(",
")",
")",
"contains",
"exactly",
"(",
"path",
"fragment",
"create",
"(",
"\"",
"out",
"/",
"foo",
"/",
"bar",
"\"",
")",
",",
"\"",
"/",
"foo",
"/",
"bar",
"\"",
")",
";",
"}"
] |
[
"proxy",
"c",
"a",
"manager",
"calls",
"this",
"to",
"store",
"the",
"ca",
"certificate",
"and",
"private",
"key"
] |
[
"public",
"void",
"store",
"proxy",
"c",
"a",
"cert",
"(",
"x",
"5",
"0",
"9",
"certificate",
"ca",
"cert",
",",
"private",
"key",
"ca",
"private",
"key",
")",
"{",
"handle",
"store",
"event",
"(",
"new",
"r",
"m",
"state",
"store",
"proxy",
"c",
"a",
"event",
"(",
"ca",
"cert",
",",
"ca",
"private",
"key",
",",
"r",
"m",
"state",
"store",
"event",
"type",
"store",
"proxy",
"ca",
"cert",
")",
")",
";",
"}"
] |
[
"sets",
"whether",
"the",
"subtitle",
"button",
"is",
"shown"
] |
[
"public",
"void",
"set",
"show",
"subtitle",
"button",
"(",
"boolean",
"show",
"subtitle",
"button",
")",
"{",
"control",
"view",
"layout",
"manager",
"set",
"show",
"button",
"(",
"subtitle",
"button",
",",
"show",
"subtitle",
"button",
")",
";",
"}"
] |
[
"creates",
"list",
"of",
"users",
"with",
"given",
"input",
"array"
] |
[
"public",
"void",
"create",
"users",
"with",
"array",
"input",
"(",
"list",
"<",
"user",
">",
"body",
")",
"{",
"/",
"/",
"todo",
":",
"implement",
"}"
] |
[
"decodes",
"a",
"leb128",
"number",
"using",
"a",
"binary",
"reader",
"and",
"stores",
"it",
"in",
"a",
"long",
"large",
"unsigned",
"integers",
"that",
"use",
"64",
"bits",
"will",
"be",
"returned",
"in",
"java",
"'",
"s",
"native",
"'",
"long",
"'",
"type",
",",
"which",
"is",
"signed",
"it",
"is",
"up",
"to",
"the",
"caller",
"to",
"treat",
"the",
"value",
"as",
"unsigned",
"large",
"integers",
"that",
"use",
"more",
"than",
"64",
"bits",
"will",
"cause",
"an",
"i",
"o",
"exception",
"to",
"be",
"thrown"
] |
[
"public",
"static",
"long",
"decode",
"(",
"binary",
"reader",
"reader",
",",
"boolean",
"is",
"signed",
")",
"throws",
"i",
"o",
"exception",
"{",
"int",
"next",
"byte",
"=",
"0",
";",
"int",
"shift",
"=",
"0",
";",
"long",
"value",
"=",
"0",
";",
"boolean",
"overflow",
"=",
"false",
";",
"while",
"(",
"true",
")",
"{",
"next",
"byte",
"=",
"reader",
"read",
"next",
"unsigned",
"byte",
"(",
")",
";",
"if",
"(",
"shift",
"=",
"=",
"70",
"|",
"|",
"(",
"is",
"signed",
"=",
"=",
"false",
"&",
"&",
"shift",
"=",
"=",
"63",
"&",
"&",
"next",
"byte",
">",
"1",
")",
")",
"{",
"/",
"/",
"if",
"the",
"value",
"being",
"read",
"is",
"more",
"than",
"64",
"bits",
"long",
"mark",
"it",
"as",
"overflow",
"/",
"/",
"keep",
"reading",
"the",
"rest",
"of",
"the",
"number",
"so",
"the",
"caller",
"is",
"not",
"left",
"in",
"the",
"/",
"/",
"middle",
"of",
"the",
"leb128",
"number",
"'",
"s",
"guts",
"overflow",
"=",
"true",
";",
"}",
"/",
"/",
"must",
"cast",
"to",
"long",
"before",
"shifting",
"otherwise",
"shift",
"values",
"greater",
"than",
"32",
"cause",
"problems",
"value",
"|",
"=",
"(",
"(",
"long",
")",
"(",
"next",
"byte",
"&",
"0x",
"7",
"f",
")",
")",
"<",
"<",
"shift",
";",
"shift",
"+",
"=",
"7",
";",
"if",
"(",
"(",
"next",
"byte",
"&",
"0x",
"8",
"0",
")",
"=",
"=",
"0",
")",
"{",
"break",
";",
"}",
"}",
"if",
"(",
"overflow",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"unsupported",
"leb128",
"value",
",",
"too",
"large",
"to",
"fit",
"in",
"6",
"4bit",
"java",
"long",
"variable",
"\"",
")",
";",
"}",
"if",
"(",
"(",
"is",
"signed",
")",
"&",
"&",
"(",
"shift",
"<",
"long",
"size",
")",
"&",
"&",
"(",
"(",
"next",
"byte",
"&",
"0x",
"4",
"0",
")",
"!",
"=",
"0",
")",
")",
"{",
"value",
"|",
"=",
"-",
"(",
"1",
"<",
"<",
"shift",
")",
";",
"}",
"return",
"value",
";",
"}"
] |
[
"applies",
"a",
"key",
"down",
"event",
"to",
"the",
"actor",
"that",
"has",
"{",
"@",
"link",
"stage",
"#",
"set",
"keyboard",
"focus",
"(",
"actor",
")",
"keyboard",
"focus",
"}",
",",
"if",
"any",
",",
"and",
"returns",
"true",
"if",
"the",
"event",
"was",
"{",
"@",
"link",
"event",
"#",
"handle",
"(",
")",
"handled",
"}"
] |
[
"public",
"boolean",
"key",
"down",
"(",
"int",
"key",
"code",
")",
"{",
"actor",
"target",
"=",
"keyboard",
"focus",
"=",
"=",
"null",
"?",
"root",
":",
"keyboard",
"focus",
";",
"input",
"event",
"event",
"=",
"pools",
"obtain",
"(",
"input",
"event",
"class",
")",
";",
"event",
"set",
"stage",
"(",
"this",
")",
";",
"event",
"set",
"type",
"(",
"input",
"event",
"type",
"key",
"down",
")",
";",
"event",
"set",
"key",
"code",
"(",
"key",
"code",
")",
";",
"target",
"fire",
"(",
"event",
")",
";",
"boolean",
"handled",
"=",
"event",
"is",
"handled",
"(",
")",
";",
"pools",
"free",
"(",
"event",
")",
";",
"return",
"handled",
";",
"}"
] |
[
"helper",
"to",
"deal",
"with",
"{",
"@",
"code",
"lookupswitch",
"}"
] |
[
"private",
"int",
"parse",
"lookupswitch",
"(",
"int",
"offset",
",",
"visitor",
"visitor",
")",
"{",
"int",
"at",
"=",
"(",
"offset",
"+",
"4",
")",
"&",
"~",
"3",
";",
"/",
"/",
"\"",
"at",
"\"",
"skips",
"the",
"padding",
"/",
"/",
"collect",
"the",
"padding",
"int",
"padding",
"=",
"0",
";",
"for",
"(",
"int",
"i",
"=",
"offset",
"+",
"1",
";",
"i",
"<",
"at",
";",
"i",
"+",
"+",
")",
"{",
"padding",
"=",
"(",
"padding",
"<",
"<",
"8",
")",
"|",
"bytes",
"get",
"unsigned",
"byte",
"(",
"i",
")",
";",
"}",
"int",
"default",
"target",
"=",
"offset",
"+",
"bytes",
"get",
"int",
"(",
"at",
")",
";",
"int",
"npairs",
"=",
"bytes",
"get",
"int",
"(",
"at",
"+",
"4",
")",
";",
"at",
"+",
"=",
"8",
";",
"switch",
"list",
"cases",
"=",
"new",
"switch",
"list",
"(",
"npairs",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"npairs",
";",
"i",
"+",
"+",
")",
"{",
"int",
"match",
"=",
"bytes",
"get",
"int",
"(",
"at",
")",
";",
"int",
"target",
"=",
"offset",
"+",
"bytes",
"get",
"int",
"(",
"at",
"+",
"4",
")",
";",
"at",
"+",
"=",
"8",
";",
"cases",
"add",
"(",
"match",
",",
"target",
")",
";",
"}",
"cases",
"set",
"default",
"target",
"(",
"default",
"target",
")",
";",
"cases",
"remove",
"superfluous",
"defaults",
"(",
")",
";",
"cases",
"set",
"immutable",
"(",
")",
";",
"int",
"length",
"=",
"at",
"-",
"offset",
";",
"visitor",
"visit",
"switch",
"(",
"byte",
"ops",
"lookupswitch",
",",
"offset",
",",
"length",
",",
"cases",
",",
"padding",
")",
";",
"return",
"length",
";",
"}"
] |
[
"validates",
"a",
"parameter",
"value"
] |
[
"boolean",
"validate",
"(",
"v",
"value",
")",
";"
] |
[
"callback",
"for",
"the",
"cancel",
"button"
] |
[
"protected",
"void",
"cancel",
"callback",
"(",
")",
"{",
"if",
"(",
"was",
"changed",
")",
"{",
"int",
"result",
"=",
"option",
"dialog",
"show",
"yes",
"no",
"cancel",
"dialog",
"(",
"get",
"component",
"(",
")",
",",
"\"",
"save",
"changes",
"?",
"\"",
",",
"\"",
"some",
"comments",
"were",
"modified",
"\\",
"n",
"save",
"changes",
"?",
"\"",
")",
";",
"if",
"(",
"result",
"=",
"=",
"option",
"dialog",
"option",
"one",
")",
"{",
"apply",
"callback",
"(",
")",
";",
"}",
"else",
"if",
"(",
"result",
"=",
"=",
"option",
"dialog",
"option",
"two",
")",
"{",
"if",
"(",
"!",
"pre",
"field",
"get",
"text",
"(",
")",
"equals",
"(",
"pre",
"comment",
")",
")",
"{",
"pre",
"field",
"set",
"text",
"(",
"pre",
"comment",
")",
";",
"}",
"if",
"(",
"!",
"post",
"field",
"get",
"text",
"(",
")",
"equals",
"(",
"post",
"comment",
")",
")",
"{",
"post",
"field",
"set",
"text",
"(",
"post",
"comment",
")",
";",
"}",
"if",
"(",
"!",
"eol",
"field",
"get",
"text",
"(",
")",
"equals",
"(",
"eol",
"comment",
")",
")",
"{",
"eol",
"field",
"set",
"text",
"(",
"eol",
"comment",
")",
";",
"}",
"if",
"(",
"!",
"plate",
"field",
"get",
"text",
"(",
")",
"equals",
"(",
"plate",
"comment",
")",
")",
"{",
"plate",
"field",
"set",
"text",
"(",
"plate",
"comment",
")",
";",
"}",
"if",
"(",
"!",
"repeatable",
"field",
"get",
"text",
"(",
")",
"equals",
"(",
"repeatable",
"comment",
")",
")",
"{",
"repeatable",
"field",
"set",
"text",
"(",
"repeatable",
"comment",
")",
";",
"}",
"was",
"changed",
"=",
"false",
";",
"set",
"apply",
"enabled",
"(",
"false",
")",
";",
"}",
"else",
"{",
"/",
"/",
"cancel",
"cancel",
"return",
";",
"}",
"}",
"close",
"(",
")",
";",
"}"
] |
[
"gets",
"the",
"number",
"of",
"characters",
"required",
"to",
"display",
"a",
"unit"
] |
[
"public",
"int",
"get",
"data",
"unit",
"symbol",
"size",
"(",
")",
"{",
"return",
"symbol",
"size",
";",
"}"
] |
[
"returns",
"a",
"user",
"-",
"friendly",
"name",
"for",
"this",
"worker",
"type"
] |
[
"public",
"static",
"string",
"make",
"worker",
"type",
"name",
"(",
"boolean",
"proxied",
")",
"{",
"if",
"(",
"proxied",
")",
"{",
"return",
"\"",
"multiplex",
"-",
"worker",
"\"",
";",
"}",
"else",
"{",
"return",
"\"",
"worker",
"\"",
";",
"}",
"}"
] |
[
"gets",
"all",
"the",
"values",
"of",
"the",
"query",
"param",
"example",
":",
"query",
"parameter",
"'",
"id",
"'",
"from",
"the",
"following",
"request",
"uri",
":",
"hello",
"?",
"id",
"=",
"foo",
"&",
"amp",
";",
"id",
"=",
"bar"
] |
[
"public",
"string",
"[",
"]",
"query",
"params",
"values",
"(",
"string",
"query",
"param",
")",
"{",
"return",
"servlet",
"request",
"get",
"parameter",
"values",
"(",
"query",
"param",
")",
";",
"}"
] |
[
"tests",
"the",
"reverse",
"x",
"m",
"l",
"processor",
"1",
"translate",
"fsimage",
"-",
">",
"reverse",
"image",
"xml",
"2",
"translate",
"reverse",
"image",
"xml",
"-",
">",
"reverse",
"image",
"3",
"translate",
"reverse",
"image",
"-",
">",
"reverse",
"2",
"image",
"xml",
"4",
"verify",
"that",
"reverse",
"image",
"xml",
"and",
"reverse",
"2",
"image",
"xml",
"match"
] |
[
"public",
"void",
"test",
"reverse",
"xml",
"round",
"trip",
"(",
")",
"throws",
"throwable",
"{",
"generic",
"test",
"utils",
"set",
"log",
"level",
"(",
"offline",
"image",
"reconstructor",
"log",
",",
"level",
"trace",
")",
";",
"file",
"reverse",
"image",
"xml",
"=",
"new",
"file",
"(",
"temp",
"dir",
",",
"\"",
"reverse",
"image",
"xml",
"\"",
")",
";",
"file",
"reverse",
"image",
"=",
"new",
"file",
"(",
"temp",
"dir",
",",
"\"",
"reverse",
"image",
"\"",
")",
";",
"file",
"reverse",
"image",
"2",
"xml",
"=",
"new",
"file",
"(",
"temp",
"dir",
",",
"\"",
"reverse",
"image",
"2",
"xml",
"\"",
")",
";",
"log",
"info",
"(",
"\"",
"creating",
"reverse",
"image",
"xml",
"=",
"\"",
"+",
"reverse",
"image",
"xml",
"get",
"absolute",
"path",
"(",
")",
"+",
"\"",
",",
"reverse",
"image",
"=",
"\"",
"+",
"reverse",
"image",
"get",
"absolute",
"path",
"(",
")",
"+",
"\"",
",",
"reverse",
"image",
"2",
"xml",
"=",
"\"",
"+",
"reverse",
"image",
"2",
"xml",
"get",
"absolute",
"path",
"(",
")",
")",
";",
"if",
"(",
"offline",
"image",
"viewer",
"p",
"b",
"run",
"(",
"new",
"string",
"[",
"]",
"{",
"\"",
"-",
"p",
"\"",
",",
"\"",
"xml",
"\"",
",",
"\"",
"-",
"i",
"\"",
",",
"original",
"fsimage",
"get",
"absolute",
"path",
"(",
")",
",",
"\"",
"-",
"o",
"\"",
",",
"reverse",
"image",
"xml",
"get",
"absolute",
"path",
"(",
")",
"}",
")",
"!",
"=",
"0",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"oiv",
"returned",
"failure",
"creating",
"first",
"xml",
"file",
"\"",
")",
";",
"}",
"if",
"(",
"offline",
"image",
"viewer",
"p",
"b",
"run",
"(",
"new",
"string",
"[",
"]",
"{",
"\"",
"-",
"p",
"\"",
",",
"\"",
"reverse",
"x",
"m",
"l",
"\"",
",",
"\"",
"-",
"i",
"\"",
",",
"reverse",
"image",
"xml",
"get",
"absolute",
"path",
"(",
")",
",",
"\"",
"-",
"o",
"\"",
",",
"reverse",
"image",
"get",
"absolute",
"path",
"(",
")",
"}",
")",
"!",
"=",
"0",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"oiv",
"returned",
"failure",
"recreating",
"fsimage",
"file",
"\"",
")",
";",
"}",
"if",
"(",
"offline",
"image",
"viewer",
"p",
"b",
"run",
"(",
"new",
"string",
"[",
"]",
"{",
"\"",
"-",
"p",
"\"",
",",
"\"",
"xml",
"\"",
",",
"\"",
"-",
"i",
"\"",
",",
"reverse",
"image",
"get",
"absolute",
"path",
"(",
")",
",",
"\"",
"-",
"o",
"\"",
",",
"reverse",
"image",
"2",
"xml",
"get",
"absolute",
"path",
"(",
")",
"}",
")",
"!",
"=",
"0",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"oiv",
"returned",
"failure",
"creating",
"second",
"\"",
"+",
"\"",
"xml",
"file",
"\"",
")",
";",
"}",
"/",
"/",
"the",
"xml",
"file",
"we",
"wrote",
"based",
"on",
"the",
"re",
"-",
"created",
"fsimage",
"should",
"be",
"the",
"/",
"/",
"same",
"as",
"the",
"one",
"we",
"dumped",
"from",
"the",
"original",
"fsimage",
"assert",
"assert",
"equals",
"(",
"\"",
"\"",
",",
"generic",
"test",
"utils",
"get",
"files",
"diff",
"(",
"reverse",
"image",
"xml",
",",
"reverse",
"image",
"2",
"xml",
")",
")",
";",
"}"
] |
[
"get",
"prefix",
"ns",
"number"
] |
[
"public",
"big",
"decimal",
"get",
"prefix",
"ns",
"number",
"(",
")",
"{",
"return",
"prefix",
"ns",
"number",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"anytype",
"2",
"'"
] |
[
"public",
"void",
"anytype",
"2",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"anytype",
"2",
"}"
] |
[
"gets",
"sql",
"data",
"type"
] |
[
"public",
"int",
"get",
"sql",
"data",
"type",
"(",
")",
"{",
"return",
"sql",
"data",
"type",
";",
"}"
] |
[
"\"",
"saves",
"\"",
"an",
"entity",
"to",
"the",
"database",
":",
"depending",
"on",
"the",
"existence",
"of",
"the",
"key",
"property",
",",
"it",
"will",
"be",
"inserted",
"(",
"key",
"is",
"null",
")",
"or",
"updated",
"(",
"key",
"is",
"not",
"null",
")",
"this",
"is",
"similar",
"to",
"{",
"@",
"link",
"#",
"insert",
"or",
"replace",
"(",
"object",
")",
"}",
",",
"but",
"may",
"be",
"more",
"efficient",
",",
"because",
"if",
"a",
"key",
"is",
"present",
",",
"it",
"does",
"not",
"have",
"to",
"query",
"if",
"that",
"key",
"already",
"exists"
] |
[
"public",
"void",
"save",
"(",
"t",
"entity",
")",
"{",
"if",
"(",
"has",
"key",
"(",
"entity",
")",
")",
"{",
"update",
"(",
"entity",
")",
";",
"}",
"else",
"{",
"insert",
"(",
"entity",
")",
";",
"}",
"}"
] |
[
"reads",
"the",
"named",
"file",
",",
"translating",
"{",
"@",
"link",
"i",
"o",
"exception",
"}",
"to",
"a",
"{",
"@",
"link",
"runtime",
"exception",
"}",
"of",
"some",
"sort"
] |
[
"public",
"static",
"byte",
"[",
"]",
"read",
"file",
"(",
"string",
"file",
"name",
")",
"{",
"file",
"file",
"=",
"new",
"file",
"(",
"file",
"name",
")",
";",
"return",
"read",
"file",
"(",
"file",
")",
";",
"}"
] |
[
"compute",
"an",
"environment",
"map",
"for",
"local",
"actions",
"on",
"unix",
"-",
"like",
"platforms",
"(",
"e",
"g",
"linux",
",",
"mac",
"o",
"s",
")",
"returns",
"a",
"map",
"with",
"the",
"same",
"keys",
"and",
"values",
"as",
"{",
"@",
"code",
"env",
"}",
"overrides",
"the",
"value",
"of",
"tmpdir",
"(",
"or",
"adds",
"it",
"if",
"not",
"present",
"in",
"{",
"@",
"code",
"env",
"}",
")",
"by",
"the",
"value",
"of",
"{",
"@",
"code",
"client",
"env",
"get",
"(",
"\"",
"tmpdir",
"\"",
")",
"}",
",",
"or",
"if",
"that",
"'",
"s",
"empty",
"or",
"null",
",",
"then",
"by",
"\"",
"tmp",
"\""
] |
[
"public",
"immutable",
"map",
"<",
"string",
",",
"string",
">",
"rewrite",
"local",
"env",
"(",
"map",
"<",
"string",
",",
"string",
">",
"env",
",",
"bin",
"tools",
"bin",
"tools",
",",
"string",
"fallback",
"tmp",
"dir",
")",
"{",
"immutable",
"map",
"builder",
"<",
"string",
",",
"string",
">",
"result",
"=",
"immutable",
"map",
"builder",
"(",
")",
";",
"result",
"put",
"all",
"(",
"maps",
"filter",
"keys",
"(",
"env",
",",
"k",
"-",
">",
"!",
"k",
"equals",
"(",
"\"",
"tmpdir",
"\"",
")",
")",
")",
";",
"string",
"p",
"=",
"client",
"env",
"get",
"(",
"\"",
"tmpdir",
"\"",
")",
";",
"if",
"(",
"strings",
"is",
"null",
"or",
"empty",
"(",
"p",
")",
")",
"{",
"/",
"/",
"do",
"not",
"use",
"`",
"fallback",
"tmp",
"dir",
"`",
",",
"use",
"`",
"/",
"tmp",
"`",
"instead",
"this",
"way",
"if",
"the",
"user",
"didn",
"'",
"t",
"export",
"tmpdir",
"/",
"/",
"in",
"their",
"environment",
",",
"bazel",
"will",
"still",
"set",
"a",
"tmpdir",
"that",
"'",
"s",
"posixy",
"enough",
"and",
"plays",
"well",
"/",
"/",
"with",
"heavily",
"path",
"-",
"length",
"-",
"limited",
"scenarios",
",",
"such",
"as",
"the",
"socket",
"creation",
"scenario",
"that",
"/",
"/",
"motivated",
"https",
":",
"/",
"/",
"github",
"com",
"/",
"bazelbuild",
"/",
"bazel",
"/",
"issues",
"/",
"4376",
"p",
"=",
"\"",
"/",
"tmp",
"\"",
";",
"}",
"result",
"put",
"(",
"\"",
"tmpdir",
"\"",
",",
"p",
")",
";",
"return",
"result",
"build",
"(",
")",
";",
"}"
] |
[
"creates",
"the",
"new",
"fs",
"permission",
"for",
"an",
"inode",
"that",
"is",
"receiving",
"an",
"extended",
"acl",
",",
"based",
"on",
"its",
"access",
"acl",
"entries",
"for",
"a",
"correctly",
"sorted",
"acl",
",",
"the",
"first",
"entry",
"is",
"the",
"owner",
"and",
"the",
"last",
"2",
"entries",
"are",
"the",
"mask",
"and",
"other",
"entries",
"respectively",
"also",
"preserve",
"sticky",
"bit",
"and",
"toggle",
"acl",
"bit",
"on",
"note",
"that",
"this",
"method",
"intentionally",
"copies",
"the",
"permissions",
"of",
"the",
"mask",
"entry",
"into",
"the",
"fs",
"permission",
"group",
"permissions",
"this",
"is",
"consistent",
"with",
"the",
"posix",
"a",
"c",
"ls",
"model",
",",
"which",
"presents",
"the",
"mask",
"as",
"the",
"permissions",
"of",
"the",
"group",
"class"
] |
[
"private",
"static",
"fs",
"permission",
"create",
"fs",
"permission",
"for",
"extended",
"acl",
"(",
"list",
"<",
"acl",
"entry",
">",
"access",
"entries",
",",
"fs",
"permission",
"existing",
"perm",
")",
"{",
"return",
"new",
"fs",
"permission",
"(",
"access",
"entries",
"get",
"(",
"0",
")",
"get",
"permission",
"(",
")",
",",
"access",
"entries",
"get",
"(",
"access",
"entries",
"size",
"(",
")",
"-",
"2",
")",
"get",
"permission",
"(",
")",
",",
"access",
"entries",
"get",
"(",
"access",
"entries",
"size",
"(",
")",
"-",
"1",
")",
"get",
"permission",
"(",
")",
",",
"existing",
"perm",
"get",
"sticky",
"bit",
"(",
")",
")",
";",
"}"
] |
[
"gets",
"the",
"{",
"@",
"link",
"index",
"type",
"}",
"for",
"the",
"given",
"opcode",
"value"
] |
[
"public",
"static",
"index",
"type",
"get",
"index",
"type",
"(",
"int",
"opcode",
")",
"{",
"return",
"get",
"(",
"opcode",
")",
"get",
"index",
"type",
"(",
")",
";",
"}"
] |
[
"sets",
"the",
"level",
"of",
"interruption",
"of",
"this",
"notification",
"channel",
"only",
"modifiable",
"before",
"the",
"channel",
"is",
"submitted",
"to",
"{",
"@",
"link",
"notification",
"manager",
"#",
"create",
"notification",
"channel",
"(",
"notification",
"channel",
")",
"}"
] |
[
"public",
"channel",
"config",
"set",
"importance",
"(",
"@",
"importance",
"int",
"importance",
")",
"{",
"if",
"(",
"build",
"version",
"sdk",
"int",
">",
"=",
"build",
"version",
"codes",
"o",
")",
"{",
"m",
"notification",
"channel",
"set",
"importance",
"(",
"importance",
")",
";",
"}",
"return",
"this",
";",
"}"
] |
[
"model",
"tests",
"for",
"enum",
"test"
] |
[
"public",
"void",
"test",
"enum",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"enum",
"test",
"}"
] |
[
"returns",
"the",
"testlogs",
"directory",
"for",
"this",
"build",
"configuration"
] |
[
"artifact",
"root",
"get",
"test",
"logs",
"directory",
"(",
"repository",
"name",
"repository",
"name",
")",
"{",
"return",
"sibling",
"repository",
"layout",
"?",
"build",
"derived",
"root",
"(",
"\"",
"testlogs",
"\"",
",",
"repository",
"name",
")",
":",
"testlogs",
"directory",
";",
"}"
] |
[
"gets",
"the",
"class",
"describing",
"the",
"input",
"format",
"this",
"method",
"is",
"basically",
"identical",
"to",
"{",
"@",
"link",
"#",
"get",
"format",
"wrapper",
"(",
")",
"}"
] |
[
"public",
"user",
"code",
"wrapper",
"<",
"?",
"extends",
"t",
">",
"get",
"user",
"code",
"wrapper",
"(",
")",
"{",
"return",
"this",
"format",
"wrapper",
";",
"}"
] |
[
"the",
"algorithm",
"for",
"this",
"cycle",
"detector",
"is",
"as",
"follows",
"we",
"visit",
"the",
"graph",
"depth",
"-",
"first",
",",
"keeping",
"track",
"of",
"the",
"path",
"we",
"are",
"currently",
"on",
"we",
"skip",
"any",
"done",
"nodes",
"(",
"they",
"are",
"transitively",
"error",
"-",
"free",
")",
"if",
"we",
"come",
"to",
"a",
"node",
"already",
"on",
"the",
"path",
",",
"we",
"immediately",
"construct",
"a",
"cycle",
"if",
"we",
"are",
"in",
"the",
"no",
"keep",
"going",
"case",
",",
"we",
"return",
"error",
"info",
"with",
"that",
"cycle",
"to",
"the",
"caller",
"otherwise",
",",
"we",
"continue",
"once",
"all",
"of",
"a",
"node",
"'",
"s",
"children",
"are",
"done",
",",
"we",
"construct",
"an",
"error",
"value",
"for",
"it",
",",
"based",
"on",
"those",
"children",
"finally",
",",
"when",
"the",
"original",
"root",
"'",
"s",
"node",
"is",
"constructed",
",",
"we",
"return",
"its",
"error",
"info"
] |
[
"private",
"static",
"error",
"info",
"check",
"for",
"cycles",
"(",
"sky",
"key",
"root",
",",
"parallel",
"evaluator",
"context",
"evaluator",
"context",
")",
"throws",
"interrupted",
"exception",
"{",
"/",
"/",
"the",
"number",
"of",
"cycles",
"found",
"do",
"not",
"keep",
"on",
"searching",
"for",
"more",
"cycles",
"after",
"this",
"many",
"were",
"/",
"/",
"found",
"int",
"cycles",
"found",
"=",
"0",
";",
"/",
"/",
"the",
"path",
"through",
"the",
"graph",
"currently",
"being",
"visited",
"list",
"<",
"sky",
"key",
">",
"graph",
"path",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"/",
"/",
"set",
"of",
"nodes",
"on",
"the",
"path",
",",
"to",
"avoid",
"expensive",
"searches",
"through",
"the",
"path",
"for",
"cycles",
"set",
"<",
"sky",
"key",
">",
"path",
"set",
"=",
"new",
"hash",
"set",
"<",
">",
"(",
")",
";",
"/",
"/",
"maintain",
"a",
"stack",
"explicitly",
"instead",
"of",
"recursion",
"to",
"avoid",
"stack",
"overflows",
"/",
"/",
"on",
"extreme",
"graphs",
"(",
"with",
"long",
"dependency",
"chains",
")",
"deque",
"<",
"sky",
"key",
">",
"to",
"visit",
"=",
"new",
"array",
"deque",
"<",
">",
"(",
")",
";",
"to",
"visit",
"push",
"(",
"root",
")",
";",
"/",
"/",
"the",
"procedure",
"for",
"this",
"check",
"is",
"as",
"follows",
":",
"we",
"visit",
"a",
"node",
",",
"push",
"it",
"onto",
"the",
"graph",
"path",
",",
"/",
"/",
"push",
"a",
"marker",
"value",
"onto",
"the",
"to",
"visit",
"stack",
",",
"and",
"then",
"push",
"all",
"of",
"its",
"children",
"onto",
"the",
"/",
"/",
"to",
"visit",
"stack",
"thus",
",",
"when",
"the",
"marker",
"node",
"comes",
"to",
"the",
"top",
"of",
"the",
"to",
"visit",
"stack",
",",
"we",
"have",
"/",
"/",
"visited",
"the",
"downward",
"transitive",
"closure",
"of",
"the",
"value",
"at",
"that",
"point",
",",
"all",
"of",
"its",
"children",
"must",
"/",
"/",
"be",
"finished",
",",
"and",
"so",
"we",
"can",
"build",
"the",
"definitive",
"error",
"info",
"for",
"the",
"node",
",",
"popping",
"it",
"off",
"the",
"/",
"/",
"graph",
"path",
"while",
"(",
"!",
"to",
"visit",
"is",
"empty",
"(",
")",
")",
"{",
"sky",
"key",
"key",
"=",
"to",
"visit",
"pop",
"(",
")",
";",
"node",
"entry",
"entry",
";",
"if",
"(",
"key",
"=",
"=",
"children",
"finished",
")",
"{",
"/",
"/",
"we",
"have",
"reached",
"the",
"marker",
"node",
"-",
"that",
"means",
"all",
"children",
"of",
"a",
"node",
"have",
"been",
"visited",
"/",
"/",
"since",
"all",
"nodes",
"have",
"errors",
",",
"we",
"must",
"have",
"found",
"errors",
"in",
"the",
"children",
"at",
"this",
"point",
"key",
"=",
"graph",
"path",
"remove",
"(",
"graph",
"path",
"size",
"(",
")",
"-",
"1",
")",
";",
"entry",
"=",
"preconditions",
"check",
"not",
"null",
"(",
"evaluator",
"context",
"get",
"graph",
"(",
")",
"get",
"(",
"null",
",",
"reason",
"cycle",
"checking",
",",
"key",
")",
",",
"key",
")",
";",
"path",
"set",
"remove",
"(",
"key",
")",
";",
"/",
"/",
"skip",
"this",
"node",
"if",
"it",
"was",
"first",
"/",
"last",
"node",
"of",
"a",
"cycle",
",",
"and",
"so",
"has",
"already",
"been",
"processed",
"if",
"(",
"entry",
"is",
"done",
"(",
")",
")",
"{",
"continue",
";",
"}",
"if",
"(",
"!",
"evaluator",
"context",
"keep",
"going",
"(",
")",
")",
"{",
"/",
"/",
"in",
"the",
"-",
"-",
"nokeep",
"going",
"mode",
",",
"we",
"would",
"have",
"already",
"returned",
"if",
"we",
"'",
"d",
"found",
"a",
"cycle",
"below",
"/",
"/",
"this",
"node",
"we",
"haven",
"'",
"t",
",",
"so",
"there",
"are",
"no",
"cycles",
"below",
"this",
"node",
";",
"skip",
"further",
"evaluation",
"continue",
";",
"}",
"set",
"<",
"sky",
"key",
">",
"removed",
"deps",
"=",
"immutable",
"set",
"of",
"(",
")",
";",
"if",
"(",
"cycles",
"found",
"<",
"max",
"cycles",
")",
"{",
"/",
"/",
"value",
"must",
"be",
"ready",
",",
"because",
"all",
"of",
"its",
"children",
"have",
"finished",
",",
"so",
"we",
"can",
"build",
"its",
"/",
"/",
"error",
"preconditions",
"check",
"state",
"(",
"entry",
"is",
"ready",
"(",
")",
",",
"\"",
"%",
"s",
"not",
"ready",
"value",
"entry",
":",
"%",
"s",
"\"",
",",
"key",
",",
"entry",
")",
";",
"}",
"else",
"if",
"(",
"!",
"entry",
"is",
"ready",
"(",
")",
")",
"{",
"removed",
"deps",
"=",
"remove",
"incomplete",
"children",
"for",
"cycle",
"(",
"key",
",",
"entry",
",",
"iterables",
"concat",
"(",
"entry",
"get",
"temporary",
"direct",
"deps",
"(",
")",
")",
",",
"evaluator",
"context",
")",
";",
"}",
"if",
"(",
"maybe",
"handle",
"verified",
"clean",
"node",
"(",
"key",
",",
"entry",
",",
"evaluator",
"context",
",",
"graph",
"path",
")",
")",
"{",
"continue",
";",
"}",
"maybe",
"mark",
"rebuilding",
"(",
"entry",
")",
";",
"grouped",
"list",
"<",
"sky",
"key",
">",
"direct",
"deps",
"=",
"entry",
"get",
"temporary",
"direct",
"deps",
"(",
")",
";",
"/",
"/",
"find",
"out",
"which",
"children",
"have",
"errors",
"similar",
"logic",
"to",
"that",
"in",
"evaluate",
"#",
"run",
"(",
")",
"list",
"<",
"error",
"info",
">",
"error",
"deps",
"=",
"get",
"children",
"errors",
"for",
"cycle",
"(",
"key",
",",
"iterables",
"concat",
"(",
"direct",
"deps",
")",
",",
"direct",
"deps",
"num",
"elements",
"(",
")",
",",
"entry",
",",
"evaluator",
"context",
")",
";",
"preconditions",
"check",
"state",
"(",
"!",
"error",
"deps",
"is",
"empty",
"(",
")",
",",
"\"",
"node",
"%",
"s",
"was",
"not",
"successfully",
"evaluated",
",",
"but",
"had",
"no",
"child",
"errors",
"node",
"entry",
":",
"%",
"s",
"\"",
",",
"key",
",",
"entry",
")",
";",
"sky",
"function",
"environment",
"env",
";",
"try",
"{",
"env",
"=",
"new",
"sky",
"function",
"environment",
"(",
"key",
",",
"direct",
"deps",
",",
"sets",
"difference",
"(",
"entry",
"get",
"all",
"remaining",
"dirty",
"direct",
"deps",
"(",
")",
",",
"removed",
"deps",
")",
",",
"evaluator",
"context",
")",
";",
"}",
"catch",
"(",
"undone",
"previously",
"requested",
"deps",
"undone",
"deps",
")",
"{",
"/",
"/",
"all",
"children",
"were",
"finished",
"according",
"to",
"the",
"children",
"finished",
"sentinel",
",",
"and",
"cycle",
"/",
"/",
"detection",
"does",
"not",
"do",
"normal",
"sky",
"function",
"evaluation",
",",
"so",
"no",
"restarting",
"nor",
"child",
"/",
"/",
"dirtying",
"was",
"possible",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"previously",
"requested",
"dep",
"not",
"done",
":",
"\"",
"+",
"undone",
"deps",
"get",
"dep",
"keys",
"(",
")",
",",
"undone",
"deps",
")",
";",
"}",
"env",
"set",
"error",
"(",
"entry",
",",
"error",
"info",
"from",
"child",
"errors",
"(",
"key",
",",
"error",
"deps",
")",
")",
";",
"env",
"commit",
"(",
"entry",
",",
"enqueue",
"parent",
"behavior",
"signal",
")",
";",
"}",
"else",
"{",
"entry",
"=",
"evaluator",
"context",
"get",
"graph",
"(",
")",
"get",
"(",
"null",
",",
"reason",
"cycle",
"checking",
",",
"key",
")",
";",
"}",
"preconditions",
"check",
"not",
"null",
"(",
"entry",
",",
"key",
")",
";",
"/",
"/",
"nothing",
"to",
"be",
"done",
"for",
"this",
"node",
"if",
"it",
"already",
"has",
"an",
"entry",
"if",
"(",
"entry",
"is",
"done",
"(",
")",
")",
"{",
"continue",
";",
"}",
"if",
"(",
"cycles",
"found",
"=",
"=",
"max",
"cycles",
")",
"{",
"/",
"/",
"do",
"not",
"keep",
"on",
"searching",
"for",
"cycles",
"indefinitely",
",",
"to",
"avoid",
"excessive",
"runtime",
"/",
"o",
"o",
"ms",
"continue",
";",
"}",
"if",
"(",
"path",
"set",
"contains",
"(",
"key",
")",
")",
"{",
"int",
"cycle",
"start",
"=",
"graph",
"path",
"index",
"of",
"(",
"key",
")",
";",
"/",
"/",
"found",
"a",
"cycle",
"!",
"cycles",
"found",
"+",
"+",
";",
"iterable",
"<",
"sky",
"key",
">",
"cycle",
"=",
"graph",
"path",
"sub",
"list",
"(",
"cycle",
"start",
",",
"graph",
"path",
"size",
"(",
")",
")",
";",
"logger",
"at",
"info",
"(",
")",
"log",
"(",
"\"",
"found",
"cycle",
":",
"%",
"s",
"from",
"%",
"s",
"\"",
",",
"cycle",
",",
"graph",
"path",
")",
";",
"/",
"/",
"put",
"this",
"node",
"into",
"a",
"consistent",
"state",
"for",
"building",
"if",
"it",
"is",
"dirty",
"if",
"(",
"entry",
"is",
"dirty",
"(",
")",
")",
"{",
"/",
"/",
"if",
"this",
"loop",
"runs",
"more",
"than",
"once",
",",
"we",
"are",
"in",
"the",
"peculiar",
"position",
"of",
"entry",
"not",
"needing",
"/",
"/",
"rebuilding",
"even",
"though",
"it",
"was",
"signaled",
"with",
"the",
"graph",
"version",
"this",
"can",
"happen",
"when",
"the",
"/",
"/",
"entry",
"was",
"previously",
"evaluated",
"at",
"this",
"version",
",",
"but",
"then",
"invalidated",
"anyway",
",",
"even",
"/",
"/",
"though",
"nothing",
"changed",
"int",
"loop",
"count",
"=",
"0",
";",
"version",
"graph",
"version",
"=",
"evaluator",
"context",
"get",
"graph",
"version",
"(",
")",
";",
"while",
"(",
"entry",
"get",
"dirty",
"state",
"(",
")",
"=",
"=",
"node",
"entry",
"dirty",
"state",
"check",
"dependencies",
")",
"{",
"entry",
"signal",
"dep",
"(",
"graph",
"version",
",",
"null",
")",
";",
"loop",
"count",
"+",
"+",
";",
"}",
"if",
"(",
"loop",
"count",
">",
"1",
"&",
"&",
"!",
"entry",
"get",
"version",
"(",
")",
"equals",
"(",
"graph",
"version",
")",
")",
"{",
"bug",
"report",
"send",
"bug",
"report",
"(",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"entry",
"needed",
"multiple",
"signaling",
"but",
"didn",
"'",
"t",
"have",
"the",
"graph",
"version",
":",
"\"",
"+",
"key",
"+",
"\"",
",",
"\"",
"+",
"entry",
"+",
"\"",
",",
"\"",
"+",
"graph",
"version",
"+",
"\"",
",",
"\"",
"+",
"graph",
"path",
")",
")",
";",
"}",
"if",
"(",
"entry",
"get",
"dirty",
"state",
"(",
")",
"=",
"=",
"node",
"entry",
"dirty",
"state",
"needs",
"rebuilding",
")",
"{",
"entry",
"mark",
"rebuilding",
"(",
")",
";",
"}",
"else",
"if",
"(",
"maybe",
"handle",
"verified",
"clean",
"node",
"(",
"key",
",",
"entry",
",",
"evaluator",
"context",
",",
"graph",
"path",
")",
")",
"{",
"continue",
";",
"}",
"}",
"if",
"(",
"evaluator",
"context",
"keep",
"going",
"(",
")",
")",
"{",
"/",
"/",
"any",
"children",
"of",
"this",
"node",
"that",
"we",
"haven",
"'",
"t",
"already",
"visited",
"are",
"not",
"worth",
"visiting",
",",
"/",
"/",
"since",
"this",
"node",
"is",
"about",
"to",
"be",
"done",
"thus",
",",
"the",
"only",
"child",
"worth",
"visiting",
"is",
"the",
"one",
"in",
"/",
"/",
"this",
"cycle",
",",
"the",
"cycle",
"child",
"(",
"which",
"may",
"=",
"=",
"key",
"if",
"this",
"cycle",
"is",
"a",
"self",
"-",
"edge",
")",
"sky",
"key",
"cycle",
"child",
"=",
"select",
"cycle",
"child",
"(",
"key",
",",
"graph",
"path",
",",
"cycle",
"start",
")",
";",
"set",
"<",
"sky",
"key",
">",
"removed",
"deps",
"=",
"remove",
"descendants",
"of",
"cycle",
"value",
"(",
"key",
",",
"entry",
",",
"cycle",
"child",
",",
"to",
"visit",
",",
"graph",
"path",
"size",
"(",
")",
"-",
"cycle",
"start",
",",
"evaluator",
"context",
")",
";",
"value",
"with",
"metadata",
"dummy",
"value",
"=",
"value",
"with",
"metadata",
"wrap",
"with",
"metadata",
"(",
"new",
"sky",
"value",
"(",
")",
"{",
"}",
")",
";",
"sky",
"function",
"environment",
"env",
"=",
"new",
"sky",
"function",
"environment",
"(",
"key",
",",
"entry",
"get",
"temporary",
"direct",
"deps",
"(",
")",
",",
"immutable",
"map",
"of",
"(",
"cycle",
"child",
",",
"dummy",
"value",
")",
",",
"sets",
"difference",
"(",
"entry",
"get",
"all",
"remaining",
"dirty",
"direct",
"deps",
"(",
")",
",",
"removed",
"deps",
")",
",",
"evaluator",
"context",
")",
";",
"/",
"/",
"construct",
"error",
"info",
"for",
"this",
"node",
"get",
"errors",
"from",
"children",
",",
"which",
"are",
"all",
"done",
"/",
"/",
"except",
"possibly",
"for",
"the",
"cycle",
"child",
"list",
"<",
"error",
"info",
">",
"all",
"errors",
"=",
"get",
"children",
"errors",
"for",
"cycle",
"checking",
"(",
"iterables",
"concat",
"(",
"entry",
"get",
"temporary",
"direct",
"deps",
"(",
")",
")",
",",
"/",
"*",
"unfinished",
"child",
"=",
"*",
"/",
"cycle",
"child",
",",
"evaluator",
"context",
")",
";",
"cycle",
"info",
"cycle",
"info",
"=",
"new",
"cycle",
"info",
"(",
"cycle",
")",
";",
"/",
"/",
"add",
"in",
"this",
"cycle",
"all",
"errors",
"add",
"(",
"error",
"info",
"from",
"cycle",
"(",
"cycle",
"info",
")",
")",
";",
"env",
"set",
"error",
"(",
"entry",
",",
"error",
"info",
"from",
"child",
"errors",
"(",
"key",
",",
"all",
"errors",
")",
")",
";",
"env",
"commit",
"(",
"entry",
",",
"enqueue",
"parent",
"behavior",
"signal",
")",
";",
"continue",
";",
"}",
"else",
"{",
"/",
"/",
"we",
"need",
"to",
"return",
"right",
"away",
"in",
"the",
"no",
"keep",
"going",
"case",
",",
"so",
"construct",
"the",
"cycle",
"(",
"with",
"the",
"/",
"/",
"path",
")",
"and",
"return",
"preconditions",
"check",
"state",
"(",
"graph",
"path",
"get",
"(",
"0",
")",
"equals",
"(",
"root",
")",
",",
"\"",
"%",
"s",
"not",
"reached",
"from",
"%",
"s",
"value",
"entry",
":",
"%",
"s",
"\"",
",",
"key",
",",
"root",
",",
"entry",
")",
";",
"return",
"error",
"info",
"from",
"cycle",
"(",
"new",
"cycle",
"info",
"(",
"graph",
"path",
"sub",
"list",
"(",
"0",
",",
"cycle",
"start",
")",
",",
"cycle",
")",
")",
";",
"}",
"}",
"/",
"/",
"this",
"node",
"is",
"not",
"yet",
"known",
"to",
"be",
"in",
"a",
"cycle",
"so",
"process",
"its",
"children",
"grouped",
"list",
"<",
"sky",
"key",
">",
"temporary",
"direct",
"deps",
"=",
"entry",
"get",
"temporary",
"direct",
"deps",
"(",
")",
";",
"iterable",
"<",
"sky",
"key",
">",
"children",
"=",
"temporary",
"direct",
"deps",
"get",
"all",
"elements",
"as",
"iterable",
"(",
")",
";",
"if",
"(",
"temporary",
"direct",
"deps",
"is",
"empty",
"(",
")",
")",
"{",
"continue",
";",
"}",
"/",
"/",
"prefetch",
"all",
"children",
",",
"in",
"case",
"our",
"graph",
"performs",
"better",
"with",
"a",
"primed",
"cache",
"no",
"need",
"to",
"/",
"/",
"recurse",
"into",
"done",
"nodes",
"the",
"fields",
"of",
"done",
"nodes",
"aren",
"'",
"t",
"necessary",
",",
"since",
"we",
"'",
"ll",
"filter",
"them",
"/",
"/",
"out",
"/",
"/",
"todo",
"(",
"janakr",
")",
":",
"if",
"graph",
"implementations",
"start",
"using",
"these",
"hints",
"for",
"not",
"-",
"done",
"nodes",
",",
"we",
"may",
"/",
"/",
"have",
"to",
"change",
"this",
"map",
"<",
"sky",
"key",
",",
"?",
"extends",
"node",
"entry",
">",
"children",
"nodes",
"=",
"evaluator",
"context",
"get",
"graph",
"(",
")",
"get",
"batch",
"(",
"key",
",",
"reason",
"existence",
"checking",
",",
"children",
")",
";",
"if",
"(",
"children",
"nodes",
"size",
"(",
")",
"!",
"=",
"temporary",
"direct",
"deps",
"num",
"elements",
"(",
")",
")",
"{",
"immutable",
"set",
"<",
"sky",
"key",
">",
"children",
"set",
"=",
"immutable",
"set",
"copy",
"of",
"(",
"children",
")",
";",
"set",
"<",
"sky",
"key",
">",
"missing",
"children",
"=",
"sets",
"difference",
"(",
"children",
"set",
",",
"children",
"nodes",
"key",
"set",
"(",
")",
")",
";",
"if",
"(",
"missing",
"children",
"is",
"empty",
"(",
")",
")",
"{",
"logger",
"at",
"warning",
"(",
")",
"log",
"(",
"\"",
"mismatch",
"for",
"children",
"?",
"?",
"%",
"d",
",",
"%",
"d",
",",
"%",
"s",
",",
"%",
"s",
",",
"%",
"s",
",",
"%",
"s",
"\"",
",",
"children",
"nodes",
"size",
"(",
")",
",",
"temporary",
"direct",
"deps",
"num",
"elements",
"(",
")",
",",
"children",
"set",
",",
"children",
"nodes",
",",
"key",
",",
"entry",
")",
";",
"}",
"else",
"{",
"evaluator",
"context",
"get",
"graph",
"inconsistency",
"receiver",
"(",
")",
"note",
"inconsistency",
"and",
"maybe",
"throw",
"(",
"key",
",",
"missing",
"children",
",",
"inconsistency",
"already",
"declared",
"child",
"missing",
")",
";",
"entry",
"remove",
"unfinished",
"deps",
"(",
"missing",
"children",
")",
";",
"}",
"}",
"children",
"=",
"maps",
"filter",
"values",
"(",
"children",
"nodes",
",",
"node",
"entry",
"-",
">",
"!",
"node",
"entry",
"is",
"done",
"(",
")",
")",
"key",
"set",
"(",
")",
";",
"/",
"/",
"this",
"marker",
"flag",
"will",
"tell",
"us",
"when",
"all",
"this",
"node",
"'",
"s",
"children",
"have",
"been",
"processed",
"to",
"visit",
"push",
"(",
"children",
"finished",
")",
";",
"/",
"/",
"this",
"node",
"is",
"now",
"part",
"of",
"the",
"path",
"through",
"the",
"graph",
"graph",
"path",
"add",
"(",
"key",
")",
";",
"path",
"set",
"add",
"(",
"key",
")",
";",
"for",
"(",
"sky",
"key",
"next",
"value",
":",
"children",
")",
"{",
"to",
"visit",
"push",
"(",
"next",
"value",
")",
";",
"}",
"}",
"return",
"evaluator",
"context",
"keep",
"going",
"(",
")",
"?",
"get",
"and",
"check",
"done",
"for",
"cycle",
"(",
"root",
",",
"evaluator",
"context",
")",
"get",
"error",
"info",
"(",
")",
":",
"null",
";",
"}"
] |
[
"convenience",
"method",
"to",
"build",
"and",
"return",
"a",
"new",
"{",
"@",
"link",
"script",
"metadata",
"}",
"deleting",
"the",
"specified",
"stored",
"script"
] |
[
"static",
"script",
"metadata",
"delete",
"stored",
"script",
"(",
"script",
"metadata",
"previous",
",",
"string",
"id",
")",
"{",
"builder",
"builder",
"=",
"new",
"script",
"metadata",
"builder",
"(",
"previous",
")",
";",
"builder",
"delete",
"script",
"(",
"id",
")",
";",
"return",
"builder",
"build",
"(",
")",
";",
"}"
] |
[
"returns",
"an",
"instance",
"with",
"the",
"specified",
"ad",
"resume",
"position",
",",
"in",
"microseconds",
",",
"relative",
"to",
"the",
"start",
"of",
"the",
"current",
"ad"
] |
[
"public",
"ad",
"playback",
"state",
"with",
"ad",
"resume",
"position",
"us",
"(",
"long",
"ad",
"resume",
"position",
"us",
")",
"{",
"if",
"(",
"this",
"ad",
"resume",
"position",
"us",
"=",
"=",
"ad",
"resume",
"position",
"us",
")",
"{",
"return",
"this",
";",
"}",
"else",
"{",
"return",
"new",
"ad",
"playback",
"state",
"(",
"ad",
"group",
"times",
"us",
",",
"ad",
"groups",
",",
"ad",
"resume",
"position",
"us",
",",
"content",
"duration",
"us",
")",
";",
"}",
"}"
] |
[
"return",
"the",
"innermost",
"target",
"session",
"of",
"the",
"given",
"session",
"if",
"the",
"given",
"session",
"is",
"a",
"proxy",
",",
"it",
"will",
"be",
"unwrapped",
"until",
"a",
"non",
"-",
"proxy",
"session",
"is",
"found",
"otherwise",
",",
"the",
"passed",
"-",
"in",
"session",
"will",
"be",
"returned",
"as",
"-",
"is"
] |
[
"public",
"static",
"session",
"get",
"target",
"session",
"(",
"session",
"session",
")",
"{",
"session",
"session",
"to",
"use",
"=",
"session",
";",
"while",
"(",
"session",
"to",
"use",
"instanceof",
"session",
"proxy",
")",
"{",
"session",
"to",
"use",
"=",
"(",
"(",
"session",
"proxy",
")",
"session",
"to",
"use",
")",
"get",
"target",
"session",
"(",
")",
";",
"}",
"return",
"session",
"to",
"use",
";",
"}"
] |
[
"model",
"tests",
"for",
"additional",
"properties",
"boolean"
] |
[
"public",
"void",
"test",
"additional",
"properties",
"boolean",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"additional",
"properties",
"boolean",
"}"
] |
[
"provides",
"reading",
"iterator",
"after",
"the",
"records",
"are",
"written",
"to",
"the",
"{",
"@",
"link",
"#",
"columnar",
"batch",
"}"
] |
[
"public",
"abstract",
"record",
"iterator",
"<",
"t",
">",
"convert",
"and",
"get",
"iterator",
"(",
"long",
"rows",
"returned",
")",
"throws",
"i",
"o",
"exception",
";"
] |
[
"process",
"the",
"service",
"type",
"including",
"the",
"sub",
"-",
"routines",
":",
"{",
"@",
"link",
"service",
"rest",
"metadata",
"#",
"set",
"service",
"interface",
"(",
"string",
")",
"}",
"{",
"@",
"link",
"service",
"rest",
"metadata",
"#",
"set",
"version",
"(",
"string",
")",
"}",
"{",
"@",
"link",
"service",
"rest",
"metadata",
"#",
"set",
"group",
"(",
"string",
")",
"}"
] |
[
"protected",
"void",
"process",
"service",
"rest",
"metadata",
"(",
"service",
"rest",
"metadata",
"service",
"rest",
"metadata",
",",
"class",
"<",
"?",
">",
"service",
"type",
")",
"{",
"service",
"annotation",
"resolver",
"resolver",
"=",
"new",
"service",
"annotation",
"resolver",
"(",
"service",
"type",
")",
";",
"service",
"rest",
"metadata",
"set",
"service",
"interface",
"(",
"resolver",
"resolve",
"interface",
"class",
"name",
"(",
")",
")",
";",
"service",
"rest",
"metadata",
"set",
"version",
"(",
"resolver",
"resolve",
"version",
"(",
")",
")",
";",
"service",
"rest",
"metadata",
"set",
"group",
"(",
"resolver",
"resolve",
"group",
"(",
")",
")",
";",
"}"
] |
[
"get",
"the",
"id",
"associated",
"with",
"<",
"code",
">",
"key",
"<",
"code",
">",
"or",
"-",
"1",
"if",
"the",
"key",
"is",
"not",
"contained",
"in",
"the",
"hash"
] |
[
"public",
"long",
"find",
"(",
"long",
"key",
"1",
",",
"long",
"key",
"2",
")",
"{",
"final",
"long",
"slot",
"=",
"slot",
"(",
"hash",
"(",
"key",
"1",
",",
"key",
"2",
")",
",",
"mask",
")",
";",
"for",
"(",
"long",
"index",
"=",
"slot",
";",
";",
"index",
"=",
"next",
"slot",
"(",
"index",
",",
"mask",
")",
")",
"{",
"final",
"long",
"id",
"=",
"id",
"(",
"index",
")",
";",
"long",
"key",
"offset",
"=",
"2",
"*",
"id",
";",
"if",
"(",
"id",
"=",
"=",
"-",
"1",
"|",
"|",
"(",
"keys",
"get",
"(",
"key",
"offset",
")",
"=",
"=",
"key",
"1",
"&",
"&",
"keys",
"get",
"(",
"key",
"offset",
"+",
"1",
")",
"=",
"=",
"key",
"2",
")",
")",
"{",
"return",
"id",
";",
"}",
"}",
"}"
] |
[
"returns",
"true",
"if",
"animation",
"is",
"enabled",
";",
"false",
"if",
"animation",
"has",
"been",
"disable",
",",
"such",
"as",
"by",
"a",
"user",
"option"
] |
[
"public",
"static",
"boolean",
"is",
"animation",
"enabled",
"(",
")",
"{",
"return",
"animation",
"enabled",
";",
"}"
] |
[
"returns",
"the",
"text",
"to",
"be",
"analyzed"
] |
[
"public",
"string",
"[",
"]",
"text",
"(",
")",
"{",
"return",
"this",
"text",
";",
"}"
] |
[
"returns",
"the",
"shard",
"number",
"for",
"this",
"action",
"if",
"get",
"total",
"shards",
"(",
")",
">",
"0",
",",
"must",
"be",
">",
"=",
"0",
"and",
"<",
"get",
"total",
"shards",
"(",
")",
"otherwise",
",",
"must",
"be",
"0"
] |
[
"public",
"int",
"get",
"shard",
"num",
"(",
")",
"{",
"return",
"shard",
"num",
";",
"}"
] |
[
"returns",
"the",
"actual",
"bytes",
"for",
"this",
"resource"
] |
[
"public",
"byte",
"[",
"]",
"get",
"bytes",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"reader",
"read",
"byte",
"array",
"(",
"get",
"file",
"offset",
"shifted",
"(",
")",
",",
"get",
"file",
"length",
"shifted",
"(",
")",
")",
";",
"}"
] |
[
"convert",
"an",
"array",
"of",
"{",
"@",
"code",
"m",
"bean",
"parameter",
"info",
"}",
"into",
"an",
"array",
"of",
"{",
"@",
"code",
"class",
"}",
"instances",
"corresponding",
"to",
"the",
"parameters"
] |
[
"public",
"static",
"class",
"<",
"?",
">",
"[",
"]",
"parameter",
"info",
"to",
"types",
"(",
"@",
"nullable",
"m",
"bean",
"parameter",
"info",
"[",
"]",
"param",
"info",
",",
"@",
"nullable",
"class",
"loader",
"class",
"loader",
")",
"throws",
"class",
"not",
"found",
"exception",
"{",
"class",
"<",
"?",
">",
"[",
"]",
"types",
"=",
"null",
";",
"if",
"(",
"param",
"info",
"!",
"=",
"null",
"&",
"&",
"param",
"info",
"length",
">",
"0",
")",
"{",
"types",
"=",
"new",
"class",
"<",
"?",
">",
"[",
"param",
"info",
"length",
"]",
";",
"for",
"(",
"int",
"x",
"=",
"0",
";",
"x",
"<",
"param",
"info",
"length",
";",
"x",
"+",
"+",
")",
"{",
"types",
"[",
"x",
"]",
"=",
"class",
"utils",
"for",
"name",
"(",
"param",
"info",
"[",
"x",
"]",
"get",
"type",
"(",
")",
",",
"class",
"loader",
")",
";",
"}",
"}",
"return",
"types",
";",
"}"
] |
[
"get",
"small",
"camel"
] |
[
"public",
"string",
"get",
"small",
"camel",
"(",
")",
"{",
"return",
"small",
"camel",
";",
"}"
] |
[
"a",
"main",
"method",
"that",
"runs",
"blaze",
"commands",
"in",
"batch",
"mode",
"the",
"return",
"value",
"indicates",
"the",
"desired",
"exit",
"status",
"of",
"the",
"program"
] |
[
"private",
"static",
"int",
"batch",
"main",
"(",
"iterable",
"<",
"blaze",
"module",
">",
"modules",
",",
"string",
"[",
"]",
"args",
")",
"{",
"interrupt",
"signal",
"handler",
"signal",
"handler",
"=",
"capture",
"sigint",
"(",
")",
";",
"command",
"line",
"options",
"command",
"line",
"options",
"=",
"split",
"startup",
"options",
"(",
"modules",
",",
"args",
")",
";",
"logger",
"at",
"info",
"(",
")",
"log",
"(",
"\"",
"running",
"bazel",
"in",
"batch",
"mode",
"with",
"%",
"s",
",",
"startup",
"args",
"%",
"s",
"\"",
",",
"maybe",
"get",
"pid",
"string",
"(",
")",
",",
"command",
"line",
"options",
"get",
"startup",
"args",
"(",
")",
")",
";",
"blaze",
"runtime",
"runtime",
";",
"invocation",
"policy",
"policy",
";",
"try",
"{",
"runtime",
"=",
"new",
"runtime",
"(",
"modules",
",",
"command",
"line",
"options",
"get",
"startup",
"args",
"(",
")",
",",
"null",
")",
";",
"policy",
"=",
"invocation",
"policy",
"parser",
"parse",
"policy",
"(",
"runtime",
"get",
"startup",
"options",
"provider",
"(",
")",
"get",
"options",
"(",
"blaze",
"server",
"startup",
"options",
"class",
")",
"invocation",
"policy",
")",
";",
"}",
"catch",
"(",
"options",
"parsing",
"exception",
"e",
")",
"{",
"out",
"err",
"system",
"out",
"err",
"print",
"err",
"ln",
"(",
"e",
"get",
"message",
"(",
")",
")",
";",
"return",
"exit",
"code",
"command",
"line",
"error",
"get",
"numeric",
"exit",
"code",
"(",
")",
";",
"}",
"catch",
"(",
"abrupt",
"exit",
"exception",
"e",
")",
"{",
"out",
"err",
"system",
"out",
"err",
"print",
"err",
"ln",
"(",
"e",
"get",
"message",
"(",
")",
")",
";",
"return",
"e",
"get",
"exit",
"code",
"(",
")",
"get",
"numeric",
"exit",
"code",
"(",
")",
";",
"}",
"immutable",
"list",
"builder",
"<",
"pair",
"<",
"string",
",",
"string",
">",
">",
"startup",
"options",
"from",
"command",
"line",
"=",
"immutable",
"list",
"builder",
"(",
")",
";",
"for",
"(",
"string",
"option",
":",
"command",
"line",
"options",
"get",
"startup",
"args",
"(",
")",
")",
"{",
"startup",
"options",
"from",
"command",
"line",
"add",
"(",
"new",
"pair",
"<",
">",
"(",
"\"",
"\"",
",",
"option",
")",
")",
";",
"}",
"blaze",
"command",
"dispatcher",
"dispatcher",
"=",
"new",
"blaze",
"command",
"dispatcher",
"(",
"runtime",
",",
"blaze",
"command",
"dispatcher",
"unknown",
"server",
"pid",
")",
";",
"boolean",
"shutdown",
"done",
"=",
"false",
";",
"try",
"{",
"logger",
"at",
"info",
"(",
")",
"log",
"(",
"safe",
"request",
"logging",
"get",
"request",
"log",
"string",
"(",
"command",
"line",
"options",
"get",
"other",
"args",
"(",
")",
")",
")",
";",
"blaze",
"command",
"result",
"result",
"=",
"dispatcher",
"exec",
"(",
"policy",
",",
"command",
"line",
"options",
"get",
"other",
"args",
"(",
")",
",",
"out",
"err",
"system",
"out",
"err",
",",
"locking",
"mode",
"error",
"out",
",",
"\"",
"batch",
"client",
"\"",
",",
"runtime",
"get",
"clock",
"(",
")",
"current",
"time",
"millis",
"(",
")",
",",
"optional",
"of",
"(",
"startup",
"options",
"from",
"command",
"line",
"build",
"(",
")",
")",
",",
"/",
"*",
"command",
"extensions",
"=",
"*",
"/",
"immutable",
"list",
"of",
"(",
")",
")",
";",
"if",
"(",
"result",
"get",
"exec",
"request",
"(",
")",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"simple",
"case",
":",
"we",
"are",
"given",
"an",
"exit",
"code",
"return",
"result",
"get",
"exit",
"code",
"(",
")",
"get",
"numeric",
"exit",
"code",
"(",
")",
";",
"}",
"/",
"/",
"not",
"so",
"simple",
"case",
":",
"we",
"need",
"to",
"execute",
"a",
"binary",
"on",
"shutdown",
"exec",
"(",
")",
"is",
"not",
"accessible",
"from",
"/",
"/",
"java",
"and",
"is",
"impossible",
"on",
"windows",
"in",
"any",
"case",
",",
"so",
"we",
"just",
"execute",
"the",
"binary",
"after",
"getting",
"/",
"/",
"out",
"of",
"the",
"way",
"as",
"completely",
"as",
"possible",
"and",
"forward",
"its",
"exit",
"code",
"/",
"/",
"when",
"this",
"code",
"is",
"executed",
",",
"no",
"locks",
"are",
"held",
":",
"the",
"client",
"lock",
"is",
"released",
"by",
"the",
"client",
"/",
"/",
"before",
"it",
"executes",
"any",
"command",
"and",
"the",
"server",
"lock",
"is",
"handled",
"by",
"blaze",
"command",
"dispatcher",
",",
"/",
"/",
"whose",
"job",
"is",
"done",
"by",
"the",
"time",
"we",
"get",
"here",
"runtime",
"shutdown",
"(",
")",
";",
"dispatcher",
"shutdown",
"(",
")",
";",
"shutdown",
"done",
"=",
"true",
";",
"signal",
"handler",
"uninstall",
"(",
")",
";",
"exec",
"request",
"request",
"=",
"result",
"get",
"exec",
"request",
"(",
")",
";",
"string",
"[",
"]",
"argv",
"=",
"new",
"string",
"[",
"request",
"get",
"argv",
"count",
"(",
")",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"argv",
"length",
";",
"i",
"+",
"+",
")",
"{",
"argv",
"[",
"i",
"]",
"=",
"request",
"get",
"argv",
"(",
"i",
")",
"to",
"string",
"(",
"standard",
"charsets",
"iso",
"8859",
"1",
")",
";",
"}",
"string",
"working",
"directory",
"=",
"request",
"get",
"working",
"directory",
"(",
")",
"to",
"string",
"(",
"standard",
"charsets",
"iso",
"8859",
"1",
")",
";",
"try",
"{",
"process",
"builder",
"process",
"=",
"new",
"process",
"builder",
"(",
")",
"command",
"(",
"argv",
")",
"directory",
"(",
"new",
"file",
"(",
"working",
"directory",
")",
")",
"inherit",
"i",
"o",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"request",
"get",
"environment",
"variable",
"count",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"environment",
"variable",
"variable",
"=",
"request",
"get",
"environment",
"variable",
"(",
"i",
")",
";",
"process",
"environment",
"(",
")",
"put",
"(",
"variable",
"get",
"name",
"(",
")",
"to",
"string",
"(",
"standard",
"charsets",
"iso",
"8859",
"1",
")",
",",
"variable",
"get",
"value",
"(",
")",
"to",
"string",
"(",
"standard",
"charsets",
"iso",
"8859",
"1",
")",
")",
";",
"}",
"return",
"process",
"start",
"(",
")",
"wait",
"for",
"(",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"/",
"/",
"we",
"are",
"in",
"batch",
"mode",
",",
"thus",
",",
"stdout",
"/",
"stderr",
"are",
"the",
"same",
"as",
"that",
"of",
"the",
"client",
"system",
"err",
"println",
"(",
"\"",
"cannot",
"execute",
"process",
"for",
"'",
"run",
"'",
"command",
":",
"\"",
"+",
"e",
"get",
"message",
"(",
")",
")",
";",
"logger",
"at",
"severe",
"(",
")",
"with",
"cause",
"(",
"e",
")",
"log",
"(",
"\"",
"exception",
"while",
"executing",
"binary",
"from",
"'",
"run",
"'",
"command",
"\"",
")",
";",
"return",
"exit",
"code",
"local",
"environmental",
"error",
"get",
"numeric",
"exit",
"code",
"(",
")",
";",
"}",
"}",
"catch",
"(",
"interrupted",
"exception",
"e",
")",
"{",
"/",
"/",
"this",
"is",
"almost",
"main",
"(",
")",
",",
"so",
"it",
"'",
"s",
"okay",
"to",
"just",
"swallow",
"it",
"we",
"are",
"exiting",
"soon",
"return",
"exit",
"code",
"interrupted",
"get",
"numeric",
"exit",
"code",
"(",
")",
";",
"}",
"finally",
"{",
"if",
"(",
"!",
"shutdown",
"done",
")",
"{",
"runtime",
"shutdown",
"(",
")",
";",
"dispatcher",
"shutdown",
"(",
")",
";",
"}",
"}",
"}"
] |
[
"render",
"the",
"sub",
"-",
"view"
] |
[
"void",
"render",
"partial",
"(",
")",
";"
] |
[
"add",
"audit",
"log",
"for",
"server",
"start",
"and",
"register",
"server",
"stop",
"log"
] |
[
"public",
"static",
"void",
"add",
"z",
"k",
"start",
"stop",
"audit",
"log",
"(",
")",
"{",
"if",
"(",
"is",
"audit",
"enabled",
"(",
")",
")",
"{",
"log",
"(",
"get",
"z",
"k",
"user",
"(",
")",
",",
"audit",
"constants",
"op",
"start",
",",
"result",
"success",
")",
";",
"runtime",
"get",
"runtime",
"(",
")",
"add",
"shutdown",
"hook",
"(",
"new",
"thread",
"(",
"(",
")",
"-",
">",
"{",
"log",
"(",
"get",
"z",
"k",
"user",
"(",
")",
",",
"audit",
"constants",
"op",
"stop",
",",
"result",
"invoked",
")",
";",
"}",
")",
")",
";",
"}",
"}"
] |
[
"open",
"a",
"named",
"pipe",
"created",
"elsewhere",
"for",
"input"
] |
[
"public",
"input",
"stream",
"open",
"named",
"pipe",
"input",
"stream",
"(",
"path",
"file",
",",
"duration",
"timeout",
")",
"throws",
"i",
"o",
"exception",
"{",
"long",
"timeout",
"millis",
"remaining",
"=",
"timeout",
"to",
"millis",
"(",
")",
";",
"/",
"/",
"can",
"'",
"t",
"use",
"files",
"is",
"regular",
"file",
"(",
")",
"on",
"on",
"named",
"pipes",
"on",
"windows",
",",
"as",
"it",
"renders",
"them",
"unusable",
",",
"/",
"/",
"but",
"luckily",
"there",
"'",
"s",
"an",
"even",
"simpler",
"check",
"(",
"that",
"'",
"s",
"not",
"possible",
"on",
"*",
"nix",
")",
"if",
"(",
"constants",
"windows",
"&",
"&",
"!",
"file",
"to",
"string",
"(",
")",
"starts",
"with",
"(",
"win",
"pipe",
"prefix",
")",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"file",
"+",
"\"",
"is",
"not",
"a",
"named",
"pipe",
"\"",
")",
";",
"}",
"security",
"manager",
"sm",
"=",
"system",
"get",
"security",
"manager",
"(",
")",
";",
"if",
"(",
"sm",
"!",
"=",
"null",
")",
"{",
"sm",
"check",
"permission",
"(",
"new",
"special",
"permission",
"(",
")",
")",
";",
"}",
"/",
"/",
"try",
"to",
"open",
"the",
"file",
"periodically",
"until",
"the",
"timeout",
"expires",
",",
"then",
",",
"if",
"/",
"/",
"it",
"'",
"s",
"still",
"not",
"available",
"throw",
"the",
"exception",
"from",
"file",
"input",
"stream",
"while",
"(",
"true",
")",
"{",
"/",
"/",
"on",
"windows",
"files",
"is",
"regular",
"file",
"(",
")",
"will",
"render",
"a",
"genuine",
"named",
"pipe",
"unusable",
"if",
"(",
"!",
"constants",
"windows",
"&",
"&",
"files",
"is",
"regular",
"file",
"(",
"file",
")",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"file",
"+",
"\"",
"is",
"not",
"a",
"named",
"pipe",
"\"",
")",
";",
"}",
"try",
"{",
"privileged",
"input",
"pipe",
"opener",
"privileged",
"input",
"pipe",
"opener",
"=",
"new",
"privileged",
"input",
"pipe",
"opener",
"(",
"file",
")",
";",
"return",
"access",
"controller",
"do",
"privileged",
"(",
"privileged",
"input",
"pipe",
"opener",
")",
";",
"}",
"catch",
"(",
"runtime",
"exception",
"e",
")",
"{",
"if",
"(",
"timeout",
"millis",
"remaining",
"<",
"=",
"0",
")",
"{",
"propagate",
"privileged",
"exception",
"(",
"e",
")",
";",
"}",
"long",
"this",
"sleep",
"=",
"math",
"min",
"(",
"timeout",
"millis",
"remaining",
",",
"pause",
"time",
"ms",
")",
";",
"timeout",
"millis",
"remaining",
"-",
"=",
"this",
"sleep",
";",
"try",
"{",
"thread",
"sleep",
"(",
"this",
"sleep",
")",
";",
"}",
"catch",
"(",
"interrupted",
"exception",
"ie",
")",
"{",
"thread",
"current",
"thread",
"(",
")",
"interrupt",
"(",
")",
";",
"propagate",
"privileged",
"exception",
"(",
"e",
")",
";",
"}",
"}",
"}",
"}"
] |
[
"map",
"the",
"route",
"for",
"http",
"get",
"requests"
] |
[
"public",
"static",
"void",
"get",
"(",
"string",
"path",
",",
"string",
"accept",
"type",
",",
"route",
"route",
",",
"response",
"transformer",
"transformer",
")",
"{",
"get",
"instance",
"(",
")",
"get",
"(",
"path",
",",
"accept",
"type",
",",
"route",
",",
"transformer",
")",
";",
"}"
] |
[
"set",
"the",
"thread",
"pool",
"executor",
"'",
"s",
"maximum",
"pool",
"size",
"default",
"is",
"{",
"@",
"code",
"integer",
"max",
"value",
"}"
] |
[
"public",
"void",
"set",
"max",
"pool",
"size",
"(",
"int",
"max",
"pool",
"size",
")",
"{",
"this",
"max",
"pool",
"size",
"=",
"max",
"pool",
"size",
";",
"}"
] |
[
"returns",
"whether",
"the",
"decimal",
"value",
"is",
"small",
"enough",
"to",
"be",
"stored",
"in",
"a",
"long"
] |
[
"public",
"static",
"boolean",
"is",
"compact",
"(",
"int",
"precision",
")",
"{",
"return",
"precision",
"<",
"=",
"max",
"compact",
"precision",
";",
"}"
] |
[
"sets",
"the",
"target",
"playback",
"speed",
"this",
"method",
"may",
"only",
"be",
"called",
"after",
"draining",
"data",
"through",
"the",
"processor",
"the",
"value",
"returned",
"by",
"{",
"@",
"link",
"#",
"is",
"active",
"(",
")",
"}",
"may",
"change",
",",
"and",
"the",
"processor",
"must",
"be",
"{",
"@",
"link",
"#",
"flush",
"(",
")",
"flushed",
"}",
"before",
"queueing",
"more",
"data"
] |
[
"public",
"void",
"set",
"speed",
"(",
"float",
"speed",
")",
"{",
"if",
"(",
"this",
"speed",
"!",
"=",
"speed",
")",
"{",
"this",
"speed",
"=",
"speed",
";",
"pending",
"sonic",
"recreation",
"=",
"true",
";",
"}",
"}"
] |
[
"complete",
"a",
"future",
"with",
"another",
"future",
"returns",
"a",
"future",
"that",
"reports",
"whether",
"the",
"completion",
"was",
"successful",
"if",
"the",
"future",
"was",
"not",
"completed",
"due",
"to",
"cancellation",
",",
"the",
"callback",
"will",
"be",
"called",
"with",
"a",
"cancellation",
"exception",
",",
"and",
"the",
"original",
"future",
"result",
",",
"if",
"one",
"was",
"provided"
] |
[
"public",
"future",
"<",
"t",
">",
"set",
"complete",
"(",
"future",
"<",
"t",
">",
"future",
")",
"{",
"return",
"set",
"complete",
"(",
"future",
",",
"null",
")",
";",
"}"
] |
[
"tests",
"that",
"duration",
"of",
"the",
"current",
"media",
"info",
"is",
"correctly",
"propagated",
"to",
"the",
"timeline"
] |
[
"public",
"void",
"get",
"cast",
"timeline",
"persists",
"duration",
"(",
")",
"{",
"cast",
"timeline",
"tracker",
"tracker",
"=",
"new",
"cast",
"timeline",
"tracker",
"(",
")",
";",
"remote",
"media",
"client",
"remote",
"media",
"client",
"=",
"mock",
"remote",
"media",
"client",
"(",
"/",
"*",
"item",
"ids",
"=",
"*",
"/",
"new",
"int",
"[",
"]",
"{",
"1",
",",
"2",
",",
"3",
",",
"4",
",",
"5",
"}",
",",
"/",
"*",
"current",
"item",
"id",
"=",
"*",
"/",
"2",
",",
"/",
"*",
"current",
"duration",
"ms",
"=",
"*",
"/",
"duration",
"2",
"ms",
")",
";",
"timeline",
"asserts",
"assert",
"period",
"durations",
"(",
"tracker",
"get",
"cast",
"timeline",
"(",
"remote",
"media",
"client",
")",
",",
"c",
"time",
"unset",
",",
"c",
"ms",
"to",
"us",
"(",
"duration",
"2",
"ms",
")",
",",
"c",
"time",
"unset",
",",
"c",
"time",
"unset",
",",
"c",
"time",
"unset",
")",
";",
"remote",
"media",
"client",
"=",
"mock",
"remote",
"media",
"client",
"(",
"/",
"*",
"item",
"ids",
"=",
"*",
"/",
"new",
"int",
"[",
"]",
"{",
"1",
",",
"2",
",",
"3",
"}",
",",
"/",
"*",
"current",
"item",
"id",
"=",
"*",
"/",
"3",
",",
"/",
"*",
"current",
"duration",
"ms",
"=",
"*",
"/",
"duration",
"3",
"ms",
")",
";",
"timeline",
"asserts",
"assert",
"period",
"durations",
"(",
"tracker",
"get",
"cast",
"timeline",
"(",
"remote",
"media",
"client",
")",
",",
"c",
"time",
"unset",
",",
"c",
"ms",
"to",
"us",
"(",
"duration",
"2",
"ms",
")",
",",
"c",
"ms",
"to",
"us",
"(",
"duration",
"3",
"ms",
")",
")",
";",
"remote",
"media",
"client",
"=",
"mock",
"remote",
"media",
"client",
"(",
"/",
"*",
"item",
"ids",
"=",
"*",
"/",
"new",
"int",
"[",
"]",
"{",
"1",
",",
"3",
"}",
",",
"/",
"*",
"current",
"item",
"id",
"=",
"*",
"/",
"3",
",",
"/",
"*",
"current",
"duration",
"ms",
"=",
"*",
"/",
"duration",
"3",
"ms",
")",
";",
"timeline",
"asserts",
"assert",
"period",
"durations",
"(",
"tracker",
"get",
"cast",
"timeline",
"(",
"remote",
"media",
"client",
")",
",",
"c",
"time",
"unset",
",",
"c",
"ms",
"to",
"us",
"(",
"duration",
"3",
"ms",
")",
")",
";",
"remote",
"media",
"client",
"=",
"mock",
"remote",
"media",
"client",
"(",
"/",
"*",
"item",
"ids",
"=",
"*",
"/",
"new",
"int",
"[",
"]",
"{",
"1",
",",
"2",
",",
"3",
",",
"4",
",",
"5",
"}",
",",
"/",
"*",
"current",
"item",
"id",
"=",
"*",
"/",
"4",
",",
"/",
"*",
"current",
"duration",
"ms",
"=",
"*",
"/",
"duration",
"4",
"ms",
")",
";",
"timeline",
"asserts",
"assert",
"period",
"durations",
"(",
"tracker",
"get",
"cast",
"timeline",
"(",
"remote",
"media",
"client",
")",
",",
"c",
"time",
"unset",
",",
"c",
"time",
"unset",
",",
"c",
"ms",
"to",
"us",
"(",
"duration",
"3",
"ms",
")",
",",
"c",
"ms",
"to",
"us",
"(",
"duration",
"4",
"ms",
")",
",",
"c",
"time",
"unset",
")",
";",
"remote",
"media",
"client",
"=",
"mock",
"remote",
"media",
"client",
"(",
"/",
"*",
"item",
"ids",
"=",
"*",
"/",
"new",
"int",
"[",
"]",
"{",
"1",
",",
"2",
",",
"3",
",",
"4",
",",
"5",
"}",
",",
"/",
"*",
"current",
"item",
"id",
"=",
"*",
"/",
"5",
",",
"/",
"*",
"current",
"duration",
"ms",
"=",
"*",
"/",
"duration",
"5",
"ms",
")",
";",
"timeline",
"asserts",
"assert",
"period",
"durations",
"(",
"tracker",
"get",
"cast",
"timeline",
"(",
"remote",
"media",
"client",
")",
",",
"c",
"time",
"unset",
",",
"c",
"time",
"unset",
",",
"c",
"ms",
"to",
"us",
"(",
"duration",
"3",
"ms",
")",
",",
"c",
"ms",
"to",
"us",
"(",
"duration",
"4",
"ms",
")",
",",
"c",
"ms",
"to",
"us",
"(",
"duration",
"5",
"ms",
")",
")",
";",
"}"
] |
[
"copies",
"values",
"from",
"another",
"instance",
"to",
"the",
"current",
"one"
] |
[
"public",
"void",
"set",
"(",
"settings",
"settings",
")",
"{",
"fast",
"=",
"settings",
"fast",
";",
"rotation",
"=",
"settings",
"rotation",
";",
"pot",
"=",
"settings",
"pot",
";",
"multiple",
"of",
"four",
"=",
"settings",
"multiple",
"of",
"four",
";",
"min",
"width",
"=",
"settings",
"min",
"width",
";",
"min",
"height",
"=",
"settings",
"min",
"height",
";",
"max",
"width",
"=",
"settings",
"max",
"width",
";",
"max",
"height",
"=",
"settings",
"max",
"height",
";",
"padding",
"x",
"=",
"settings",
"padding",
"x",
";",
"padding",
"y",
"=",
"settings",
"padding",
"y",
";",
"edge",
"padding",
"=",
"settings",
"edge",
"padding",
";",
"duplicate",
"padding",
"=",
"settings",
"duplicate",
"padding",
";",
"alpha",
"threshold",
"=",
"settings",
"alpha",
"threshold",
";",
"ignore",
"blank",
"images",
"=",
"settings",
"ignore",
"blank",
"images",
";",
"strip",
"whitespace",
"x",
"=",
"settings",
"strip",
"whitespace",
"x",
";",
"strip",
"whitespace",
"y",
"=",
"settings",
"strip",
"whitespace",
"y",
";",
"alias",
"=",
"settings",
"alias",
";",
"format",
"=",
"settings",
"format",
";",
"jpeg",
"quality",
"=",
"settings",
"jpeg",
"quality",
";",
"output",
"format",
"=",
"settings",
"output",
"format",
";",
"filter",
"min",
"=",
"settings",
"filter",
"min",
";",
"filter",
"mag",
"=",
"settings",
"filter",
"mag",
";",
"wrap",
"x",
"=",
"settings",
"wrap",
"x",
";",
"wrap",
"y",
"=",
"settings",
"wrap",
"y",
";",
"debug",
"=",
"settings",
"debug",
";",
"silent",
"=",
"settings",
"silent",
";",
"combine",
"subdirectories",
"=",
"settings",
"combine",
"subdirectories",
";",
"ignore",
"=",
"settings",
"ignore",
";",
"flatten",
"paths",
"=",
"settings",
"flatten",
"paths",
";",
"premultiply",
"alpha",
"=",
"settings",
"premultiply",
"alpha",
";",
"square",
"=",
"settings",
"square",
";",
"use",
"indexes",
"=",
"settings",
"use",
"indexes",
";",
"bleed",
"=",
"settings",
"bleed",
";",
"bleed",
"iterations",
"=",
"settings",
"bleed",
"iterations",
";",
"limit",
"memory",
"=",
"settings",
"limit",
"memory",
";",
"grid",
"=",
"settings",
"grid",
";",
"scale",
"=",
"arrays",
"copy",
"of",
"(",
"settings",
"scale",
",",
"settings",
"scale",
"length",
")",
";",
"scale",
"suffix",
"=",
"arrays",
"copy",
"of",
"(",
"settings",
"scale",
"suffix",
",",
"settings",
"scale",
"suffix",
"length",
")",
";",
"scale",
"resampling",
"=",
"arrays",
"copy",
"of",
"(",
"settings",
"scale",
"resampling",
",",
"settings",
"scale",
"resampling",
"length",
")",
";",
"atlas",
"extension",
"=",
"settings",
"atlas",
"extension",
";",
"pretty",
"print",
"=",
"settings",
"pretty",
"print",
";",
"legacy",
"output",
"=",
"settings",
"legacy",
"output",
";",
"}"
] |
[
"called",
"when",
"a",
"{",
"@",
"link",
"counter",
"}",
"is",
"added",
"to",
"the",
"registry"
] |
[
"void",
"on",
"counter",
"added",
"(",
"string",
"name",
",",
"counter",
"counter",
")",
";"
] |
[
"returns",
"the",
"directory",
"where",
"actions",
"can",
"store",
"temporary",
"files",
"(",
"such",
"as",
"their",
"stdout",
"and",
"stderr",
")",
"during",
"a",
"build",
"if",
"the",
"directory",
"already",
"exists",
",",
"the",
"directory",
"is",
"cleaned"
] |
[
"public",
"path",
"get",
"action",
"temps",
"directory",
"(",
"path",
"exec",
"root",
")",
"{",
"return",
"exec",
"root",
"get",
"relative",
"(",
"get",
"relative",
"output",
"path",
"(",
")",
")",
"get",
"relative",
"(",
"\"",
"tmp",
"/",
"actions",
"\"",
")",
";",
"}"
] |
[
"uses",
"an",
"{",
"@",
"link",
"array",
"list",
"}",
"to",
"store",
"value",
"collections"
] |
[
"public",
"list",
"multimap",
"builder",
"<",
"k0",
",",
"object",
">",
"array",
"list",
"values",
"(",
")",
"{",
"return",
"array",
"list",
"values",
"(",
"default",
"expected",
"values",
"per",
"key",
")",
";",
"}"
] |
[
"signals",
"copy",
"block",
"to",
"exit"
] |
[
"public",
"void",
"set",
"exit",
"flag",
"(",
")",
"{",
"this",
"should",
"run",
"set",
"(",
"false",
")",
";",
"}"
] |
[
"set",
"the",
"body",
"of",
"the",
"request",
"calling",
"this",
"methods",
"will",
"{",
"@",
"linkplain",
"org",
"springframework",
"core",
"io",
"buffer",
"data",
"buffer",
"utils",
"#",
"release",
"(",
"data",
"buffer",
")",
"release",
"}",
"the",
"existing",
"body",
"of",
"the",
"builder"
] |
[
"builder",
"body",
"(",
"flux",
"<",
"data",
"buffer",
">",
"body",
")",
";"
] |
[
"get",
"key",
"type",
"for",
"{",
"@",
"link",
"map",
"}",
"directly",
"implemented",
"by",
"{",
"@",
"code",
"clazz",
"}",
"if",
"{",
"@",
"code",
"clazz",
"}",
"does",
"not",
"implement",
"{",
"@",
"link",
"map",
"}",
"directly",
",",
"return",
"{",
"@",
"code",
"null",
"}"
] |
[
"private",
"static",
"type",
"get",
"key",
"type",
"for",
"map",
"(",
"class",
"<",
"?",
">",
"clazz",
")",
"{",
"type",
"[",
"]",
"interfaces",
"=",
"clazz",
"get",
"generic",
"interfaces",
"(",
")",
";",
"if",
"(",
"!",
"array",
"utils",
"is",
"empty",
"(",
"interfaces",
")",
")",
"{",
"for",
"(",
"type",
"type",
":",
"interfaces",
")",
"{",
"if",
"(",
"type",
"instanceof",
"parameterized",
"type",
")",
"{",
"parameterized",
"type",
"t",
"=",
"(",
"parameterized",
"type",
")",
"type",
";",
"if",
"(",
"\"",
"java",
"util",
"map",
"\"",
"equals",
"(",
"t",
"get",
"raw",
"type",
"(",
")",
"get",
"type",
"name",
"(",
")",
")",
")",
"{",
"return",
"t",
"get",
"actual",
"type",
"arguments",
"(",
")",
"[",
"0",
"]",
";",
"}",
"}",
"}",
"}",
"return",
"null",
";",
"}"
] |
[
"get",
"the",
"{",
"@",
"link",
"sub",
"cluster",
"id",
"}",
"representing",
"the",
"unique",
"identifier",
"of",
"the",
"subcluster"
] |
[
"public",
"abstract",
"sub",
"cluster",
"id",
"get",
"sub",
"cluster",
"id",
"(",
")",
";"
] |
[
"print",
"all",
"the",
"job",
"information"
] |
[
"public",
"void",
"print",
"all",
"(",
")",
"{",
"system",
"out",
"println",
"(",
"\"",
"jobname",
":",
"\"",
"+",
"jobname",
")",
";",
"system",
"out",
"println",
"(",
"\"",
"username",
":",
"\"",
"+",
"username",
")",
";",
"system",
"out",
"println",
"(",
"\"",
"job",
"queue",
"name",
":",
"\"",
"+",
"job",
"queue",
"name",
")",
";",
"system",
"out",
"println",
"(",
"\"",
"submit",
"time",
"\"",
"+",
"submit",
"time",
")",
";",
"system",
"out",
"println",
"(",
"\"",
"launch",
"time",
":",
"\"",
"+",
"launch",
"time",
")",
";",
"system",
"out",
"println",
"(",
"\"",
"job",
"status",
":",
"\"",
"+",
"job",
"status",
")",
";",
"system",
"out",
"println",
"(",
"\"",
"priority",
":",
"\"",
"+",
"priority",
")",
";",
"system",
"out",
"println",
"(",
"\"",
"total",
"maps",
":",
"\"",
"+",
"total",
"maps",
")",
";",
"system",
"out",
"println",
"(",
"\"",
"total",
"reduces",
":",
"\"",
"+",
"total",
"reduces",
")",
";",
"if",
"(",
"map",
"counters",
"!",
"=",
"null",
")",
"{",
"system",
"out",
"println",
"(",
"\"",
"map",
"counters",
":",
"\"",
"+",
"map",
"counters",
"to",
"string",
"(",
")",
")",
";",
"}",
"if",
"(",
"reduce",
"counters",
"!",
"=",
"null",
")",
"{",
"system",
"out",
"println",
"(",
"\"",
"reduce",
"counters",
":",
"\"",
"+",
"reduce",
"counters",
"to",
"string",
"(",
")",
")",
";",
"}",
"if",
"(",
"total",
"counters",
"!",
"=",
"null",
")",
"{",
"system",
"out",
"println",
"(",
"\"",
"total",
"counters",
":",
"\"",
"+",
"total",
"counters",
"to",
"string",
"(",
")",
")",
";",
"}",
"system",
"out",
"println",
"(",
"\"",
"uberized",
":",
"\"",
"+",
"uberized",
")",
";",
"if",
"(",
"am",
"infos",
"!",
"=",
"null",
")",
"{",
"for",
"(",
"a",
"m",
"info",
"am",
"info",
":",
"am",
"infos",
")",
"{",
"am",
"info",
"print",
"all",
"(",
")",
";",
"}",
"}",
"for",
"(",
"task",
"info",
"ti",
":",
"tasks",
"map",
"values",
"(",
")",
")",
"{",
"ti",
"print",
"all",
"(",
")",
";",
"}",
"}"
] |
[
"stop",
"the",
"cluster"
] |
[
"public",
"void",
"tear",
"down",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"cluster",
"!",
"=",
"null",
")",
"{",
"i",
"o",
"utils",
"close",
"stream",
"(",
"dfs",
")",
";",
"cluster",
"shutdown",
"(",
")",
";",
"}",
"}"
] |
[
"the",
"total",
"number",
"of",
"input",
"connections",
"that",
"a",
"file",
"system",
"for",
"the",
"given",
"scheme",
"may",
"open",
"unlimited",
"be",
"default"
] |
[
"public",
"static",
"config",
"option",
"<",
"integer",
">",
"file",
"system",
"connection",
"limit",
"in",
"(",
"string",
"scheme",
")",
"{",
"return",
"config",
"options",
"key",
"(",
"\"",
"fs",
"\"",
"+",
"scheme",
"+",
"\"",
"limit",
"input",
"\"",
")",
"default",
"value",
"(",
"-",
"1",
")",
";",
"}"
] |
[
"this",
"tests",
"the",
"case",
"where",
"no",
"additional",
"partition",
"buffers",
"are",
"used",
"at",
"the",
"point",
"when",
"spilling",
"is",
"triggered",
",",
"testing",
"that",
"overflow",
"bucket",
"buffers",
"are",
"taken",
"into",
"account",
"when",
"deciding",
"which",
"partition",
"to",
"spill"
] |
[
"public",
"void",
"test",
"spilling",
"frees",
"only",
"overflow",
"segments",
"(",
")",
"{",
"final",
"type",
"serializer",
"<",
"byte",
"value",
">",
"serializer",
"=",
"byte",
"value",
"serializer",
"instance",
";",
"final",
"type",
"comparator",
"<",
"byte",
"value",
">",
"build",
"comparator",
"=",
"new",
"value",
"comparator",
"<",
">",
"(",
"true",
",",
"byte",
"value",
"class",
")",
";",
"final",
"type",
"comparator",
"<",
"byte",
"value",
">",
"probe",
"comparator",
"=",
"new",
"value",
"comparator",
"<",
">",
"(",
"true",
",",
"byte",
"value",
"class",
")",
";",
"@",
"suppress",
"warnings",
"(",
"\"",
"unchecked",
"\"",
")",
"final",
"type",
"pair",
"comparator",
"<",
"byte",
"value",
",",
"byte",
"value",
">",
"pair",
"comparator",
"=",
"mockito",
"mock",
"(",
"type",
"pair",
"comparator",
"class",
")",
";",
"try",
"(",
"final",
"i",
"o",
"manager",
"io",
"man",
"=",
"new",
"i",
"o",
"manager",
"async",
"(",
")",
")",
"{",
"final",
"int",
"page",
"size",
"=",
"32",
"*",
"1024",
";",
"final",
"int",
"num",
"segments",
"=",
"34",
";",
"list",
"<",
"memory",
"segment",
">",
"memory",
"=",
"get",
"memory",
"(",
"num",
"segments",
",",
"page",
"size",
")",
";",
"mutable",
"hash",
"table",
"<",
"byte",
"value",
",",
"byte",
"value",
">",
"table",
"=",
"new",
"mutable",
"hash",
"table",
"<",
">",
"(",
"serializer",
",",
"serializer",
",",
"build",
"comparator",
",",
"probe",
"comparator",
",",
"pair",
"comparator",
",",
"memory",
",",
"io",
"man",
",",
"1",
",",
"false",
")",
";",
"table",
"open",
"(",
"new",
"byte",
"value",
"iterator",
"(",
"100000000",
")",
",",
"new",
"byte",
"value",
"iterator",
"(",
"1",
")",
")",
";",
"table",
"close",
"(",
")",
";",
"check",
"no",
"temp",
"files",
"remain",
"(",
"io",
"man",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"e",
"print",
"stack",
"trace",
"(",
")",
";",
"fail",
"(",
"e",
"get",
"message",
"(",
")",
")",
";",
"}",
"}"
] |
[
"deletes",
"all",
"directory",
"trees",
"recursively",
"beneath",
"the",
"given",
"path",
",",
"which",
"is",
"expected",
"to",
"be",
"a",
"directory",
"does",
"not",
"remove",
"the",
"top",
"directory"
] |
[
"public",
"static",
"native",
"void",
"delete",
"trees",
"below",
"(",
"string",
"dir",
")",
"throws",
"i",
"o",
"exception",
";"
] |
[
"performs",
"a",
"call",
"in",
"a",
"transaction"
] |
[
"public",
"<",
"t",
">",
"t",
"in",
"transaction",
"(",
"callable",
"<",
"t",
">",
"call",
")",
"{",
"return",
"dao",
"test",
"in",
"transaction",
"(",
"call",
")",
";",
"}"
] |
[
"check",
"if",
"the",
"given",
"array",
"contains",
"the",
"given",
"value",
"(",
"with",
"case",
"-",
"insensitive",
"comparison",
")"
] |
[
"public",
"static",
"boolean",
"contains",
"ignore",
"case",
"(",
"string",
"[",
"]",
"array",
",",
"string",
"value",
")",
"{",
"for",
"(",
"string",
"str",
":",
"array",
")",
"{",
"if",
"(",
"value",
"=",
"=",
"null",
"&",
"&",
"str",
"=",
"=",
"null",
")",
"{",
"return",
"true",
";",
"}",
"if",
"(",
"value",
"!",
"=",
"null",
"&",
"&",
"value",
"equals",
"ignore",
"case",
"(",
"str",
")",
")",
"{",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}"
] |
[
"test",
"verifies",
"deletion",
"of",
"node",
"created",
"data",
"watches"
] |
[
"public",
"void",
"test",
"remove",
"node",
"created",
"watches",
"(",
")",
"throws",
"exception",
"{",
"list",
"<",
"event",
"type",
">",
"expected",
"events",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"expected",
"events",
"add",
"(",
"event",
"type",
"data",
"watch",
"removed",
")",
";",
"my",
"watcher",
"my",
"watcher",
"1",
"=",
"new",
"my",
"watcher",
"(",
"\"",
"/",
"testnode",
"1",
"\"",
",",
"expected",
"events",
",",
"1",
")",
";",
"my",
"watcher",
"my",
"watcher",
"2",
"=",
"new",
"my",
"watcher",
"(",
"\"",
"/",
"testnode",
"1",
"/",
"testnode",
"2",
"\"",
",",
"expected",
"events",
",",
"1",
")",
";",
"/",
"/",
"adding",
"pre",
"-",
"created",
"watcher",
"log",
"info",
"(",
"\"",
"adding",
"node",
"created",
"watcher",
"\"",
")",
";",
"zk",
"exists",
"(",
"\"",
"/",
"testnode",
"1",
"\"",
",",
"my",
"watcher",
"1",
")",
";",
"zk",
"exists",
"(",
"\"",
"/",
"testnode",
"1",
"/",
"testnode",
"2",
"\"",
",",
"my",
"watcher",
"2",
")",
";",
"string",
"cmdstring",
"1",
"=",
"\"",
"removewatches",
"/",
"testnode",
"1",
"-",
"d",
"\"",
";",
"log",
"info",
"(",
"\"",
"remove",
"watchers",
"using",
"shell",
"command",
":",
"{",
"}",
"\"",
",",
"cmdstring",
"1",
")",
";",
"zk",
"main",
"cl",
"parse",
"command",
"(",
"cmdstring",
"1",
")",
";",
"assert",
"true",
"(",
"zk",
"main",
"process",
"z",
"k",
"cmd",
"(",
"zk",
"main",
"cl",
")",
",",
"\"",
"removewatches",
"cmd",
"fails",
"to",
"remove",
"pre",
"-",
"create",
"watches",
"\"",
")",
";",
"my",
"watcher",
"1",
"matches",
"(",
")",
";",
"assert",
"equals",
"(",
"1",
",",
"zk",
"get",
"exist",
"watches",
"(",
")",
"size",
"(",
")",
",",
"\"",
"failed",
"to",
"remove",
"pre",
"-",
"create",
"watches",
":",
"\"",
"+",
"zk",
"get",
"exist",
"watches",
"(",
")",
")",
";",
"assert",
"true",
"(",
"zk",
"get",
"exist",
"watches",
"(",
")",
"contains",
"(",
"\"",
"/",
"testnode",
"1",
"/",
"testnode",
"2",
"\"",
")",
",",
"\"",
"failed",
"to",
"remove",
"pre",
"-",
"create",
"watches",
":",
"\"",
"+",
"zk",
"get",
"exist",
"watches",
"(",
")",
")",
";",
"string",
"cmdstring",
"2",
"=",
"\"",
"removewatches",
"/",
"testnode",
"1",
"/",
"testnode",
"2",
"-",
"d",
"\"",
";",
"log",
"info",
"(",
"\"",
"remove",
"watchers",
"using",
"shell",
"command",
":",
"{",
"}",
"\"",
",",
"cmdstring",
"2",
")",
";",
"zk",
"main",
"cl",
"parse",
"command",
"(",
"cmdstring",
"2",
")",
";",
"assert",
"true",
"(",
"zk",
"main",
"process",
"z",
"k",
"cmd",
"(",
"zk",
"main",
"cl",
")",
",",
"\"",
"removewatches",
"cmd",
"fails",
"to",
"remove",
"data",
"watches",
"\"",
")",
";",
"my",
"watcher",
"2",
"matches",
"(",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"zk",
"get",
"exist",
"watches",
"(",
")",
"size",
"(",
")",
",",
"\"",
"failed",
"to",
"remove",
"pre",
"-",
"create",
"watches",
":",
"\"",
"+",
"zk",
"get",
"exist",
"watches",
"(",
")",
")",
";",
"}"
] |
[
"lightweight",
"method",
"to",
"replace",
"unsupported",
"characters",
"if",
"the",
"string",
"does",
"not",
"contain",
"any",
"unsupported",
"characters",
",",
"this",
"method",
"creates",
"no",
"new",
"string",
"(",
"and",
"in",
"fact",
"no",
"new",
"objects",
"at",
"all",
")",
"replacements",
":",
"{",
"@",
"code",
"space",
":",
",",
"}",
"are",
"replaced",
"by",
"{",
"@",
"code",
"}",
"(",
"underscore",
")"
] |
[
"private",
"static",
"string",
"replace",
"invalid",
"chars",
"(",
"string",
"str",
")",
"{",
"char",
"[",
"]",
"chars",
"=",
"null",
";",
"final",
"int",
"str",
"len",
"=",
"str",
"length",
"(",
")",
";",
"int",
"pos",
"=",
"0",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"str",
"len",
";",
"i",
"+",
"+",
")",
"{",
"final",
"char",
"c",
"=",
"str",
"char",
"at",
"(",
"i",
")",
";",
"switch",
"(",
"c",
")",
"{",
"case",
"'",
"'",
":",
"case",
"'",
"'",
":",
"case",
"'",
":",
"'",
":",
"case",
"'",
",",
"'",
":",
"if",
"(",
"chars",
"=",
"=",
"null",
")",
"{",
"chars",
"=",
"str",
"to",
"char",
"array",
"(",
")",
";",
"}",
"chars",
"[",
"pos",
"+",
"+",
"]",
"=",
"'",
"'",
";",
"break",
";",
"default",
":",
"if",
"(",
"chars",
"!",
"=",
"null",
")",
"{",
"chars",
"[",
"pos",
"]",
"=",
"c",
";",
"}",
"pos",
"+",
"+",
";",
"}",
"}",
"return",
"chars",
"=",
"=",
"null",
"?",
"str",
":",
"new",
"string",
"(",
"chars",
",",
"0",
",",
"pos",
")",
";",
"}"
] |
[
"get",
"the",
"\"",
"same",
"site",
"\"",
"attribute",
"for",
"this",
"cookie"
] |
[
"public",
"string",
"get",
"same",
"site",
"(",
")",
"{",
"return",
"this",
"same",
"site",
";",
"}"
] |
[
"grow",
"an",
"array",
"to",
"a",
"size",
"that",
"is",
"larger",
"than",
"<",
"code",
">",
"min",
"size",
"<",
"code",
">",
",",
"preserving",
"content",
",",
"and",
"potentially",
"reusing",
"part",
"of",
"the",
"provided",
"array"
] |
[
"public",
"long",
"array",
"grow",
"(",
"long",
"array",
"array",
",",
"long",
"min",
"size",
")",
"{",
"if",
"(",
"min",
"size",
"<",
"=",
"array",
"size",
"(",
")",
")",
"{",
"return",
"array",
";",
"}",
"final",
"long",
"new",
"size",
"=",
"over",
"size",
"(",
"min",
"size",
",",
"page",
"cache",
"recycler",
"long",
"page",
"size",
",",
"long",
"bytes",
")",
";",
"return",
"resize",
"(",
"array",
",",
"new",
"size",
")",
";",
"}"
] |
[
"abstract",
"template",
"method",
"for",
"unmarshalling",
"from",
"a",
"given",
"stax",
"{",
"@",
"code",
"x",
"m",
"l",
"stream",
"reader",
"}"
] |
[
"protected",
"abstract",
"object",
"unmarshal",
"xml",
"stream",
"reader",
"(",
"x",
"m",
"l",
"stream",
"reader",
"stream",
"reader",
")",
"throws",
"xml",
"mapping",
"exception",
";"
] |
[
"fully",
"resolve",
"folderitem",
"reference",
"once",
"connected",
"to",
"the",
"associated",
"repository",
"due",
"to",
"possible",
"ambiguity"
] |
[
"protected",
"void",
"resolve",
"item",
"path",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"/",
"/",
"note",
":",
"assume",
"path",
"may",
"correspond",
"to",
"non",
"-",
"existent",
"folder",
"if",
"not",
"found",
"/",
"/",
"-",
"this",
"is",
"why",
"ghidra",
"not",
"found",
"response",
"code",
"setting",
"has",
"been",
"disabled",
"if",
"(",
"folder",
"item",
"name",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"item",
"path",
"ends",
"with",
"(",
"\"",
"/",
"\"",
")",
")",
"{",
"/",
"/",
"explicit",
"folder",
"path",
"-",
"force",
"folder",
"url",
"folder",
"path",
"=",
"append",
"subfolder",
"name",
"(",
"folder",
"path",
",",
"folder",
"item",
"name",
")",
";",
"folder",
"item",
"name",
"=",
"null",
";",
"/",
"/",
"if",
"(",
"read",
"only",
"&",
"&",
"!",
"repository",
"folder",
"exists",
"(",
"item",
"path",
")",
")",
"{",
"/",
"/",
"/",
"/",
"todo",
":",
"url",
"location",
"not",
"found",
"/",
"/",
"response",
"code",
"=",
"ghidra",
"not",
"found",
";",
"/",
"/",
"return",
";",
"/",
"/",
"}",
"}",
"else",
"if",
"(",
"!",
"repository",
"adapter",
"file",
"exists",
"(",
"folder",
"path",
",",
"folder",
"item",
"name",
")",
")",
"{",
"/",
"/",
"file",
"item",
"not",
"found",
"-",
"check",
"for",
"existing",
"sub",
"-",
"folder",
"instead",
"string",
"path",
"=",
"append",
"subfolder",
"name",
"(",
"folder",
"path",
",",
"folder",
"item",
"name",
")",
";",
"if",
"(",
"repository",
"adapter",
"folder",
"exists",
"(",
"path",
")",
")",
"{",
"/",
"/",
"item",
"name",
"found",
"as",
"folder",
"-",
"force",
"folder",
"url",
"folder",
"path",
"=",
"path",
";",
"folder",
"item",
"name",
"=",
"null",
";",
"}",
"/",
"/",
"if",
"(",
"folder",
"item",
"name",
"!",
"=",
"null",
")",
"{",
"/",
"/",
"/",
"/",
"todo",
":",
"url",
"location",
"not",
"found",
"/",
"/",
"response",
"code",
"=",
"ghidra",
"not",
"found",
";",
"/",
"/",
"return",
";",
"/",
"/",
"}",
"}",
"}",
"}"
] |
[
"builds",
"the",
"parquet",
"table",
"source",
"for",
"this",
"builder"
] |
[
"public",
"parquet",
"table",
"source",
"build",
"(",
")",
"{",
"preconditions",
"check",
"not",
"null",
"(",
"path",
",",
"\"",
"path",
"must",
"not",
"be",
"null",
"\"",
")",
";",
"preconditions",
"check",
"not",
"null",
"(",
"schema",
",",
"\"",
"parquet",
"schema",
"must",
"not",
"be",
"null",
"\"",
")",
";",
"if",
"(",
"config",
"=",
"=",
"null",
")",
"{",
"this",
"config",
"=",
"new",
"configuration",
"(",
")",
";",
"}",
"return",
"new",
"parquet",
"table",
"source",
"(",
"this",
"path",
",",
"this",
"schema",
",",
"this",
"config",
",",
"this",
"recursive",
")",
";",
"}"
] |
[
"removes",
"any",
"filters",
"that",
"should",
"not",
"be",
"considered",
",",
"returning",
"a",
"new",
"{",
"@",
"link",
"discovery",
"node",
"filters",
"}",
"object",
"if",
"the",
"filtered",
"object",
"has",
"no",
"filters",
"after",
"trimming",
",",
"{",
"@",
"code",
"null",
"}",
"is",
"returned"
] |
[
"public",
"static",
"discovery",
"node",
"filters",
"trim",
"tier",
"(",
"@",
"nullable",
"discovery",
"node",
"filters",
"original",
")",
"{",
"if",
"(",
"original",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"map",
"<",
"string",
",",
"string",
"[",
"]",
">",
"new",
"filters",
"=",
"original",
"filters",
"entry",
"set",
"(",
")",
"stream",
"(",
")",
"/",
"/",
"remove",
"all",
"entries",
"that",
"start",
"with",
"\"",
"tier",
"\"",
",",
"as",
"these",
"will",
"be",
"handled",
"elsewhere",
"filter",
"(",
"entry",
"-",
">",
"{",
"string",
"attr",
"=",
"entry",
"get",
"key",
"(",
")",
";",
"return",
"attr",
"!",
"=",
"null",
"&",
"&",
"attr",
"starts",
"with",
"(",
"\"",
"tier",
"\"",
")",
"=",
"=",
"false",
";",
"}",
")",
"collect",
"(",
"collectors",
"to",
"map",
"(",
"map",
"entry",
":",
":",
"get",
"key",
",",
"map",
"entry",
":",
":",
"get",
"value",
")",
")",
";",
"if",
"(",
"new",
"filters",
"size",
"(",
")",
"=",
"=",
"0",
")",
"{",
"return",
"null",
";",
"}",
"else",
"{",
"return",
"new",
"discovery",
"node",
"filters",
"(",
"original",
"op",
"type",
",",
"new",
"filters",
")",
";",
"}",
"}"
] |
[
"paints",
"additional",
"buttons",
"decorations"
] |
[
"protected",
"boolean",
"paint",
"decorations",
"(",
"final",
"graphics",
"2",
"d",
"g",
",",
"final",
"j",
"component",
"c",
")",
"{",
"final",
"int",
"w",
"=",
"c",
"get",
"width",
"(",
")",
";",
"final",
"int",
"h",
"=",
"c",
"get",
"height",
"(",
")",
";",
"final",
"color",
"background",
"=",
"c",
"get",
"background",
"(",
")",
";",
"/",
"/",
"need",
"to",
"set",
"the",
"background",
"because",
"it",
"is",
"not",
"set",
"at",
"install",
"defaults",
"if",
"(",
"is",
"not",
"themed",
"&",
"&",
"is",
"default",
"button",
"(",
"c",
")",
")",
"{",
"c",
"set",
"background",
"(",
"primary",
"button",
"bg",
"(",
")",
")",
";",
"/",
"/",
"if",
"(",
"c",
"is",
"focusable",
"(",
")",
")",
"{",
"is",
"not",
"themed",
"=",
"false",
";",
"/",
"/",
"}",
"}",
"if",
"(",
"segmented",
"bar",
"action",
"component",
"companion",
"is",
"custom",
"bar",
"(",
"c",
")",
")",
"{",
"return",
"segmented",
"bar",
"action",
"component",
"companion",
"paint",
"button",
"decorations",
"(",
"g",
",",
"c",
",",
"button",
"bg",
"(",
")",
")",
";",
"}",
"rectangle",
"r",
"=",
"new",
"rectangle",
"(",
"c",
"get",
"size",
"(",
")",
")",
";",
"j",
"b",
"insets",
"remove",
"from",
"(",
"r",
",",
"is",
"small",
"variant",
"(",
"c",
")",
"|",
"|",
"is",
"borderless",
"(",
"c",
")",
"?",
"c",
"get",
"insets",
"(",
")",
":",
"jbui",
"insets",
"(",
"1",
")",
")",
";",
"final",
"color",
"background",
"color",
"=",
"button",
"bg",
"(",
")",
";",
"final",
"color",
"focused",
"color",
"=",
"primary",
"button",
"hover",
"color",
"(",
")",
";",
"if",
"(",
"u",
"i",
"util",
"is",
"help",
"button",
"(",
"c",
")",
")",
"{",
"return",
"paint",
"help",
"icon",
"(",
"g",
",",
"c",
",",
"w",
",",
"h",
",",
"background",
"color",
")",
";",
"}",
"else",
"{",
"final",
"graphics",
"config",
"config",
"=",
"graphics",
"util",
"setup",
"a",
"a",
"painting",
"(",
"g",
")",
";",
"final",
"int",
"x",
"off",
"=",
"0",
";",
"final",
"int",
"y",
"off",
"=",
"0",
";",
"if",
"(",
"c",
"has",
"focus",
"(",
")",
")",
"{",
"g",
"set",
"paint",
"(",
"focused",
"color",
")",
";",
"}",
"else",
"{",
"g",
"set",
"paint",
"(",
"background",
")",
";",
"}",
"final",
"int",
"rad",
"=",
"jbui",
"scale",
"(",
"3",
")",
";",
"g",
"fill",
"round",
"rect",
"(",
"x",
"off",
",",
"y",
"off",
",",
"w",
",",
"h",
",",
"rad",
",",
"rad",
")",
";",
"config",
"restore",
"(",
")",
";",
"return",
"true",
";",
"}",
"}"
] |
[
"constructs",
"an",
"event",
"with",
"kind",
"{",
"@",
"link",
"event",
"kind",
"#",
"error",
"}",
",",
"with",
"an",
"optional",
"{",
"@",
"link",
"location",
"}"
] |
[
"public",
"static",
"event",
"error",
"(",
"@",
"nullable",
"location",
"location",
",",
"string",
"message",
")",
"{",
"return",
"location",
"=",
"=",
"null",
"?",
"of",
"(",
"event",
"kind",
"error",
",",
"message",
")",
":",
"of",
"(",
"event",
"kind",
"error",
",",
"message",
",",
"location",
"class",
",",
"location",
")",
";",
"}"
] |
[
"returns",
"the",
"comparator",
"used",
"to",
"order",
"the",
"elements",
"in",
"this",
"queue",
"obeys",
"the",
"general",
"contract",
"of",
"{",
"@",
"link",
"priority",
"queue",
"#",
"comparator",
"}",
",",
"but",
"returns",
"{",
"@",
"link",
"ordering",
"#",
"natural",
"}",
"instead",
"of",
"{",
"@",
"code",
"null",
"}",
"to",
"indicate",
"natural",
"ordering"
] |
[
"public",
"comparator",
"<",
"?",
"super",
"e",
">",
"comparator",
"(",
")",
"{",
"return",
"min",
"heap",
"ordering",
";",
"}"
] |
[
"tests",
"obtaining",
"delegation",
"token",
"from",
"stored",
"key"
] |
[
"public",
"void",
"test",
"delegation",
"token",
"(",
")",
"throws",
"exception",
"{",
"user",
"group",
"information",
"create",
"remote",
"user",
"(",
"\"",
"job",
"tracker",
"\"",
")",
";",
"distributed",
"file",
"system",
"dfs",
"=",
"cluster",
"get",
"file",
"system",
"(",
")",
";",
"key",
"provider",
"key",
"provider",
"=",
"mockito",
"mock",
"(",
"key",
"provider",
"class",
",",
"with",
"settings",
"(",
")",
"extra",
"interfaces",
"(",
"delegation",
"token",
"extension",
"class",
",",
"crypto",
"extension",
"class",
")",
")",
";",
"mockito",
"when",
"(",
"key",
"provider",
"get",
"conf",
"(",
")",
")",
"then",
"return",
"(",
"conf",
")",
";",
"byte",
"[",
"]",
"test",
"identifier",
"=",
"\"",
"test",
"identifier",
"for",
"delegation",
"token",
"\"",
"get",
"bytes",
"(",
")",
";",
"@",
"suppress",
"warnings",
"(",
"\"",
"rawtypes",
"\"",
")",
"token",
"test",
"token",
"=",
"new",
"token",
"(",
"test",
"identifier",
",",
"new",
"byte",
"[",
"0",
"]",
",",
"new",
"text",
"(",
")",
",",
"new",
"text",
"(",
")",
")",
";",
"mockito",
"when",
"(",
"(",
"(",
"delegation",
"token",
"issuer",
")",
"key",
"provider",
")",
"get",
"canonical",
"service",
"name",
"(",
")",
")",
"then",
"return",
"(",
"\"",
"service",
"\"",
")",
";",
"mockito",
"when",
"(",
"(",
"(",
"delegation",
"token",
"issuer",
")",
"key",
"provider",
")",
"get",
"delegation",
"token",
"(",
"any",
"string",
"(",
")",
")",
")",
"then",
"return",
"(",
"test",
"token",
")",
";",
"dfs",
"get",
"client",
"(",
")",
"set",
"key",
"provider",
"(",
"key",
"provider",
")",
";",
"credentials",
"creds",
"=",
"new",
"credentials",
"(",
")",
";",
"final",
"token",
"<",
"?",
">",
"tokens",
"[",
"]",
"=",
"dfs",
"add",
"delegation",
"tokens",
"(",
"\"",
"job",
"tracker",
"\"",
",",
"creds",
")",
";",
"distributed",
"file",
"system",
"log",
"debug",
"(",
"\"",
"delegation",
"tokens",
":",
"\"",
"+",
"arrays",
"as",
"list",
"(",
"tokens",
")",
")",
";",
"assert",
"assert",
"equals",
"(",
"2",
",",
"tokens",
"length",
")",
";",
"assert",
"assert",
"equals",
"(",
"tokens",
"[",
"1",
"]",
",",
"test",
"token",
")",
";",
"assert",
"assert",
"equals",
"(",
"2",
",",
"creds",
"number",
"of",
"tokens",
"(",
")",
")",
";",
"}"
] |
[
"optional",
":",
"default",
"value",
"is",
"(",
"char",
"sequence",
")",
"null"
] |
[
"public",
"null",
"on",
"recycle",
"view",
"model",
"title",
"(",
"@",
"nullable",
"char",
"sequence",
"title",
")",
"{",
"on",
"mutation",
"(",
")",
";",
"this",
"title",
"char",
"sequence",
"=",
"title",
";",
"return",
"this",
";",
"}"
] |
[
"only",
"for",
"unit",
"test"
] |
[
"void",
"set",
"class",
"loader",
"(",
"class",
"loader",
"class",
"loader",
")",
"{",
"try",
"{",
"class",
"<",
"?",
">",
"druid",
"db",
"type",
"parser",
"impl",
"class",
"=",
"class",
"loader",
"load",
"class",
"(",
"\"",
"io",
"seata",
"sqlparser",
"druid",
"druid",
"db",
"type",
"parser",
"impl",
"\"",
")",
";",
"constructor",
"<",
"?",
">",
"impl",
"constructor",
"=",
"druid",
"db",
"type",
"parser",
"impl",
"class",
"get",
"declared",
"constructor",
"(",
")",
";",
"impl",
"constructor",
"set",
"accessible",
"(",
"true",
")",
";",
"try",
"{",
"db",
"type",
"parser",
"impl",
"=",
"(",
"db",
"type",
"parser",
")",
"impl",
"constructor",
"new",
"instance",
"(",
")",
";",
"}",
"finally",
"{",
"impl",
"constructor",
"set",
"accessible",
"(",
"false",
")",
";",
"}",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"e",
")",
";",
"}",
"}"
] |
[
"returns",
"the",
"slope",
"of",
"the",
"transformation",
",",
"i",
"e",
"the",
"rate",
"of",
"change",
"of",
"{",
"@",
"code",
"y",
"}",
"with",
"respect",
"to",
"{",
"@",
"code",
"x",
"}",
"this",
"must",
"not",
"be",
"called",
"on",
"a",
"vertical",
"transformation",
"(",
"i",
"e",
"when",
"{",
"@",
"link",
"#",
"is",
"vertical",
"(",
")",
"}",
"is",
"true",
")"
] |
[
"public",
"abstract",
"double",
"slope",
"(",
")",
";"
] |
[
"get",
"integer",
"minimum",
":",
"10",
"maximum",
":",
"100"
] |
[
"public",
"integer",
"get",
"integer",
"(",
")",
"{",
"return",
"integer",
";",
"}"
] |
[
"https",
":",
"github",
"comsquarejavapoetissues",
"2",
"5",
"3"
] |
[
"@",
"test",
"public",
"void",
"enum",
"with",
"annotated",
"values",
"(",
")",
"throws",
"exception",
"{",
"type",
"spec",
"roshambo",
"=",
"type",
"spec",
"enum",
"builder",
"(",
"\"",
"roshambo",
"\"",
")",
"add",
"modifiers",
"(",
"modifier",
"public",
")",
"add",
"enum",
"constant",
"(",
"\"",
"rock",
"\"",
",",
"type",
"spec",
"anonymous",
"class",
"builder",
"(",
"\"",
"\"",
")",
"add",
"annotation",
"(",
"deprecated",
"class",
")",
"build",
"(",
")",
")",
"add",
"enum",
"constant",
"(",
"\"",
"paper",
"\"",
")",
"add",
"enum",
"constant",
"(",
"\"",
"scissors",
"\"",
")",
"build",
"(",
")",
";",
"assert",
"that",
"(",
"to",
"string",
"(",
"roshambo",
")",
")",
"is",
"equal",
"to",
"(",
"\"",
"\"",
"+",
"\"",
"package",
"com",
"squareup",
"tacos",
";",
"\\",
"n",
"\"",
"+",
"\"",
"\\",
"n",
"\"",
"+",
"\"",
"import",
"java",
"lang",
"deprecated",
";",
"\\",
"n",
"\"",
"+",
"\"",
"\\",
"n",
"\"",
"+",
"\"",
"public",
"enum",
"roshambo",
"{",
"\\",
"n",
"\"",
"+",
"\"",
"@",
"deprecated",
"\\",
"n",
"\"",
"+",
"\"",
"rock",
",",
"\\",
"n",
"\"",
"+",
"\"",
"\\",
"n",
"\"",
"+",
"\"",
"paper",
",",
"\\",
"n",
"\"",
"+",
"\"",
"\\",
"n",
"\"",
"+",
"\"",
"scissors",
"\\",
"n",
"\"",
"+",
"\"",
"}",
"\\",
"n",
"\"",
")",
";",
"}"
] |
[
"helper",
"to",
"be",
"used",
"by",
"subclasses",
"to",
"emit",
"simple",
"critical",
"warnings"
] |
[
"protected",
"void",
"critical",
"(",
"string",
"type",
")",
"{",
"add",
"issue",
"(",
"type",
",",
"null",
",",
"q",
"a",
"warning",
"severity",
"critical",
",",
"1",
")",
";",
"}"
] |
[
"returns",
"the",
"offset"
] |
[
"public",
"int",
"get",
"offset",
"(",
")",
"{",
"return",
"offset",
";",
"}"
] |
[
"cancels",
"this",
"stream"
] |
[
"private",
"void",
"cancel",
"stream",
"(",
"channel",
"handler",
"context",
"ctx",
",",
"cancel",
"client",
"stream",
"command",
"cmd",
",",
"channel",
"promise",
"promise",
")",
"{",
"netty",
"client",
"stream",
"transport",
"state",
"stream",
"=",
"cmd",
"stream",
"(",
")",
";",
"perf",
"mark",
"start",
"task",
"(",
"\"",
"netty",
"client",
"handler",
"cancel",
"stream",
"\"",
",",
"stream",
"tag",
"(",
")",
")",
";",
"perf",
"mark",
"link",
"in",
"(",
"cmd",
"get",
"link",
"(",
")",
")",
";",
"try",
"{",
"status",
"reason",
"=",
"cmd",
"reason",
"(",
")",
";",
"if",
"(",
"reason",
"!",
"=",
"null",
")",
"{",
"stream",
"transport",
"report",
"status",
"(",
"reason",
",",
"true",
",",
"new",
"metadata",
"(",
")",
")",
";",
"}",
"if",
"(",
"!",
"cmd",
"stream",
"(",
")",
"is",
"non",
"existent",
"(",
")",
")",
"{",
"encoder",
"(",
")",
"write",
"rst",
"stream",
"(",
"ctx",
",",
"stream",
"id",
"(",
")",
",",
"http",
"2",
"error",
"cancel",
"code",
"(",
")",
",",
"promise",
")",
";",
"}",
"else",
"{",
"promise",
"set",
"success",
"(",
")",
";",
"}",
"}",
"finally",
"{",
"perf",
"mark",
"stop",
"task",
"(",
"\"",
"netty",
"client",
"handler",
"cancel",
"stream",
"\"",
",",
"stream",
"tag",
"(",
")",
")",
";",
"}",
"}"
] |
[
"the",
"test",
"verifies",
"output",
"stream",
"write",
"of",
"buffer",
"size",
"(",
"4kb",
")",
"followed",
"by",
"a",
"flush",
"call",
"is",
"making",
"correct",
"http",
"calls",
"to",
"the",
"server"
] |
[
"public",
"void",
"verify",
"write",
"request",
"of",
"buffer",
"size",
"and",
"flush",
"(",
")",
"throws",
"exception",
"{",
"abfs",
"client",
"client",
"=",
"mock",
"(",
"abfs",
"client",
"class",
")",
";",
"abfs",
"rest",
"operation",
"op",
"=",
"mock",
"(",
"abfs",
"rest",
"operation",
"class",
")",
";",
"abfs",
"configuration",
"abfs",
"conf",
";",
"final",
"configuration",
"conf",
"=",
"new",
"configuration",
"(",
")",
";",
"conf",
"set",
"(",
"account",
"key",
"1",
",",
"account",
"value",
"1",
")",
";",
"abfs",
"conf",
"=",
"new",
"abfs",
"configuration",
"(",
"conf",
",",
"account",
"name",
"1",
")",
";",
"abfs",
"perf",
"tracker",
"tracker",
"=",
"new",
"abfs",
"perf",
"tracker",
"(",
"\"",
"test",
"\"",
",",
"account",
"name",
"1",
",",
"abfs",
"conf",
")",
";",
"when",
"(",
"client",
"get",
"abfs",
"perf",
"tracker",
"(",
")",
")",
"then",
"return",
"(",
"tracker",
")",
";",
"when",
"(",
"client",
"append",
"(",
"any",
"string",
"(",
")",
",",
"any",
"(",
"byte",
"[",
"]",
"class",
")",
",",
"any",
"(",
"append",
"request",
"parameters",
"class",
")",
",",
"any",
"(",
")",
")",
")",
"then",
"return",
"(",
"op",
")",
";",
"when",
"(",
"client",
"flush",
"(",
"any",
"string",
"(",
")",
",",
"any",
"long",
"(",
")",
",",
"any",
"boolean",
"(",
")",
",",
"any",
"boolean",
"(",
")",
",",
"any",
"(",
")",
")",
")",
"then",
"return",
"(",
"op",
")",
";",
"abfs",
"output",
"stream",
"out",
"=",
"new",
"abfs",
"output",
"stream",
"(",
"client",
",",
"null",
",",
"path",
",",
"0",
",",
"populate",
"abfs",
"output",
"stream",
"context",
"(",
"buffer",
"size",
",",
"true",
",",
"false",
",",
"false",
")",
")",
";",
"final",
"byte",
"[",
"]",
"b",
"=",
"new",
"byte",
"[",
"buffer",
"size",
"]",
";",
"new",
"random",
"(",
")",
"next",
"bytes",
"(",
"b",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"2",
";",
"i",
"+",
"+",
")",
"{",
"out",
"write",
"(",
"b",
")",
";",
"}",
"thread",
"sleep",
"(",
"1000",
")",
";",
"out",
"flush",
"(",
")",
";",
"thread",
"sleep",
"(",
"1000",
")",
";",
"append",
"request",
"parameters",
"first",
"req",
"parameters",
"=",
"new",
"append",
"request",
"parameters",
"(",
"0",
",",
"0",
",",
"buffer",
"size",
",",
"append",
"mode",
",",
"false",
")",
";",
"append",
"request",
"parameters",
"second",
"req",
"parameters",
"=",
"new",
"append",
"request",
"parameters",
"(",
"buffer",
"size",
",",
"0",
",",
"buffer",
"size",
",",
"append",
"mode",
",",
"false",
")",
";",
"verify",
"(",
"client",
",",
"times",
"(",
"1",
")",
")",
"append",
"(",
"eq",
"(",
"path",
")",
",",
"any",
"(",
"byte",
"[",
"]",
"class",
")",
",",
"ref",
"eq",
"(",
"first",
"req",
"parameters",
")",
",",
"any",
"(",
")",
")",
";",
"verify",
"(",
"client",
",",
"times",
"(",
"1",
")",
")",
"append",
"(",
"eq",
"(",
"path",
")",
",",
"any",
"(",
"byte",
"[",
"]",
"class",
")",
",",
"ref",
"eq",
"(",
"second",
"req",
"parameters",
")",
",",
"any",
"(",
")",
")",
";",
"/",
"/",
"confirm",
"there",
"were",
"only",
"2",
"invocations",
"in",
"all",
"verify",
"(",
"client",
",",
"times",
"(",
"2",
")",
")",
"append",
"(",
"eq",
"(",
"path",
")",
",",
"any",
"(",
"byte",
"[",
"]",
"class",
")",
",",
"any",
"(",
")",
",",
"any",
"(",
")",
")",
";",
"}"
] |
[
"inverts",
"the",
"given",
"matcher"
] |
[
"public",
"static",
"<",
"t",
">",
"matcher",
"<",
"t",
">",
"not",
"(",
"final",
"matcher",
"<",
"?",
"super",
"t",
">",
"p",
")",
"{",
"return",
"new",
"not",
"<",
">",
"(",
"p",
")",
";",
"}"
] |
[
"return",
"the",
"current",
"offset",
"from",
"the",
"start",
"of",
"the",
"file"
] |
[
"public",
"synchronized",
"long",
"get",
"pos",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"closed",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"f",
"s",
"exception",
"messages",
"stream",
"is",
"closed",
")",
";",
"}",
"return",
"f",
"cursor",
"-",
"limit",
"+",
"b",
"cursor",
";",
"}"
] |
[
"extracts",
"all",
"installed",
"plugin",
"directories",
"from",
"the",
"provided",
"{",
"@",
"code",
"root",
"path",
"}"
] |
[
"public",
"static",
"list",
"<",
"path",
">",
"find",
"plugin",
"dirs",
"(",
"final",
"path",
"root",
"path",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"list",
"<",
"path",
">",
"plugins",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"final",
"set",
"<",
"string",
">",
"seen",
"=",
"new",
"hash",
"set",
"<",
">",
"(",
")",
";",
"if",
"(",
"files",
"exists",
"(",
"root",
"path",
")",
")",
"{",
"try",
"(",
"directory",
"stream",
"<",
"path",
">",
"stream",
"=",
"files",
"new",
"directory",
"stream",
"(",
"root",
"path",
")",
")",
"{",
"for",
"(",
"path",
"plugin",
":",
"stream",
")",
"{",
"if",
"(",
"file",
"system",
"utils",
"is",
"desktop",
"services",
"store",
"(",
"plugin",
")",
"|",
"|",
"plugin",
"get",
"file",
"name",
"(",
")",
"to",
"string",
"(",
")",
"starts",
"with",
"(",
"\"",
"removing",
"-",
"\"",
")",
")",
"{",
"continue",
";",
"}",
"if",
"(",
"seen",
"add",
"(",
"plugin",
"get",
"file",
"name",
"(",
")",
"to",
"string",
"(",
")",
")",
"=",
"=",
"false",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"duplicate",
"plugin",
":",
"\"",
"+",
"plugin",
")",
";",
"}",
"plugins",
"add",
"(",
"plugin",
")",
";",
"}",
"}",
"}",
"return",
"plugins",
";",
"}"
] |
[
"get",
"name",
"string"
] |
[
"public",
"string",
"get",
"name",
"string",
"(",
")",
"{",
"return",
"name",
"string",
";",
"}"
] |
[
"finds",
"any",
"{",
"@",
"link",
"#",
"equals",
"}",
"or",
"{",
"@",
"link",
"#",
"hash",
"code",
"}",
"method",
"that",
"may",
"be",
"defined",
"on",
"the",
"supplied",
"set",
"of",
"interfaces"
] |
[
"private",
"void",
"find",
"defined",
"equals",
"and",
"hash",
"code",
"methods",
"(",
"class",
"<",
"?",
">",
"[",
"]",
"proxied",
"interfaces",
")",
"{",
"for",
"(",
"class",
"<",
"?",
">",
"proxied",
"interface",
":",
"proxied",
"interfaces",
")",
"{",
"method",
"[",
"]",
"methods",
"=",
"proxied",
"interface",
"get",
"declared",
"methods",
"(",
")",
";",
"for",
"(",
"method",
"method",
":",
"methods",
")",
"{",
"if",
"(",
"aop",
"utils",
"is",
"equals",
"method",
"(",
"method",
")",
")",
"{",
"this",
"equals",
"defined",
"=",
"true",
";",
"}",
"if",
"(",
"aop",
"utils",
"is",
"hash",
"code",
"method",
"(",
"method",
")",
")",
"{",
"this",
"hash",
"code",
"defined",
"=",
"true",
";",
"}",
"if",
"(",
"this",
"equals",
"defined",
"&",
"&",
"this",
"hash",
"code",
"defined",
")",
"{",
"return",
";",
"}",
"}",
"}",
"}"
] |
[
"get",
"the",
"processor",
"designator",
"used",
"to",
"identify",
"test",
"binary",
"filesfolder",
"the",
"default",
"implementation",
"requires",
"the",
"j",
"unit",
"test",
"class",
"name",
"to",
"end",
"with",
"\"",
"emulator",
"test",
"\"",
"where",
"the",
"portion",
"of",
"the",
"name",
"proceeding",
"this",
"suffix",
"will",
"be",
"used",
"as",
"the",
"processor",
"designator"
] |
[
"protected",
"string",
"get",
"processor",
"designator",
"(",
")",
"{",
"string",
"class",
"name",
"=",
"get",
"class",
"(",
")",
"get",
"simple",
"name",
"(",
")",
";",
"if",
"(",
"!",
"class",
"name",
"ends",
"with",
"(",
"emulator",
"test",
"suffix",
")",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"invalid",
"emulator",
"test",
"classname",
",",
"must",
"end",
"with",
"'",
"\"",
"+",
"emulator",
"test",
"suffix",
"+",
"\"",
"'",
"\"",
")",
";",
"}",
"return",
"class",
"name",
"substring",
"(",
"0",
",",
"class",
"name",
"length",
"(",
")",
"-",
"emulator",
"test",
"suffix",
"length",
"(",
")",
")",
";",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.