docstring_tokens
list | code_tokens
list |
|---|---|
[
"encodes",
"\"",
"-",
"ch",
"-",
"\"",
"to",
"k",
"in",
"mostly",
"germanic",
"context",
"of",
"internal",
"\"",
"-",
"ach",
"-",
"\"",
",",
"with",
"exceptions"
] |
[
"boolean",
"encode",
"germanic",
"ch",
"to",
"k",
"(",
")",
"{",
"/",
"/",
"various",
"germanic",
"/",
"/",
"\"",
"<",
"consonant",
">",
"<",
"vowel",
">",
"ch",
"-",
"\"",
"implies",
"a",
"german",
"word",
"where",
"'",
"ch",
"'",
"=",
">",
"k",
"if",
"(",
"(",
"(",
"m",
"current",
">",
"1",
")",
"&",
"&",
"!",
"is",
"vowel",
"(",
"m",
"current",
"-",
"2",
")",
"&",
"&",
"string",
"at",
"(",
"(",
"m",
"current",
"-",
"1",
")",
",",
"3",
",",
"\"",
"ach",
"\"",
",",
"\"",
"\"",
")",
"&",
"&",
"!",
"string",
"at",
"(",
"(",
"m",
"current",
"-",
"2",
")",
",",
"7",
",",
"\"",
"machado",
"\"",
",",
"\"",
"machuca",
"\"",
",",
"\"",
"lachanc",
"\"",
",",
"\"",
"lachape",
"\"",
",",
"\"",
"kachatu",
"\"",
",",
"\"",
"\"",
")",
"&",
"&",
"!",
"string",
"at",
"(",
"(",
"m",
"current",
"-",
"3",
")",
",",
"7",
",",
"\"",
"khachat",
"\"",
",",
"\"",
"\"",
")",
"&",
"&",
"(",
"(",
"char",
"at",
"(",
"m",
"current",
"+",
"2",
")",
"!",
"=",
"'",
"i",
"'",
")",
"&",
"&",
"(",
"(",
"char",
"at",
"(",
"m",
"current",
"+",
"2",
")",
"!",
"=",
"'",
"e",
"'",
")",
"|",
"|",
"string",
"at",
"(",
"(",
"m",
"current",
"-",
"2",
")",
",",
"6",
",",
"\"",
"bacher",
"\"",
",",
"\"",
"macher",
"\"",
",",
"\"",
"machen",
"\"",
",",
"\"",
"lacher",
"\"",
",",
"\"",
"\"",
")",
")",
")",
"/",
"/",
"e",
"g",
"'",
"brecht",
"'",
",",
"'",
"fuchs",
"'",
"|",
"|",
"(",
"string",
"at",
"(",
"(",
"m",
"current",
"+",
"2",
")",
",",
"1",
",",
"\"",
"t",
"\"",
",",
"\"",
"s",
"\"",
",",
"\"",
"\"",
")",
"&",
"&",
"!",
"(",
"string",
"at",
"(",
"0",
",",
"11",
",",
"\"",
"whichsoever",
"\"",
",",
"\"",
"\"",
")",
"|",
"|",
"string",
"at",
"(",
"0",
",",
"9",
",",
"\"",
"lunchtime",
"\"",
",",
"\"",
"\"",
")",
")",
")",
"/",
"/",
"e",
"g",
"'",
"andromache",
"'",
"|",
"|",
"string",
"at",
"(",
"0",
",",
"4",
",",
"\"",
"schr",
"\"",
",",
"\"",
"\"",
")",
"|",
"|",
"(",
"(",
"m",
"current",
">",
"2",
")",
"&",
"&",
"string",
"at",
"(",
"(",
"m",
"current",
"-",
"2",
")",
",",
"5",
",",
"\"",
"mache",
"\"",
",",
"\"",
"\"",
")",
")",
"|",
"|",
"(",
"(",
"m",
"current",
"=",
"=",
"2",
")",
"&",
"&",
"string",
"at",
"(",
"(",
"m",
"current",
"-",
"2",
")",
",",
"4",
",",
"\"",
"zach",
"\"",
",",
"\"",
"\"",
")",
")",
"|",
"|",
"string",
"at",
"(",
"(",
"m",
"current",
"-",
"4",
")",
",",
"6",
",",
"\"",
"schach",
"\"",
",",
"\"",
"\"",
")",
"|",
"|",
"string",
"at",
"(",
"(",
"m",
"current",
"-",
"1",
")",
",",
"5",
",",
"\"",
"achen",
"\"",
",",
"\"",
"\"",
")",
"|",
"|",
"string",
"at",
"(",
"(",
"m",
"current",
"-",
"3",
")",
",",
"5",
",",
"\"",
"spich",
"\"",
",",
"\"",
"zurch",
"\"",
",",
"\"",
"buech",
"\"",
",",
"\"",
"\"",
")",
"|",
"|",
"(",
"string",
"at",
"(",
"(",
"m",
"current",
"-",
"3",
")",
",",
"5",
",",
"\"",
"kirch",
"\"",
",",
"\"",
"joach",
"\"",
",",
"\"",
"blech",
"\"",
",",
"\"",
"malch",
"\"",
",",
"\"",
"\"",
")",
"/",
"/",
"\"",
"kirch",
"\"",
"and",
"\"",
"blech",
"\"",
"both",
"get",
"'",
"x",
"'",
"&",
"&",
"!",
"(",
"string",
"at",
"(",
"(",
"m",
"current",
"-",
"3",
")",
",",
"8",
",",
"\"",
"kirchner",
"\"",
",",
"\"",
"\"",
")",
"|",
"|",
"(",
"(",
"m",
"current",
"+",
"1",
")",
"=",
"=",
"m",
"last",
")",
")",
")",
"|",
"|",
"(",
"(",
"(",
"m",
"current",
"+",
"1",
")",
"=",
"=",
"m",
"last",
")",
"&",
"&",
"string",
"at",
"(",
"(",
"m",
"current",
"-",
"2",
")",
",",
"4",
",",
"\"",
"nich",
"\"",
",",
"\"",
"lich",
"\"",
",",
"\"",
"bach",
"\"",
",",
"\"",
"\"",
")",
")",
"|",
"|",
"(",
"(",
"(",
"m",
"current",
"+",
"1",
")",
"=",
"=",
"m",
"last",
")",
"&",
"&",
"string",
"at",
"(",
"(",
"m",
"current",
"-",
"3",
")",
",",
"5",
",",
"\"",
"urich",
"\"",
",",
"\"",
"brich",
"\"",
",",
"\"",
"erich",
"\"",
",",
"\"",
"drich",
"\"",
",",
"\"",
"nrich",
"\"",
",",
"\"",
"\"",
")",
"&",
"&",
"!",
"string",
"at",
"(",
"(",
"m",
"current",
"-",
"5",
")",
",",
"7",
",",
"\"",
"aldrich",
"\"",
",",
"\"",
"\"",
")",
"&",
"&",
"!",
"string",
"at",
"(",
"(",
"m",
"current",
"-",
"6",
")",
",",
"8",
",",
"\"",
"goodrich",
"\"",
",",
"\"",
"\"",
")",
"&",
"&",
"!",
"string",
"at",
"(",
"(",
"m",
"current",
"-",
"7",
")",
",",
"9",
",",
"\"",
"gingerich",
"\"",
",",
"\"",
"\"",
")",
")",
")",
"|",
"|",
"(",
"(",
"(",
"m",
"current",
"+",
"1",
")",
"=",
"=",
"m",
"last",
")",
"&",
"&",
"string",
"at",
"(",
"(",
"m",
"current",
"-",
"4",
")",
",",
"6",
",",
"\"",
"ulrich",
"\"",
",",
"\"",
"lfrich",
"\"",
",",
"\"",
"llrich",
"\"",
",",
"\"",
"emrich",
"\"",
",",
"\"",
"zurich",
"\"",
",",
"\"",
"eyrich",
"\"",
",",
"\"",
"\"",
")",
")",
"/",
"/",
"e",
"g",
",",
"'",
"wachtler",
"'",
",",
"'",
"wechsler",
"'",
",",
"but",
"not",
"'",
"tichner",
"'",
"|",
"|",
"(",
"(",
"string",
"at",
"(",
"(",
"m",
"current",
"-",
"1",
")",
",",
"1",
",",
"\"",
"a",
"\"",
",",
"\"",
"o",
"\"",
",",
"\"",
"u",
"\"",
",",
"\"",
"e",
"\"",
",",
"\"",
"\"",
")",
"|",
"|",
"(",
"m",
"current",
"=",
"=",
"0",
")",
")",
"&",
"&",
"string",
"at",
"(",
"(",
"m",
"current",
"+",
"2",
")",
",",
"1",
",",
"\"",
"l",
"\"",
",",
"\"",
"r",
"\"",
",",
"\"",
"n",
"\"",
",",
"\"",
"m",
"\"",
",",
"\"",
"b",
"\"",
",",
"\"",
"h",
"\"",
",",
"\"",
"f",
"\"",
",",
"\"",
"v",
"\"",
",",
"\"",
"w",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
")",
")",
"{",
"/",
"/",
"\"",
"chr",
"/",
"l",
"-",
"\"",
"e",
"g",
"'",
"chris",
"'",
"do",
"not",
"get",
"/",
"/",
"alt",
"pronunciation",
"of",
"'",
"x",
"'",
"if",
"(",
"string",
"at",
"(",
"(",
"m",
"current",
"+",
"2",
")",
",",
"1",
",",
"\"",
"r",
"\"",
",",
"\"",
"l",
"\"",
",",
"\"",
"\"",
")",
"|",
"|",
"slavo",
"germanic",
"(",
")",
")",
"{",
"metaph",
"add",
"(",
"\"",
"k",
"\"",
")",
";",
"}",
"else",
"{",
"metaph",
"add",
"(",
"\"",
"k",
"\"",
",",
"\"",
"x",
"\"",
")",
";",
"}",
"m",
"current",
"+",
"=",
"2",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}"
] |
[
"serializes",
"a",
"long",
"to",
"a",
"binary",
"stream",
"with",
"zero",
"-",
"compressed",
"encoding",
"for",
"-",
"112",
"<",
"=",
"i",
"<",
"=",
"127",
",",
"only",
"one",
"byte",
"is",
"used",
"with",
"the",
"actual",
"value",
"for",
"other",
"values",
"of",
"i",
",",
"the",
"first",
"byte",
"value",
"indicates",
"whether",
"the",
"long",
"is",
"positive",
"or",
"negative",
",",
"and",
"the",
"number",
"of",
"bytes",
"that",
"follow",
"if",
"the",
"first",
"byte",
"value",
"v",
"is",
"between",
"-",
"113",
"and",
"-",
"120",
",",
"the",
"following",
"long",
"is",
"positive",
",",
"with",
"number",
"of",
"bytes",
"that",
"follow",
"are",
"-",
"(",
"v",
"+",
"112",
")",
"if",
"the",
"first",
"byte",
"value",
"v",
"is",
"between",
"-",
"121",
"and",
"-",
"128",
",",
"the",
"following",
"long",
"is",
"negative",
",",
"with",
"number",
"of",
"bytes",
"that",
"follow",
"are",
"-",
"(",
"v",
"+",
"120",
")",
"bytes",
"are",
"stored",
"in",
"the",
"high",
"-",
"non",
"-",
"zero",
"-",
"byte",
"-",
"first",
"order"
] |
[
"public",
"static",
"void",
"write",
"v",
"long",
"(",
"data",
"output",
"stream",
",",
"long",
"i",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"i",
">",
"=",
"-",
"112",
"&",
"&",
"i",
"<",
"=",
"127",
")",
"{",
"stream",
"write",
"byte",
"(",
"(",
"byte",
")",
"i",
")",
";",
"return",
";",
"}",
"int",
"len",
"=",
"-",
"112",
";",
"if",
"(",
"i",
"<",
"0",
")",
"{",
"i",
"^",
"=",
"-",
"1l",
";",
"/",
"/",
"take",
"one",
"'",
"s",
"complement",
"'",
"len",
"=",
"-",
"120",
";",
"}",
"long",
"tmp",
"=",
"i",
";",
"while",
"(",
"tmp",
"!",
"=",
"0",
")",
"{",
"tmp",
"=",
"tmp",
">",
">",
"8",
";",
"len",
"-",
"-",
";",
"}",
"stream",
"write",
"byte",
"(",
"(",
"byte",
")",
"len",
")",
";",
"len",
"=",
"(",
"len",
"<",
"-",
"120",
")",
"?",
"-",
"(",
"len",
"+",
"120",
")",
":",
"-",
"(",
"len",
"+",
"112",
")",
";",
"for",
"(",
"int",
"idx",
"=",
"len",
";",
"idx",
"!",
"=",
"0",
";",
"idx",
"-",
"-",
")",
"{",
"int",
"shiftbits",
"=",
"(",
"idx",
"-",
"1",
")",
"*",
"8",
";",
"long",
"mask",
"=",
"0x",
"f",
"f",
"l",
"<",
"<",
"shiftbits",
";",
"stream",
"write",
"byte",
"(",
"(",
"byte",
")",
"(",
"(",
"i",
"&",
"mask",
")",
">",
">",
"shiftbits",
")",
")",
";",
"}",
"}"
] |
[
"adds",
"a",
"given",
"bootstrap",
"method",
"to",
"the",
"bootstrap",
"methods",
"attribute"
] |
[
"public",
"int",
"add",
"bootstrap",
"method",
"info",
"(",
"bootstrap",
"method",
"info",
"bootstrap",
"method",
"info",
")",
"{",
"target",
"bootstrap",
"methods",
"attribute",
"bootstrap",
"methods",
"=",
"(",
"bootstrap",
"method",
"info",
"[",
"]",
")",
"array",
"util",
"add",
"(",
"target",
"bootstrap",
"methods",
"attribute",
"bootstrap",
"methods",
",",
"target",
"bootstrap",
"methods",
"attribute",
"u",
"2bootstrap",
"methods",
"count",
",",
"bootstrap",
"method",
"info",
")",
";",
"return",
"target",
"bootstrap",
"methods",
"attribute",
"u",
"2bootstrap",
"methods",
"count",
"+",
"+",
";",
"}"
] |
[
"send",
"the",
"object",
"formatted",
"as",
"a",
"single",
"sse",
"\"",
"data",
"\"",
"line",
"it",
"'",
"s",
"equivalent",
"to",
":",
"static",
"import",
"of",
"sse",
"emitter",
"sse",
"emitter",
"emitter",
"=",
"new",
"sse",
"emitter",
"(",
")",
";",
"emitter",
"send",
"(",
"event",
"(",
")",
"data",
"(",
"my",
"object",
")",
")",
";",
"please",
",",
"see",
"{",
"@",
"link",
"response",
"body",
"emitter",
"#",
"send",
"(",
"object",
")",
"parent",
"javadoc",
"}",
"for",
"important",
"notes",
"on",
"exception",
"handling"
] |
[
"public",
"void",
"send",
"(",
"object",
"object",
")",
"throws",
"i",
"o",
"exception",
"{",
"send",
"(",
"object",
",",
"null",
")",
";",
"}"
] |
[
"read",
"in",
"data"
] |
[
"public",
"synchronized",
"int",
"read",
"(",
"final",
"byte",
"[",
"]",
"b",
",",
"final",
"int",
"offset",
",",
"final",
"int",
"length",
")",
"throws",
"i",
"o",
"exception",
"{",
"preconditions",
"check",
"argument",
"(",
"length",
">",
"=",
"0",
",",
"\"",
"length",
"is",
"negative",
"\"",
")",
";",
"preconditions",
"check",
"argument",
"(",
"b",
"!",
"=",
"null",
",",
"\"",
"null",
"buffer",
"\"",
")",
";",
"if",
"(",
"b",
"length",
"-",
"offset",
"<",
"length",
")",
"{",
"throw",
"new",
"index",
"out",
"of",
"bounds",
"exception",
"(",
"f",
"s",
"exception",
"messages",
"too",
"many",
"bytes",
"for",
"dest",
"buffer",
"+",
"\"",
":",
"request",
"length",
"=",
"\"",
"+",
"length",
"+",
"\"",
",",
"with",
"offset",
"=",
"\"",
"+",
"offset",
"+",
"\"",
";",
"buffer",
"capacity",
"=",
"\"",
"+",
"(",
"b",
"length",
"-",
"offset",
")",
")",
";",
"}",
"verify",
"open",
"(",
")",
";",
"if",
"(",
"!",
"has",
"remaining",
"(",
")",
")",
"{",
"return",
"-",
"1",
";",
"}",
"int",
"to",
"read",
"=",
"math",
"min",
"(",
"length",
",",
"available",
"(",
")",
")",
";",
"byte",
"buffer",
"get",
"(",
"b",
",",
"offset",
",",
"to",
"read",
")",
";",
"return",
"to",
"read",
";",
"}"
] |
[
"returns",
"a",
"string",
"containing",
"the",
"supplied",
"{",
"@",
"code",
"char",
"}",
"values",
"separated",
"by",
"{",
"@",
"code",
"separator",
"}",
"for",
"example",
",",
"{",
"@",
"code",
"join",
"(",
"\"",
"-",
"\"",
",",
"'",
"1",
"'",
",",
"'",
"2",
"'",
",",
"'",
"3",
"'",
")",
"}",
"returns",
"the",
"string",
"{",
"@",
"code",
"\"",
"1",
"-",
"2",
"-",
"3",
"\"",
"}"
] |
[
"public",
"static",
"string",
"join",
"(",
"string",
"separator",
",",
"char",
"array",
")",
"{",
"check",
"not",
"null",
"(",
"separator",
")",
";",
"int",
"len",
"=",
"array",
"length",
";",
"if",
"(",
"len",
"=",
"=",
"0",
")",
"{",
"return",
"\"",
"\"",
";",
"}",
"string",
"builder",
"builder",
"=",
"new",
"string",
"builder",
"(",
"len",
"+",
"separator",
"length",
"(",
")",
"*",
"(",
"len",
"-",
"1",
")",
")",
";",
"builder",
"append",
"(",
"array",
"[",
"0",
"]",
")",
";",
"for",
"(",
"int",
"i",
"=",
"1",
";",
"i",
"<",
"len",
";",
"i",
"+",
"+",
")",
"{",
"builder",
"append",
"(",
"separator",
")",
"append",
"(",
"array",
"[",
"i",
"]",
")",
";",
"}",
"return",
"builder",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"aha",
"!",
"this",
"is",
"where",
"any",
"potential",
"subclasses",
"can",
"update",
"the",
"returned",
"value"
] |
[
"protected",
"file",
"do",
"get",
"user",
"application",
"settings",
"directory",
"(",
")",
"{",
"return",
"file",
"utilities",
"create",
"temp",
"directory",
"(",
"\"",
"application",
"settings",
"\"",
")",
";",
"}"
] |
[
"applies",
"and",
"updates",
"media",
"position",
"parameters"
] |
[
"private",
"long",
"apply",
"media",
"position",
"parameters",
"(",
"long",
"position",
"us",
")",
"{",
"while",
"(",
"!",
"media",
"position",
"parameters",
"checkpoints",
"is",
"empty",
"(",
")",
"&",
"&",
"position",
"us",
">",
"=",
"media",
"position",
"parameters",
"checkpoints",
"get",
"first",
"(",
")",
"audio",
"track",
"position",
"us",
")",
"{",
"/",
"/",
"we",
"are",
"playing",
"(",
"or",
"about",
"to",
"play",
")",
"media",
"with",
"the",
"new",
"parameters",
",",
"so",
"update",
"them",
"media",
"position",
"parameters",
"=",
"media",
"position",
"parameters",
"checkpoints",
"remove",
"(",
")",
";",
"}",
"long",
"playout",
"duration",
"since",
"last",
"checkpoint",
"us",
"=",
"position",
"us",
"-",
"media",
"position",
"parameters",
"audio",
"track",
"position",
"us",
";",
"if",
"(",
"media",
"position",
"parameters",
"playback",
"parameters",
"equals",
"(",
"playback",
"parameters",
"default",
")",
")",
"{",
"return",
"media",
"position",
"parameters",
"media",
"time",
"us",
"+",
"playout",
"duration",
"since",
"last",
"checkpoint",
"us",
";",
"}",
"else",
"if",
"(",
"media",
"position",
"parameters",
"checkpoints",
"is",
"empty",
"(",
")",
")",
"{",
"long",
"media",
"duration",
"since",
"last",
"checkpoint",
"us",
"=",
"audio",
"processor",
"chain",
"get",
"media",
"duration",
"(",
"playout",
"duration",
"since",
"last",
"checkpoint",
"us",
")",
";",
"return",
"media",
"position",
"parameters",
"media",
"time",
"us",
"+",
"media",
"duration",
"since",
"last",
"checkpoint",
"us",
";",
"}",
"else",
"{",
"/",
"/",
"the",
"processor",
"chain",
"has",
"been",
"configured",
"with",
"new",
"parameters",
",",
"but",
"we",
"'",
"re",
"still",
"playing",
"audio",
"/",
"/",
"that",
"was",
"processed",
"using",
"previous",
"parameters",
"we",
"can",
"'",
"t",
"scale",
"the",
"playout",
"duration",
"using",
"the",
"/",
"/",
"processor",
"chain",
"in",
"this",
"case",
",",
"so",
"we",
"fall",
"back",
"to",
"scaling",
"using",
"the",
"previous",
"parameters",
"'",
"/",
"/",
"target",
"speed",
"instead",
"since",
"the",
"processor",
"chain",
"may",
"not",
"have",
"achieved",
"the",
"target",
"speed",
"/",
"/",
"precisely",
",",
"we",
"scale",
"the",
"duration",
"to",
"the",
"next",
"checkpoint",
"(",
"which",
"will",
"always",
"be",
"small",
")",
"rather",
"/",
"/",
"than",
"the",
"duration",
"from",
"the",
"previous",
"checkpoint",
"(",
"which",
"may",
"be",
"arbitrarily",
"large",
")",
"this",
"/",
"/",
"limits",
"the",
"amount",
"of",
"error",
"that",
"can",
"be",
"introduced",
"due",
"to",
"a",
"difference",
"between",
"the",
"target",
"/",
"/",
"and",
"actual",
"speeds",
"media",
"position",
"parameters",
"next",
"media",
"position",
"parameters",
"=",
"media",
"position",
"parameters",
"checkpoints",
"get",
"first",
"(",
")",
";",
"long",
"playout",
"duration",
"until",
"next",
"checkpoint",
"us",
"=",
"next",
"media",
"position",
"parameters",
"audio",
"track",
"position",
"us",
"-",
"position",
"us",
";",
"long",
"media",
"duration",
"until",
"next",
"checkpoint",
"us",
"=",
"util",
"get",
"media",
"duration",
"for",
"playout",
"duration",
"(",
"playout",
"duration",
"until",
"next",
"checkpoint",
"us",
",",
"media",
"position",
"parameters",
"playback",
"parameters",
"speed",
")",
";",
"return",
"next",
"media",
"position",
"parameters",
"media",
"time",
"us",
"-",
"media",
"duration",
"until",
"next",
"checkpoint",
"us",
";",
"}",
"}"
] |
[
"<",
"code",
">",
"optional",
"int",
"6",
"4",
"num",
"=",
"4",
";",
"<",
"code",
">"
] |
[
"public",
"long",
"get",
"num",
"(",
")",
"{",
"return",
"num",
";",
"}"
] |
[
"model",
"tests",
"for",
"category"
] |
[
"public",
"void",
"test",
"category",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"category",
"}"
] |
[
"the",
"amount",
"the",
"mouse",
"was",
"scrolled",
"horizontally",
"valid",
"for",
":",
"scrolled"
] |
[
"public",
"float",
"get",
"scroll",
"amount",
"x",
"(",
")",
"{",
"return",
"scroll",
"amount",
"x",
";",
"}"
] |
[
"furiously",
"rethrottles",
"a",
"delayed",
"request",
"to",
"make",
"sure",
"that",
"we",
"never",
"run",
"it",
"twice"
] |
[
"public",
"void",
"test",
"delay",
"and",
"rethrottle",
"(",
")",
"throws",
"i",
"o",
"exception",
",",
"interrupted",
"exception",
"{",
"list",
"<",
"throwable",
">",
"errors",
"=",
"new",
"copy",
"on",
"write",
"array",
"list",
"<",
">",
"(",
")",
";",
"atomic",
"boolean",
"done",
"=",
"new",
"atomic",
"boolean",
"(",
")",
";",
"int",
"threads",
"=",
"between",
"(",
"1",
",",
"10",
")",
";",
"cyclic",
"barrier",
"wait",
"for",
"shutdown",
"=",
"new",
"cyclic",
"barrier",
"(",
"threads",
")",
";",
"/",
"*",
"*",
"we",
"never",
"end",
"up",
"waiting",
"this",
"long",
"because",
"the",
"test",
"rethrottles",
"over",
"and",
"over",
"again",
",",
"ratcheting",
"down",
"the",
"delay",
"a",
"random",
"amount",
"*",
"each",
"time",
"*",
"/",
"float",
"original",
"requests",
"per",
"second",
"=",
"(",
"float",
")",
"random",
"double",
"between",
"(",
"1",
",",
"10000",
",",
"true",
")",
";",
"worker",
"state",
"rethrottle",
"(",
"original",
"requests",
"per",
"second",
")",
";",
"time",
"value",
"max",
"delay",
"=",
"time",
"value",
"seconds",
"(",
"between",
"(",
"1",
",",
"5",
")",
")",
";",
"assert",
"that",
"(",
"max",
"delay",
"nanos",
"(",
")",
",",
"greater",
"than",
"or",
"equal",
"to",
"(",
"0l",
")",
")",
";",
"int",
"batch",
"size",
"for",
"max",
"delay",
"=",
"(",
"int",
")",
"(",
"max",
"delay",
"seconds",
"(",
")",
"*",
"original",
"requests",
"per",
"second",
")",
";",
"thread",
"pool",
"thread",
"pool",
"=",
"new",
"test",
"thread",
"pool",
"(",
"get",
"test",
"name",
"(",
")",
")",
"{",
"@",
"override",
"public",
"scheduled",
"cancellable",
"schedule",
"(",
"runnable",
"command",
",",
"time",
"value",
"delay",
",",
"string",
"name",
")",
"{",
"assert",
"that",
"(",
"delay",
"nanos",
"(",
")",
",",
"both",
"(",
"greater",
"than",
"or",
"equal",
"to",
"(",
"0l",
")",
")",
"and",
"(",
"less",
"than",
"or",
"equal",
"to",
"(",
"max",
"delay",
"nanos",
"(",
")",
")",
")",
")",
";",
"return",
"super",
"schedule",
"(",
"command",
",",
"delay",
",",
"name",
")",
";",
"}",
"}",
";",
"try",
"{",
"worker",
"state",
"delay",
"prepare",
"bulk",
"request",
"(",
"thread",
"pool",
",",
"system",
"nano",
"time",
"(",
")",
",",
"batch",
"size",
"for",
"max",
"delay",
",",
"new",
"abstract",
"runnable",
"(",
")",
"{",
"@",
"override",
"protected",
"void",
"do",
"run",
"(",
")",
"throws",
"exception",
"{",
"boolean",
"old",
"value",
"=",
"done",
"get",
"and",
"set",
"(",
"true",
")",
";",
"if",
"(",
"old",
"value",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"ran",
"twice",
"oh",
"no",
"!",
"\"",
")",
";",
"}",
"}",
"@",
"override",
"public",
"void",
"on",
"failure",
"(",
"exception",
"e",
")",
"{",
"errors",
"add",
"(",
"e",
")",
";",
"}",
"}",
")",
";",
"/",
"/",
"rethrottle",
"on",
"a",
"random",
"number",
"of",
"threads",
",",
"one",
"of",
"which",
"is",
"this",
"thread",
"runnable",
"test",
"=",
"(",
")",
"-",
">",
"{",
"try",
"{",
"int",
"rethrottles",
"=",
"0",
";",
"while",
"(",
"false",
"=",
"=",
"done",
"get",
"(",
")",
")",
"{",
"float",
"requests",
"per",
"second",
"=",
"(",
"float",
")",
"random",
"double",
"between",
"(",
"0",
",",
"original",
"requests",
"per",
"second",
"*",
"2",
",",
"true",
")",
";",
"worker",
"state",
"rethrottle",
"(",
"requests",
"per",
"second",
")",
";",
"rethrottles",
"+",
"=",
"1",
";",
"}",
"logger",
"info",
"(",
"\"",
"rethrottled",
"[",
"{",
"}",
"]",
"times",
"\"",
",",
"rethrottles",
")",
";",
"wait",
"for",
"shutdown",
"await",
"(",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"errors",
"add",
"(",
"e",
")",
";",
"}",
"}",
";",
"for",
"(",
"int",
"i",
"=",
"1",
";",
"i",
"<",
"threads",
";",
"i",
"+",
"+",
")",
"{",
"thread",
"pool",
"generic",
"(",
")",
"execute",
"(",
"test",
")",
";",
"}",
"test",
"run",
"(",
")",
";",
"}",
"finally",
"{",
"/",
"/",
"other",
"threads",
"should",
"finish",
"up",
"quickly",
"as",
"they",
"are",
"checking",
"the",
"same",
"atomic",
"boolean",
"thread",
"pool",
"shutdown",
"(",
")",
";",
"thread",
"pool",
"await",
"termination",
"(",
"10",
",",
"time",
"unit",
"seconds",
")",
";",
"}",
"assert",
"that",
"(",
"errors",
",",
"empty",
"(",
")",
")",
";",
"}"
] |
[
"find",
"the",
"fields",
"constant",
"that",
"matches",
"field",
"id",
",",
"or",
"null",
"if",
"its",
"not",
"found"
] |
[
"public",
"static",
"fields",
"find",
"by",
"thrift",
"id",
"(",
"int",
"field",
"id",
")",
"{",
"switch",
"(",
"field",
"id",
")",
"{",
"default",
":",
"return",
"null",
";",
"}",
"}"
] |
[
"returns",
"a",
"dockable",
"component",
"that",
"wraps",
"the",
"component",
"for",
"this",
"placeholder"
] |
[
"public",
"dockable",
"component",
"get",
"component",
"(",
")",
"{",
"if",
"(",
"disposed",
")",
"{",
"throw",
"new",
"assert",
"exception",
"(",
"\"",
"attempted",
"to",
"get",
"a",
"component",
"for",
"a",
"disposed",
"component",
"placeholder",
"\"",
")",
";",
"}",
"boolean",
"is",
"docking",
"=",
"true",
";",
"if",
"(",
"comp",
"node",
"!",
"=",
"null",
")",
"{",
"is",
"docking",
"=",
"comp",
"node",
"win",
"mgr",
"is",
"docking",
"(",
")",
";",
"}",
"if",
"(",
"comp",
"=",
"=",
"null",
"&",
"&",
"is",
"showing",
")",
"{",
"comp",
"=",
"new",
"dockable",
"component",
"(",
"this",
",",
"is",
"docking",
")",
";",
"}",
"return",
"comp",
";",
"}"
] |
[
"return",
"whether",
"you",
"have",
"been",
"granted",
"the",
"permissions"
] |
[
"public",
"static",
"boolean",
"is",
"granted",
"(",
"final",
"string",
"permissions",
")",
"{",
"pair",
"<",
"list",
"<",
"string",
">",
",",
"list",
"<",
"string",
">",
">",
"request",
"and",
"denied",
"permissions",
"=",
"get",
"request",
"and",
"denied",
"permissions",
"(",
"permissions",
")",
";",
"list",
"<",
"string",
">",
"denied",
"permissions",
"=",
"request",
"and",
"denied",
"permissions",
"second",
";",
"if",
"(",
"!",
"denied",
"permissions",
"is",
"empty",
"(",
")",
")",
"{",
"return",
"false",
";",
"}",
"list",
"<",
"string",
">",
"request",
"permissions",
"=",
"request",
"and",
"denied",
"permissions",
"first",
";",
"for",
"(",
"string",
"permission",
":",
"request",
"permissions",
")",
"{",
"if",
"(",
"!",
"is",
"granted",
"(",
"permission",
")",
")",
"{",
"return",
"false",
";",
"}",
"}",
"return",
"true",
";",
"}"
] |
[
"close",
"a",
"channel",
"when",
"a",
"channel",
"is",
"inactive",
"directly",
"return",
"the",
"unfinished",
"requests"
] |
[
"public",
"static",
"void",
"close",
"channel",
"(",
"channel",
"channel",
")",
"{",
"for",
"(",
"map",
"entry",
"<",
"long",
",",
"channel",
">",
"entry",
":",
"channels",
"entry",
"set",
"(",
")",
")",
"{",
"if",
"(",
"channel",
"equals",
"(",
"entry",
"get",
"value",
"(",
")",
")",
")",
"{",
"default",
"future",
"future",
"=",
"get",
"future",
"(",
"entry",
"get",
"key",
"(",
")",
")",
";",
"if",
"(",
"future",
"!",
"=",
"null",
"&",
"&",
"!",
"future",
"is",
"done",
"(",
")",
")",
"{",
"executor",
"service",
"future",
"executor",
"=",
"future",
"get",
"executor",
"(",
")",
";",
"if",
"(",
"future",
"executor",
"!",
"=",
"null",
"&",
"&",
"!",
"future",
"executor",
"is",
"terminated",
"(",
")",
")",
"{",
"future",
"executor",
"shutdown",
"now",
"(",
")",
";",
"}",
"response",
"disconnect",
"response",
"=",
"new",
"response",
"(",
"future",
"get",
"id",
"(",
")",
")",
";",
"disconnect",
"response",
"set",
"status",
"(",
"response",
"channel",
"inactive",
")",
";",
"disconnect",
"response",
"set",
"error",
"message",
"(",
"\"",
"channel",
"\"",
"+",
"channel",
"+",
"\"",
"is",
"inactive",
"directly",
"return",
"the",
"un",
"finished",
"request",
":",
"\"",
"+",
"future",
"get",
"request",
"(",
")",
")",
";",
"default",
"future",
"received",
"(",
"channel",
",",
"disconnect",
"response",
")",
";",
"}",
"}",
"}",
"}"
] |
[
"returns",
"an",
"instance",
"with",
"the",
"specified",
"ad",
"marked",
"as",
"played"
] |
[
"public",
"ad",
"playback",
"state",
"with",
"played",
"ad",
"(",
"int",
"ad",
"group",
"index",
",",
"int",
"ad",
"index",
"in",
"ad",
"group",
")",
"{",
"ad",
"group",
"[",
"]",
"ad",
"groups",
"=",
"util",
"null",
"safe",
"array",
"copy",
"(",
"this",
"ad",
"groups",
",",
"this",
"ad",
"groups",
"length",
")",
";",
"ad",
"groups",
"[",
"ad",
"group",
"index",
"]",
"=",
"ad",
"groups",
"[",
"ad",
"group",
"index",
"]",
"with",
"ad",
"state",
"(",
"ad",
"state",
"played",
",",
"ad",
"index",
"in",
"ad",
"group",
")",
";",
"return",
"new",
"ad",
"playback",
"state",
"(",
"ad",
"group",
"times",
"us",
",",
"ad",
"groups",
",",
"ad",
"resume",
"position",
"us",
",",
"content",
"duration",
"us",
")",
";",
"}"
] |
[
"gets",
"primary",
"key",
"only",
"name"
] |
[
"public",
"list",
"<",
"string",
">",
"get",
"primary",
"key",
"only",
"name",
"(",
")",
"{",
"list",
"<",
"string",
">",
"list",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"for",
"(",
"entry",
"<",
"string",
",",
"column",
"meta",
">",
"entry",
":",
"get",
"primary",
"key",
"map",
"(",
")",
"entry",
"set",
"(",
")",
")",
"{",
"list",
"add",
"(",
"entry",
"get",
"key",
"(",
")",
")",
";",
"}",
"return",
"list",
";",
"}"
] |
[
"return",
"the",
"element",
"index",
"of",
"the",
"first",
"element",
"on",
"the",
"current",
"page",
"element",
"numbering",
"starts",
"with",
"0"
] |
[
"public",
"int",
"get",
"first",
"element",
"on",
"page",
"(",
")",
"{",
"return",
"(",
"get",
"page",
"size",
"(",
")",
"*",
"get",
"page",
"(",
")",
")",
";",
"}"
] |
[
"does",
"not",
"change",
"between",
"incremental",
"builds",
",",
"so",
"does",
"not",
"need",
"to",
"be",
"@",
"input"
] |
[
"public",
"variant",
"type",
"get",
"type",
"(",
")",
"{",
"return",
"type",
";",
"}"
] |
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
] |
[
"private",
"string",
"to",
"indented",
"string",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
] |
[
"get",
"prefix",
"integer"
] |
[
"public",
"integer",
"get",
"prefix",
"integer",
"(",
")",
"{",
"return",
"prefix",
"integer",
";",
"}"
] |
[
"gets",
"the",
"{",
"@",
"link",
"pseudo",
"header",
"name",
"#",
"status",
"}",
"header",
"or",
"{",
"@",
"code",
"null",
"}",
"if",
"there",
"is",
"no",
"such",
"header"
] |
[
"char",
"sequence",
"status",
"(",
")",
";"
] |
[
"returns",
"the",
"index",
"of",
"the",
"leftmost",
"part",
"of",
"the",
"suffix",
",",
"or",
"-",
"1",
"if",
"not",
"found",
"note",
"that",
"the",
"value",
"defined",
"as",
"a",
"suffix",
"may",
"not",
"produce",
"{",
"@",
"code",
"true",
"}",
"results",
"from",
"{",
"@",
"link",
"#",
"is",
"public",
"suffix",
"(",
")",
"}",
"or",
"{",
"@",
"link",
"#",
"is",
"registry",
"suffix",
"(",
")",
"}",
"if",
"the",
"domain",
"ends",
"with",
"an",
"excluded",
"domain",
"pattern",
"such",
"as",
"{",
"@",
"code",
"\"",
"nhs",
"uk",
"\"",
"}",
"if",
"a",
"{",
"@",
"code",
"desired",
"type",
"}",
"is",
"specified",
",",
"this",
"method",
"only",
"finds",
"suffixes",
"of",
"the",
"given",
"type",
"otherwise",
",",
"it",
"finds",
"the",
"first",
"suffix",
"of",
"any",
"type"
] |
[
"private",
"int",
"find",
"suffix",
"of",
"type",
"(",
"optional",
"<",
"public",
"suffix",
"type",
">",
"desired",
"type",
")",
"{",
"final",
"int",
"parts",
"size",
"=",
"parts",
"size",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"parts",
"size",
";",
"i",
"+",
"+",
")",
"{",
"string",
"ancestor",
"name",
"=",
"dot",
"joiner",
"join",
"(",
"parts",
"sub",
"list",
"(",
"i",
",",
"parts",
"size",
")",
")",
";",
"if",
"(",
"matches",
"type",
"(",
"desired",
"type",
",",
"optional",
"from",
"nullable",
"(",
"public",
"suffix",
"patterns",
"exact",
"get",
"(",
"ancestor",
"name",
")",
")",
")",
")",
"{",
"return",
"i",
";",
"}",
"/",
"/",
"excluded",
"domains",
"(",
"e",
"g",
"!",
"nhs",
"uk",
")",
"use",
"the",
"next",
"highest",
"/",
"/",
"domain",
"as",
"the",
"effective",
"public",
"suffix",
"(",
"e",
"g",
"uk",
")",
"if",
"(",
"public",
"suffix",
"patterns",
"excluded",
"contains",
"key",
"(",
"ancestor",
"name",
")",
")",
"{",
"return",
"i",
"+",
"1",
";",
"}",
"if",
"(",
"matches",
"wildcard",
"suffix",
"type",
"(",
"desired",
"type",
",",
"ancestor",
"name",
")",
")",
"{",
"return",
"i",
";",
"}",
"}",
"return",
"no",
"suffix",
"found",
";",
"}"
] |
[
"concatenates",
"the",
"contents",
"of",
"the",
"two",
"given",
"collections",
"of",
"exceptions",
"if",
"either",
"collection",
"is",
"null",
",",
"the",
"other",
"collection",
"is",
"returned",
"otherwise",
",",
"the",
"elements",
"of",
"{",
"@",
"code",
"other",
"}",
"are",
"added",
"to",
"{",
"@",
"code",
"exceptions",
"}",
"and",
"{",
"@",
"code",
"exceptions",
"}",
"is",
"returned"
] |
[
"private",
"static",
"@",
"nullable",
"collection",
"<",
"i",
"o",
"exception",
">",
"concat",
"(",
"@",
"nullable",
"collection",
"<",
"i",
"o",
"exception",
">",
"exceptions",
",",
"@",
"nullable",
"collection",
"<",
"i",
"o",
"exception",
">",
"other",
")",
"{",
"if",
"(",
"exceptions",
"=",
"=",
"null",
")",
"{",
"return",
"other",
";",
"}",
"else",
"if",
"(",
"other",
"!",
"=",
"null",
")",
"{",
"exceptions",
"add",
"all",
"(",
"other",
")",
";",
"}",
"return",
"exceptions",
";",
"}"
] |
[
"returns",
"the",
"major",
"version",
"of",
"this",
"platform"
] |
[
"public",
"int",
"get",
"major",
"version",
"(",
")",
"{",
"return",
"major",
"version",
";",
"}"
] |
[
"multiplies",
"this",
"quaternion",
"with",
"another",
"one",
"in",
"the",
"form",
"of",
"this",
"=",
"this",
"other"
] |
[
"public",
"quaternion",
"mul",
"(",
"final",
"float",
"x",
",",
"final",
"float",
"y",
",",
"final",
"float",
"z",
",",
"final",
"float",
"w",
")",
"{",
"final",
"float",
"new",
"x",
"=",
"this",
"w",
"*",
"x",
"+",
"this",
"x",
"*",
"w",
"+",
"this",
"y",
"*",
"z",
"-",
"this",
"z",
"*",
"y",
";",
"final",
"float",
"new",
"y",
"=",
"this",
"w",
"*",
"y",
"+",
"this",
"y",
"*",
"w",
"+",
"this",
"z",
"*",
"x",
"-",
"this",
"x",
"*",
"z",
";",
"final",
"float",
"new",
"z",
"=",
"this",
"w",
"*",
"z",
"+",
"this",
"z",
"*",
"w",
"+",
"this",
"x",
"*",
"y",
"-",
"this",
"y",
"*",
"x",
";",
"final",
"float",
"new",
"w",
"=",
"this",
"w",
"*",
"w",
"-",
"this",
"x",
"*",
"x",
"-",
"this",
"y",
"*",
"y",
"-",
"this",
"z",
"*",
"z",
";",
"this",
"x",
"=",
"new",
"x",
";",
"this",
"y",
"=",
"new",
"y",
";",
"this",
"z",
"=",
"new",
"z",
";",
"this",
"w",
"=",
"new",
"w",
";",
"return",
"this",
";",
"}"
] |
[
"access",
"the",
"current",
"{",
"@",
"link",
"web",
"connection",
"}",
"for",
"the",
"{",
"@",
"link",
"web",
"client",
"}"
] |
[
"public",
"web",
"connection",
"get",
"web",
"connection",
"(",
")",
"{",
"return",
"get",
"web",
"client",
"(",
")",
"get",
"web",
"connection",
"(",
")",
";",
"}"
] |
[
"releases",
"all",
"allocated",
"resources"
] |
[
"public",
"void",
"release",
"(",
")",
"{",
"handler",
"remove",
"callbacks",
"(",
"this",
")",
";",
"try",
"{",
"if",
"(",
"texture",
"!",
"=",
"null",
")",
"{",
"texture",
"release",
"(",
")",
";",
"gles20",
"gl",
"delete",
"textures",
"(",
"1",
",",
"texture",
"id",
"holder",
",",
"0",
")",
";",
"}",
"}",
"finally",
"{",
"if",
"(",
"display",
"!",
"=",
"null",
"&",
"&",
"!",
"display",
"equals",
"(",
"egl14",
"egl",
"no",
"display",
")",
")",
"{",
"egl14",
"egl",
"make",
"current",
"(",
"display",
",",
"egl14",
"egl",
"no",
"surface",
",",
"egl14",
"egl",
"no",
"surface",
",",
"egl14",
"egl",
"no",
"context",
")",
";",
"}",
"if",
"(",
"surface",
"!",
"=",
"null",
"&",
"&",
"!",
"surface",
"equals",
"(",
"egl14",
"egl",
"no",
"surface",
")",
")",
"{",
"egl14",
"egl",
"destroy",
"surface",
"(",
"display",
",",
"surface",
")",
";",
"}",
"if",
"(",
"context",
"!",
"=",
"null",
")",
"{",
"egl14",
"egl",
"destroy",
"context",
"(",
"display",
",",
"context",
")",
";",
"}",
"/",
"/",
"egl14",
"egl",
"release",
"thread",
"could",
"crash",
"before",
"android",
"k",
"(",
"see",
"[",
"internal",
":",
"b",
"/",
"11327779",
"]",
")",
"if",
"(",
"util",
"sdk",
"int",
">",
"=",
"19",
")",
"{",
"egl14",
"egl",
"release",
"thread",
"(",
")",
";",
"}",
"if",
"(",
"display",
"!",
"=",
"null",
"&",
"&",
"!",
"display",
"equals",
"(",
"egl14",
"egl",
"no",
"display",
")",
")",
"{",
"/",
"/",
"android",
"is",
"unusual",
"in",
"that",
"it",
"uses",
"a",
"reference",
"-",
"counted",
"e",
"g",
"l",
"display",
"so",
"for",
"/",
"/",
"every",
"egl",
"initialize",
"(",
")",
"we",
"need",
"an",
"egl",
"terminate",
"(",
")",
"egl14",
"egl",
"terminate",
"(",
"display",
")",
";",
"}",
"display",
"=",
"null",
";",
"context",
"=",
"null",
";",
"surface",
"=",
"null",
";",
"texture",
"=",
"null",
";",
"}",
"}"
] |
[
"check",
"whether",
"the",
"datanode",
"can",
"be",
"started"
] |
[
"private",
"boolean",
"can",
"start",
"data",
"node",
"(",
"configuration",
"conf",
")",
"throws",
"i",
"o",
"exception",
"{",
"data",
"node",
"dn",
"=",
"null",
";",
"try",
"{",
"dn",
"=",
"data",
"node",
"create",
"data",
"node",
"(",
"new",
"string",
"[",
"]",
"{",
"}",
",",
"conf",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"if",
"(",
"e",
"instanceof",
"java",
"net",
"bind",
"exception",
")",
"return",
"false",
";",
"throw",
"e",
";",
"}",
"finally",
"{",
"if",
"(",
"dn",
"!",
"=",
"null",
")",
"dn",
"shutdown",
"(",
")",
";",
"}",
"return",
"true",
";",
"}"
] |
[
"tests",
"verifies",
"the",
"jmx",
"attributes",
"of",
"local",
"and",
"remote",
"peer",
"bean",
"-",
"remove",
"one",
"quorum",
"peer",
"and",
"again",
"adding",
"it",
"back"
] |
[
"public",
"void",
"test",
"j",
"m",
"x",
"bean",
"after",
"remove",
"add",
"one",
"(",
")",
"throws",
"exception",
"{",
"qu",
"=",
"new",
"quorum",
"util",
"(",
"1",
")",
";",
"/",
"/",
"create",
"3",
"servers",
"qu",
"disable",
"j",
"m",
"x",
"test",
"=",
"true",
";",
"qu",
"start",
"all",
"(",
")",
";",
"zk",
"arr",
"=",
"create",
"handles",
"(",
"qu",
")",
";",
"zk",
"admin",
"arr",
"=",
"create",
"admin",
"handles",
"(",
"qu",
")",
";",
"list",
"<",
"string",
">",
"leaving",
"servers",
"=",
"new",
"array",
"list",
"<",
"string",
">",
"(",
")",
";",
"list",
"<",
"string",
">",
"joining",
"servers",
"=",
"new",
"array",
"list",
"<",
"string",
">",
"(",
")",
";",
"/",
"/",
"assert",
"remote",
"peer",
"bean",
"1",
"of",
"replicated",
"server",
"2",
"int",
"leaving",
"index",
"=",
"1",
";",
"int",
"replica",
"2",
"=",
"2",
";",
"quorum",
"peer",
"peer",
"2",
"=",
"qu",
"get",
"peer",
"(",
"replica",
"2",
")",
"peer",
";",
"quorum",
"server",
"leaving",
"q",
"s",
"2",
"=",
"peer",
"2",
"get",
"view",
"(",
")",
"get",
"(",
"long",
"value",
"of",
"(",
"leaving",
"index",
")",
")",
";",
"string",
"remote",
"peer",
"bean",
"2",
"=",
"m",
"bean",
"registry",
"domain",
"+",
"\"",
":",
"name",
"0",
"=",
"replicated",
"server",
"id",
"\"",
"+",
"replica",
"2",
"+",
"\"",
",",
"name",
"1",
"=",
"replica",
"\"",
"+",
"leaving",
"index",
";",
"assert",
"remote",
"peer",
"m",
"x",
"bean",
"attributes",
"(",
"leaving",
"q",
"s",
"2",
",",
"remote",
"peer",
"bean",
"2",
")",
";",
"/",
"/",
"assert",
"remote",
"peer",
"bean",
"1",
"of",
"replicated",
"server",
"3",
"int",
"replica",
"3",
"=",
"3",
";",
"quorum",
"peer",
"peer",
"3",
"=",
"qu",
"get",
"peer",
"(",
"replica",
"3",
")",
"peer",
";",
"quorum",
"server",
"leaving",
"q",
"s",
"3",
"=",
"peer",
"3",
"get",
"view",
"(",
")",
"get",
"(",
"long",
"value",
"of",
"(",
"leaving",
"index",
")",
")",
";",
"string",
"remote",
"peer",
"bean",
"3",
"=",
"m",
"bean",
"registry",
"domain",
"+",
"\"",
":",
"name",
"0",
"=",
"replicated",
"server",
"id",
"\"",
"+",
"replica",
"3",
"+",
"\"",
",",
"name",
"1",
"=",
"replica",
"\"",
"+",
"leaving",
"index",
";",
"assert",
"remote",
"peer",
"m",
"x",
"bean",
"attributes",
"(",
"leaving",
"q",
"s",
"3",
",",
"remote",
"peer",
"bean",
"3",
")",
";",
"zoo",
"keeper",
"zk",
"=",
"zk",
"arr",
"[",
"leaving",
"index",
"]",
";",
"zoo",
"keeper",
"admin",
"zk",
"admin",
"=",
"zk",
"admin",
"arr",
"[",
"leaving",
"index",
"]",
";",
"leaving",
"servers",
"add",
"(",
"integer",
"to",
"string",
"(",
"leaving",
"index",
")",
")",
";",
"/",
"/",
"remember",
"this",
"server",
"so",
"we",
"can",
"add",
"it",
"back",
"later",
"joining",
"servers",
"add",
"(",
"\"",
"server",
"\"",
"+",
"leaving",
"index",
"+",
"\"",
"=",
"127",
"0",
"0",
"1",
":",
"\"",
"+",
"qu",
"get",
"peer",
"(",
"leaving",
"index",
")",
"peer",
"get",
"quorum",
"address",
"(",
")",
"get",
"all",
"ports",
"(",
")",
"get",
"(",
"0",
")",
"+",
"\"",
":",
"\"",
"+",
"qu",
"get",
"peer",
"(",
"leaving",
"index",
")",
"peer",
"get",
"election",
"address",
"(",
")",
"get",
"all",
"ports",
"(",
")",
"get",
"(",
"0",
")",
"+",
"\"",
":",
"participant",
";",
"127",
"0",
"0",
"1",
":",
"\"",
"+",
"qu",
"get",
"peer",
"(",
"leaving",
"index",
")",
"peer",
"get",
"client",
"port",
"(",
")",
")",
";",
"/",
"/",
"remove",
"replicated",
"server",
"1",
"from",
"the",
"ensemble",
"reconfig",
"(",
"zk",
"admin",
",",
"null",
",",
"leaving",
"servers",
",",
"null",
",",
"-",
"1",
")",
";",
"/",
"/",
"local",
"peer",
"bean",
"1",
"of",
"replicated",
"server",
"1",
"quorum",
"peer",
"removed",
"peer",
"=",
"qu",
"get",
"peer",
"(",
"leaving",
"index",
")",
"peer",
";",
"string",
"local",
"peer",
"bean",
"=",
"m",
"bean",
"registry",
"domain",
"+",
"\"",
":",
"name",
"0",
"=",
"replicated",
"server",
"id",
"\"",
"+",
"leaving",
"index",
"+",
"\"",
",",
"name",
"1",
"=",
"replica",
"\"",
"+",
"leaving",
"index",
";",
"assert",
"local",
"peer",
"m",
"x",
"bean",
"attributes",
"(",
"removed",
"peer",
",",
"local",
"peer",
"bean",
",",
"false",
")",
";",
"/",
"/",
"remote",
"peer",
"bean",
"1",
"shouldn",
"'",
"t",
"exists",
"in",
"replicated",
"server",
"2",
"j",
"m",
"x",
"env",
"ensure",
"none",
"(",
"remote",
"peer",
"bean",
"2",
")",
";",
"/",
"/",
"remote",
"peer",
"bean",
"1",
"shouldn",
"'",
"t",
"exists",
"in",
"replicated",
"server",
"3",
"j",
"m",
"x",
"env",
"ensure",
"none",
"(",
"remote",
"peer",
"bean",
"3",
")",
";",
"/",
"/",
"add",
"replicated",
"server",
"1",
"back",
"to",
"the",
"ensemble",
"reconfig",
"(",
"zk",
"admin",
",",
"joining",
"servers",
",",
"null",
",",
"null",
",",
"-",
"1",
")",
";",
"/",
"/",
"local",
"peer",
"bean",
"1",
"of",
"replicated",
"server",
"1",
"assert",
"local",
"peer",
"m",
"x",
"bean",
"attributes",
"(",
"removed",
"peer",
",",
"local",
"peer",
"bean",
",",
"true",
")",
";",
"/",
"/",
"assert",
"remote",
"peer",
"bean",
"1",
"of",
"replicated",
"server",
"2",
"leaving",
"q",
"s",
"2",
"=",
"peer",
"2",
"get",
"view",
"(",
")",
"get",
"(",
"long",
"value",
"of",
"(",
"leaving",
"index",
")",
")",
";",
"assert",
"remote",
"peer",
"m",
"x",
"bean",
"attributes",
"(",
"leaving",
"q",
"s",
"2",
",",
"remote",
"peer",
"bean",
"2",
")",
";",
"/",
"/",
"assert",
"remote",
"peer",
"bean",
"1",
"of",
"replicated",
"server",
"3",
"leaving",
"q",
"s",
"3",
"=",
"peer",
"3",
"get",
"view",
"(",
")",
"get",
"(",
"long",
"value",
"of",
"(",
"leaving",
"index",
")",
")",
";",
"assert",
"remote",
"peer",
"m",
"x",
"bean",
"attributes",
"(",
"leaving",
"q",
"s",
"3",
",",
"remote",
"peer",
"bean",
"3",
")",
";",
"}"
] |
[
"visit",
"a",
"parse",
"tree",
"produced",
"by",
"the",
"{",
"@",
"code",
"cast",
"}",
"labeled",
"alternative",
"in",
"{",
"@",
"link",
"sql",
"base",
"parser",
"#",
"primary",
"expression",
"}"
] |
[
"t",
"visit",
"cast",
"(",
"sql",
"base",
"parser",
"cast",
"context",
"ctx",
")",
";"
] |
[
"toggle",
"whether",
"or",
"not",
"the",
"decompiler",
"process",
"should",
"return",
"information",
"about",
"tables",
"used",
"to",
"recover",
"switch",
"statements",
"most",
"compilers",
"implement",
"switch",
"statements",
"using",
"a",
"so",
"called",
"\"",
"jumptable",
"\"",
"of",
"addresses",
"or",
"offsets",
"the",
"decompiler",
"can",
"frequently",
"recover",
"this",
"and",
"can",
"return",
"a",
"description",
"of",
"the",
"table"
] |
[
"public",
"synchronized",
"boolean",
"toggle",
"jump",
"loads",
"(",
"boolean",
"val",
")",
"{",
"jump",
"load",
"=",
"val",
";",
"/",
"/",
"property",
"can",
"be",
"set",
"before",
"process",
"exists",
"if",
"(",
"decomp",
"process",
"=",
"=",
"null",
")",
"{",
"return",
"true",
";",
"}",
"string",
"jumpstring",
"=",
"val",
"?",
"\"",
"jumpload",
"\"",
":",
"\"",
"nojumpload",
"\"",
";",
"try",
"{",
"verify",
"process",
"(",
")",
";",
"return",
"decomp",
"process",
"send",
"command",
"2",
"params",
"(",
"\"",
"set",
"action",
"\"",
",",
"\"",
"\"",
",",
"jumpstring",
")",
"to",
"string",
"(",
")",
"equals",
"(",
"\"",
"t",
"\"",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"/",
"/",
"don",
"'",
"t",
"care",
"}",
"catch",
"(",
"decompile",
"exception",
"e",
")",
"{",
"/",
"/",
"don",
"'",
"t",
"care",
"}",
"stop",
"process",
"(",
")",
";",
"return",
"false",
";",
"}"
] |
[
"return",
"whether",
"this",
"code",
"unit",
"info",
"has",
"a",
"dynamic",
"symbol"
] |
[
"public",
"boolean",
"has",
"dynamic",
"symbol",
"(",
")",
"{",
"return",
"has",
"dynamic",
"symbol",
";",
"}"
] |
[
"gets",
"the",
"metadata",
"associated",
"with",
"the",
"action",
"that",
"is",
"running"
] |
[
"public",
"action",
"execution",
"metadata",
"get",
"action",
"metadata",
"(",
")",
"{",
"return",
"action",
";",
"}"
] |
[
"creates",
"a",
"new",
"query",
"latch",
"with",
"an",
"expected",
"number",
"of",
"<",
"code",
">",
"num",
"shard",
"failures",
"<",
"code",
">"
] |
[
"public",
"static",
"synchronized",
"query",
"latch",
"acquire",
"query",
"latch",
"(",
"int",
"num",
"shard",
"failures",
")",
"{",
"assert",
"query",
"latch",
"=",
"=",
"null",
";",
"return",
"query",
"latch",
"=",
"new",
"query",
"latch",
"(",
"num",
"shard",
"failures",
")",
";",
"}"
] |
[
"returns",
"the",
"{",
"@",
"link",
"uri",
"}",
"associated",
"with",
"the",
"last",
"{",
"@",
"link",
"data",
"source",
"#",
"open",
"}",
"call",
"if",
"redirection",
"occurred",
",",
"this",
"is",
"the",
"redirected",
"uri",
"must",
"only",
"be",
"called",
"after",
"the",
"load",
"completed",
",",
"failed",
",",
"or",
"was",
"canceled"
] |
[
"public",
"final",
"uri",
"get",
"uri",
"(",
")",
"{",
"return",
"data",
"source",
"get",
"last",
"opened",
"uri",
"(",
")",
";",
"}"
] |
[
"true",
"if",
"at",
"current",
"get",
"status",
",",
"there",
"is",
"an",
"available",
"decoded",
"interface",
"http",
"data",
"from",
"the",
"body",
"this",
"get",
"method",
"works",
"for",
"chunked",
"and",
"not",
"chunked",
"request"
] |
[
"public",
"boolean",
"has",
"next",
"(",
")",
"{",
"check",
"destroyed",
"(",
")",
";",
"if",
"(",
"current",
"status",
"=",
"=",
"multi",
"part",
"status",
"epilogue",
")",
"{",
"/",
"/",
"ok",
"except",
"if",
"end",
"of",
"list",
"if",
"(",
"body",
"list",
"http",
"data",
"rank",
">",
"=",
"body",
"list",
"http",
"data",
"size",
"(",
")",
")",
"{",
"throw",
"new",
"end",
"of",
"data",
"decoder",
"exception",
"(",
")",
";",
"}",
"}",
"return",
"!",
"body",
"list",
"http",
"data",
"is",
"empty",
"(",
")",
"&",
"&",
"body",
"list",
"http",
"data",
"rank",
"<",
"body",
"list",
"http",
"data",
"size",
"(",
")",
";",
"}"
] |
[
"shortcut",
"for",
"{",
"@",
"link",
"user",
"details",
"service",
"#",
"load",
"user",
"by",
"username",
"(",
"string",
")",
"}"
] |
[
"public",
"user",
"details",
"load",
"user",
"by",
"username",
"2",
"(",
"string",
"username",
")",
"throws",
"username",
"not",
"found",
"exception",
"{",
"if",
"(",
"util",
"is",
"overridden",
"(",
"security",
"realm",
"class",
",",
"get",
"class",
"(",
")",
",",
"\"",
"load",
"user",
"by",
"username",
"\"",
",",
"string",
"class",
")",
")",
"{",
"try",
"{",
"return",
"load",
"user",
"by",
"username",
"(",
"username",
")",
"to",
"spring",
"(",
")",
";",
"}",
"catch",
"(",
"org",
"acegisecurity",
"acegi",
"security",
"exception",
"x",
")",
"{",
"throw",
"x",
"to",
"spring",
"(",
")",
";",
"}",
"catch",
"(",
"org",
"springframework",
"dao",
"data",
"access",
"exception",
"x",
")",
"{",
"throw",
"x",
"to",
"spring",
"(",
")",
";",
"}",
"}",
"else",
"{",
"return",
"get",
"security",
"components",
"(",
")",
"user",
"details",
"2",
"load",
"user",
"by",
"username",
"(",
"username",
")",
";",
"}",
"}"
] |
[
"whether",
"it",
"'",
"s",
"the",
"platform",
"that",
"has",
"defined",
"a",
"custom",
"java",
"comparator",
"native",
"task",
"doesn",
"'",
"t",
"support",
"custom",
"java",
"comparators",
"(",
"set",
"with",
"mapreduce",
"job",
"output",
"key",
"comparator",
"class",
")",
"but",
"a",
"platform",
"(",
"e",
"g",
"pig",
")",
"could",
"also",
"set",
"that",
"conf",
"and",
"implement",
"native",
"comparators",
"so",
"we",
"shouldn",
"'",
"t",
"bail",
"out"
] |
[
"protected",
"abstract",
"boolean",
"define",
"(",
"class",
"<",
"?",
">",
"key",
"comparator",
")",
";"
] |
[
"add",
"multiple",
"attributes",
"to",
"this",
"material",
"if",
"the",
"material",
"already",
"contains",
"an",
"attribute",
"of",
"the",
"same",
"type",
"it",
"is",
"overwritten"
] |
[
"public",
"final",
"void",
"set",
"(",
"final",
"attribute",
"attribute",
"1",
",",
"final",
"attribute",
"attribute",
"2",
")",
"{",
"set",
"(",
"attribute",
"1",
")",
";",
"set",
"(",
"attribute",
"2",
")",
";",
"}"
] |
[
"parses",
"a",
"constant",
"string",
"target",
"pattern",
",",
"throwing",
"illegal",
"state",
"exception",
"on",
"invalid",
"pattern"
] |
[
"public",
"target",
"pattern",
"parse",
"constant",
"unchecked",
"(",
"@",
"compile",
"time",
"constant",
"string",
"pattern",
")",
"{",
"try",
"{",
"return",
"parse",
"(",
"pattern",
")",
";",
"}",
"catch",
"(",
"target",
"parsing",
"exception",
"e",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"e",
")",
";",
"}",
"}"
] |
[
"flushes",
"the",
"batch",
"and",
"realigns",
"the",
"real",
"matrix",
"on",
"the",
"gpu",
"subsequent",
"draws",
"won",
"'",
"t",
"need",
"adjustment",
"and",
"will",
"be",
"slightly",
"faster",
"as",
"long",
"as",
"the",
"transform",
"matrix",
"is",
"not",
"{",
"@",
"link",
"#",
"set",
"transform",
"matrix",
"(",
"matrix",
"4",
")",
"changed",
"}",
"note",
":",
"the",
"real",
"transform",
"matrix",
"must",
"be",
"invertible",
"if",
"a",
"singular",
"matrix",
"is",
"detected",
",",
"gdx",
"runtime",
"exception",
"will",
"be",
"thrown"
] |
[
"public",
"void",
"flush",
"and",
"sync",
"transform",
"matrix",
"(",
")",
"{",
"flush",
"(",
")",
";",
"if",
"(",
"adjust",
"needed",
")",
"{",
"/",
"/",
"vertices",
"flushed",
",",
"safe",
"now",
"to",
"replace",
"matrix",
"have",
"identity",
"real",
"matrix",
"=",
"check",
"idt",
"(",
"virtual",
"matrix",
")",
";",
"if",
"(",
"!",
"have",
"identity",
"real",
"matrix",
"&",
"&",
"virtual",
"matrix",
"det",
"(",
")",
"=",
"=",
"0",
")",
"throw",
"new",
"gdx",
"runtime",
"exception",
"(",
"\"",
"transform",
"matrix",
"is",
"singular",
",",
"can",
"'",
"t",
"sync",
"\"",
")",
";",
"adjust",
"needed",
"=",
"false",
";",
"super",
"set",
"transform",
"matrix",
"(",
"virtual",
"matrix",
")",
";",
"}",
"}"
] |
[
"convenient",
"method",
"to",
"execute",
"an",
"update",
"given",
"one",
"int",
"arg"
] |
[
"public",
"int",
"update",
"(",
"int",
"p",
"1",
")",
"throws",
"data",
"access",
"exception",
"{",
"return",
"update",
"(",
"new",
"object",
"[",
"]",
"{",
"p",
"1",
"}",
")",
";",
"}"
] |
[
"this",
"test",
"ensures",
"that",
"when",
"explicitly",
"set",
"to",
"start",
"from",
"latest",
"record",
",",
"the",
"consumer",
"ignores",
"the",
"\"",
"auto",
"offset",
"reset",
"\"",
"behaviour",
"as",
"well",
"as",
"any",
"committed",
"group",
"offsets",
"in",
"kafka"
] |
[
"public",
"void",
"run",
"start",
"from",
"latest",
"offsets",
"(",
")",
"throws",
"exception",
"{",
"/",
"/",
"50",
"records",
"written",
"to",
"each",
"of",
"3",
"partitions",
"before",
"launching",
"a",
"latest",
"-",
"starting",
"consuming",
"/",
"/",
"job",
"final",
"int",
"parallelism",
"=",
"3",
";",
"final",
"int",
"records",
"in",
"each",
"partition",
"=",
"50",
";",
"/",
"/",
"each",
"partition",
"will",
"be",
"written",
"an",
"extra",
"200",
"records",
"final",
"int",
"extra",
"records",
"in",
"each",
"partition",
"=",
"200",
";",
"/",
"/",
"all",
"already",
"existing",
"data",
"in",
"the",
"topic",
",",
"before",
"the",
"consuming",
"topology",
"has",
"started",
",",
"should",
"/",
"/",
"be",
"ignored",
"final",
"string",
"topic",
"name",
"=",
"write",
"sequence",
"(",
"\"",
"test",
"start",
"from",
"latest",
"offsets",
"topic",
"\"",
",",
"records",
"in",
"each",
"partition",
",",
"parallelism",
",",
"1",
")",
";",
"/",
"/",
"the",
"committed",
"offsets",
"should",
"be",
"ignored",
"kafka",
"test",
"environment",
"kafka",
"offset",
"handler",
"kafka",
"offset",
"handler",
"=",
"kafka",
"server",
"create",
"offset",
"handler",
"(",
")",
";",
"kafka",
"offset",
"handler",
"set",
"committed",
"offset",
"(",
"topic",
"name",
",",
"0",
",",
"23",
")",
";",
"kafka",
"offset",
"handler",
"set",
"committed",
"offset",
"(",
"topic",
"name",
",",
"1",
",",
"31",
")",
";",
"kafka",
"offset",
"handler",
"set",
"committed",
"offset",
"(",
"topic",
"name",
",",
"2",
",",
"43",
")",
";",
"/",
"/",
"job",
"names",
"for",
"the",
"topologies",
"for",
"writing",
"and",
"consuming",
"the",
"extra",
"records",
"final",
"string",
"consume",
"extra",
"records",
"job",
"name",
"=",
"\"",
"consume",
"extra",
"records",
"job",
"\"",
";",
"final",
"string",
"write",
"extra",
"records",
"job",
"name",
"=",
"\"",
"write",
"extra",
"records",
"job",
"\"",
";",
"/",
"/",
"serialization",
"/",
"deserialization",
"schemas",
"for",
"writing",
"and",
"consuming",
"the",
"extra",
"records",
"final",
"type",
"information",
"<",
"tuple",
"2",
"<",
"integer",
",",
"integer",
">",
">",
"result",
"type",
"=",
"type",
"information",
"of",
"(",
"new",
"type",
"hint",
"<",
"tuple",
"2",
"<",
"integer",
",",
"integer",
">",
">",
"(",
")",
"{",
"}",
")",
";",
"final",
"serialization",
"schema",
"<",
"tuple",
"2",
"<",
"integer",
",",
"integer",
">",
">",
"ser",
"schema",
"=",
"new",
"type",
"information",
"serialization",
"schema",
"<",
">",
"(",
"result",
"type",
",",
"new",
"execution",
"config",
"(",
")",
")",
";",
"final",
"kafka",
"deserialization",
"schema",
"<",
"tuple",
"2",
"<",
"integer",
",",
"integer",
">",
">",
"deser",
"schema",
"=",
"new",
"kafka",
"deserialization",
"schema",
"wrapper",
"<",
">",
"(",
"new",
"type",
"information",
"serialization",
"schema",
"<",
">",
"(",
"result",
"type",
",",
"new",
"execution",
"config",
"(",
")",
")",
")",
";",
"/",
"/",
"setup",
"and",
"run",
"the",
"latest",
"-",
"consuming",
"job",
"final",
"stream",
"execution",
"environment",
"env",
"=",
"stream",
"execution",
"environment",
"get",
"execution",
"environment",
"(",
")",
";",
"env",
"set",
"parallelism",
"(",
"parallelism",
")",
";",
"final",
"properties",
"read",
"props",
"=",
"new",
"properties",
"(",
")",
";",
"read",
"props",
"put",
"all",
"(",
"standard",
"props",
")",
";",
"read",
"props",
"set",
"property",
"(",
"\"",
"auto",
"offset",
"reset",
"\"",
",",
"\"",
"earliest",
"\"",
")",
";",
"/",
"/",
"this",
"should",
"be",
"ignored",
"flink",
"kafka",
"consumer",
"base",
"<",
"tuple",
"2",
"<",
"integer",
",",
"integer",
">",
">",
"latest",
"reading",
"consumer",
"=",
"kafka",
"server",
"get",
"consumer",
"(",
"topic",
"name",
",",
"deser",
"schema",
",",
"read",
"props",
")",
";",
"latest",
"reading",
"consumer",
"set",
"start",
"from",
"latest",
"(",
")",
";",
"env",
"add",
"source",
"(",
"latest",
"reading",
"consumer",
")",
"set",
"parallelism",
"(",
"parallelism",
")",
"flat",
"map",
"(",
"new",
"flat",
"map",
"function",
"<",
"tuple",
"2",
"<",
"integer",
",",
"integer",
">",
",",
"object",
">",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"flat",
"map",
"(",
"tuple",
"2",
"<",
"integer",
",",
"integer",
">",
"value",
",",
"collector",
"<",
"object",
">",
"out",
")",
"throws",
"exception",
"{",
"if",
"(",
"value",
"f",
"1",
"-",
"records",
"in",
"each",
"partition",
"<",
"0",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"test",
"failed",
";",
"consumed",
"a",
"record",
"that",
"was",
"previously",
"written",
":",
"\"",
"+",
"value",
")",
";",
"}",
"}",
"}",
")",
"set",
"parallelism",
"(",
"1",
")",
"add",
"sink",
"(",
"new",
"discarding",
"sink",
"<",
">",
"(",
")",
")",
";",
"job",
"graph",
"job",
"graph",
"=",
"streaming",
"job",
"graph",
"generator",
"create",
"job",
"graph",
"(",
"env",
"get",
"stream",
"graph",
"(",
")",
")",
";",
"final",
"job",
"i",
"d",
"consume",
"job",
"id",
"=",
"job",
"graph",
"get",
"job",
"i",
"d",
"(",
")",
";",
"final",
"atomic",
"reference",
"<",
"throwable",
">",
"error",
"=",
"new",
"atomic",
"reference",
"<",
">",
"(",
")",
";",
"thread",
"consume",
"thread",
"=",
"new",
"thread",
"(",
"(",
")",
"-",
">",
"{",
"try",
"{",
"submit",
"job",
"and",
"wait",
"for",
"result",
"(",
"client",
",",
"job",
"graph",
",",
"get",
"class",
"(",
")",
"get",
"class",
"loader",
"(",
")",
")",
";",
"}",
"catch",
"(",
"throwable",
"t",
")",
"{",
"if",
"(",
"!",
"exception",
"utils",
"find",
"throwable",
"(",
"t",
",",
"job",
"cancellation",
"exception",
"class",
")",
"is",
"present",
"(",
")",
")",
"{",
"error",
"set",
"(",
"t",
")",
";",
"}",
"}",
"}",
")",
";",
"consume",
"thread",
"start",
"(",
")",
";",
"/",
"/",
"wait",
"until",
"the",
"consuming",
"job",
"has",
"started",
",",
"to",
"be",
"extra",
"safe",
"wait",
"until",
"job",
"is",
"running",
"(",
"client",
")",
";",
"/",
"/",
"setup",
"the",
"extra",
"records",
"writing",
"job",
"final",
"stream",
"execution",
"environment",
"env",
"2",
"=",
"stream",
"execution",
"environment",
"get",
"execution",
"environment",
"(",
")",
";",
"env",
"2",
"set",
"parallelism",
"(",
"parallelism",
")",
";",
"data",
"stream",
"<",
"tuple",
"2",
"<",
"integer",
",",
"integer",
">",
">",
"extra",
"records",
"stream",
"=",
"env",
"2",
"add",
"source",
"(",
"new",
"rich",
"parallel",
"source",
"function",
"<",
"tuple",
"2",
"<",
"integer",
",",
"integer",
">",
">",
"(",
")",
"{",
"private",
"boolean",
"running",
"=",
"true",
";",
"@",
"override",
"public",
"void",
"run",
"(",
"source",
"context",
"<",
"tuple",
"2",
"<",
"integer",
",",
"integer",
">",
">",
"ctx",
")",
"throws",
"exception",
"{",
"int",
"count",
"=",
"records",
"in",
"each",
"partition",
";",
"/",
"/",
"the",
"extra",
"records",
"should",
"start",
"/",
"/",
"from",
"the",
"last",
"written",
"value",
"int",
"partition",
"=",
"get",
"runtime",
"context",
"(",
")",
"get",
"index",
"of",
"this",
"subtask",
"(",
")",
";",
"while",
"(",
"running",
"&",
"&",
"count",
"<",
"records",
"in",
"each",
"partition",
"+",
"extra",
"records",
"in",
"each",
"partition",
")",
"{",
"ctx",
"collect",
"(",
"new",
"tuple",
"2",
"<",
">",
"(",
"partition",
",",
"count",
")",
")",
";",
"count",
"+",
"+",
";",
"}",
"}",
"@",
"override",
"public",
"void",
"cancel",
"(",
")",
"{",
"running",
"=",
"false",
";",
"}",
"}",
")",
";",
"kafka",
"server",
"produce",
"into",
"kafka",
"(",
"extra",
"records",
"stream",
",",
"topic",
"name",
",",
"ser",
"schema",
",",
"read",
"props",
",",
"null",
")",
";",
"try",
"{",
"env",
"2",
"execute",
"(",
"write",
"extra",
"records",
"job",
"name",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"writing",
"extra",
"records",
"failed",
"\"",
",",
"e",
")",
";",
"}",
"/",
"/",
"cancel",
"the",
"consume",
"job",
"after",
"all",
"extra",
"records",
"are",
"written",
"client",
"cancel",
"(",
"consume",
"job",
"id",
")",
"get",
"(",
")",
";",
"consume",
"thread",
"join",
"(",
")",
";",
"kafka",
"offset",
"handler",
"close",
"(",
")",
";",
"delete",
"test",
"topic",
"(",
"topic",
"name",
")",
";",
"/",
"/",
"check",
"whether",
"the",
"consuming",
"thread",
"threw",
"any",
"test",
"errors",
";",
"/",
"/",
"test",
"will",
"fail",
"here",
"if",
"the",
"consume",
"job",
"had",
"incorrectly",
"read",
"any",
"records",
"other",
"than",
"the",
"/",
"/",
"extra",
"records",
"final",
"throwable",
"consumer",
"error",
"=",
"error",
"get",
"(",
")",
";",
"if",
"(",
"consumer",
"error",
"!",
"=",
"null",
")",
"{",
"throw",
"new",
"exception",
"(",
"\"",
"exception",
"in",
"the",
"consuming",
"thread",
"\"",
",",
"consumer",
"error",
")",
";",
"}",
"}"
] |
[
"get",
"array",
"enum"
] |
[
"public",
"list",
"<",
"array",
"enum",
"enum",
">",
"get",
"array",
"enum",
"(",
")",
"{",
"return",
"array",
"enum",
";",
"}"
] |
[
"associate",
"the",
"given",
"time",
"zone",
"with",
"the",
"current",
"thread",
",",
"preserving",
"any",
"locale",
"that",
"may",
"have",
"been",
"set",
"already",
"will",
"implicitly",
"create",
"a",
"locale",
"context",
"for",
"the",
"given",
"locale",
",",
"not",
"exposing",
"it",
"as",
"inheritable",
"for",
"child",
"threads"
] |
[
"public",
"static",
"void",
"set",
"time",
"zone",
"(",
"@",
"nullable",
"time",
"zone",
"time",
"zone",
")",
"{",
"set",
"time",
"zone",
"(",
"time",
"zone",
",",
"false",
")",
";",
"}"
] |
[
"this",
"is",
"meant",
"for",
"help",
"files",
"that",
"are",
"not",
"included",
"in",
"the",
"standard",
"help",
"system",
"their",
"id",
"paths",
"are",
"expected",
"to",
"be",
"relative",
"to",
"the",
"application",
"install",
"directory"
] |
[
"private",
"url",
"try",
"to",
"create",
"u",
"r",
"l",
"from",
"i",
"d",
"(",
"string",
"id",
")",
"{",
"url",
"file",
"u",
"r",
"l",
"=",
"create",
"file",
"u",
"r",
"l",
"(",
"id",
")",
";",
"if",
"(",
"file",
"u",
"r",
"l",
"!",
"=",
"null",
")",
"{",
"return",
"file",
"u",
"r",
"l",
";",
"}",
"url",
"raw",
"u",
"r",
"l",
"=",
"create",
"raw",
"u",
"r",
"l",
"(",
"id",
")",
";",
"return",
"raw",
"u",
"r",
"l",
";",
"}"
] |
[
"removes",
"all",
"but",
"the",
"latest",
"{",
"@",
"link",
"header",
"}",
"objects",
"whose",
"{",
"@",
"link",
"header",
"#",
"key",
"(",
")",
"key",
"}",
"matches",
"the",
"specified",
"key"
] |
[
"headers",
"retain",
"latest",
"(",
"string",
"key",
")",
";"
] |
[
"returns",
"the",
"file",
"system",
"for",
"this",
"uri",
"'",
"s",
"scheme",
"and",
"authority",
"the",
"entire",
"uri",
"is",
"passed",
"to",
"the",
"file",
"system",
"instance",
"'",
"s",
"initialize",
"method",
"this",
"always",
"returns",
"a",
"new",
"file",
"system",
"object"
] |
[
"public",
"static",
"file",
"system",
"new",
"instance",
"(",
"uri",
"uri",
",",
"configuration",
"config",
")",
"throws",
"i",
"o",
"exception",
"{",
"string",
"scheme",
"=",
"uri",
"get",
"scheme",
"(",
")",
";",
"string",
"authority",
"=",
"uri",
"get",
"authority",
"(",
")",
";",
"if",
"(",
"scheme",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"no",
"scheme",
":",
"use",
"default",
"fs",
"return",
"new",
"instance",
"(",
"config",
")",
";",
"}",
"if",
"(",
"authority",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"no",
"authority",
"uri",
"default",
"uri",
"=",
"get",
"default",
"uri",
"(",
"config",
")",
";",
"if",
"(",
"scheme",
"equals",
"(",
"default",
"uri",
"get",
"scheme",
"(",
")",
")",
"/",
"/",
"if",
"scheme",
"matches",
"default",
"&",
"&",
"default",
"uri",
"get",
"authority",
"(",
")",
"!",
"=",
"null",
")",
"{",
"/",
"/",
"&",
"default",
"has",
"authority",
"return",
"new",
"instance",
"(",
"default",
"uri",
",",
"config",
")",
";",
"/",
"/",
"return",
"default",
"}",
"}",
"return",
"cache",
"get",
"unique",
"(",
"uri",
",",
"config",
")",
";",
"}"
] |
[
"a",
"3",
"wants",
"itself"
] |
[
"public",
"void",
"recursive",
"(",
")",
"throws",
"exception",
"{",
"aspect",
"a",
"1",
"=",
"create",
"aspect",
"(",
"\"",
"a",
"1",
"\"",
")",
";",
"aspect",
"a",
"2",
"=",
"create",
"aspect",
"(",
"\"",
"a",
"2",
"\"",
")",
";",
"aspect",
"a",
"3",
"=",
"create",
"aspect",
"(",
"\"",
"a",
"3",
"\"",
",",
"\"",
"a",
"3",
"\"",
")",
";",
"aspect",
"collection",
"collection",
"=",
"aspect",
"collection",
"create",
"(",
"immutable",
"list",
"of",
"(",
"a",
"1",
",",
"a",
"2",
",",
"a",
"3",
")",
")",
";",
"validate",
"aspect",
"collection",
"(",
"collection",
",",
"immutable",
"list",
"of",
"(",
"a",
"1",
",",
"a",
"2",
",",
"a",
"3",
")",
",",
"expect",
"deps",
"(",
"a",
"1",
")",
",",
"expect",
"deps",
"(",
"a",
"2",
")",
",",
"expect",
"deps",
"(",
"a",
"3",
")",
")",
";",
"}"
] |
[
"extract",
"treeprops",
"from",
"a",
"scoped",
"{",
"@",
"link",
"component",
"context",
"}",
"and",
"turn",
"them",
"into",
"a",
"single",
"colon",
"-",
"separated",
"string"
] |
[
"public",
"static",
"string",
"get",
"annotation",
"bundle",
"from",
"logger",
"(",
"component",
"context",
"scoped",
"context",
",",
"components",
"logger",
"logger",
")",
"{",
"if",
"(",
"scoped",
"context",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"@",
"nullable",
"final",
"tree",
"props",
"tree",
"props",
"=",
"scoped",
"context",
"get",
"tree",
"props",
"(",
")",
";",
"if",
"(",
"tree",
"props",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"@",
"nullable",
"final",
"map",
"<",
"string",
",",
"string",
">",
"extra",
"annotations",
"=",
"logger",
"get",
"extra",
"annotations",
"(",
"tree",
"props",
")",
";",
"if",
"(",
"extra",
"annotations",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"final",
"string",
"builder",
"sb",
"=",
"new",
"string",
"builder",
"(",
"extra",
"annotations",
"size",
"(",
")",
"*",
"16",
")",
";",
"for",
"(",
"map",
"entry",
"<",
"string",
",",
"string",
">",
"entry",
":",
"extra",
"annotations",
"entry",
"set",
"(",
")",
")",
"{",
"sb",
"append",
"(",
"entry",
"get",
"key",
"(",
")",
")",
";",
"sb",
"append",
"(",
"'",
":",
"'",
")",
";",
"sb",
"append",
"(",
"entry",
"get",
"value",
"(",
")",
")",
";",
"sb",
"append",
"(",
"'",
";",
"'",
")",
";",
"}",
"return",
"sb",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"writes",
"the",
"content",
"of",
"the",
"\"",
"ready",
"\"",
"buffer",
"to",
"the",
"given",
"output",
"stream",
",",
"and",
"resets",
"it",
"does",
"not",
"swap",
"any",
"buffers"
] |
[
"public",
"void",
"flush",
"to",
"(",
"output",
"stream",
"out",
")",
"throws",
"i",
"o",
"exception",
"{",
"buf",
"ready",
"write",
"to",
"(",
"out",
")",
";",
"/",
"/",
"write",
"data",
"to",
"file",
"buf",
"ready",
"reset",
"(",
")",
";",
"/",
"/",
"erase",
"all",
"data",
"in",
"the",
"buffer",
"}"
] |
[
"checks",
"whether",
"a",
"given",
"value",
"is",
"valid",
"for",
"this",
"definition"
] |
[
"public",
"boolean",
"is",
"valid",
"(",
"parameter",
"value",
"value",
")",
"{",
"/",
"/",
"the",
"base",
"implementation",
"just",
"accepts",
"the",
"value",
"return",
"true",
";",
"}"
] |
[
"handle",
"an",
"ioe",
"on",
"a",
"read",
"by",
"attempting",
"to",
"re",
"-",
"open",
"the",
"stream",
"the",
"filesystem",
"'",
"s",
"read",
"exception",
"count",
"will",
"be",
"incremented"
] |
[
"private",
"void",
"on",
"read",
"failure",
"(",
"final",
"i",
"o",
"exception",
"ioe",
",",
"final",
"int",
"length",
")",
"throws",
"i",
"o",
"exception",
"{",
"log",
"debug",
"(",
"\"",
"got",
"exception",
"while",
"trying",
"to",
"read",
"from",
"stream",
"{",
"}",
"\"",
"+",
"\"",
"trying",
"to",
"recover",
":",
"\"",
"+",
"ioe",
",",
"uri",
")",
";",
"int",
"i",
"=",
"1",
";",
"while",
"(",
"true",
")",
"{",
"try",
"{",
"reopen",
"(",
"\"",
"failure",
"recovery",
"\"",
",",
"stream",
"current",
"pos",
",",
"length",
")",
";",
"return",
";",
"}",
"catch",
"(",
"o",
"b",
"s",
"i",
"o",
"exception",
"e",
")",
"{",
"log",
"warn",
"(",
"\"",
"o",
"b",
"s",
"i",
"o",
"exception",
"occurred",
"in",
"reopen",
"for",
"failure",
"recovery",
",",
"\"",
"+",
"\"",
"the",
"{",
"}",
"retry",
"time",
"\"",
",",
"i",
",",
"e",
")",
";",
"if",
"(",
"i",
"=",
"=",
"read",
"retry",
"time",
")",
"{",
"throw",
"e",
";",
"}",
"try",
"{",
"thread",
"sleep",
"(",
"delay",
"time",
")",
";",
"}",
"catch",
"(",
"interrupted",
"exception",
"ie",
")",
"{",
"throw",
"e",
";",
"}",
"}",
"i",
"+",
"+",
";",
"}",
"}"
] |
[
"test",
"case",
"for",
"old",
"namenode",
"where",
"the",
"namenode",
"doesn",
"'",
"t",
"support",
"returning",
"key",
"provider",
"uri"
] |
[
"public",
"void",
"test",
"f",
"s",
"server",
"defaults",
"helper",
"(",
")",
"{",
"hdfs",
"protos",
"fs",
"server",
"defaults",
"proto",
"builder",
"b",
"=",
"hdfs",
"protos",
"fs",
"server",
"defaults",
"proto",
"new",
"builder",
"(",
")",
";",
"b",
"set",
"block",
"size",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"block",
"size",
"default",
")",
";",
"b",
"set",
"bytes",
"per",
"checksum",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"bytes",
"per",
"checksum",
"default",
")",
";",
"b",
"set",
"write",
"packet",
"size",
"(",
"hdfs",
"client",
"config",
"keys",
"dfs",
"client",
"write",
"packet",
"size",
"default",
")",
";",
"b",
"set",
"replication",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"replication",
"default",
")",
";",
"b",
"set",
"file",
"buffer",
"size",
"(",
"d",
"f",
"s",
"config",
"keys",
"io",
"file",
"buffer",
"size",
"default",
")",
";",
"b",
"set",
"encrypt",
"data",
"transfer",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"encrypt",
"data",
"transfer",
"default",
")",
";",
"b",
"set",
"trash",
"interval",
"(",
"d",
"f",
"s",
"config",
"keys",
"fs",
"trash",
"interval",
"default",
")",
";",
"b",
"set",
"checksum",
"type",
"(",
"hdfs",
"protos",
"checksum",
"type",
"proto",
"for",
"number",
"(",
"data",
"checksum",
"type",
"value",
"of",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"checksum",
"type",
"default",
")",
"id",
")",
")",
";",
"hdfs",
"protos",
"fs",
"server",
"defaults",
"proto",
"proto",
"=",
"b",
"build",
"(",
")",
";",
"assert",
"false",
"(",
"\"",
"key",
"provider",
"uri",
"is",
"not",
"supported",
"\"",
",",
"proto",
"has",
"key",
"provider",
"uri",
"(",
")",
")",
";",
"fs",
"server",
"defaults",
"fs",
"server",
"defaults",
"=",
"p",
"b",
"helper",
"client",
"convert",
"(",
"proto",
")",
";",
"assert",
"assert",
"not",
"null",
"(",
"\"",
"fs",
"server",
"defaults",
"is",
"null",
"\"",
",",
"fs",
"server",
"defaults",
")",
";",
"assert",
"assert",
"null",
"(",
"\"",
"key",
"provider",
"uri",
"should",
"be",
"null",
"\"",
",",
"fs",
"server",
"defaults",
"get",
"key",
"provider",
"uri",
"(",
")",
")",
";",
"}"
] |
[
"get",
"the",
"boolean",
"value",
"indicating",
"the",
"state",
"of",
"the",
"option",
"for",
"updating",
"only",
"changed",
"files"
] |
[
"public",
"boolean",
"is",
"enable",
"minimal",
"update",
"(",
")",
"{",
"return",
"enable",
"minimal",
"update",
";",
"}"
] |
[
"throws",
"an",
"exception",
"due",
"to",
"an",
"error",
"in",
"<",
"code",
">",
"federation",
"state",
"store",
"<",
"code",
">"
] |
[
"public",
"static",
"void",
"log",
"and",
"throw",
"exception",
"(",
"logger",
"log",
",",
"string",
"err",
"msg",
",",
"throwable",
"t",
")",
"throws",
"yarn",
"exception",
"{",
"if",
"(",
"t",
"!",
"=",
"null",
")",
"{",
"log",
"error",
"(",
"err",
"msg",
",",
"t",
")",
";",
"throw",
"new",
"yarn",
"exception",
"(",
"err",
"msg",
",",
"t",
")",
";",
"}",
"else",
"{",
"log",
"error",
"(",
"err",
"msg",
")",
";",
"throw",
"new",
"yarn",
"exception",
"(",
"err",
"msg",
")",
";",
"}",
"}"
] |
[
"parse",
"and",
"evaluate",
"a",
"grel",
"expression",
"and",
"compare",
"the",
"result",
"an",
"expected",
"type",
"using",
"instanceof"
] |
[
"protected",
"void",
"parse",
"eval",
"type",
"(",
"properties",
"bindings",
",",
"string",
"test",
",",
"@",
"suppress",
"warnings",
"(",
"\"",
"rawtypes",
"\"",
")",
"class",
"clazz",
")",
"throws",
"parsing",
"exception",
"{",
"evaluable",
"eval",
"=",
"meta",
"parser",
"parse",
"(",
"\"",
"grel",
":",
"\"",
"+",
"test",
")",
";",
"object",
"result",
"=",
"eval",
"evaluate",
"(",
"bindings",
")",
";",
"assert",
"assert",
"true",
"(",
"clazz",
"is",
"instance",
"(",
"result",
")",
",",
"\"",
"wrong",
"result",
"type",
"for",
"expression",
":",
"\"",
"+",
"test",
")",
";",
"}"
] |
[
"<",
"code",
">",
"optional",
"aapt",
"pb",
"value",
"value",
"=",
"2",
";",
"<",
"code",
">"
] |
[
"private",
"void",
"merge",
"value",
"(",
"com",
"android",
"aapt",
"resources",
"value",
"value",
")",
"{",
"if",
"(",
"value",
"!",
"=",
"null",
"&",
"&",
"value",
"!",
"=",
"com",
"android",
"aapt",
"resources",
"value",
"get",
"default",
"instance",
"(",
")",
")",
"{",
"value",
"=",
"com",
"android",
"aapt",
"resources",
"value",
"new",
"builder",
"(",
"value",
")",
"merge",
"from",
"(",
"value",
")",
"build",
"partial",
"(",
")",
";",
"}",
"else",
"{",
"value",
"=",
"value",
";",
"}",
"bit",
"field",
"0",
"|",
"=",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"2",
";",
"}"
] |
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
] |
[
"private",
"string",
"to",
"indented",
"string",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"float",
"'"
] |
[
"public",
"void",
"float",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"float",
"}"
] |
[
"adapt",
"the",
"way",
"ans",
"gets",
"tenant",
"on",
"the",
"cloud"
] |
[
"public",
"static",
"string",
"get",
"user",
"tenant",
"for",
"ans",
"(",
")",
"{",
"string",
"tmp",
"=",
"user",
"tenant",
";",
"if",
"(",
"string",
"utils",
"is",
"blank",
"(",
"user",
"tenant",
")",
")",
"{",
"tmp",
"=",
"system",
"get",
"property",
"(",
"\"",
"ans",
"namespace",
"\"",
")",
";",
"}",
"return",
"tmp",
";",
"}"
] |
[
"tests",
"that",
"a",
"tree",
"prop",
"is",
"propagated",
"down",
"a",
"component",
"tree",
",",
"is",
"scoped",
"correctly",
",",
"and",
"can",
"be",
"overwritten"
] |
[
"public",
"void",
"test",
"tree",
"props",
"propagated",
"(",
")",
"{",
"final",
"tree",
"prop",
"test",
"result",
"prop",
"a",
"leaf",
"1",
"=",
"new",
"tree",
"prop",
"test",
"result",
"(",
")",
";",
"final",
"tree",
"prop",
"test",
"result",
"prop",
"b",
"leaf",
"1",
"=",
"new",
"tree",
"prop",
"test",
"result",
"(",
")",
";",
"final",
"tree",
"prop",
"test",
"result",
"prob",
"b",
"leaf",
"2",
"=",
"new",
"tree",
"prop",
"test",
"result",
"(",
")",
";",
"final",
"tree",
"prop",
"test",
"result",
"prop",
"a",
"mount",
"=",
"new",
"tree",
"prop",
"test",
"result",
"(",
")",
";",
"final",
"tree",
"prop",
"number",
"type",
"tree",
"prop",
"a",
"=",
"new",
"tree",
"prop",
"number",
"type",
"(",
"9",
")",
";",
"final",
"tree",
"prop",
"string",
"type",
"tree",
"prop",
"b",
"=",
"new",
"tree",
"prop",
"string",
"type",
"(",
"\"",
"prop",
"b",
"\"",
")",
";",
"final",
"tree",
"prop",
"string",
"type",
"tree",
"prop",
"b",
"changed",
"=",
"new",
"tree",
"prop",
"string",
"type",
"(",
"\"",
"prop",
"b",
"changed",
"\"",
")",
";",
"component",
"component",
"=",
"tree",
"prop",
"test",
"parent",
"create",
"(",
"m",
"context",
")",
"prop",
"a",
"(",
"tree",
"prop",
"a",
")",
"prop",
"b",
"(",
"tree",
"prop",
"b",
")",
"result",
"prop",
"a",
"leaf",
"1",
"(",
"prop",
"a",
"leaf",
"1",
")",
"result",
"prop",
"b",
"leaf",
"1",
"(",
"prop",
"b",
"leaf",
"1",
")",
"result",
"prop",
"b",
"leaf",
"2",
"(",
"prob",
"b",
"leaf",
"2",
")",
"result",
"prop",
"a",
"mount",
"(",
"prop",
"a",
"mount",
")",
"build",
"(",
")",
";",
"litho",
"view",
"litho",
"view",
"=",
"new",
"litho",
"view",
"(",
"m",
"context",
")",
";",
"litho",
"view",
"set",
"component",
"(",
"component",
")",
";",
"litho",
"view",
"measure",
"(",
"make",
"measure",
"spec",
"(",
"1000",
",",
"exactly",
")",
",",
"make",
"measure",
"spec",
"(",
"0",
",",
"unspecified",
")",
")",
";",
"assert",
"that",
"(",
"prop",
"a",
"leaf",
"1",
"m",
"prop",
")",
"is",
"equal",
"to",
"(",
"tree",
"prop",
"a",
")",
";",
"/",
"/",
"tree",
"prop",
"test",
"middle",
"spec",
"modifies",
"\"",
"prop",
"b",
"\"",
"assert",
"that",
"(",
"prop",
"b",
"leaf",
"1",
"m",
"prop",
")",
"is",
"equal",
"to",
"(",
"tree",
"prop",
"b",
"changed",
")",
";",
"/",
"/",
"the",
"second",
"leaf",
"spec",
"does",
"not",
"see",
"the",
"modification",
"to",
"\"",
"prop",
"b",
"\"",
"/",
"/",
"because",
"its",
"not",
"a",
"descendant",
"of",
"middle",
"spec",
"assert",
"that",
"(",
"prob",
"b",
"leaf",
"2",
"m",
"prop",
")",
"is",
"equal",
"to",
"(",
"tree",
"prop",
"b",
")",
";",
"assert",
"that",
"(",
"prop",
"a",
"mount",
"m",
"prop",
")",
"is",
"equal",
"to",
"(",
"tree",
"prop",
"a",
")",
";",
"}"
] |
[
"helper",
"method",
"for",
"summarizing",
"a",
"list",
"of",
"values",
"this",
"method",
"breaks",
"the",
"rule",
"of",
"\"",
"testing",
"only",
"one",
"thing",
"\"",
"by",
"aggregating",
"and",
"combining",
"a",
"bunch",
"of",
"different",
"ways"
] |
[
"protected",
"string",
"column",
"summary",
"summarize",
"(",
"string",
"values",
")",
"{",
"string",
"value",
"[",
"]",
"string",
"values",
"=",
"new",
"string",
"value",
"[",
"values",
"length",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"values",
"length",
";",
"i",
"+",
"+",
")",
"{",
"if",
"(",
"values",
"[",
"i",
"]",
"!",
"=",
"null",
")",
"{",
"string",
"values",
"[",
"i",
"]",
"=",
"new",
"string",
"value",
"(",
"values",
"[",
"i",
"]",
")",
";",
"}",
"}",
"return",
"new",
"aggregate",
"combine",
"harness",
"<",
"string",
"value",
",",
"string",
"column",
"summary",
",",
"value",
"summary",
"aggregator",
"string",
"value",
"summary",
"aggregator",
">",
"(",
")",
"{",
"@",
"override",
"protected",
"void",
"compare",
"results",
"(",
"string",
"column",
"summary",
"result",
"1",
",",
"string",
"column",
"summary",
"result",
"2",
")",
"{",
"assert",
"assert",
"equals",
"(",
"result",
"1",
"get",
"empty",
"count",
"(",
")",
",",
"result",
"2",
"get",
"empty",
"count",
"(",
")",
")",
";",
"assert",
"assert",
"equals",
"(",
"result",
"1",
"get",
"max",
"length",
"(",
")",
",",
"result",
"2",
"get",
"max",
"length",
"(",
")",
")",
";",
"assert",
"assert",
"equals",
"(",
"result",
"1",
"get",
"min",
"length",
"(",
")",
",",
"result",
"2",
"get",
"min",
"length",
"(",
")",
")",
";",
"if",
"(",
"result",
"1",
"get",
"mean",
"length",
"(",
")",
"=",
"=",
"null",
")",
"{",
"assert",
"assert",
"equals",
"(",
"result",
"1",
"get",
"mean",
"length",
"(",
")",
",",
"result",
"2",
"get",
"mean",
"length",
"(",
")",
")",
";",
"}",
"else",
"{",
"assert",
"assert",
"equals",
"(",
"result",
"1",
"get",
"mean",
"length",
"(",
")",
"double",
"value",
"(",
")",
",",
"result",
"2",
"get",
"mean",
"length",
"(",
")",
"double",
"value",
"(",
")",
",",
"1e",
"-",
"5d",
")",
";",
"}",
"assert",
"assert",
"equals",
"(",
"result",
"1",
"get",
"null",
"count",
"(",
")",
",",
"result",
"2",
"get",
"null",
"count",
"(",
")",
")",
";",
"assert",
"assert",
"equals",
"(",
"result",
"1",
"get",
"non",
"null",
"count",
"(",
")",
",",
"result",
"2",
"get",
"non",
"null",
"count",
"(",
")",
")",
";",
"}",
"}",
"summarize",
"(",
"string",
"values",
")",
";",
"}"
] |
[
"if",
"the",
"given",
"attribute",
"type",
"is",
"non",
"-",
"configurable",
",",
"returns",
"the",
"reason",
"why",
"otherwise",
",",
"returns",
"{",
"@",
"code",
"null",
"}"
] |
[
"public",
"static",
"string",
"maybe",
"get",
"non",
"configurable",
"reason",
"(",
"type",
"<",
"?",
">",
"type",
")",
"{",
"return",
"why",
"not",
"configurable",
"get",
"(",
"type",
")",
";",
"}"
] |
[
"writes",
"ints",
"from",
"the",
"given",
"int",
"array",
"to",
"the",
"current",
"position",
"and",
"increases",
"the",
"position",
"by",
"the",
"number",
"of",
"ints",
"written",
"calling",
"this",
"method",
"has",
"the",
"same",
"effect",
"as",
"{",
"@",
"code",
"put",
"(",
"src",
",",
"0",
",",
"src",
"length",
")",
"}"
] |
[
"public",
"final",
"int",
"buffer",
"put",
"(",
"int",
"[",
"]",
"src",
")",
"{",
"return",
"put",
"(",
"src",
",",
"0",
",",
"src",
"length",
")",
";",
"}"
] |
[
"ensures",
"that",
"all",
"indices",
"are",
"compatible",
"with",
"the",
"given",
"node",
"version",
"this",
"will",
"ensure",
"that",
"all",
"indices",
"in",
"the",
"given",
"metadata",
"will",
"not",
"be",
"created",
"with",
"a",
"newer",
"version",
"of",
"elasticsearch",
"as",
"well",
"as",
"that",
"all",
"indices",
"are",
"newer",
"or",
"equal",
"to",
"the",
"minimum",
"index",
"compatibility",
"version"
] |
[
"public",
"static",
"void",
"ensure",
"index",
"compatibility",
"(",
"final",
"version",
"node",
"version",
",",
"metadata",
"metadata",
")",
"{",
"version",
"supported",
"index",
"version",
"=",
"node",
"version",
"minimum",
"index",
"compatibility",
"version",
"(",
")",
";",
"/",
"/",
"we",
"ensure",
"that",
"all",
"indices",
"in",
"the",
"cluster",
"we",
"join",
"are",
"compatible",
"with",
"us",
"no",
"matter",
"if",
"they",
"are",
"/",
"/",
"closed",
"or",
"not",
"we",
"can",
"'",
"t",
"read",
"mappings",
"of",
"these",
"indices",
"so",
"we",
"need",
"to",
"reject",
"the",
"join",
"for",
"(",
"index",
"metadata",
"idx",
"metadata",
":",
"metadata",
")",
"{",
"if",
"(",
"idx",
"metadata",
"get",
"creation",
"version",
"(",
")",
"after",
"(",
"node",
"version",
")",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"index",
"\"",
"+",
"idx",
"metadata",
"get",
"index",
"(",
")",
"+",
"\"",
"version",
"not",
"supported",
":",
"\"",
"+",
"idx",
"metadata",
"get",
"creation",
"version",
"(",
")",
"+",
"\"",
"the",
"node",
"version",
"is",
":",
"\"",
"+",
"node",
"version",
")",
";",
"}",
"if",
"(",
"idx",
"metadata",
"get",
"creation",
"version",
"(",
")",
"before",
"(",
"supported",
"index",
"version",
")",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"index",
"\"",
"+",
"idx",
"metadata",
"get",
"index",
"(",
")",
"+",
"\"",
"version",
"not",
"supported",
":",
"\"",
"+",
"idx",
"metadata",
"get",
"creation",
"version",
"(",
")",
"+",
"\"",
"minimum",
"compatible",
"index",
"version",
"is",
":",
"\"",
"+",
"supported",
"index",
"version",
")",
";",
"}",
"}",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}",
"the",
"default",
"implementation",
"does",
"nothing"
] |
[
"@",
"override",
"public",
"void",
"exit",
"param",
"literal",
"(",
"sql",
"base",
"parser",
"param",
"literal",
"context",
"ctx",
")",
"{",
"}"
] |
[
"removes",
"the",
"value",
"of",
"the",
"hystrix",
"request",
"variable",
"from",
"the",
"current",
"request",
"this",
"will",
"invoke",
"{",
"@",
"link",
"#",
"shutdown",
"}",
"if",
"implemented",
"if",
"the",
"value",
"is",
"subsequently",
"fetched",
"in",
"the",
"thread",
",",
"the",
"{",
"@",
"link",
"#",
"initial",
"value",
"}",
"method",
"will",
"be",
"called",
"again"
] |
[
"public",
"void",
"remove",
"(",
")",
"{",
"if",
"(",
"hystrix",
"request",
"context",
"get",
"context",
"for",
"current",
"thread",
"(",
")",
"!",
"=",
"null",
")",
"{",
"remove",
"(",
"hystrix",
"request",
"context",
"get",
"context",
"for",
"current",
"thread",
"(",
")",
",",
"this",
")",
";",
"}",
"}"
] |
[
"calculates",
"the",
"delay",
"for",
"the",
"next",
"trigger",
"time",
"when",
"<",
"code",
">",
"now",
"<",
"code",
">",
"is",
"in",
"a",
"valid",
"time",
"bracket",
"with",
"respect",
"to",
"<",
"code",
">",
"expiration",
"date",
"<",
"code",
">",
",",
"the",
"delay",
"is",
"0",
"when",
"<",
"code",
">",
"now",
"<",
"code",
">",
"is",
"before",
"the",
"time",
"bracket",
",",
"than",
"delay",
"to",
"the",
"start",
"of",
"the",
"time",
"bracket",
"and",
"when",
"<",
"code",
">",
"now",
"<",
"code",
">",
"is",
"passed",
"the",
"valid",
"time",
"bracket",
",",
"the",
"delay",
"is",
"<",
"code",
">",
"null",
"<",
"code",
">"
] |
[
"final",
"time",
"value",
"delay",
"(",
"long",
"expiration",
"date",
",",
"long",
"now",
")",
"{",
"final",
"time",
"value",
"delay",
";",
"switch",
"(",
"orientation",
")",
"{",
"case",
"pre",
":",
"if",
"(",
"expiration",
"date",
">",
"=",
"now",
")",
"{",
"/",
"/",
"license",
"not",
"yet",
"expired",
"long",
"pre",
"expiry",
"duration",
"=",
"expiration",
"date",
"-",
"now",
";",
"if",
"(",
"pre",
"expiry",
"duration",
">",
"max",
")",
"{",
"/",
"/",
"license",
"duration",
"is",
"longer",
"than",
"maximum",
"duration",
",",
"delay",
"it",
"to",
"the",
"first",
"match",
"time",
"delay",
"=",
"time",
"value",
"time",
"value",
"millis",
"(",
"pre",
"expiry",
"duration",
"-",
"max",
")",
";",
"}",
"else",
"if",
"(",
"pre",
"expiry",
"duration",
"<",
"=",
"max",
"&",
"&",
"pre",
"expiry",
"duration",
">",
"=",
"min",
")",
"{",
"/",
"/",
"no",
"delay",
"in",
"valid",
"time",
"bracket",
"delay",
"=",
"time",
"value",
"time",
"value",
"millis",
"(",
"0",
")",
";",
"}",
"else",
"{",
"/",
"/",
"passed",
"last",
"match",
"time",
"delay",
"=",
"null",
";",
"}",
"}",
"else",
"{",
"/",
"/",
"invalid",
"after",
"license",
"expiry",
"delay",
"=",
"null",
";",
"}",
"break",
";",
"case",
"post",
":",
"if",
"(",
"expiration",
"date",
">",
"=",
"now",
")",
"{",
"/",
"/",
"license",
"not",
"yet",
"expired",
",",
"delay",
"it",
"to",
"the",
"first",
"match",
"time",
"delay",
"=",
"time",
"value",
"time",
"value",
"millis",
"(",
"expiration",
"date",
"-",
"now",
"+",
"min",
")",
";",
"}",
"else",
"{",
"/",
"/",
"license",
"has",
"expired",
"long",
"expired",
"duration",
"=",
"now",
"-",
"expiration",
"date",
";",
"if",
"(",
"expired",
"duration",
"<",
"min",
")",
"{",
"/",
"/",
"license",
"expiry",
"duration",
"is",
"shorter",
"than",
"minimum",
"duration",
",",
"delay",
"it",
"to",
"the",
"first",
"match",
"time",
"delay",
"=",
"time",
"value",
"time",
"value",
"millis",
"(",
"min",
"-",
"expired",
"duration",
")",
";",
"}",
"else",
"if",
"(",
"expired",
"duration",
">",
"=",
"min",
"&",
"&",
"expired",
"duration",
"<",
"=",
"max",
")",
"{",
"/",
"/",
"no",
"delay",
"in",
"valid",
"time",
"bracket",
"delay",
"=",
"time",
"value",
"time",
"value",
"millis",
"(",
"0",
")",
";",
"}",
"else",
"{",
"/",
"/",
"passed",
"last",
"match",
"time",
"delay",
"=",
"null",
";",
"}",
"}",
"break",
";",
"default",
":",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"orientation",
"[",
"\"",
"+",
"orientation",
"+",
"\"",
"]",
"unknown",
"\"",
")",
";",
"}",
"return",
"delay",
";",
"}"
] |
[
"get",
"all",
"zookeeper",
"urls",
"(",
"such",
"as",
":",
"zookeeper",
":",
"127",
"0",
"0",
"1",
":",
"2181",
"?",
"127",
"0",
"0",
"1",
":",
"8989",
",",
"127",
"0",
"0",
"1",
":",
"9999",
")"
] |
[
"list",
"<",
"string",
">",
"get",
"u",
"r",
"l",
"backup",
"address",
"(",
"url",
"url",
")",
"{",
"list",
"<",
"string",
">",
"address",
"list",
"=",
"new",
"array",
"list",
"<",
"string",
">",
"(",
")",
";",
"address",
"list",
"add",
"(",
"url",
"get",
"address",
"(",
")",
")",
";",
"address",
"list",
"add",
"all",
"(",
"url",
"get",
"parameter",
"(",
"remoting",
"constants",
"backup",
"key",
",",
"collections",
"empty",
"list",
")",
")",
";",
"string",
"auth",
"prefix",
"=",
"null",
";",
"if",
"(",
"string",
"utils",
"is",
"not",
"empty",
"(",
"url",
"get",
"username",
"(",
")",
")",
")",
"{",
"string",
"builder",
"buf",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"buf",
"append",
"(",
"url",
"get",
"username",
"(",
")",
")",
";",
"if",
"(",
"string",
"utils",
"is",
"not",
"empty",
"(",
"url",
"get",
"password",
"(",
")",
")",
")",
"{",
"buf",
"append",
"(",
"\"",
":",
"\"",
")",
";",
"buf",
"append",
"(",
"url",
"get",
"password",
"(",
")",
")",
";",
"}",
"buf",
"append",
"(",
"\"",
"@",
"\"",
")",
";",
"auth",
"prefix",
"=",
"buf",
"to",
"string",
"(",
")",
";",
"}",
"if",
"(",
"string",
"utils",
"is",
"not",
"empty",
"(",
"auth",
"prefix",
")",
")",
"{",
"list",
"<",
"string",
">",
"authed",
"address",
"list",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"address",
"list",
"size",
"(",
")",
")",
";",
"for",
"(",
"string",
"addr",
":",
"address",
"list",
")",
"{",
"authed",
"address",
"list",
"add",
"(",
"auth",
"prefix",
"+",
"addr",
")",
";",
"}",
"return",
"authed",
"address",
"list",
";",
"}",
"return",
"address",
"list",
";",
"}"
] |
[
"convert",
"bytes",
"to",
"string",
",",
"taking",
"into",
"account",
"{",
"@",
"link",
"#",
"printable",
"characters",
"}"
] |
[
"protected",
"string",
"convert",
"bytes",
"to",
"string",
"(",
"final",
"byte",
"[",
"]",
"random",
")",
"{",
"val",
"output",
"=",
"new",
"char",
"[",
"random",
"length",
"]",
";",
"int",
"stream",
"range",
"(",
"0",
",",
"random",
"length",
")",
"for",
"each",
"(",
"i",
"-",
">",
"{",
"val",
"printable",
"characters",
"=",
"get",
"printable",
"characters",
"(",
")",
";",
"val",
"index",
"=",
"math",
"abs",
"(",
"random",
"[",
"i",
"]",
"%",
"printable",
"characters",
"length",
")",
";",
"output",
"[",
"i",
"]",
"=",
"printable",
"characters",
"[",
"index",
"]",
";",
"}",
")",
";",
"return",
"new",
"string",
"(",
"output",
")",
";",
"}"
] |
[
"creates",
"a",
"mutable",
",",
"empty",
"{",
"@",
"code",
"linked",
"hash",
"set",
"}",
"instance"
] |
[
"public",
"static",
"<",
"e",
">",
"linked",
"hash",
"set",
"<",
"e",
">",
"new",
"linked",
"hash",
"set",
"(",
")",
"{",
"return",
"new",
"linked",
"hash",
"set",
"<",
"e",
">",
"(",
")",
";",
"}"
] |
[
"get",
"int",
"6",
"4"
] |
[
"public",
"long",
"get",
"int",
"6",
"4",
"(",
")",
"{",
"return",
"int",
"6",
"4",
";",
"}"
] |
[
"confirm",
"that",
"we",
"account",
"for",
"discarded",
"data",
"frames",
"it",
"'",
"s",
"possible",
"that",
"data",
"frames",
"are",
"in",
"-",
"flight",
"just",
"prior",
"to",
"us",
"canceling",
"a",
"stream"
] |
[
"@",
"test",
"public",
"void",
"discarded",
"data",
"frames",
"are",
"counted",
"(",
")",
"throws",
"exception",
"{",
"/",
"/",
"write",
"the",
"mocking",
"script",
"peer",
"send",
"frame",
"(",
")",
"settings",
"(",
"new",
"settings",
"(",
")",
")",
";",
"peer",
"accept",
"frame",
"(",
")",
";",
"/",
"/",
"ack",
"peer",
"accept",
"frame",
"(",
")",
";",
"/",
"/",
"syn",
"stream",
"3",
"peer",
"send",
"frame",
"(",
")",
"headers",
"(",
"false",
",",
"3",
",",
"header",
"entries",
"(",
"\"",
"a",
"\"",
",",
"\"",
"apple",
"\"",
")",
")",
";",
"peer",
"send",
"frame",
"(",
")",
"data",
"(",
"false",
",",
"3",
",",
"data",
"(",
"1024",
")",
",",
"1024",
")",
";",
"peer",
"accept",
"frame",
"(",
")",
";",
"/",
"/",
"rst",
"stream",
"peer",
"send",
"frame",
"(",
")",
"data",
"(",
"true",
",",
"3",
",",
"data",
"(",
"1024",
")",
",",
"1024",
")",
";",
"peer",
"accept",
"frame",
"(",
")",
";",
"/",
"/",
"rst",
"stream",
"peer",
"play",
"(",
")",
";",
"http",
"2",
"connection",
"connection",
"=",
"connect",
"(",
"peer",
")",
";",
"http",
"2",
"stream",
"stream",
"1",
"=",
"connection",
"new",
"stream",
"(",
"header",
"entries",
"(",
"\"",
"b",
"\"",
",",
"\"",
"bark",
"\"",
")",
",",
"false",
")",
";",
"source",
"source",
"=",
"stream",
"1",
"get",
"source",
"(",
")",
";",
"buffer",
"buffer",
"=",
"new",
"buffer",
"(",
")",
";",
"while",
"(",
"buffer",
"size",
"(",
")",
"!",
"=",
"1024",
")",
"source",
"read",
"(",
"buffer",
",",
"1024",
")",
";",
"stream",
"1",
"close",
"(",
"error",
"code",
"cancel",
",",
"null",
")",
";",
"in",
"frame",
"frame",
"1",
"=",
"peer",
"take",
"frame",
"(",
")",
";",
"assert",
"that",
"(",
"frame",
"1",
"type",
")",
"is",
"equal",
"to",
"(",
"http",
"2",
"type",
"headers",
")",
";",
"in",
"frame",
"frame",
"2",
"=",
"peer",
"take",
"frame",
"(",
")",
";",
"assert",
"that",
"(",
"frame",
"2",
"type",
")",
"is",
"equal",
"to",
"(",
"http",
"2",
"type",
"rst",
"stream",
")",
";",
"in",
"frame",
"frame",
"3",
"=",
"peer",
"take",
"frame",
"(",
")",
";",
"assert",
"that",
"(",
"frame",
"3",
"type",
")",
"is",
"equal",
"to",
"(",
"http",
"2",
"type",
"rst",
"stream",
")",
";",
"assert",
"that",
"(",
"connection",
"get",
"read",
"bytes",
"acknowledged",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"0l",
")",
";",
"assert",
"that",
"(",
"connection",
"get",
"read",
"bytes",
"total",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"2048l",
")",
";",
"}"
] |
[
"returns",
"true",
"if",
"the",
"candidate",
"invocation",
"has",
"the",
"same",
"method",
"(",
"method",
"name",
"and",
"parameter",
"types",
")"
] |
[
"boolean",
"has",
"same",
"method",
"(",
"invocation",
"candidate",
")",
";"
] |
[
"get",
"the",
"current",
"key",
"version",
"name",
"for",
"the",
"given",
"ez",
"this",
"will",
"first",
"drain",
"the",
"provider",
"'",
"s",
"local",
"cache",
",",
"then",
"generate",
"a",
"new",
"edek",
"the",
"encryption",
"key",
"version",
"of",
"the",
"newly",
"generated",
"edek",
"will",
"be",
"used",
"as",
"the",
"target",
"key",
"version",
"of",
"this",
"re",
"-",
"encryption",
"-",
"meaning",
"all",
"edeks",
"'",
"key",
"version",
"are",
"compared",
"with",
"it",
",",
"and",
"only",
"sent",
"to",
"the",
"kms",
"for",
"re",
"-",
"encryption",
"when",
"the",
"version",
"is",
"different",
"note",
":",
"key",
"provider",
"has",
"a",
"get",
"current",
"key",
"interface",
",",
"but",
"that",
"is",
"under",
"a",
"different",
"acl",
"hdfs",
"should",
"not",
"try",
"to",
"operate",
"on",
"additional",
"a",
"c",
"ls",
",",
"but",
"rather",
"use",
"the",
"generate",
"acl",
"it",
"already",
"has"
] |
[
"static",
"string",
"get",
"current",
"key",
"version",
"(",
"final",
"f",
"s",
"directory",
"dir",
",",
"final",
"f",
"s",
"permission",
"checker",
"pc",
",",
"final",
"string",
"zone",
")",
"throws",
"i",
"o",
"exception",
"{",
"assert",
"dir",
"get",
"provider",
"(",
")",
"!",
"=",
"null",
";",
"assert",
"!",
"dir",
"has",
"read",
"lock",
"(",
")",
";",
"final",
"string",
"key",
"name",
"=",
"f",
"s",
"dir",
"encryption",
"zone",
"op",
"get",
"key",
"name",
"for",
"zone",
"(",
"dir",
",",
"pc",
",",
"zone",
")",
";",
"if",
"(",
"key",
"name",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"zone",
"+",
"\"",
"is",
"not",
"an",
"encryption",
"zone",
"\"",
")",
";",
"}",
"/",
"/",
"drain",
"the",
"local",
"cache",
"of",
"the",
"key",
"provider",
"/",
"/",
"do",
"not",
"invalidate",
"cache",
"on",
"the",
"server",
",",
"since",
"that",
"'",
"s",
"the",
"responsibility",
"/",
"/",
"when",
"rolling",
"the",
"key",
"version",
"dir",
"get",
"provider",
"(",
")",
"drain",
"(",
"key",
"name",
")",
";",
"final",
"encrypted",
"key",
"version",
"edek",
";",
"try",
"{",
"edek",
"=",
"dir",
"get",
"provider",
"(",
")",
"generate",
"encrypted",
"key",
"(",
"key",
"name",
")",
";",
"}",
"catch",
"(",
"general",
"security",
"exception",
"gse",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"gse",
")",
";",
"}",
"preconditions",
"check",
"not",
"null",
"(",
"edek",
")",
";",
"return",
"edek",
"get",
"encryption",
"key",
"version",
"name",
"(",
")",
";",
"}"
] |
[
"the",
"analysis",
"field"
] |
[
"public",
"string",
"get",
"field",
"name",
"(",
")",
"{",
"return",
"field",
"name",
";",
"}"
] |
[
"gets",
"the",
"minor",
"version"
] |
[
"public",
"int",
"get",
"minor",
"(",
")",
"{",
"return",
"minor",
";",
"}"
] |
[
"reads",
"up",
"to",
"<",
"code",
">",
"b",
"length",
"<",
"code",
">",
"bytes",
"of",
"data",
"from",
"this",
"file",
"into",
"an",
"array",
"of",
"bytes",
"this",
"method",
"blocks",
"until",
"at",
"least",
"one",
"byte",
"of",
"input",
"is",
"available"
] |
[
"public",
"int",
"read",
"(",
"byte",
"[",
"]",
"b",
")",
"throws",
"i",
"o",
"exception",
"{",
"check",
"open",
"(",
")",
";",
"return",
"read",
"(",
"b",
",",
"0",
",",
"b",
"length",
")",
";",
"}"
] |
[
"write",
"2",
"byte",
"fixed",
"length",
"integer",
"to",
"byte",
"buffers"
] |
[
"public",
"void",
"write",
"int",
"2",
"(",
"final",
"int",
"value",
")",
"{",
"byte",
"buf",
"write",
"short",
"(",
"value",
")",
";",
"}"
] |
[
"handle",
"the",
"given",
"exception",
"a",
"completion",
"signal",
"through",
"the",
"return",
"value",
"indicates",
"error",
"handling",
"is",
"complete",
"while",
"an",
"error",
"signal",
"indicates",
"the",
"exception",
"is",
"still",
"not",
"handled"
] |
[
"mono",
"<",
"void",
">",
"handle",
"(",
"server",
"web",
"exchange",
"exchange",
",",
"throwable",
"ex",
")",
";"
] |
[
"returns",
"the",
"u",
"r",
"ls",
"in",
"the",
"class",
"path"
] |
[
"static",
"url",
"[",
"]",
"get",
"class",
"path",
"urls",
"(",
")",
"{",
"return",
"class",
"path",
"util",
"class",
"get",
"class",
"loader",
"(",
")",
"instanceof",
"u",
"r",
"l",
"class",
"loader",
"?",
"(",
"(",
"u",
"r",
"l",
"class",
"loader",
")",
"class",
"path",
"util",
"class",
"get",
"class",
"loader",
"(",
")",
")",
"get",
"u",
"r",
"ls",
"(",
")",
":",
"parse",
"java",
"class",
"path",
"(",
")",
";",
"}"
] |
[
"parses",
"the",
"provided",
"job",
"history",
"file",
"name",
"to",
"construct",
"a",
"job",
"index",
"info",
"object",
"which",
"is",
"returned"
] |
[
"public",
"static",
"job",
"index",
"info",
"get",
"index",
"info",
"(",
"string",
"jh",
"file",
"name",
")",
"throws",
"i",
"o",
"exception",
"{",
"string",
"file",
"name",
"=",
"jh",
"file",
"name",
"substring",
"(",
"0",
",",
"jh",
"file",
"name",
"index",
"of",
"(",
"job",
"history",
"utils",
"job",
"history",
"file",
"extension",
")",
")",
";",
"job",
"index",
"info",
"index",
"info",
"=",
"new",
"job",
"index",
"info",
"(",
")",
";",
"string",
"[",
"]",
"job",
"details",
"=",
"file",
"name",
"split",
"(",
"delimiter",
")",
";",
"job",
"i",
"d",
"old",
"job",
"id",
"=",
"job",
"i",
"d",
"for",
"name",
"(",
"decode",
"job",
"history",
"file",
"name",
"(",
"job",
"details",
"[",
"job",
"id",
"index",
"]",
")",
")",
";",
"job",
"id",
"job",
"id",
"=",
"type",
"converter",
"to",
"yarn",
"(",
"old",
"job",
"id",
")",
";",
"index",
"info",
"set",
"job",
"id",
"(",
"job",
"id",
")",
";",
"/",
"/",
"do",
"not",
"fail",
"if",
"there",
"are",
"some",
"minor",
"parse",
"errors",
"try",
"{",
"try",
"{",
"index",
"info",
"set",
"submit",
"time",
"(",
"long",
"parse",
"long",
"(",
"decode",
"job",
"history",
"file",
"name",
"(",
"job",
"details",
"[",
"submit",
"time",
"index",
"]",
")",
")",
")",
";",
"}",
"catch",
"(",
"number",
"format",
"exception",
"e",
")",
"{",
"log",
"warn",
"(",
"\"",
"unable",
"to",
"parse",
"submit",
"time",
"from",
"job",
"history",
"file",
"\"",
"+",
"jh",
"file",
"name",
"+",
"\"",
":",
"\"",
"+",
"e",
")",
";",
"}",
"index",
"info",
"set",
"user",
"(",
"decode",
"job",
"history",
"file",
"name",
"(",
"job",
"details",
"[",
"user",
"index",
"]",
")",
")",
";",
"index",
"info",
"set",
"job",
"name",
"(",
"decode",
"job",
"history",
"file",
"name",
"(",
"job",
"details",
"[",
"job",
"name",
"index",
"]",
")",
")",
";",
"try",
"{",
"index",
"info",
"set",
"finish",
"time",
"(",
"long",
"parse",
"long",
"(",
"decode",
"job",
"history",
"file",
"name",
"(",
"job",
"details",
"[",
"finish",
"time",
"index",
"]",
")",
")",
")",
";",
"}",
"catch",
"(",
"number",
"format",
"exception",
"e",
")",
"{",
"log",
"warn",
"(",
"\"",
"unable",
"to",
"parse",
"finish",
"time",
"from",
"job",
"history",
"file",
"\"",
"+",
"jh",
"file",
"name",
"+",
"\"",
":",
"\"",
"+",
"e",
")",
";",
"}",
"try",
"{",
"index",
"info",
"set",
"num",
"maps",
"(",
"integer",
"parse",
"int",
"(",
"decode",
"job",
"history",
"file",
"name",
"(",
"job",
"details",
"[",
"num",
"maps",
"index",
"]",
")",
")",
")",
";",
"}",
"catch",
"(",
"number",
"format",
"exception",
"e",
")",
"{",
"log",
"warn",
"(",
"\"",
"unable",
"to",
"parse",
"num",
"maps",
"from",
"job",
"history",
"file",
"\"",
"+",
"jh",
"file",
"name",
"+",
"\"",
":",
"\"",
"+",
"e",
")",
";",
"}",
"try",
"{",
"index",
"info",
"set",
"num",
"reduces",
"(",
"integer",
"parse",
"int",
"(",
"decode",
"job",
"history",
"file",
"name",
"(",
"job",
"details",
"[",
"num",
"reduces",
"index",
"]",
")",
")",
")",
";",
"}",
"catch",
"(",
"number",
"format",
"exception",
"e",
")",
"{",
"log",
"warn",
"(",
"\"",
"unable",
"to",
"parse",
"num",
"reduces",
"from",
"job",
"history",
"file",
"\"",
"+",
"jh",
"file",
"name",
"+",
"\"",
":",
"\"",
"+",
"e",
")",
";",
"}",
"index",
"info",
"set",
"job",
"status",
"(",
"decode",
"job",
"history",
"file",
"name",
"(",
"job",
"details",
"[",
"job",
"status",
"index",
"]",
")",
")",
";",
"index",
"info",
"set",
"queue",
"name",
"(",
"decode",
"job",
"history",
"file",
"name",
"(",
"job",
"details",
"[",
"queue",
"name",
"index",
"]",
")",
")",
";",
"try",
"{",
"if",
"(",
"job",
"details",
"length",
"<",
"=",
"job",
"start",
"time",
"index",
")",
"{",
"index",
"info",
"set",
"job",
"start",
"time",
"(",
"index",
"info",
"get",
"submit",
"time",
"(",
")",
")",
";",
"}",
"else",
"{",
"index",
"info",
"set",
"job",
"start",
"time",
"(",
"long",
"parse",
"long",
"(",
"decode",
"job",
"history",
"file",
"name",
"(",
"job",
"details",
"[",
"job",
"start",
"time",
"index",
"]",
")",
")",
")",
";",
"}",
"}",
"catch",
"(",
"number",
"format",
"exception",
"e",
")",
"{",
"log",
"warn",
"(",
"\"",
"unable",
"to",
"parse",
"start",
"time",
"from",
"job",
"history",
"file",
"\"",
"+",
"jh",
"file",
"name",
"+",
"\"",
":",
"\"",
"+",
"e",
")",
";",
"}",
"}",
"catch",
"(",
"index",
"out",
"of",
"bounds",
"exception",
"e",
")",
"{",
"log",
"warn",
"(",
"\"",
"parsing",
"job",
"history",
"file",
"with",
"partial",
"data",
"encoded",
"into",
"name",
":",
"\"",
"+",
"jh",
"file",
"name",
")",
";",
"}",
"return",
"index",
"info",
";",
"}"
] |
[
"initializes",
"the",
"<",
"code",
">",
"servlet",
"context",
"listener",
"<",
"code",
">",
"which",
"initializes",
"the",
"server"
] |
[
"public",
"void",
"context",
"initialized",
"(",
"servlet",
"context",
"event",
"event",
")",
"{",
"try",
"{",
"init",
"(",
")",
";",
"}",
"catch",
"(",
"server",
"exception",
"ex",
")",
"{",
"event",
"get",
"servlet",
"context",
"(",
")",
"log",
"(",
"\"",
"error",
":",
"\"",
"+",
"ex",
"get",
"message",
"(",
")",
")",
";",
"throw",
"new",
"runtime",
"exception",
"(",
"ex",
")",
";",
"}",
"}"
] |
[
"gets",
"data",
"id"
] |
[
"public",
"string",
"get",
"data",
"id",
"(",
")",
"{",
"return",
"data",
"id",
";",
"}"
] |
[
"method",
"implements",
"a",
"heuristic",
"used",
"to",
"set",
"default",
"value",
"of",
"the",
"-",
"-",
"instrumentation",
"filter",
"option",
"the",
"following",
"algorithm",
"is",
"used",
":",
"identify",
"all",
"test",
"targets",
"on",
"the",
"command",
"line",
"expand",
"all",
"test",
"suites",
"into",
"the",
"individual",
"test",
"targets",
"calculate",
"list",
"of",
"package",
"names",
"containing",
"all",
"test",
"targets",
"above",
"replace",
"all",
"\"",
"javatests",
"\"",
"directories",
"in",
"packages",
"with",
"\"",
"java",
"\"",
"similarly",
",",
"replace",
"\"",
"testjava",
"\"",
"with",
"\"",
"mainjava",
"\"",
"also",
",",
"strip",
"trailing",
"\"",
"internal",
"\"",
",",
"\"",
"public",
"\"",
",",
"and",
"\"",
"tests",
"\"",
"from",
"packages",
"(",
"see",
"{",
"@",
"link",
"#",
"get",
"instrumented",
"prefix",
"}",
")",
"set",
"-",
"-",
"instrumentation",
"filter",
"default",
"value",
"to",
"instrument",
"everything",
"in",
"those",
"packages"
] |
[
"public",
"static",
"string",
"compute",
"instrumentation",
"filter",
"(",
"event",
"handler",
"event",
"handler",
",",
"collection",
"<",
"target",
">",
"test",
"targets",
")",
"{",
"sorted",
"set",
"<",
"string",
">",
"package",
"filters",
"=",
"sets",
"new",
"tree",
"set",
"(",
")",
";",
"collect",
"instrumented",
"packages",
"(",
"test",
"targets",
",",
"package",
"filters",
")",
";",
"optimize",
"filter",
"set",
"(",
"package",
"filters",
")",
";",
"string",
"instrumentation",
"filter",
"=",
"joiner",
"on",
"(",
"\"",
"[",
"/",
":",
"]",
",",
"^",
"/",
"/",
"\"",
")",
"append",
"to",
"(",
"new",
"string",
"builder",
"(",
"\"",
"^",
"/",
"/",
"\"",
")",
",",
"package",
"filters",
")",
"append",
"(",
"\"",
"[",
"/",
":",
"]",
"\"",
")",
"to",
"string",
"(",
")",
";",
"/",
"/",
"fix",
"up",
"if",
"one",
"of",
"the",
"test",
"targets",
"is",
"a",
"top",
"-",
"level",
"target",
"\"",
"/",
"/",
"foo",
"[",
"/",
":",
"]",
"\"",
"matches",
"everything",
"/",
"/",
"under",
"/",
"/",
"foo",
"and",
"subpackages",
",",
"but",
"\"",
"/",
"/",
"[",
"/",
":",
"]",
"\"",
"only",
"matches",
"targets",
"directly",
"under",
"the",
"top",
"-",
"level",
"/",
"/",
"package",
"if",
"(",
"instrumentation",
"filter",
"equals",
"(",
"\"",
"^",
"/",
"/",
"[",
"/",
":",
"]",
"\"",
")",
")",
"{",
"instrumentation",
"filter",
"=",
"\"",
"^",
"/",
"/",
"\"",
";",
"}",
"if",
"(",
"!",
"package",
"filters",
"is",
"empty",
"(",
")",
")",
"{",
"event",
"handler",
"handle",
"(",
"event",
"info",
"(",
"\"",
"using",
"default",
"value",
"for",
"-",
"-",
"instrumentation",
"filter",
":",
"\\",
"\"",
"\"",
"+",
"instrumentation",
"filter",
"+",
"\"",
"\\",
"\"",
"\"",
")",
")",
";",
"event",
"handler",
"handle",
"(",
"event",
"info",
"(",
"\"",
"override",
"the",
"above",
"default",
"with",
"-",
"-",
"\"",
"+",
"instrumentation",
"filter",
"flag",
")",
")",
";",
"}",
"return",
"instrumentation",
"filter",
";",
"}"
] |
[
"the",
"body",
"of",
"the",
"request",
"if",
"{",
"@",
"code",
"null",
"}",
"then",
"no",
"body",
"is",
"sent",
"with",
"the",
"request"
] |
[
"public",
"http",
"entity",
"get",
"entity",
"(",
")",
"{",
"return",
"entity",
";",
"}"
] |
[
"it",
"prints",
"the",
"usage",
"of",
"the",
"command"
] |
[
"private",
"void",
"print",
"usage",
"(",
"options",
"opts",
")",
"{",
"new",
"help",
"formatter",
"(",
")",
"print",
"help",
"(",
"\"",
"node",
"\"",
",",
"opts",
")",
";",
"}"
] |
[
"a",
"sequence",
"of",
"requests",
"followed",
"by",
"one",
"response",
"(",
"streamed",
"upload",
")",
"the",
"server",
"returns",
"the",
"aggregated",
"size",
"of",
"client",
"payload",
"as",
"the",
"result"
] |
[
"public",
"io",
"grpc",
"stub",
"stream",
"observer",
"<",
"io",
"grpc",
"testing",
"integration",
"messages",
"streaming",
"input",
"call",
"request",
">",
"streaming",
"input",
"call",
"(",
"io",
"grpc",
"stub",
"stream",
"observer",
"<",
"io",
"grpc",
"testing",
"integration",
"messages",
"streaming",
"input",
"call",
"response",
">",
"response",
"observer",
")",
"{",
"return",
"io",
"grpc",
"stub",
"server",
"calls",
"async",
"unimplemented",
"streaming",
"call",
"(",
"get",
"streaming",
"input",
"call",
"method",
"(",
")",
",",
"response",
"observer",
")",
";",
"}"
] |
[
"builds",
"a",
"byte",
"array",
"including",
"the",
"final",
"string",
"delimiter"
] |
[
"public",
"byte",
"[",
"]",
"get",
"bytes",
"for",
"lookup",
"(",
")",
"{",
"byte",
"[",
"]",
"bytes",
"=",
"new",
"byte",
"[",
"length",
"]",
";",
"int",
"cur",
"pos",
"=",
"0",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"index",
";",
"i",
"+",
"+",
")",
"{",
"system",
"arraycopy",
"(",
"b",
"[",
"i",
"]",
",",
"0",
",",
"bytes",
",",
"cur",
"pos",
",",
"b",
"[",
"i",
"]",
"length",
")",
";",
"cur",
"pos",
"+",
"=",
"b",
"[",
"i",
"]",
"length",
";",
"if",
"(",
"use",
"separator",
"[",
"i",
"]",
")",
"{",
"bytes",
"[",
"cur",
"pos",
"+",
"+",
"]",
"=",
"0x",
"0",
";",
"}",
"}",
"return",
"bytes",
";",
"}"
] |
[
"this",
"member",
"holds",
"the",
"program",
"header",
"table",
"'",
"s",
"file",
"offset",
"in",
"bytes",
"if",
"the",
"file",
"has",
"no",
"program",
"header",
"table",
",",
"this",
"member",
"holds",
"zero"
] |
[
"public",
"long",
"e",
"phoff",
"(",
")",
"{",
"return",
"e",
"phoff",
";",
"}"
] |
[
"get",
"the",
"block",
"address"
] |
[
"public",
"address",
"get",
"block",
"address",
"(",
")",
"{",
"return",
"block",
"start",
"addr",
";",
"}"
] |
[
"examines",
"the",
"filter",
"init",
"parameter",
"names",
"and",
"throws",
"servlet",
"exception",
"if",
"they",
"contain",
"an",
"unrecognized",
"init",
"parameter",
"name",
"this",
"is",
"a",
"stateless",
"static",
"method",
"this",
"method",
"is",
"an",
"implementation",
"detail",
"and",
"is",
"not",
"exposed",
"api",
"this",
"method",
"is",
"only",
"non",
"-",
"private",
"to",
"allow",
"j",
"unit",
"testing"
] |
[
"private",
"static",
"void",
"throw",
"if",
"unrecognized",
"param",
"name",
"(",
"final",
"enumeration",
"init",
"param",
"names",
")",
"{",
"val",
"recognized",
"parameter",
"names",
"=",
"new",
"hash",
"set",
"<",
"string",
">",
"(",
")",
";",
"recognized",
"parameter",
"names",
"add",
"(",
"init",
"param",
"enable",
"cache",
"control",
")",
";",
"recognized",
"parameter",
"names",
"add",
"(",
"init",
"param",
"enable",
"xcontent",
"options",
")",
";",
"recognized",
"parameter",
"names",
"add",
"(",
"init",
"param",
"enable",
"strict",
"transport",
"security",
")",
";",
"recognized",
"parameter",
"names",
"add",
"(",
"init",
"param",
"enable",
"strict",
"xframe",
"options",
")",
";",
"recognized",
"parameter",
"names",
"add",
"(",
"init",
"param",
"strict",
"xframe",
"options",
")",
";",
"recognized",
"parameter",
"names",
"add",
"(",
"init",
"param",
"content",
"security",
"policy",
")",
";",
"recognized",
"parameter",
"names",
"add",
"(",
"init",
"param",
"enable",
"xss",
"protection",
")",
";",
"recognized",
"parameter",
"names",
"add",
"(",
"init",
"param",
"xss",
"protection",
")",
";",
"recognized",
"parameter",
"names",
"add",
"(",
"throw",
"on",
"error",
")",
";",
"while",
"(",
"init",
"param",
"names",
"has",
"more",
"elements",
"(",
")",
")",
"{",
"val",
"init",
"param",
"name",
"=",
"(",
"string",
")",
"init",
"param",
"names",
"next",
"element",
"(",
")",
";",
"if",
"(",
"!",
"recognized",
"parameter",
"names",
"contains",
"(",
"init",
"param",
"name",
")",
")",
"{",
"log",
"exception",
"(",
"new",
"servlet",
"exception",
"(",
"\"",
"unrecognized",
"init",
"parameter",
"[",
"\"",
"+",
"init",
"param",
"name",
"+",
"'",
"]",
"'",
")",
")",
";",
"}",
"}",
"}"
] |
[
"for",
"unit",
"test",
"to",
"override"
] |
[
"protected",
"sub",
"cluster",
"id",
"get",
"sub",
"cluster",
"for",
"un",
"resolved",
"request",
"(",
"allocation",
"bookkeeper",
"book",
"keeper",
",",
"long",
"allocation",
"id",
")",
"{",
"return",
"book",
"keeper",
"get",
"sub",
"cluster",
"for",
"un",
"resolved",
"request",
"(",
"allocation",
"id",
")",
";",
"}"
] |
[
"bridge",
"to",
"actual",
"controller",
"type",
"-",
"level",
"annotations"
] |
[
"public",
"class",
"<",
"?",
">",
"get",
"bean",
"type",
"(",
")",
"{",
"return",
"servlet",
"invocable",
"handler",
"method",
"this",
"get",
"bean",
"type",
"(",
")",
";",
"}"
] |
[
"get",
"the",
"underlying",
"byte",
"array"
] |
[
"public",
"byte",
"[",
"]",
"read",
"(",
")",
"{",
"return",
"m",
"bytes",
";",
"}"
] |
[
"set",
"the",
"data",
"in",
"the",
"form",
"of",
"the",
"appropriate",
"object",
"for",
"this",
"data",
"type"
] |
[
"public",
"void",
"set",
"value",
"(",
"mem",
"buffer",
"buf",
",",
"settings",
"settings",
",",
"int",
"length",
",",
"object",
"value",
")",
"{",
"throw",
"new",
"not",
"yet",
"implemented",
"exception",
"(",
"\"",
"set",
"value",
"(",
")",
"not",
"implemented",
"\"",
")",
";",
"}"
] |
[
"get",
"the",
"number",
"of",
"entries",
"in",
"the",
"current",
"batch"
] |
[
"public",
"int",
"get",
"batch",
"size",
"(",
")",
"{",
"return",
"batch",
"size",
";",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.