docstring_tokens
list | code_tokens
list |
|---|---|
[
"{",
"@",
"inherit",
"doc",
"}"
] |
[
"public",
"void",
"visit",
"no",
"args",
"(",
"int",
"opcode",
",",
"int",
"offset",
",",
"int",
"length",
",",
"type",
"type",
")",
"{",
"switch",
"(",
"opcode",
")",
"{",
"case",
"byte",
"ops",
"nop",
":",
"{",
"machine",
"clear",
"args",
"(",
")",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"ineg",
":",
"{",
"machine",
"pop",
"args",
"(",
"frame",
",",
"type",
")",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"i2l",
":",
"case",
"byte",
"ops",
"i2f",
":",
"case",
"byte",
"ops",
"i2d",
":",
"case",
"byte",
"ops",
"i2b",
":",
"case",
"byte",
"ops",
"i2c",
":",
"case",
"byte",
"ops",
"i2s",
":",
"{",
"machine",
"pop",
"args",
"(",
"frame",
",",
"type",
"int",
")",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"l2i",
":",
"case",
"byte",
"ops",
"l2f",
":",
"case",
"byte",
"ops",
"l2d",
":",
"{",
"machine",
"pop",
"args",
"(",
"frame",
",",
"type",
"long",
")",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"f2i",
":",
"case",
"byte",
"ops",
"f2l",
":",
"case",
"byte",
"ops",
"f2d",
":",
"{",
"machine",
"pop",
"args",
"(",
"frame",
",",
"type",
"float",
")",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"d2i",
":",
"case",
"byte",
"ops",
"d2l",
":",
"case",
"byte",
"ops",
"d2f",
":",
"{",
"machine",
"pop",
"args",
"(",
"frame",
",",
"type",
"double",
")",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"return",
":",
"{",
"machine",
"clear",
"args",
"(",
")",
";",
"check",
"return",
"type",
"(",
"type",
"void",
")",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"ireturn",
":",
"{",
"type",
"check",
"type",
"=",
"type",
";",
"if",
"(",
"type",
"=",
"=",
"type",
"object",
")",
"{",
"/",
"*",
"*",
"for",
"an",
"object",
"return",
",",
"use",
"the",
"best",
"-",
"known",
"*",
"type",
"of",
"the",
"popped",
"value",
"*",
"/",
"check",
"type",
"=",
"frame",
"get",
"stack",
"(",
")",
"peek",
"type",
"(",
"0",
")",
";",
"}",
"machine",
"pop",
"args",
"(",
"frame",
",",
"type",
")",
";",
"check",
"return",
"type",
"(",
"check",
"type",
")",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"pop",
":",
"{",
"type",
"peek",
"type",
"=",
"frame",
"get",
"stack",
"(",
")",
"peek",
"type",
"(",
"0",
")",
";",
"if",
"(",
"peek",
"type",
"is",
"category",
"2",
"(",
")",
")",
"{",
"throw",
"illegal",
"tos",
"(",
")",
";",
"}",
"machine",
"pop",
"args",
"(",
"frame",
",",
"1",
")",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"arraylength",
":",
"{",
"type",
"array",
"type",
"=",
"frame",
"get",
"stack",
"(",
")",
"peek",
"type",
"(",
"0",
")",
";",
"if",
"(",
"!",
"array",
"type",
"is",
"array",
"or",
"known",
"null",
"(",
")",
")",
"{",
"throw",
"new",
"sim",
"exception",
"(",
"\"",
"type",
"mismatch",
":",
"expected",
"\"",
"+",
"\"",
"array",
"type",
"but",
"encountered",
"\"",
"+",
"array",
"type",
"to",
"human",
"(",
")",
")",
";",
"}",
"machine",
"pop",
"args",
"(",
"frame",
",",
"type",
"object",
")",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"athrow",
":",
"case",
"byte",
"ops",
"monitorenter",
":",
"case",
"byte",
"ops",
"monitorexit",
":",
"{",
"machine",
"pop",
"args",
"(",
"frame",
",",
"type",
"object",
")",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"iaload",
":",
"{",
"/",
"*",
"*",
"see",
"comment",
"on",
"required",
"array",
"type",
"for",
"(",
")",
"for",
"explanation",
"*",
"about",
"what",
"'",
"s",
"going",
"on",
"here",
"*",
"/",
"type",
"found",
"array",
"type",
"=",
"frame",
"get",
"stack",
"(",
")",
"peek",
"type",
"(",
"1",
")",
";",
"type",
"required",
"array",
"type",
"=",
"required",
"array",
"type",
"for",
"(",
"type",
",",
"found",
"array",
"type",
")",
";",
"/",
"/",
"make",
"type",
"agree",
"with",
"the",
"discovered",
"required",
"array",
"type",
"type",
"=",
"(",
"required",
"array",
"type",
"=",
"=",
"type",
"known",
"null",
")",
"?",
"type",
"known",
"null",
":",
"required",
"array",
"type",
"get",
"component",
"type",
"(",
")",
";",
"machine",
"pop",
"args",
"(",
"frame",
",",
"required",
"array",
"type",
",",
"type",
"int",
")",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"iadd",
":",
"case",
"byte",
"ops",
"isub",
":",
"case",
"byte",
"ops",
"imul",
":",
"case",
"byte",
"ops",
"idiv",
":",
"case",
"byte",
"ops",
"irem",
":",
"case",
"byte",
"ops",
"iand",
":",
"case",
"byte",
"ops",
"ior",
":",
"case",
"byte",
"ops",
"ixor",
":",
"{",
"machine",
"pop",
"args",
"(",
"frame",
",",
"type",
",",
"type",
")",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"ishl",
":",
"case",
"byte",
"ops",
"ishr",
":",
"case",
"byte",
"ops",
"iushr",
":",
"{",
"machine",
"pop",
"args",
"(",
"frame",
",",
"type",
",",
"type",
"int",
")",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"lcmp",
":",
"{",
"machine",
"pop",
"args",
"(",
"frame",
",",
"type",
"long",
",",
"type",
"long",
")",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"fcmpl",
":",
"case",
"byte",
"ops",
"fcmpg",
":",
"{",
"machine",
"pop",
"args",
"(",
"frame",
",",
"type",
"float",
",",
"type",
"float",
")",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"dcmpl",
":",
"case",
"byte",
"ops",
"dcmpg",
":",
"{",
"machine",
"pop",
"args",
"(",
"frame",
",",
"type",
"double",
",",
"type",
"double",
")",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"iastore",
":",
"{",
"/",
"*",
"*",
"see",
"comment",
"on",
"required",
"array",
"type",
"for",
"(",
")",
"for",
"*",
"explanation",
"about",
"what",
"'",
"s",
"going",
"on",
"here",
"in",
"*",
"addition",
"to",
"that",
",",
"the",
"category",
"1",
"vs",
"2",
"thing",
"*",
"below",
"is",
"to",
"deal",
"with",
"the",
"fact",
"that",
",",
"if",
"the",
"*",
"element",
"type",
"is",
"category",
"2",
",",
"we",
"have",
"to",
"skip",
"*",
"over",
"one",
"extra",
"stack",
"slot",
"to",
"find",
"the",
"array",
"*",
"/",
"execution",
"stack",
"stack",
"=",
"frame",
"get",
"stack",
"(",
")",
";",
"int",
"peek",
"depth",
"=",
"type",
"is",
"category",
"1",
"(",
")",
"?",
"2",
":",
"3",
";",
"type",
"found",
"array",
"type",
"=",
"stack",
"peek",
"type",
"(",
"peek",
"depth",
")",
";",
"boolean",
"found",
"array",
"local",
"=",
"stack",
"peek",
"local",
"(",
"peek",
"depth",
")",
";",
"type",
"required",
"array",
"type",
"=",
"required",
"array",
"type",
"for",
"(",
"type",
",",
"found",
"array",
"type",
")",
";",
"/",
"*",
"*",
"make",
"type",
"agree",
"with",
"the",
"discovered",
"required",
"array",
"type",
"*",
"if",
"it",
"has",
"local",
"info",
"*",
"/",
"if",
"(",
"found",
"array",
"local",
")",
"{",
"type",
"=",
"(",
"required",
"array",
"type",
"=",
"=",
"type",
"known",
"null",
")",
"?",
"type",
"known",
"null",
":",
"required",
"array",
"type",
"get",
"component",
"type",
"(",
")",
";",
"}",
"machine",
"pop",
"args",
"(",
"frame",
",",
"required",
"array",
"type",
",",
"type",
"int",
",",
"type",
")",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"pop2",
":",
"case",
"byte",
"ops",
"dup2",
":",
"{",
"execution",
"stack",
"stack",
"=",
"frame",
"get",
"stack",
"(",
")",
";",
"int",
"pattern",
";",
"if",
"(",
"stack",
"peek",
"type",
"(",
"0",
")",
"is",
"category",
"2",
"(",
")",
")",
"{",
"/",
"/",
"\"",
"form",
"2",
"\"",
"in",
"vmspec",
"-",
"2",
"machine",
"pop",
"args",
"(",
"frame",
",",
"1",
")",
";",
"pattern",
"=",
"0x",
"1",
"1",
";",
"}",
"else",
"if",
"(",
"stack",
"peek",
"type",
"(",
"1",
")",
"is",
"category",
"1",
"(",
")",
")",
"{",
"/",
"/",
"\"",
"form",
"1",
"\"",
"machine",
"pop",
"args",
"(",
"frame",
",",
"2",
")",
";",
"pattern",
"=",
"0x",
"2",
"1",
"2",
"1",
";",
"}",
"else",
"{",
"throw",
"illegal",
"tos",
"(",
")",
";",
"}",
"if",
"(",
"opcode",
"=",
"=",
"byte",
"ops",
"dup2",
")",
"{",
"machine",
"aux",
"int",
"arg",
"(",
"pattern",
")",
";",
"}",
"break",
";",
"}",
"case",
"byte",
"ops",
"dup",
":",
"{",
"type",
"peek",
"type",
"=",
"frame",
"get",
"stack",
"(",
")",
"peek",
"type",
"(",
"0",
")",
";",
"if",
"(",
"peek",
"type",
"is",
"category",
"2",
"(",
")",
")",
"{",
"throw",
"illegal",
"tos",
"(",
")",
";",
"}",
"machine",
"pop",
"args",
"(",
"frame",
",",
"1",
")",
";",
"machine",
"aux",
"int",
"arg",
"(",
"0x",
"1",
"1",
")",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"dup",
"x1",
":",
"{",
"execution",
"stack",
"stack",
"=",
"frame",
"get",
"stack",
"(",
")",
";",
"if",
"(",
"!",
"(",
"stack",
"peek",
"type",
"(",
"0",
")",
"is",
"category",
"1",
"(",
")",
"&",
"&",
"stack",
"peek",
"type",
"(",
"1",
")",
"is",
"category",
"1",
"(",
")",
")",
")",
"{",
"throw",
"illegal",
"tos",
"(",
")",
";",
"}",
"machine",
"pop",
"args",
"(",
"frame",
",",
"2",
")",
";",
"machine",
"aux",
"int",
"arg",
"(",
"0x",
"2",
"1",
"2",
")",
";",
"break",
";",
"}",
"case",
"byte",
"ops",
"dup",
"x2",
":",
"{",
"execution",
"stack",
"stack",
"=",
"frame",
"get",
"stack",
"(",
")",
";",
"if",
"(",
"stack",
"peek",
"type",
"(",
"0",
")",
"is",
"category",
"2",
"(",
")",
")",
"{",
"throw",
"illegal",
"tos",
"(",
")",
";",
"}",
"if",
"(",
"stack",
"peek",
"type",
"(",
"1",
")",
"is",
"category",
"2",
"(",
")",
")",
"{",
"/",
"/",
"\"",
"form",
"2",
"\"",
"in",
"vmspec",
"-",
"2",
"machine",
"pop",
"args",
"(",
"frame",
",",
"2",
")",
";",
"machine",
"aux",
"int",
"arg",
"(",
"0x",
"2",
"1",
"2",
")",
";",
"}",
"else",
"if",
"(",
"stack",
"peek",
"type",
"(",
"2",
")",
"is",
"category",
"1",
"(",
")",
")",
"{",
"/",
"/",
"\"",
"form",
"1",
"\"",
"machine",
"pop",
"args",
"(",
"frame",
",",
"3",
")",
";",
"machine",
"aux",
"int",
"arg",
"(",
"0x",
"3",
"2",
"1",
"3",
")",
";",
"}",
"else",
"{",
"throw",
"illegal",
"tos",
"(",
")",
";",
"}",
"break",
";",
"}",
"case",
"byte",
"ops",
"dup2",
"x1",
":",
"{",
"execution",
"stack",
"stack",
"=",
"frame",
"get",
"stack",
"(",
")",
";",
"if",
"(",
"stack",
"peek",
"type",
"(",
"0",
")",
"is",
"category",
"2",
"(",
")",
")",
"{",
"/",
"/",
"\"",
"form",
"2",
"\"",
"in",
"vmspec",
"-",
"2",
"if",
"(",
"stack",
"peek",
"type",
"(",
"2",
")",
"is",
"category",
"2",
"(",
")",
")",
"{",
"throw",
"illegal",
"tos",
"(",
")",
";",
"}",
"machine",
"pop",
"args",
"(",
"frame",
",",
"2",
")",
";",
"machine",
"aux",
"int",
"arg",
"(",
"0x",
"2",
"1",
"2",
")",
";",
"}",
"else",
"{",
"/",
"/",
"\"",
"form",
"1",
"\"",
"if",
"(",
"stack",
"peek",
"type",
"(",
"1",
")",
"is",
"category",
"2",
"(",
")",
"|",
"|",
"stack",
"peek",
"type",
"(",
"2",
")",
"is",
"category",
"2",
"(",
")",
")",
"{",
"throw",
"illegal",
"tos",
"(",
")",
";",
"}",
"machine",
"pop",
"args",
"(",
"frame",
",",
"3",
")",
";",
"machine",
"aux",
"int",
"arg",
"(",
"0x",
"3",
"2",
"1",
"3",
"2",
")",
";",
"}",
"break",
";",
"}",
"case",
"byte",
"ops",
"dup2",
"x2",
":",
"{",
"execution",
"stack",
"stack",
"=",
"frame",
"get",
"stack",
"(",
")",
";",
"if",
"(",
"stack",
"peek",
"type",
"(",
"0",
")",
"is",
"category",
"2",
"(",
")",
")",
"{",
"if",
"(",
"stack",
"peek",
"type",
"(",
"2",
")",
"is",
"category",
"2",
"(",
")",
")",
"{",
"/",
"/",
"\"",
"form",
"4",
"\"",
"in",
"vmspec",
"-",
"2",
"machine",
"pop",
"args",
"(",
"frame",
",",
"2",
")",
";",
"machine",
"aux",
"int",
"arg",
"(",
"0x",
"2",
"1",
"2",
")",
";",
"}",
"else",
"if",
"(",
"stack",
"peek",
"type",
"(",
"3",
")",
"is",
"category",
"1",
"(",
")",
")",
"{",
"/",
"/",
"\"",
"form",
"2",
"\"",
"machine",
"pop",
"args",
"(",
"frame",
",",
"3",
")",
";",
"machine",
"aux",
"int",
"arg",
"(",
"0x",
"3",
"2",
"1",
"3",
")",
";",
"}",
"else",
"{",
"throw",
"illegal",
"tos",
"(",
")",
";",
"}",
"}",
"else",
"if",
"(",
"stack",
"peek",
"type",
"(",
"1",
")",
"is",
"category",
"1",
"(",
")",
")",
"{",
"if",
"(",
"stack",
"peek",
"type",
"(",
"2",
")",
"is",
"category",
"2",
"(",
")",
")",
"{",
"/",
"/",
"\"",
"form",
"3",
"\"",
"machine",
"pop",
"args",
"(",
"frame",
",",
"3",
")",
";",
"machine",
"aux",
"int",
"arg",
"(",
"0x",
"3",
"2",
"1",
"3",
"2",
")",
";",
"}",
"else",
"if",
"(",
"stack",
"peek",
"type",
"(",
"3",
")",
"is",
"category",
"1",
"(",
")",
")",
"{",
"/",
"/",
"\"",
"form",
"1",
"\"",
"machine",
"pop",
"args",
"(",
"frame",
",",
"4",
")",
";",
"machine",
"aux",
"int",
"arg",
"(",
"0x",
"4",
"3",
"2",
"1",
"4",
"3",
")",
";",
"}",
"else",
"{",
"throw",
"illegal",
"tos",
"(",
")",
";",
"}",
"}",
"else",
"{",
"throw",
"illegal",
"tos",
"(",
")",
";",
"}",
"break",
";",
"}",
"case",
"byte",
"ops",
"swap",
":",
"{",
"execution",
"stack",
"stack",
"=",
"frame",
"get",
"stack",
"(",
")",
";",
"if",
"(",
"!",
"(",
"stack",
"peek",
"type",
"(",
"0",
")",
"is",
"category",
"1",
"(",
")",
"&",
"&",
"stack",
"peek",
"type",
"(",
"1",
")",
"is",
"category",
"1",
"(",
")",
")",
")",
"{",
"throw",
"illegal",
"tos",
"(",
")",
";",
"}",
"machine",
"pop",
"args",
"(",
"frame",
",",
"2",
")",
";",
"machine",
"aux",
"int",
"arg",
"(",
"0x",
"1",
"2",
")",
";",
"break",
";",
"}",
"default",
":",
"{",
"visit",
"invalid",
"(",
"opcode",
",",
"offset",
",",
"length",
")",
";",
"return",
";",
"}",
"}",
"machine",
"aux",
"type",
"(",
"type",
")",
";",
"machine",
"run",
"(",
"frame",
",",
"offset",
",",
"opcode",
")",
";",
"}"
] |
[
"return",
"the",
"maximum",
"elapsed",
"time",
"in",
"milliseconds",
"after",
"which",
"a",
"call",
"to",
"{",
"@",
"link",
"back",
"off",
"execution",
"#",
"next",
"back",
"off",
"(",
")",
"}",
"returns",
"{",
"@",
"link",
"back",
"off",
"execution",
"#",
"stop",
"}"
] |
[
"public",
"long",
"get",
"max",
"elapsed",
"time",
"(",
")",
"{",
"return",
"this",
"max",
"elapsed",
"time",
";",
"}"
] |
[
"handle",
"{",
"@",
"link",
"nacos",
"exception",
"}"
] |
[
"public",
"response",
"entity",
"<",
"string",
">",
"handle",
"nacos",
"exception",
"(",
"nacos",
"exception",
"e",
")",
"{",
"loggers",
"srv",
"log",
"error",
"(",
"\"",
"got",
"exception",
"{",
"}",
"\"",
",",
"e",
"get",
"err",
"msg",
"(",
")",
",",
"exception",
"util",
"get",
"all",
"exception",
"msg",
"(",
"e",
")",
")",
";",
"return",
"response",
"entity",
"status",
"(",
"e",
"get",
"err",
"code",
"(",
")",
")",
"body",
"(",
"e",
"get",
"message",
"(",
")",
")",
";",
"}"
] |
[
"returns",
"the",
"map",
"of",
"metadata",
"keys",
"and",
"their",
"corresponding",
"data",
"types",
"that",
"can",
"be",
"consumed",
"by",
"this",
"table",
"sink",
"for",
"writing",
"the",
"returned",
"map",
"will",
"be",
"used",
"by",
"the",
"planner",
"for",
"validation",
"and",
"insertion",
"of",
"explicit",
"casts",
"(",
"see",
"{",
"@",
"link",
"logical",
"type",
"casts",
"#",
"supports",
"explicit",
"cast",
"(",
"logical",
"type",
",",
"logical",
"type",
")",
"}",
")",
"if",
"necessary",
"the",
"iteration",
"order",
"of",
"the",
"returned",
"map",
"determines",
"the",
"order",
"of",
"metadata",
"keys",
"in",
"the",
"list",
"passed",
"in",
"{",
"@",
"link",
"#",
"apply",
"writable",
"metadata",
"(",
"list",
",",
"data",
"type",
")",
"}",
"therefore",
",",
"it",
"might",
"be",
"beneficial",
"to",
"return",
"a",
"{",
"@",
"link",
"linked",
"hash",
"map",
"}",
"if",
"a",
"strict",
"metadata",
"column",
"order",
"is",
"required",
"if",
"a",
"sink",
"forwards",
"metadata",
"to",
"one",
"or",
"more",
"formats",
",",
"we",
"recommend",
"the",
"following",
"column",
"order",
"for",
"consistency",
":",
"{",
"@",
"code",
"key",
"format",
"metadata",
"columns",
"+",
"value",
"format",
"metadata",
"columns",
"+",
"sink",
"metadata",
"columns",
"}",
"metadata",
"key",
"names",
"follow",
"the",
"same",
"pattern",
"as",
"mentioned",
"in",
"{",
"@",
"link",
"factory",
"}",
"in",
"case",
"of",
"duplicate",
"names",
"in",
"format",
"and",
"sink",
"keys",
",",
"format",
"keys",
"shall",
"have",
"higher",
"precedence",
"regardless",
"of",
"the",
"returned",
"{",
"@",
"link",
"data",
"type",
"}",
"s",
",",
"a",
"metadata",
"column",
"is",
"always",
"represented",
"using",
"internal",
"data",
"structures",
"(",
"see",
"{",
"@",
"link",
"row",
"data",
"}",
")"
] |
[
"map",
"<",
"string",
",",
"data",
"type",
">",
"list",
"writable",
"metadata",
"(",
")",
";"
] |
[
"get",
"storeorder",
"{",
"order",
"id",
"}",
":",
"find",
"purchase",
"order",
"by",
"id",
"for",
"valid",
"response",
"try",
"integer",
"i",
"ds",
"with",
"value",
"&",
"lt",
";",
"&",
"#",
"x",
"3",
"d",
";",
"5",
"or",
"&",
"gt",
";",
"10",
"other",
"values",
"will",
"generated",
"exceptions"
] |
[
"com",
"netflix",
"hystrix",
"hystrix",
"command",
"<",
"response",
"entity",
"<",
"order",
">",
">",
"get",
"order",
"by",
"id",
"(",
"@",
"min",
"(",
"1l",
")",
"@",
"max",
"(",
"5l",
")",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"id",
"of",
"pet",
"that",
"needs",
"to",
"be",
"fetched",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"path",
"variable",
"(",
"\"",
"order",
"id",
"\"",
")",
"long",
"order",
"id",
")",
";"
] |
[
"the",
"throttle",
"to",
"apply",
"to",
"all",
"matching",
"requests",
"in",
"sub",
"-",
"requests",
"per",
"second",
"0",
"means",
"set",
"no",
"throttle",
"and",
"that",
"is",
"the",
"default"
] |
[
"public",
"float",
"get",
"requests",
"per",
"second",
"(",
")",
"{",
"return",
"requests",
"per",
"second",
";",
"}"
] |
[
"returns",
"a",
"view",
"of",
"all",
"mappings",
"that",
"have",
"the",
"given",
"column",
"key",
"if",
"the",
"column",
"key",
"isn",
"'",
"t",
"in",
"{",
"@",
"link",
"#",
"column",
"key",
"set",
"(",
")",
"}",
",",
"an",
"empty",
"immutable",
"map",
"is",
"returned",
"otherwise",
",",
"for",
"each",
"row",
"key",
"in",
"{",
"@",
"link",
"#",
"row",
"key",
"set",
"(",
")",
"}",
",",
"the",
"returned",
"map",
"associates",
"the",
"row",
"key",
"with",
"the",
"corresponding",
"value",
"in",
"the",
"table",
"changes",
"to",
"the",
"returned",
"map",
"will",
"update",
"the",
"underlying",
"table",
",",
"and",
"vice",
"versa"
] |
[
"public",
"map",
"<",
"r",
",",
"v",
">",
"column",
"(",
"c",
"column",
"key",
")",
"{",
"check",
"not",
"null",
"(",
"column",
"key",
")",
";",
"integer",
"column",
"index",
"=",
"column",
"key",
"to",
"index",
"get",
"(",
"column",
"key",
")",
";",
"return",
"(",
"column",
"index",
"=",
"=",
"null",
")",
"?",
"immutable",
"map",
"<",
"r",
",",
"v",
">",
"of",
"(",
")",
":",
"new",
"column",
"(",
"column",
"index",
")",
";",
"}"
] |
[
"creates",
"a",
"{",
"@",
"link",
"local",
"stream",
"environment",
"}",
"for",
"local",
"program",
"execution",
"that",
"also",
"starts",
"the",
"web",
"monitoring",
"ui",
"the",
"local",
"execution",
"environment",
"will",
"run",
"the",
"program",
"in",
"a",
"multi",
"-",
"threaded",
"fashion",
"in",
"the",
"same",
"jvm",
"as",
"the",
"environment",
"was",
"created",
"in",
"it",
"will",
"use",
"the",
"parallelism",
"specified",
"in",
"the",
"parameter",
"if",
"the",
"configuration",
"key",
"'",
"rest",
"port",
"'",
"was",
"set",
"in",
"the",
"configuration",
",",
"that",
"particular",
"port",
"will",
"be",
"used",
"for",
"the",
"web",
"ui",
"otherwise",
",",
"the",
"default",
"port",
"(",
"8081",
")",
"will",
"be",
"used"
] |
[
"public",
"static",
"stream",
"execution",
"environment",
"create",
"local",
"environment",
"with",
"web",
"u",
"i",
"(",
"configuration",
"conf",
")",
"{",
"check",
"not",
"null",
"(",
"conf",
",",
"\"",
"conf",
"\"",
")",
";",
"if",
"(",
"!",
"conf",
"contains",
"(",
"rest",
"options",
"port",
")",
")",
"{",
"/",
"/",
"explicitly",
"set",
"this",
"option",
"so",
"that",
"it",
"'",
"s",
"not",
"set",
"to",
"0",
"later",
"conf",
"set",
"integer",
"(",
"rest",
"options",
"port",
",",
"rest",
"options",
"port",
"default",
"value",
"(",
")",
")",
";",
"}",
"return",
"create",
"local",
"environment",
"(",
"conf",
")",
";",
"}"
] |
[
"apply",
"the",
"x",
"path",
"expression",
"and",
"assert",
"the",
"resulting",
"content",
"as",
"a",
"boolean"
] |
[
"public",
"void",
"assert",
"boolean",
"(",
"byte",
"[",
"]",
"content",
",",
"@",
"nullable",
"string",
"encoding",
",",
"boolean",
"expected",
"value",
")",
"throws",
"exception",
"{",
"string",
"actual",
"=",
"evaluate",
"xpath",
"(",
"content",
",",
"encoding",
",",
"string",
"class",
")",
";",
"assertion",
"errors",
"assert",
"equals",
"(",
"\"",
"x",
"path",
"\"",
"+",
"this",
"expression",
",",
"expected",
"value",
",",
"boolean",
"parse",
"boolean",
"(",
"actual",
")",
")",
";",
"}"
] |
[
"get",
"multiple",
"attributes",
"at",
"once",
"example",
":",
"material",
"get",
"(",
"out",
",",
"color",
"attribute",
"diffuse",
"|",
"color",
"attribute",
"specular",
"|",
"texture",
"attribute",
"diffuse",
")",
";"
] |
[
"public",
"final",
"array",
"<",
"attribute",
">",
"get",
"(",
"final",
"array",
"<",
"attribute",
">",
"out",
",",
"final",
"long",
"type",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"attributes",
"size",
";",
"i",
"+",
"+",
")",
"if",
"(",
"(",
"attributes",
"get",
"(",
"i",
")",
"type",
"&",
"type",
")",
"!",
"=",
"0",
")",
"out",
"add",
"(",
"attributes",
"get",
"(",
"i",
")",
")",
";",
"return",
"out",
";",
"}"
] |
[
"get",
"or",
"create",
"a",
"sensor",
"with",
"the",
"given",
"unique",
"name",
"and",
"zero",
"or",
"more",
"parent",
"sensors",
"all",
"parent",
"sensors",
"will",
"receive",
"every",
"value",
"recorded",
"with",
"this",
"sensor"
] |
[
"public",
"sensor",
"sensor",
"(",
"string",
"name",
",",
"sensor",
"recording",
"level",
"recording",
"level",
",",
"sensor",
"parents",
")",
"{",
"return",
"sensor",
"(",
"name",
",",
"null",
",",
"recording",
"level",
",",
"parents",
")",
";",
"}"
] |
[
"configures",
"the",
"driver",
"server",
"for",
"silent",
"output"
] |
[
"public",
"edge",
"driver",
"service",
"builder",
"with",
"silent",
"(",
"boolean",
"silent",
")",
"{",
"this",
"silent",
"=",
"silent",
";",
"return",
"this",
";",
"}"
] |
[
"returns",
"all",
"variations",
"of",
"this",
"policy",
"based",
"on",
"the",
"configuration",
"parameters"
] |
[
"public",
"static",
"set",
"<",
"policy",
">",
"policies",
"(",
"config",
"config",
")",
"{",
"window",
"tiny",
"lfu",
"settings",
"settings",
"=",
"new",
"window",
"tiny",
"lfu",
"settings",
"(",
"config",
")",
";",
"return",
"settings",
"percent",
"main",
"(",
")",
"stream",
"(",
")",
"map",
"(",
"percent",
"main",
"-",
">",
"new",
"window",
"tiny",
"lfu",
"policy",
"(",
"percent",
"main",
",",
"settings",
")",
")",
"collect",
"(",
"to",
"set",
"(",
")",
")",
";",
"}"
] |
[
"test",
"the",
"case",
"when",
"an",
"expired",
"report",
"is",
"replaced",
"by",
"a",
"valid",
"one"
] |
[
"public",
"void",
"test",
"replacement",
"(",
")",
"throws",
"exception",
"{",
"add",
"slow",
"disk",
"for",
"testing",
"(",
"\"",
"dn",
"1",
"\"",
",",
"\"",
"disk",
"1",
"\"",
",",
"immutable",
"map",
"of",
"(",
"disk",
"op",
"metadata",
",",
"1",
"1",
",",
"disk",
"op",
"read",
",",
"1",
"8",
")",
")",
";",
"timer",
"advance",
"(",
"report",
"validity",
"ms",
")",
";",
"add",
"slow",
"disk",
"for",
"testing",
"(",
"\"",
"dn",
"1",
"\"",
",",
"\"",
"disk",
"1",
"\"",
",",
"immutable",
"map",
"of",
"(",
"disk",
"op",
"read",
",",
"1",
"4",
")",
")",
";",
"tracker",
"update",
"slow",
"disk",
"report",
"async",
"(",
"timer",
"monotonic",
"now",
"(",
")",
")",
";",
"generic",
"test",
"utils",
"wait",
"for",
"(",
"new",
"supplier",
"<",
"boolean",
">",
"(",
")",
"{",
"@",
"override",
"public",
"boolean",
"get",
"(",
")",
"{",
"return",
"!",
"tracker",
"get",
"slow",
"disks",
"report",
"(",
")",
"is",
"empty",
"(",
")",
";",
"}",
"}",
",",
"500",
",",
"5000",
")",
";",
"map",
"<",
"string",
",",
"disk",
"latency",
">",
"reports",
"=",
"get",
"slow",
"disks",
"report",
"for",
"testing",
"(",
"tracker",
")",
";",
"assert",
"that",
"(",
"reports",
"size",
"(",
")",
",",
"is",
"(",
"1",
")",
")",
";",
"assert",
"true",
"(",
"reports",
"get",
"(",
"\"",
"dn",
"1",
":",
"disk",
"1",
"\"",
")",
"get",
"latency",
"(",
"disk",
"op",
"metadata",
")",
"=",
"=",
"null",
")",
";",
"assert",
"true",
"(",
"math",
"abs",
"(",
"reports",
"get",
"(",
"\"",
"dn",
"1",
":",
"disk",
"1",
"\"",
")",
"get",
"latency",
"(",
"disk",
"op",
"read",
")",
"-",
"1",
"4",
")",
"<",
"0",
"0000001",
")",
";",
"}"
] |
[
"get",
"map",
"with",
"undeclared",
"properties",
"anytype",
"3"
] |
[
"public",
"map",
"<",
"string",
",",
"object",
">",
"get",
"map",
"with",
"undeclared",
"properties",
"anytype",
"3",
"(",
")",
"{",
"return",
"map",
"with",
"undeclared",
"properties",
"anytype",
"3",
";",
"}"
] |
[
"to",
"be",
"compatible",
"with",
"the",
"old",
"version",
"of",
"http",
"client",
"request",
",",
"this",
"nacos",
"async",
"rest",
"template",
"is",
"only",
"used",
"for",
"http",
"health",
"check",
"processor"
] |
[
"public",
"static",
"nacos",
"async",
"rest",
"template",
"get",
"processor",
"nacos",
"async",
"rest",
"template",
"(",
")",
"{",
"return",
"processor",
"nacos",
"async",
"rest",
"template",
";",
"}"
] |
[
"set",
"the",
"maximum",
"time",
"allowed",
"in",
"milliseconds",
"after",
"the",
"web",
"socket",
"connection",
"is",
"established",
"and",
"before",
"the",
"first",
"sub",
"-",
"protocol",
"message",
"is",
"received",
"this",
"handler",
"is",
"for",
"web",
"socket",
"connections",
"that",
"use",
"a",
"sub",
"-",
"protocol",
"therefore",
",",
"we",
"expect",
"the",
"client",
"to",
"send",
"at",
"least",
"one",
"sub",
"-",
"protocol",
"message",
"in",
"the",
"beginning",
",",
"or",
"else",
"we",
"assume",
"the",
"connection",
"isn",
"'",
"t",
"doing",
"well",
",",
"e",
"g",
"proxy",
"issue",
",",
"slow",
"network",
",",
"and",
"can",
"be",
"closed",
"by",
"default",
"this",
"is",
"set",
"to",
"{",
"@",
"code",
"60",
",",
"000",
"}",
"(",
"1",
"minute",
")"
] |
[
"public",
"void",
"set",
"time",
"to",
"first",
"message",
"(",
"int",
"time",
"to",
"first",
"message",
")",
"{",
"this",
"time",
"to",
"first",
"message",
"=",
"time",
"to",
"first",
"message",
";",
"}"
] |
[
"only",
"supposed",
"to",
"be",
"called",
"at",
"startup",
"time"
] |
[
"public",
"static",
"void",
"register",
"class",
"(",
"class",
"<",
"?",
">",
"clazz",
")",
"{",
"register",
"class",
"(",
"clazz",
",",
"null",
")",
";",
"}"
] |
[
"get",
"insert",
"into",
"statement"
] |
[
"default",
"string",
"get",
"insert",
"into",
"statement",
"(",
"string",
"table",
"name",
",",
"string",
"[",
"]",
"field",
"names",
")",
"{",
"string",
"columns",
"=",
"arrays",
"stream",
"(",
"field",
"names",
")",
"map",
"(",
"this",
":",
":",
"quote",
"identifier",
")",
"collect",
"(",
"collectors",
"joining",
"(",
"\"",
",",
"\"",
")",
")",
";",
"string",
"placeholders",
"=",
"arrays",
"stream",
"(",
"field",
"names",
")",
"map",
"(",
"f",
"-",
">",
"\"",
":",
"\"",
"+",
"f",
")",
"collect",
"(",
"collectors",
"joining",
"(",
"\"",
",",
"\"",
")",
")",
";",
"return",
"\"",
"insert",
"into",
"\"",
"+",
"quote",
"identifier",
"(",
"table",
"name",
")",
"+",
"\"",
"(",
"\"",
"+",
"columns",
"+",
"\"",
")",
"\"",
"+",
"\"",
"values",
"(",
"\"",
"+",
"placeholders",
"+",
"\"",
")",
"\"",
";",
"}"
] |
[
"creates",
"a",
"new",
"builder",
"with",
"the",
"given",
"host",
"and",
"port",
"see",
"{",
"@",
"link",
"netty",
"channel",
"builder",
"#",
"for",
"address",
"(",
"string",
",",
"int",
")",
"}",
"for",
"more",
"info"
] |
[
"public",
"static",
"xds",
"channel",
"builder",
"for",
"address",
"(",
"string",
"host",
",",
"int",
"port",
")",
"{",
"return",
"new",
"xds",
"channel",
"builder",
"(",
"netty",
"channel",
"builder",
"for",
"address",
"(",
"host",
",",
"port",
")",
")",
";",
"}"
] |
[
"returns",
"the",
"distance",
"between",
"the",
"given",
"segment",
"and",
"point"
] |
[
"public",
"static",
"float",
"distance",
"segment",
"point",
"(",
"vector",
"2",
"start",
",",
"vector",
"2",
"end",
",",
"vector",
"2",
"point",
")",
"{",
"return",
"nearest",
"segment",
"point",
"(",
"start",
",",
"end",
",",
"point",
",",
"v",
"2a",
")",
"dst",
"(",
"point",
")",
";",
"}"
] |
[
"get",
"the",
"special",
"replication",
"policy"
] |
[
"public",
"static",
"erasure",
"coding",
"policy",
"get",
"replication",
"policy",
"(",
")",
"{",
"return",
"replication",
"policy",
";",
"}"
] |
[
"resizes",
"the",
"hashtable",
"to",
"allow",
"more",
"entries"
] |
[
"private",
"void",
"grow",
"(",
")",
"{",
"capacity",
"=",
"indexer",
"get",
"capacity",
"(",
")",
";",
"int",
"[",
"]",
"old",
"values",
"=",
"values",
";",
"values",
"=",
"new",
"int",
"[",
"capacity",
"]",
";",
"system",
"arraycopy",
"(",
"old",
"values",
",",
"0",
",",
"values",
",",
"0",
",",
"old",
"values",
"length",
")",
";",
"}"
] |
[
"gets",
"the",
"server",
"addresses"
] |
[
"public",
"list",
"<",
"equivalent",
"address",
"group",
">",
"get",
"addresses",
"(",
")",
"{",
"return",
"addresses",
";",
"}"
] |
[
"hook",
"method",
"allowing",
"subclasses",
"to",
"customize",
"each",
"persistence",
"unit",
"info",
"the",
"default",
"implementation",
"delegates",
"to",
"all",
"registered",
"persistence",
"unit",
"post",
"processors",
"it",
"is",
"usually",
"preferable",
"to",
"register",
"further",
"entity",
"classes",
",",
"jar",
"files",
"etc",
"there",
"rather",
"than",
"in",
"a",
"subclass",
"of",
"this",
"manager",
",",
"to",
"be",
"able",
"to",
"reuse",
"the",
"post",
"-",
"processors"
] |
[
"protected",
"void",
"post",
"process",
"persistence",
"unit",
"info",
"(",
"mutable",
"persistence",
"unit",
"info",
"pui",
")",
"{",
"persistence",
"unit",
"post",
"processor",
"[",
"]",
"post",
"processors",
"=",
"get",
"persistence",
"unit",
"post",
"processors",
"(",
")",
";",
"if",
"(",
"post",
"processors",
"!",
"=",
"null",
")",
"{",
"for",
"(",
"persistence",
"unit",
"post",
"processor",
"post",
"processor",
":",
"post",
"processors",
")",
"{",
"post",
"processor",
"post",
"process",
"persistence",
"unit",
"info",
"(",
"pui",
")",
";",
"}",
"}",
"}"
] |
[
"ensure",
"all",
"clients",
"are",
"disconnected",
"from",
"the",
"service"
] |
[
"private",
"void",
"check",
"clients",
"disconnected",
"(",
")",
"throws",
"exception",
"{",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"zk",
"clients",
"length",
";",
"i",
"+",
"+",
")",
"{",
"check",
"client",
"disconnected",
"(",
"i",
"+",
"1",
")",
";",
"}",
"}"
] |
[
"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",
"the",
"version",
"of",
"the",
"connect",
"protocol",
"that",
"is",
"currently",
"active",
"in",
"the",
"group",
"of",
"workers"
] |
[
"public",
"short",
"current",
"protocol",
"version",
"(",
")",
"{",
"return",
"current",
"connect",
"protocol",
"protocol",
"version",
"(",
")",
";",
"}"
] |
[
"the",
"descriptor",
"for",
"the",
"service"
] |
[
"public",
"service",
"descriptor",
"get",
"service",
"descriptor",
"(",
")",
"{",
"return",
"service",
"descriptor",
";",
"}"
] |
[
"test",
"invalid",
"application",
"state",
"exception",
"should",
"be",
"thrown",
"if",
"application",
"state",
"is",
"not",
"valid"
] |
[
"public",
"void",
"test",
"invalid",
"app",
"state",
"(",
")",
"{",
"apps",
"block",
"app",
"block",
"=",
"new",
"apps",
"block",
"(",
"null",
",",
"null",
")",
"{",
"/",
"/",
"override",
"this",
"so",
"that",
"apps",
"block",
"can",
"fetch",
"app",
"state",
"@",
"override",
"public",
"map",
"<",
"string",
",",
"string",
">",
"more",
"params",
"(",
")",
"{",
"map",
"<",
"string",
",",
"string",
">",
"map",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"map",
"put",
"(",
"yarn",
"web",
"params",
"app",
"state",
",",
"\"",
"acceptedping",
"\"",
")",
";",
"return",
"map",
";",
"}",
"@",
"override",
"protected",
"void",
"render",
"data",
"(",
"block",
"html",
")",
"{",
"}",
"}",
";",
"/",
"/",
"set",
"up",
"the",
"test",
"block",
"to",
"render",
"apps",
"block",
"output",
"stream",
"output",
"stream",
"=",
"new",
"byte",
"array",
"output",
"stream",
"(",
")",
";",
"html",
"block",
"block",
"block",
"=",
"create",
"block",
"to",
"create",
"to",
"(",
"output",
"stream",
")",
";",
"/",
"/",
"if",
"application",
"state",
"is",
"invalid",
"it",
"should",
"throw",
"exception",
"/",
"/",
"instead",
"of",
"catching",
"it",
"app",
"block",
"render",
"(",
"block",
")",
";",
"}"
] |
[
"returns",
"the",
"pattern",
"that",
"resulted",
"in",
"the",
"stored",
"{",
"@",
"link",
"sky",
"key",
"}",
"or",
"{",
"@",
"link",
"target",
"parsing",
"exception",
"}"
] |
[
"string",
"get",
"original",
"pattern",
"(",
")",
";"
] |
[
"compute",
"reciprocal",
"rank",
"based",
"on",
"provided",
"relevant",
"document",
"i",
"ds"
] |
[
"public",
"eval",
"query",
"quality",
"evaluate",
"(",
"string",
"task",
"id",
",",
"search",
"hit",
"[",
"]",
"hits",
",",
"list",
"<",
"rated",
"document",
">",
"rated",
"docs",
")",
"{",
"list",
"<",
"rated",
"search",
"hit",
">",
"rated",
"hits",
"=",
"join",
"hits",
"with",
"ratings",
"(",
"hits",
",",
"rated",
"docs",
")",
";",
"int",
"first",
"relevant",
"=",
"-",
"1",
";",
"int",
"rank",
"=",
"1",
";",
"for",
"(",
"rated",
"search",
"hit",
"hit",
":",
"rated",
"hits",
")",
"{",
"optional",
"int",
"rating",
"=",
"hit",
"get",
"rating",
"(",
")",
";",
"if",
"(",
"rating",
"is",
"present",
"(",
")",
")",
"{",
"if",
"(",
"rating",
"get",
"as",
"int",
"(",
")",
">",
"=",
"this",
"relevant",
"rating",
"threshhold",
")",
"{",
"first",
"relevant",
"=",
"rank",
";",
"break",
";",
"}",
"}",
"rank",
"+",
"+",
";",
"}",
"double",
"reciprocal",
"rank",
"=",
"(",
"first",
"relevant",
"=",
"=",
"-",
"1",
")",
"?",
"0",
":",
"1",
"0d",
"/",
"first",
"relevant",
";",
"eval",
"query",
"quality",
"eval",
"query",
"quality",
"=",
"new",
"eval",
"query",
"quality",
"(",
"task",
"id",
",",
"reciprocal",
"rank",
")",
";",
"eval",
"query",
"quality",
"set",
"metric",
"details",
"(",
"new",
"detail",
"(",
"first",
"relevant",
")",
")",
";",
"eval",
"query",
"quality",
"add",
"hits",
"and",
"ratings",
"(",
"rated",
"hits",
")",
";",
"return",
"eval",
"query",
"quality",
";",
"}"
] |
[
"gets",
"an",
"unsigned",
"32",
"-",
"bit",
"integer",
"at",
"the",
"specified",
"absolute",
"{",
"@",
"code",
"index",
"}",
"in",
"this",
"buffer",
"this",
"method",
"does",
"not",
"modify",
"{",
"@",
"code",
"reader",
"index",
"}",
"or",
"{",
"@",
"code",
"writer",
"index",
"}",
"of",
"this",
"buffer"
] |
[
"public",
"abstract",
"long",
"get",
"unsigned",
"int",
"(",
"int",
"index",
")",
";"
] |
[
"returns",
"the",
"hostname",
"associated",
"with",
"the",
"specified",
"ip",
"address",
"by",
"the",
"provided",
"nameserver",
"loopback",
"addresses"
] |
[
"public",
"static",
"string",
"reverse",
"dns",
"(",
"inet",
"address",
"host",
"ip",
",",
"@",
"nullable",
"string",
"ns",
")",
"throws",
"naming",
"exception",
"{",
"/",
"/",
"/",
"/",
"builds",
"the",
"reverse",
"ip",
"lookup",
"form",
"/",
"/",
"this",
"is",
"formed",
"by",
"reversing",
"the",
"ip",
"numbers",
"and",
"appending",
"in",
"-",
"addr",
"arpa",
"/",
"/",
"string",
"[",
"]",
"parts",
"=",
"host",
"ip",
"get",
"host",
"address",
"(",
")",
"split",
"(",
"\"",
"\\",
"\\",
"\"",
")",
";",
"string",
"reverse",
"i",
"p",
"=",
"parts",
"[",
"3",
"]",
"+",
"\"",
"\"",
"+",
"parts",
"[",
"2",
"]",
"+",
"\"",
"\"",
"+",
"parts",
"[",
"1",
"]",
"+",
"\"",
"\"",
"+",
"parts",
"[",
"0",
"]",
"+",
"\"",
"in",
"-",
"addr",
"arpa",
"\"",
";",
"dir",
"context",
"ictx",
"=",
"new",
"initial",
"dir",
"context",
"(",
")",
";",
"attributes",
"attribute",
";",
"try",
"{",
"attribute",
"=",
"ictx",
"get",
"attributes",
"(",
"\"",
"dns",
":",
"/",
"/",
"\"",
"/",
"/",
"use",
"\"",
"dns",
":",
"/",
"/",
"/",
"\"",
"if",
"the",
"default",
"+",
"(",
"(",
"ns",
"=",
"=",
"null",
")",
"?",
"\"",
"\"",
":",
"ns",
")",
"+",
"/",
"/",
"nameserver",
"is",
"to",
"be",
"used",
"\"",
"/",
"\"",
"+",
"reverse",
"i",
"p",
",",
"new",
"string",
"[",
"]",
"{",
"\"",
"ptr",
"\"",
"}",
")",
";",
"}",
"finally",
"{",
"ictx",
"close",
"(",
")",
";",
"}",
"string",
"hostname",
"=",
"attribute",
"get",
"(",
"\"",
"ptr",
"\"",
")",
"get",
"(",
")",
"to",
"string",
"(",
")",
";",
"int",
"hostname",
"length",
"=",
"hostname",
"length",
"(",
")",
";",
"if",
"(",
"hostname",
"char",
"at",
"(",
"hostname",
"length",
"-",
"1",
")",
"=",
"=",
"'",
"'",
")",
"{",
"hostname",
"=",
"hostname",
"substring",
"(",
"0",
",",
"hostname",
"length",
"-",
"1",
")",
";",
"}",
"return",
"hostname",
";",
"}"
] |
[
"check",
"whether",
"the",
"given",
"session",
"is",
"locally",
"transacted",
",",
"that",
"is",
",",
"whether",
"its",
"transaction",
"is",
"managed",
"by",
"this",
"listener",
"container",
"'",
"s",
"session",
"handling",
"and",
"not",
"by",
"an",
"external",
"transaction",
"coordinator",
"note",
":",
"the",
"session",
"'",
"s",
"own",
"transacted",
"flag",
"will",
"already",
"have",
"been",
"checked",
"before",
"this",
"method",
"is",
"about",
"finding",
"out",
"whether",
"the",
"session",
"'",
"s",
"transaction",
"is",
"local",
"or",
"externally",
"coordinated"
] |
[
"protected",
"boolean",
"is",
"session",
"locally",
"transacted",
"(",
"session",
"session",
")",
"{",
"return",
"is",
"session",
"transacted",
"(",
")",
";",
"}"
] |
[
"object",
"argument",
"that",
"does",
"not",
"match",
"the",
"given",
"argument",
"matcher",
"see",
"examples",
"in",
"javadoc",
"for",
"{",
"@",
"link",
"additional",
"matchers",
"}",
"class"
] |
[
"public",
"static",
"<",
"t",
">",
"t",
"not",
"(",
"t",
"first",
")",
"{",
"mocking",
"progress",
"(",
")",
"get",
"argument",
"matcher",
"storage",
"(",
")",
"report",
"not",
"(",
")",
";",
"return",
"null",
";",
"}"
] |
[
"a",
"sensible",
"definition",
"of",
"{",
"@",
"link",
"#",
"to",
"string",
"}",
"as",
"{",
"@",
"code",
"entry",
"set",
"(",
")",
"to",
"string",
"(",
")",
"}",
"if",
"you",
"override",
"{",
"@",
"link",
"#",
"entry",
"set",
"}",
",",
"you",
"may",
"wish",
"to",
"override",
"{",
"@",
"link",
"#",
"to",
"string",
"}",
"to",
"forward",
"to",
"this",
"implementation"
] |
[
"protected",
"string",
"standard",
"to",
"string",
"(",
")",
"{",
"return",
"entry",
"set",
"(",
")",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"set",
"the",
"{",
"@",
"code",
"environment",
"}",
"that",
"this",
"component",
"runs",
"in"
] |
[
"void",
"set",
"environment",
"(",
"environment",
"environment",
")",
";"
] |
[
"positions",
"the",
"cursor",
"to",
"the",
"given",
"location"
] |
[
"public",
"boolean",
"go",
"to",
"field",
"(",
"address",
"a",
",",
"string",
"field",
"name",
",",
"int",
"occurrence",
",",
"int",
"row",
",",
"int",
"col",
",",
"boolean",
"scroll",
")",
"{",
"boolean",
"result",
"=",
"system",
"utilities",
"run",
"swing",
"now",
"(",
"(",
")",
"-",
">",
"do",
"go",
"to",
"field",
"(",
"a",
",",
"field",
"name",
",",
"occurrence",
",",
"row",
",",
"col",
",",
"scroll",
")",
")",
";",
"return",
"result",
";",
"}"
] |
[
"sets",
"the",
"{",
"@",
"link",
"configuration",
"}"
] |
[
"public",
"void",
"set",
"conf",
"(",
"configuration",
"conf",
")",
"{",
"this",
"conf",
"=",
"conf",
";",
"if",
"(",
"this",
"next",
"interceptor",
"!",
"=",
"null",
")",
"{",
"this",
"next",
"interceptor",
"set",
"conf",
"(",
"conf",
")",
";",
"}",
"}"
] |
[
"tests",
"that",
"file",
"cache",
"entries",
"expire"
] |
[
"public",
"void",
"test",
"file",
"cache",
"expiration",
"(",
")",
"throws",
"exception",
"{",
"final",
"time",
"cache",
"entry",
"duration",
"=",
"time",
"milliseconds",
"(",
"5l",
")",
";",
"final",
"file",
"output",
"file",
"=",
"run",
"file",
"caching",
"test",
"(",
"cache",
"entry",
"duration",
",",
"cache",
"entry",
"duration",
")",
";",
"assert",
"that",
"(",
"output",
"file",
"length",
"(",
")",
",",
"is",
"(",
"greater",
"than",
"(",
"0l",
")",
")",
")",
";",
"assert",
"that",
"(",
"file",
"utils",
"read",
"file",
"utf",
"8",
"(",
"output",
"file",
")",
",",
"is",
"(",
"equal",
"to",
"(",
"file",
"content",
"2",
")",
")",
")",
";",
"}"
] |
[
"create",
"a",
"rigid",
"body",
"given",
"a",
"definition",
"no",
"reference",
"to",
"the",
"definition",
"is",
"retained",
"@",
"warning",
"this",
"function",
"is",
"locked",
"during",
"callbacks"
] |
[
"public",
"body",
"create",
"body",
"(",
"body",
"def",
"def",
")",
"{",
"org",
"jbox",
"2d",
"dynamics",
"body",
"def",
"bd",
"=",
"new",
"org",
"jbox",
"2d",
"dynamics",
"body",
"def",
"(",
")",
";",
"bd",
"active",
"=",
"def",
"active",
";",
"bd",
"allow",
"sleep",
"=",
"def",
"allow",
"sleep",
";",
"bd",
"angle",
"=",
"def",
"angle",
";",
"bd",
"angular",
"damping",
"=",
"def",
"angular",
"damping",
";",
"bd",
"angular",
"velocity",
"=",
"def",
"angular",
"velocity",
";",
"bd",
"awake",
"=",
"def",
"awake",
";",
"bd",
"bullet",
"=",
"def",
"bullet",
";",
"bd",
"fixed",
"rotation",
"=",
"def",
"fixed",
"rotation",
";",
"bd",
"gravity",
"scale",
"=",
"def",
"gravity",
"scale",
";",
"bd",
"linear",
"damping",
"=",
"def",
"linear",
"damping",
";",
"bd",
"linear",
"velocity",
"set",
"(",
"def",
"linear",
"velocity",
"x",
",",
"def",
"linear",
"velocity",
"y",
")",
";",
"bd",
"position",
"set",
"(",
"def",
"position",
"x",
",",
"def",
"position",
"y",
")",
";",
"if",
"(",
"def",
"type",
"=",
"=",
"body",
"type",
"dynamic",
"body",
")",
"bd",
"type",
"=",
"org",
"jbox",
"2d",
"dynamics",
"body",
"type",
"dynamic",
";",
"if",
"(",
"def",
"type",
"=",
"=",
"body",
"type",
"static",
"body",
")",
"bd",
"type",
"=",
"org",
"jbox",
"2d",
"dynamics",
"body",
"type",
"static",
";",
"if",
"(",
"def",
"type",
"=",
"=",
"body",
"type",
"kinematic",
"body",
")",
"bd",
"type",
"=",
"org",
"jbox",
"2d",
"dynamics",
"body",
"type",
"kinematic",
";",
"org",
"jbox",
"2d",
"dynamics",
"body",
"b",
"=",
"world",
"create",
"body",
"(",
"bd",
")",
";",
"body",
"body",
"=",
"new",
"body",
"(",
"this",
",",
"b",
")",
";",
"bodies",
"put",
"(",
"b",
",",
"body",
")",
";",
"return",
"body",
";",
"}"
] |
[
"this",
"property",
"controls",
"the",
"keepalive",
"interval",
"for",
"a",
"connection",
"in",
"the",
"pool",
"an",
"in",
"-",
"use",
"connection",
"will",
"never",
"be",
"tested",
"by",
"the",
"keepalive",
"thread",
",",
"only",
"when",
"it",
"is",
"idle",
"will",
"it",
"be",
"tested"
] |
[
"public",
"long",
"get",
"keepalive",
"time",
"(",
")",
"{",
"return",
"keepalive",
"time",
";",
"}"
] |
[
"gets",
"the",
"snapshot",
"of",
"all",
"{",
"@",
"link",
"buildable",
"item",
"}",
"s"
] |
[
"public",
"list",
"<",
"buildable",
"item",
">",
"get",
"buildable",
"items",
"(",
")",
"{",
"snapshot",
"snapshot",
"=",
"this",
"snapshot",
";",
"array",
"list",
"<",
"buildable",
"item",
">",
"r",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"snapshot",
"buildables",
")",
";",
"r",
"add",
"all",
"(",
"snapshot",
"pendings",
")",
";",
"return",
"r",
";",
"}"
] |
[
"put",
"a",
"tombstone",
"to",
"the",
"shared",
"ddb",
"table"
] |
[
"protected",
"path",
"metadata",
"put",
"tombstone",
"(",
"final",
"string",
"key",
",",
"final",
"long",
"time",
",",
"bulk",
"operation",
"state",
"operation",
"state",
")",
"throws",
"i",
"o",
"exception",
"{",
"path",
"metadata",
"meta",
"=",
"tombstone",
"(",
"str",
"to",
"path",
"(",
"key",
")",
",",
"time",
")",
";",
"ms",
"put",
"(",
"meta",
",",
"operation",
"state",
")",
";",
"return",
"meta",
";",
"}"
] |
[
"this",
"field",
"is",
"deprecated",
"and",
"clients",
"should",
"switch",
"to",
"{",
"@",
"link",
"#",
"get",
"arguments",
"(",
")",
"}"
] |
[
"public",
"list",
"<",
"object",
">",
"get",
"literal",
"arguments",
"(",
")",
"{",
"list",
"<",
"object",
">",
"result",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"for",
"(",
"client",
"type",
"signature",
"parameter",
"argument",
":",
"arguments",
")",
"{",
"switch",
"(",
"argument",
"get",
"kind",
"(",
")",
")",
"{",
"case",
"named",
"type",
":",
"result",
"add",
"(",
"argument",
"get",
"named",
"type",
"signature",
"(",
")",
"get",
"name",
"(",
")",
")",
";",
"break",
";",
"default",
":",
"return",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"}",
"}",
"return",
"result",
";",
"}"
] |
[
"processes",
"each",
"model",
"'",
"s",
"property",
"mapped",
"to",
"decimal",
"type",
"and",
"adds",
"related",
"vendor",
"extensions"
] |
[
"public",
"void",
"process",
"decimal",
"type",
"property",
"(",
"codegen",
"model",
"model",
",",
"codegen",
"property",
"property",
")",
"{",
"map",
"<",
"string",
",",
"object",
">",
"vendor",
"extensions",
"=",
"property",
"get",
"vendor",
"extensions",
"(",
")",
";",
"map",
"<",
"string",
",",
"object",
">",
"mysql",
"schema",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"object",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"object",
">",
"column",
"definition",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"object",
">",
"(",
")",
";",
"array",
"list",
"column",
"data",
"type",
"arguments",
"=",
"new",
"array",
"list",
"(",
")",
";",
"string",
"base",
"name",
"=",
"property",
"get",
"base",
"name",
"(",
")",
";",
"string",
"col",
"name",
"=",
"this",
"to",
"column",
"name",
"(",
"base",
"name",
")",
";",
"string",
"data",
"type",
"=",
"property",
"get",
"data",
"type",
"(",
")",
";",
"string",
"data",
"format",
"=",
"property",
"get",
"data",
"format",
"(",
")",
";",
"string",
"description",
"=",
"property",
"get",
"description",
"(",
")",
";",
"string",
"minimum",
"=",
"property",
"get",
"minimum",
"(",
")",
";",
"string",
"maximum",
"=",
"property",
"get",
"maximum",
"(",
")",
";",
"boolean",
"exclusive",
"minimum",
"=",
"property",
"get",
"exclusive",
"minimum",
"(",
")",
";",
"boolean",
"exclusive",
"maximum",
"=",
"property",
"get",
"i",
"exclusive",
"maximum",
"(",
")",
";",
"string",
"default",
"value",
"=",
"property",
"get",
"default",
"value",
"(",
")",
";",
"boolean",
"required",
"=",
"property",
"get",
"required",
"(",
")",
";",
"boolean",
"unsigned",
"=",
"false",
";",
"boolean",
"is",
"enum",
"=",
"property",
"is",
"enum",
";",
"if",
"(",
"vendor",
"extensions",
"contains",
"key",
"(",
"vendor",
"extension",
"mysql",
"schema",
")",
")",
"{",
"/",
"/",
"user",
"already",
"specified",
"schema",
"values",
"logger",
"info",
"(",
"\"",
"found",
"vendor",
"extension",
"in",
"'",
"\"",
"+",
"base",
"name",
"+",
"\"",
"'",
"property",
",",
"autogeneration",
"skipped",
"\"",
")",
";",
"return",
";",
"}",
"if",
"(",
"this",
"get",
"identifier",
"naming",
"convention",
"(",
")",
"equals",
"(",
"\"",
"snake",
"case",
"\"",
")",
"&",
"&",
"!",
"base",
"name",
"equals",
"(",
"col",
"name",
")",
")",
"{",
"/",
"/",
"add",
"original",
"name",
"in",
"column",
"comment",
"string",
"comment",
"extra",
"=",
"\"",
"original",
"param",
"name",
"-",
"\"",
"+",
"base",
"name",
"+",
"\"",
"\"",
";",
"description",
"=",
"(",
"description",
"=",
"=",
"null",
"|",
"|",
"description",
"is",
"empty",
"(",
")",
")",
"?",
"comment",
"extra",
":",
"description",
"+",
"\"",
"\"",
"+",
"comment",
"extra",
";",
"}",
"vendor",
"extensions",
"put",
"(",
"vendor",
"extension",
"mysql",
"schema",
",",
"mysql",
"schema",
")",
";",
"mysql",
"schema",
"put",
"(",
"\"",
"column",
"definition",
"\"",
",",
"column",
"definition",
")",
";",
"column",
"definition",
"put",
"(",
"\"",
"col",
"name",
"\"",
",",
"col",
"name",
")",
";",
"if",
"(",
"boolean",
"true",
"equals",
"(",
"is",
"enum",
")",
")",
"{",
"map",
"<",
"string",
",",
"object",
">",
"allowable",
"values",
"=",
"property",
"get",
"allowable",
"values",
"(",
")",
";",
"list",
"<",
"object",
">",
"enum",
"values",
"=",
"(",
"list",
"<",
"object",
">",
")",
"allowable",
"values",
"get",
"(",
"\"",
"values",
"\"",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"enum",
"values",
"size",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"if",
"(",
"i",
">",
"enum",
"max",
"elements",
"-",
"1",
")",
"{",
"logger",
"warn",
"(",
"\"",
"enum",
"column",
"can",
"have",
"maximum",
"of",
"\"",
"+",
"enum",
"max",
"elements",
"to",
"string",
"(",
")",
"+",
"\"",
"distinct",
"elements",
",",
"following",
"value",
"will",
"be",
"skipped",
":",
"\"",
"+",
"(",
"string",
")",
"enum",
"values",
"get",
"(",
"i",
")",
")",
";",
"break",
";",
"}",
"string",
"value",
"=",
"string",
"value",
"of",
"(",
"enum",
"values",
"get",
"(",
"i",
")",
")",
";",
"column",
"data",
"type",
"arguments",
"add",
"(",
"to",
"codegen",
"mysql",
"data",
"type",
"argument",
"(",
"value",
")",
")",
";",
"}",
"column",
"definition",
"put",
"(",
"\"",
"col",
"data",
"type",
"\"",
",",
"\"",
"enum",
"\"",
")",
";",
"column",
"definition",
"put",
"(",
"\"",
"col",
"data",
"type",
"arguments",
"\"",
",",
"column",
"data",
"type",
"arguments",
")",
";",
"}",
"else",
"{",
"float",
"min",
"=",
"(",
"minimum",
"!",
"=",
"null",
")",
"?",
"float",
"value",
"of",
"(",
"minimum",
")",
":",
"null",
";",
"float",
"max",
"=",
"(",
"maximum",
"!",
"=",
"null",
")",
"?",
"float",
"value",
"of",
"(",
"maximum",
")",
":",
"null",
";",
"if",
"(",
"exclusive",
"minimum",
"&",
"&",
"min",
"!",
"=",
"null",
")",
"min",
"+",
"=",
"1",
";",
"if",
"(",
"exclusive",
"maximum",
"&",
"&",
"max",
"!",
"=",
"null",
")",
"max",
"-",
"=",
"1",
";",
"if",
"(",
"min",
"!",
"=",
"null",
"&",
"&",
"min",
">",
"=",
"0",
")",
"{",
"unsigned",
"=",
"true",
";",
"}",
"column",
"definition",
"put",
"(",
"\"",
"col",
"data",
"type",
"\"",
",",
"\"",
"decimal",
"\"",
")",
";",
"column",
"definition",
"put",
"(",
"\"",
"col",
"unsigned",
"\"",
",",
"unsigned",
")",
";",
"column",
"definition",
"put",
"(",
"\"",
"col",
"data",
"type",
"arguments",
"\"",
",",
"column",
"data",
"type",
"arguments",
")",
";",
"column",
"data",
"type",
"arguments",
"add",
"(",
"to",
"codegen",
"mysql",
"data",
"type",
"argument",
"(",
"20",
")",
")",
";",
"column",
"data",
"type",
"arguments",
"add",
"(",
"to",
"codegen",
"mysql",
"data",
"type",
"argument",
"(",
"9",
")",
")",
";",
"}",
"if",
"(",
"boolean",
"true",
"equals",
"(",
"required",
")",
")",
"{",
"column",
"definition",
"put",
"(",
"\"",
"col",
"not",
"null",
"\"",
",",
"true",
")",
";",
"}",
"else",
"{",
"column",
"definition",
"put",
"(",
"\"",
"col",
"not",
"null",
"\"",
",",
"false",
")",
";",
"try",
"{",
"column",
"definition",
"put",
"(",
"\"",
"col",
"default",
"\"",
",",
"to",
"codegen",
"mysql",
"data",
"type",
"default",
"(",
"default",
"value",
",",
"(",
"string",
")",
"column",
"definition",
"get",
"(",
"\"",
"col",
"data",
"type",
"\"",
")",
")",
")",
";",
"}",
"catch",
"(",
"runtime",
"exception",
"exception",
")",
"{",
"logger",
"warn",
"(",
"\"",
"property",
"'",
"\"",
"+",
"base",
"name",
"+",
"\"",
"'",
"of",
"model",
"'",
"\"",
"+",
"model",
"get",
"name",
"(",
")",
"+",
"\"",
"'",
"mapped",
"to",
"my",
"s",
"q",
"l",
"data",
"type",
"which",
"doesn",
"'",
"t",
"support",
"default",
"value",
"\"",
")",
";",
"column",
"definition",
"put",
"(",
"\"",
"col",
"default",
"\"",
",",
"null",
")",
";",
"}",
"}",
"if",
"(",
"description",
"!",
"=",
"null",
")",
"{",
"column",
"definition",
"put",
"(",
"\"",
"col",
"comment",
"\"",
",",
"description",
")",
";",
"}",
"}"
] |
[
"this",
"ordering",
"could",
"be",
"considered",
"to",
"be",
"backwards",
"(",
"the",
"global",
"\"",
"notification",
"\"",
"settings",
"take",
"precedence",
"over",
"the",
"account",
"level",
"\"",
"smtp",
"ssl",
"trust",
"\"",
"setting",
")",
"but",
"smtp",
"ssl",
"trust",
"was",
"ignored",
"for",
"a",
"period",
"of",
"time",
"(",
"see",
"#",
"52153",
")",
"so",
"this",
"is",
"the",
"least",
"breaking",
"way",
"to",
"resolve",
"that"
] |
[
"public",
"void",
"test",
"notification",
"ssl",
"settings",
"override",
"smtp",
"ssl",
"trust",
"(",
")",
"throws",
"exception",
"{",
"list",
"<",
"mime",
"message",
">",
"messages",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"server",
"add",
"listener",
"(",
"messages",
":",
":",
"add",
")",
";",
"try",
"{",
"final",
"settings",
"builder",
"settings",
"=",
"settings",
"builder",
"(",
")",
"put",
"(",
"\"",
"xpack",
"notification",
"email",
"account",
"test",
"smtp",
"ssl",
"trust",
"\"",
",",
"\"",
"localhost",
"\"",
")",
"put",
"(",
"\"",
"xpack",
"notification",
"email",
"ssl",
"verification",
"mode",
"\"",
",",
"\"",
"full",
"\"",
")",
";",
"final",
"mock",
"secure",
"settings",
"secure",
"settings",
"=",
"new",
"mock",
"secure",
"settings",
"(",
")",
";",
"executable",
"email",
"action",
"email",
"action",
"=",
"build",
"email",
"action",
"(",
"settings",
",",
"secure",
"settings",
")",
";",
"watch",
"execution",
"context",
"ctx",
"=",
"watcher",
"test",
"utils",
"create",
"watch",
"execution",
"context",
"(",
")",
";",
"final",
"messaging",
"exception",
"exception",
"=",
"expect",
"throws",
"(",
"messaging",
"exception",
"class",
",",
"(",
")",
"-",
">",
"email",
"action",
"execute",
"(",
"\"",
"my",
"action",
"id",
"\"",
",",
"ctx",
",",
"payload",
"empty",
")",
")",
";",
"final",
"list",
"<",
"throwable",
">",
"all",
"causes",
"=",
"get",
"all",
"causes",
"(",
"exception",
")",
";",
"assert",
"that",
"(",
"all",
"causes",
",",
"matchers",
"has",
"item",
"(",
"matchers",
"instance",
"of",
"(",
"s",
"s",
"l",
"exception",
"class",
")",
")",
")",
";",
"}",
"finally",
"{",
"server",
"clear",
"listeners",
"(",
")",
";",
"}",
"}"
] |
[
"specifies",
"the",
"types",
"for",
"the",
"csv",
"fields",
"this",
"method",
"parses",
"the",
"csv",
"data",
"to",
"a",
"23",
"-",
"tuple",
"which",
"has",
"fields",
"of",
"the",
"specified",
"types",
"this",
"method",
"is",
"overloaded",
"for",
"each",
"possible",
"length",
"of",
"the",
"tuples",
"to",
"support",
"type",
"safe",
"creation",
"of",
"data",
"sets",
"through",
"csv",
"parsing"
] |
[
"public",
"<",
"t0",
",",
"t1",
",",
"t2",
",",
"t3",
",",
"t4",
",",
"t5",
",",
"t6",
",",
"t7",
",",
"t8",
",",
"t9",
",",
"t10",
",",
"t11",
",",
"t12",
",",
"t13",
",",
"t14",
",",
"t15",
",",
"t16",
",",
"t17",
",",
"t18",
",",
"t19",
",",
"t20",
",",
"t21",
",",
"t22",
">",
"data",
"source",
"<",
"tuple",
"2",
"3",
"<",
"t0",
",",
"t1",
",",
"t2",
",",
"t3",
",",
"t4",
",",
"t5",
",",
"t6",
",",
"t7",
",",
"t8",
",",
"t9",
",",
"t10",
",",
"t11",
",",
"t12",
",",
"t13",
",",
"t14",
",",
"t15",
",",
"t16",
",",
"t17",
",",
"t18",
",",
"t19",
",",
"t20",
",",
"t21",
",",
"t22",
">",
">",
"types",
"(",
"class",
"<",
"t0",
">",
"type",
"0",
",",
"class",
"<",
"t1",
">",
"type",
"1",
",",
"class",
"<",
"t2",
">",
"type",
"2",
",",
"class",
"<",
"t3",
">",
"type",
"3",
",",
"class",
"<",
"t4",
">",
"type",
"4",
",",
"class",
"<",
"t5",
">",
"type",
"5",
",",
"class",
"<",
"t6",
">",
"type",
"6",
",",
"class",
"<",
"t7",
">",
"type",
"7",
",",
"class",
"<",
"t8",
">",
"type",
"8",
",",
"class",
"<",
"t9",
">",
"type",
"9",
",",
"class",
"<",
"t10",
">",
"type",
"1",
"0",
",",
"class",
"<",
"t11",
">",
"type",
"1",
"1",
",",
"class",
"<",
"t12",
">",
"type",
"1",
"2",
",",
"class",
"<",
"t13",
">",
"type",
"1",
"3",
",",
"class",
"<",
"t14",
">",
"type",
"1",
"4",
",",
"class",
"<",
"t15",
">",
"type",
"1",
"5",
",",
"class",
"<",
"t16",
">",
"type",
"1",
"6",
",",
"class",
"<",
"t17",
">",
"type",
"1",
"7",
",",
"class",
"<",
"t18",
">",
"type",
"1",
"8",
",",
"class",
"<",
"t19",
">",
"type",
"1",
"9",
",",
"class",
"<",
"t20",
">",
"type",
"2",
"0",
",",
"class",
"<",
"t21",
">",
"type",
"2",
"1",
",",
"class",
"<",
"t22",
">",
"type",
"2",
"2",
")",
"{",
"tuple",
"type",
"info",
"<",
"tuple",
"2",
"3",
"<",
"t0",
",",
"t1",
",",
"t2",
",",
"t3",
",",
"t4",
",",
"t5",
",",
"t6",
",",
"t7",
",",
"t8",
",",
"t9",
",",
"t10",
",",
"t11",
",",
"t12",
",",
"t13",
",",
"t14",
",",
"t15",
",",
"t16",
",",
"t17",
",",
"t18",
",",
"t19",
",",
"t20",
",",
"t21",
",",
"t22",
">",
">",
"types",
"=",
"tuple",
"type",
"info",
"get",
"basic",
"and",
"basic",
"value",
"tuple",
"type",
"info",
"(",
"type",
"0",
",",
"type",
"1",
",",
"type",
"2",
",",
"type",
"3",
",",
"type",
"4",
",",
"type",
"5",
",",
"type",
"6",
",",
"type",
"7",
",",
"type",
"8",
",",
"type",
"9",
",",
"type",
"1",
"0",
",",
"type",
"1",
"1",
",",
"type",
"1",
"2",
",",
"type",
"1",
"3",
",",
"type",
"1",
"4",
",",
"type",
"1",
"5",
",",
"type",
"1",
"6",
",",
"type",
"1",
"7",
",",
"type",
"1",
"8",
",",
"type",
"1",
"9",
",",
"type",
"2",
"0",
",",
"type",
"2",
"1",
",",
"type",
"2",
"2",
")",
";",
"csv",
"input",
"format",
"<",
"tuple",
"2",
"3",
"<",
"t0",
",",
"t1",
",",
"t2",
",",
"t3",
",",
"t4",
",",
"t5",
",",
"t6",
",",
"t7",
",",
"t8",
",",
"t9",
",",
"t10",
",",
"t11",
",",
"t12",
",",
"t13",
",",
"t14",
",",
"t15",
",",
"t16",
",",
"t17",
",",
"t18",
",",
"t19",
",",
"t20",
",",
"t21",
",",
"t22",
">",
">",
"input",
"format",
"=",
"new",
"tuple",
"csv",
"input",
"format",
"<",
"tuple",
"2",
"3",
"<",
"t0",
",",
"t1",
",",
"t2",
",",
"t3",
",",
"t4",
",",
"t5",
",",
"t6",
",",
"t7",
",",
"t8",
",",
"t9",
",",
"t10",
",",
"t11",
",",
"t12",
",",
"t13",
",",
"t14",
",",
"t15",
",",
"t16",
",",
"t17",
",",
"t18",
",",
"t19",
",",
"t20",
",",
"t21",
",",
"t22",
">",
">",
"(",
"path",
",",
"types",
",",
"this",
"included",
"mask",
")",
";",
"configure",
"input",
"format",
"(",
"input",
"format",
")",
";",
"return",
"new",
"data",
"source",
"<",
"tuple",
"2",
"3",
"<",
"t0",
",",
"t1",
",",
"t2",
",",
"t3",
",",
"t4",
",",
"t5",
",",
"t6",
",",
"t7",
",",
"t8",
",",
"t9",
",",
"t10",
",",
"t11",
",",
"t12",
",",
"t13",
",",
"t14",
",",
"t15",
",",
"t16",
",",
"t17",
",",
"t18",
",",
"t19",
",",
"t20",
",",
"t21",
",",
"t22",
">",
">",
"(",
"execution",
"context",
",",
"input",
"format",
",",
"types",
",",
"utils",
"get",
"call",
"location",
"name",
"(",
")",
")",
";",
"}"
] |
[
"finds",
"a",
"matching",
"file",
"by",
"iterating",
"path",
"components"
] |
[
"protected",
"url",
"get",
"url",
"(",
"iterable",
"<",
"file",
">",
"path",
"components",
",",
"string",
"name",
")",
"{",
"url",
"url",
"=",
"null",
";",
"for",
"(",
"file",
"path",
"component",
":",
"path",
"components",
")",
"{",
"url",
"=",
"get",
"resource",
"u",
"r",
"l",
"(",
"path",
"component",
",",
"name",
")",
";",
"if",
"(",
"url",
"!",
"=",
"null",
")",
"{",
"log",
"(",
"\"",
"resource",
"\"",
"+",
"name",
"+",
"\"",
"loaded",
"from",
"ant",
"loader",
"\"",
",",
"project",
"msg",
"debug",
")",
";",
"break",
";",
"}",
"}",
"return",
"url",
";",
"}"
] |
[
"call",
"the",
"non",
"-",
"timed",
"{",
"@",
"link",
"future",
"#",
"get",
"(",
")",
"}",
"in",
"a",
"way",
"that",
"allows",
"us",
"to",
"abort",
"if",
"it",
"'",
"s",
"expected",
"to",
"hang",
"forever",
"more",
"precisely",
",",
"if",
"it",
"'",
"s",
"expected",
"to",
"return",
",",
"we",
"simply",
"call",
"it",
"[",
"]",
",",
"but",
"if",
"it",
"'",
"s",
"expected",
"to",
"hang",
"(",
"because",
"one",
"of",
"the",
"input",
"futures",
"that",
"we",
"know",
"makes",
"it",
"up",
"isn",
"'",
"t",
"done",
"yet",
")",
",",
"then",
"we",
"call",
"it",
"in",
"a",
"separate",
"thread",
"(",
"using",
"pseudo",
"timed",
"get",
")",
"the",
"result",
"is",
"that",
"we",
"wait",
"as",
"long",
"as",
"necessary",
"when",
"the",
"method",
"is",
"expected",
"to",
"return",
"(",
"at",
"the",
"cost",
"of",
"hanging",
"forever",
"if",
"there",
"is",
"a",
"bug",
"in",
"the",
"class",
"under",
"test",
")",
"but",
"that",
"we",
"time",
"out",
"fairly",
"promptly",
"when",
"the",
"method",
"is",
"expected",
"to",
"hang",
"(",
"possibly",
"too",
"quickly",
",",
"but",
"too",
"-",
"quick",
"failures",
"should",
"be",
"very",
"unlikely",
",",
"given",
"that",
"we",
"used",
"to",
"bail",
"after",
"2",
"0ms",
"during",
"the",
"expected",
"-",
"successful",
"tests",
",",
"and",
"there",
"we",
"saw",
"a",
"failure",
"rate",
"of",
"~",
"15000",
",",
"meaning",
"that",
"the",
"other",
"thread",
"'",
"s",
"get",
"(",
")",
"call",
"nearly",
"always",
"completes",
"within",
"2",
"0ms",
"if",
"it",
"'",
"s",
"going",
"to",
"complete",
"at",
"all",
")",
"[",
"]",
"to",
"avoid",
"hangs",
",",
"i",
"'",
"ve",
"disabled",
"the",
"in",
"-",
"thread",
"calls",
"this",
"makes",
"the",
"test",
"take",
"(",
"very",
"roughly",
")",
"2",
"5s",
"longer",
"(",
"2",
"5s",
"is",
"also",
"the",
"maximum",
"length",
"of",
"time",
"we",
"will",
"wait",
"for",
"a",
"timed",
"get",
"that",
"is",
"expected",
"to",
"succeed",
";",
"the",
"fact",
"that",
"the",
"numbers",
"match",
"is",
"only",
"a",
"coincidence",
")",
"see",
"the",
"comment",
"below",
"for",
"how",
"to",
"restore",
"the",
"fast",
"but",
"hang",
"-",
"y",
"version"
] |
[
"private",
"static",
"list",
"<",
"string",
">",
"conditional",
"pseudo",
"timed",
"get",
"uninterruptibly",
"(",
"test",
"future",
"batch",
"inputs",
",",
"listenable",
"future",
"<",
"string",
">",
"i",
"future",
",",
"listenable",
"future",
"<",
"string",
">",
"j",
"future",
",",
"listenable",
"future",
"<",
"list",
"<",
"string",
">",
">",
"future",
",",
"int",
"timeout",
",",
"time",
"unit",
"unit",
")",
"throws",
"execution",
"exception",
",",
"timeout",
"exception",
"{",
"/",
"*",
"*",
"for",
"faster",
"tests",
"(",
"that",
"may",
"hang",
"indefinitely",
"if",
"the",
"class",
"under",
"test",
"has",
"*",
"a",
"bug",
"!",
")",
",",
"switch",
"the",
"second",
"branch",
"to",
"call",
"untimed",
"future",
"get",
"(",
")",
"instead",
"of",
"*",
"pseudo",
"timed",
"get",
"*",
"/",
"return",
"(",
"inputs",
"has",
"delayed",
"(",
"i",
"future",
",",
"j",
"future",
")",
")",
"?",
"pseudo",
"timed",
"get",
"uninterruptibly",
"(",
"future",
",",
"timeout",
",",
"unit",
")",
":",
"pseudo",
"timed",
"get",
"uninterruptibly",
"(",
"future",
",",
"2500",
",",
"milliseconds",
")",
";",
"}"
] |
[
"paint",
"disabled",
"text"
] |
[
"protected",
"void",
"paint",
"disabled",
"text",
"(",
"final",
"graphics",
"g",
",",
"final",
"string",
"text",
",",
"final",
"j",
"component",
"c",
",",
"final",
"rectangle",
"text",
"rect",
",",
"final",
"font",
"metrics",
"metrics",
")",
"{",
"final",
"string",
"text",
"to",
"print",
"=",
"m",
"t",
"config",
"get",
"instance",
"(",
")",
"is",
"upper",
"case",
"buttons",
"(",
")",
"?",
"text",
"to",
"upper",
"case",
"(",
"locale",
"english",
")",
":",
"text",
";",
"final",
"int",
"x",
"=",
"(",
"c",
"get",
"width",
"(",
")",
"-",
"get",
"text",
"shift",
"offset",
"(",
")",
"-",
"metrics",
"string",
"width",
"(",
"text",
"to",
"print",
")",
")",
"/",
"2",
";",
"g",
"set",
"color",
"(",
"mtui",
"button",
"get",
"disabled",
"shadow",
"color",
"(",
")",
")",
";",
"swing",
"utilities",
"2",
"draw",
"string",
"underline",
"char",
"at",
"(",
"c",
",",
"g",
",",
"text",
"to",
"print",
",",
"-",
"1",
",",
"x",
"+",
"1",
",",
"text",
"rect",
"y",
"+",
"metrics",
"get",
"ascent",
"(",
")",
"+",
"1",
")",
";",
"g",
"set",
"color",
"(",
"mtui",
"button",
"get",
"disabled",
"color",
"(",
")",
")",
";",
"swing",
"utilities",
"2",
"draw",
"string",
"underline",
"char",
"at",
"(",
"c",
",",
"g",
",",
"text",
"to",
"print",
",",
"-",
"1",
",",
"x",
",",
"text",
"rect",
"y",
"+",
"metrics",
"get",
"ascent",
"(",
")",
")",
";",
"}"
] |
[
"arrays",
"as",
"list",
"(",
")",
",",
"，"
] |
[
"public",
"static",
"list",
"<",
"long",
">",
"long",
"as",
"list",
"(",
"long",
"backing",
"array",
")",
"{",
"return",
"longs",
"as",
"list",
"(",
"backing",
"array",
")",
";",
"}"
] |
[
"returns",
"an",
"immutable",
"sorted",
"set",
"containing",
"the",
"given",
"elements",
"sorted",
"by",
"their",
"natural",
"ordering",
"when",
"multiple",
"elements",
"are",
"equivalent",
"according",
"to",
"{",
"@",
"code",
"compare",
"to",
"(",
")",
"}",
",",
"only",
"the",
"first",
"one",
"specified",
"is",
"included",
"to",
"create",
"a",
"copy",
"of",
"a",
"{",
"@",
"code",
"sorted",
"set",
"}",
"that",
"preserves",
"the",
"comparator",
",",
"call",
"{",
"@",
"link",
"#",
"copy",
"of",
"sorted",
"}",
"instead",
"this",
"method",
"iterates",
"over",
"{",
"@",
"code",
"elements",
"}",
"at",
"most",
"once",
"note",
"that",
"if",
"{",
"@",
"code",
"s",
"}",
"is",
"a",
"{",
"@",
"code",
"set",
"<",
"string",
">",
"}",
",",
"then",
"{",
"@",
"code",
"immutable",
"sorted",
"set",
"copy",
"of",
"(",
"s",
")",
"}",
"returns",
"an",
"{",
"@",
"code",
"immutable",
"sorted",
"set",
"<",
"string",
">",
"}",
"containing",
"each",
"of",
"the",
"strings",
"in",
"{",
"@",
"code",
"s",
"}",
",",
"while",
"{",
"@",
"code",
"immutable",
"sorted",
"set",
"of",
"(",
"s",
")",
"}",
"returns",
"an",
"{",
"@",
"code",
"immutable",
"sorted",
"set",
"<",
"set",
"<",
"string",
">",
">",
"}",
"containing",
"one",
"element",
"(",
"the",
"given",
"set",
"itself",
")",
"<",
"b",
">",
"note",
":",
"<",
"b",
">",
"despite",
"what",
"the",
"method",
"name",
"suggests",
",",
"if",
"{",
"@",
"code",
"elements",
"}",
"is",
"an",
"{",
"@",
"code",
"immutable",
"sorted",
"set",
"}",
",",
"it",
"may",
"be",
"returned",
"instead",
"of",
"a",
"copy",
"this",
"method",
"is",
"not",
"type",
"-",
"safe",
",",
"as",
"it",
"may",
"be",
"called",
"on",
"elements",
"that",
"are",
"not",
"mutually",
"comparable",
"this",
"method",
"is",
"safe",
"to",
"use",
"even",
"when",
"{",
"@",
"code",
"elements",
"}",
"is",
"a",
"synchronized",
"or",
"concurrent",
"collection",
"that",
"is",
"currently",
"being",
"modified",
"by",
"another",
"thread"
] |
[
"public",
"static",
"<",
"e",
">",
"immutable",
"sorted",
"set",
"<",
"e",
">",
"copy",
"of",
"(",
"collection",
"<",
"?",
"extends",
"e",
">",
"elements",
")",
"{",
"/",
"/",
"hack",
"around",
"e",
"not",
"being",
"a",
"subtype",
"of",
"comparable",
"/",
"/",
"unsafe",
",",
"see",
"immutable",
"sorted",
"set",
"fauxveride",
"shim",
"@",
"suppress",
"warnings",
"(",
"\"",
"unchecked",
"\"",
")",
"ordering",
"<",
"e",
">",
"natural",
"order",
"=",
"(",
"ordering",
"<",
"e",
">",
")",
"ordering",
"<",
"comparable",
">",
"natural",
"(",
")",
";",
"return",
"copy",
"of",
"(",
"natural",
"order",
",",
"elements",
")",
";",
"}"
] |
[
"returns",
"the",
"time",
"since",
"the",
"start",
"of",
"the",
"associated",
"gc",
"time",
"monitor"
] |
[
"public",
"long",
"get",
"gc",
"monitor",
"run",
"time",
"(",
")",
"{",
"return",
"gc",
"monitor",
"run",
"time",
";",
"}"
] |
[
"raise",
"an",
"exception",
"if",
"this",
"instance",
"indicates",
"failure",
",",
"otherwise",
"do",
"nothing"
] |
[
"public",
"void",
"throw",
"exception",
"if",
"failed",
"(",
")",
"throws",
"o",
"auth",
"bearer",
"illegal",
"token",
"exception",
"{",
"if",
"(",
"!",
"success",
"(",
")",
")",
"throw",
"new",
"o",
"auth",
"bearer",
"illegal",
"token",
"exception",
"(",
"this",
")",
";",
"}"
] |
[
"static",
"method",
"to",
"get",
"single",
"instance",
"of",
"class"
] |
[
"public",
"static",
"file",
"logger",
"module",
"get",
"singleton",
"(",
")",
"{",
"if",
"(",
"file",
"logger",
"module",
"singleton",
"=",
"=",
"null",
")",
"{",
"file",
"logger",
"module",
"singleton",
"=",
"new",
"file",
"logger",
"module",
"(",
")",
";",
"}",
"return",
"file",
"logger",
"module",
"singleton",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"property",
"class",
"'"
] |
[
"public",
"void",
"property",
"class",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"property",
"class",
"}"
] |
[
"get",
"a",
"unique",
"parameter",
"name",
"for",
"a",
"parameter",
"when",
"all",
"parameter",
"names",
"are",
"being",
"replaced",
"if",
"the",
"specified",
"name",
"is",
"a",
"default",
"parameter",
"name",
"then",
"the",
"original",
"default",
"name",
"passed",
"in",
"is",
"returned"
] |
[
"private",
"static",
"string",
"get",
"unique",
"replacement",
"parameter",
"name",
"(",
"symbol",
"table",
"symbol",
"table",
",",
"function",
"function",
",",
"string",
"name",
",",
"set",
"<",
"string",
">",
"names",
"not",
"to",
"be",
"used",
")",
"{",
"if",
"(",
"name",
"=",
"=",
"null",
"|",
"|",
"symbol",
"utilities",
"is",
"default",
"parameter",
"name",
"(",
"name",
")",
")",
"{",
"return",
"name",
";",
"}",
"return",
"get",
"unique",
"name",
"ignoring",
"current",
"parameters",
"(",
"symbol",
"table",
",",
"function",
",",
"name",
",",
"names",
"not",
"to",
"be",
"used",
")",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}",
"the",
"default",
"implementation",
"returns",
"the",
"result",
"of",
"calling",
"{",
"@",
"link",
"#",
"visit",
"children",
"}",
"on",
"{",
"@",
"code",
"ctx",
"}"
] |
[
"@",
"override",
"public",
"t",
"visit",
"notaddsub",
"(",
"painless",
"parser",
"notaddsub",
"context",
"ctx",
")",
"{",
"return",
"visit",
"children",
"(",
"ctx",
")",
";",
"}"
] |
[
"set",
"the",
"{",
"@",
"link",
"message",
"converter",
"}",
"to",
"use",
"to",
"convert",
"the",
"payload",
"of",
"incoming",
"and",
"outgoing",
"messages",
"to",
"and",
"from",
"{",
"@",
"code",
"byte",
"[",
"]",
"}",
"based",
"on",
"object",
"type",
"and",
"the",
"\"",
"content",
"-",
"type",
"\"",
"header",
"by",
"default",
",",
"{",
"@",
"link",
"simple",
"message",
"converter",
"}",
"is",
"configured"
] |
[
"public",
"void",
"set",
"message",
"converter",
"(",
"message",
"converter",
"message",
"converter",
")",
"{",
"assert",
"not",
"null",
"(",
"message",
"converter",
",",
"\"",
"message",
"converter",
"must",
"not",
"be",
"null",
"\"",
")",
";",
"this",
"message",
"converter",
"=",
"message",
"converter",
";",
"}"
] |
[
"read",
"a",
"script",
"from",
"the",
"provided",
"{",
"@",
"code",
"line",
"number",
"reader",
"}",
",",
"using",
"the",
"supplied",
"comment",
"prefix",
"and",
"statement",
"separator",
",",
"and",
"build",
"a",
"{",
"@",
"code",
"string",
"}",
"containing",
"the",
"lines",
"lines",
"beginning",
"with",
"the",
"comment",
"prefix",
"are",
"excluded",
"from",
"the",
"results",
";",
"however",
",",
"line",
"comments",
"anywhere",
"else",
"&",
"mdash",
";",
"for",
"example",
",",
"within",
"a",
"statement",
"&",
"mdash",
";",
"will",
"be",
"included",
"in",
"the",
"results"
] |
[
"public",
"static",
"string",
"read",
"script",
"(",
"line",
"number",
"reader",
"line",
"number",
"reader",
",",
"@",
"nullable",
"string",
"line",
"comment",
"prefix",
",",
"@",
"nullable",
"string",
"separator",
",",
"@",
"nullable",
"string",
"block",
"comment",
"end",
"delimiter",
")",
"throws",
"i",
"o",
"exception",
"{",
"string",
"[",
"]",
"line",
"comment",
"prefixes",
"=",
"(",
"line",
"comment",
"prefix",
"!",
"=",
"null",
")",
"?",
"new",
"string",
"[",
"]",
"{",
"line",
"comment",
"prefix",
"}",
":",
"null",
";",
"return",
"read",
"script",
"(",
"line",
"number",
"reader",
",",
"line",
"comment",
"prefixes",
",",
"separator",
",",
"block",
"comment",
"end",
"delimiter",
")",
";",
"}"
] |
[
"non",
"volatile",
"write",
"of",
"the",
"thread",
"to",
"the",
"{",
"@",
"link",
"waiter",
"#",
"thread",
"}",
"field"
] |
[
"abstract",
"void",
"put",
"thread",
"(",
"waiter",
"waiter",
",",
"thread",
"new",
"value",
")",
";"
] |
[
"verify",
"that",
"the",
"input",
"stream",
"is",
"open",
"non",
"blocking",
";",
"this",
"gives",
"the",
"last",
"state",
"of",
"the",
"volatile",
"{",
"@",
"link",
"#",
"closed",
"}",
"field"
] |
[
"private",
"void",
"check",
"not",
"closed",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"closed",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"f",
"s",
"exception",
"messages",
"stream",
"is",
"closed",
")",
";",
"}",
"}"
] |
[
"writes",
"the",
"portion",
"of",
"the",
"file",
"header",
"that",
"refers",
"to",
"this",
"instance"
] |
[
"public",
"void",
"write",
"header",
"part",
"(",
"annotated",
"output",
"out",
")",
"{",
"throw",
"if",
"not",
"prepared",
"(",
")",
";",
"int",
"sz",
"=",
"field",
"ids",
"size",
"(",
")",
";",
"int",
"offset",
"=",
"(",
"sz",
"=",
"=",
"0",
")",
"?",
"0",
":",
"get",
"file",
"offset",
"(",
")",
";",
"if",
"(",
"out",
"annotates",
"(",
")",
")",
"{",
"out",
"annotate",
"(",
"4",
",",
"\"",
"field",
"ids",
"size",
":",
"\"",
"+",
"hex",
"u",
"4",
"(",
"sz",
")",
")",
";",
"out",
"annotate",
"(",
"4",
",",
"\"",
"field",
"ids",
"off",
":",
"\"",
"+",
"hex",
"u",
"4",
"(",
"offset",
")",
")",
";",
"}",
"out",
"write",
"int",
"(",
"sz",
")",
";",
"out",
"write",
"int",
"(",
"offset",
")",
";",
"}"
] |
[
"register",
"a",
"listener",
"that",
"will",
"be",
"called",
"when",
"this",
"model",
"visibility",
"has",
"changed",
"the",
"listener",
"will",
"contribute",
"to",
"this",
"model",
"'",
"s",
"hash",
"code",
"state",
"per",
"the",
"{",
"@",
"link",
"com",
"airbnb",
"epoxy",
"epoxy",
"attribute",
"option",
"#",
"do",
"not",
"hash",
"}",
"rules"
] |
[
"public",
"test",
"field",
"prop",
"do",
"not",
"hash",
"option",
"view",
"model",
"on",
"visibility",
"changed",
"(",
"on",
"model",
"visibility",
"changed",
"listener",
"<",
"test",
"field",
"prop",
"do",
"not",
"hash",
"option",
"view",
"model",
",",
"test",
"field",
"prop",
"do",
"not",
"hash",
"option",
"view",
">",
"listener",
")",
"{",
"on",
"mutation",
"(",
")",
";",
"this",
"on",
"model",
"visibility",
"changed",
"listener",
"epoxy",
"generated",
"model",
"=",
"listener",
";",
"return",
"this",
";",
"}"
] |
[
"parses",
"a",
"language",
"compiler",
"spec",
"pair",
"from",
"a",
"string"
] |
[
"public",
"language",
"compiler",
"spec",
"pair",
"parse",
"language",
"compile",
"spec",
"pair",
"(",
"string",
"val",
")",
"{",
"if",
"(",
"val",
"is",
"empty",
"(",
")",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"no",
"language",
"compiler",
"spec",
"pair",
"specified",
"\"",
")",
";",
"}",
"set",
"<",
"language",
"compiler",
"spec",
"pair",
">",
"all",
"pairs",
"=",
"new",
"hash",
"set",
"<",
">",
"(",
")",
";",
"list",
"<",
"language",
"description",
">",
"language",
"descriptions",
"=",
"default",
"language",
"service",
"get",
"language",
"service",
"(",
")",
"get",
"language",
"descriptions",
"(",
"false",
")",
";",
"if",
"(",
"language",
"descriptions",
"!",
"=",
"null",
")",
"{",
"for",
"(",
"language",
"description",
"description",
":",
"language",
"descriptions",
")",
"{",
"collection",
"<",
"compiler",
"spec",
"description",
">",
"cs",
"descriptions",
"=",
"description",
"get",
"compatible",
"compiler",
"spec",
"descriptions",
"(",
")",
";",
"if",
"(",
"cs",
"descriptions",
"!",
"=",
"null",
")",
"{",
"for",
"(",
"compiler",
"spec",
"description",
"cs",
"description",
":",
"cs",
"descriptions",
")",
"{",
"all",
"pairs",
"add",
"(",
"new",
"language",
"compiler",
"spec",
"pair",
"(",
"description",
"get",
"language",
"i",
"d",
"(",
")",
",",
"cs",
"description",
"get",
"compiler",
"spec",
"i",
"d",
"(",
")",
")",
")",
";",
"}",
"}",
"}",
"}",
"/",
"/",
"split",
"on",
"last",
"colon",
"to",
"get",
"separated",
"language",
"i",
"d",
"and",
"compiler",
"spec",
"i",
"d",
"int",
"last",
"colon",
"=",
"val",
"last",
"index",
"of",
"(",
"'",
":",
"'",
")",
";",
"string",
"stored",
"lang",
"i",
"d",
"=",
"val",
"substring",
"(",
"0",
",",
"last",
"colon",
")",
";",
"string",
"stored",
"compiler",
"spec",
"i",
"d",
"=",
"val",
"substring",
"(",
"last",
"colon",
"+",
"1",
")",
";",
"language",
"compiler",
"spec",
"pair",
"stored",
"l",
"c",
"s",
"=",
"new",
"language",
"compiler",
"spec",
"pair",
"(",
"stored",
"lang",
"i",
"d",
",",
"stored",
"compiler",
"spec",
"i",
"d",
")",
";",
"if",
"(",
"all",
"pairs",
"contains",
"(",
"stored",
"l",
"c",
"s",
")",
")",
"{",
"return",
"stored",
"l",
"c",
"s",
";",
"}",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"invalid",
"language",
"compiler",
"spec",
"pair",
":",
"\"",
"+",
"val",
")",
";",
"}"
] |
[
"this",
"neat",
"test",
"shows",
"that",
"no",
"matter",
"what",
"weights",
"we",
"use",
"in",
"our",
"requests",
",",
"if",
"we",
"push",
"x",
"amount",
"of",
"permits",
"in",
"a",
"cool",
"state",
",",
"where",
"x",
"=",
"rate",
"time",
"to",
"cool",
"down",
",",
"and",
"we",
"have",
"specified",
"a",
"time",
"to",
"warm",
"up",
"(",
")",
"period",
",",
"it",
"will",
"cost",
"as",
"the",
"prescribed",
"amount",
"of",
"time",
"e",
"g",
",",
"calling",
"[",
"acquire",
"(",
"5",
")",
",",
"acquire",
"(",
"1",
")",
"]",
"takes",
"exactly",
"the",
"same",
"time",
"as",
"[",
"acquire",
"(",
"2",
")",
",",
"acquire",
"(",
"3",
")",
",",
"acquire",
"(",
"1",
")",
"]"
] |
[
"public",
"void",
"test",
"time",
"to",
"warm",
"up",
"is",
"honoured",
"even",
"with",
"weights",
"(",
")",
"{",
"random",
"random",
"=",
"new",
"random",
"(",
")",
";",
"int",
"warmup",
"permits",
"=",
"10",
";",
"double",
"[",
"]",
"cold",
"factors",
"to",
"test",
"=",
"{",
"2",
"0",
",",
"3",
"0",
",",
"10",
"0",
"}",
";",
"double",
"[",
"]",
"qps",
"to",
"test",
"=",
"{",
"4",
"0",
",",
"2",
"0",
",",
"1",
"0",
",",
"0",
"5",
",",
"0",
"1",
"}",
";",
"for",
"(",
"int",
"trial",
"=",
"0",
";",
"trial",
"<",
"100",
";",
"trial",
"+",
"+",
")",
"{",
"for",
"(",
"double",
"cold",
"factor",
":",
"cold",
"factors",
"to",
"test",
")",
"{",
"for",
"(",
"double",
"qps",
":",
"qps",
"to",
"test",
")",
"{",
"/",
"/",
"if",
"warmup",
"permits",
"=",
"max",
"permits",
"-",
"threshold",
"permits",
"then",
"/",
"/",
"warmup",
"period",
"=",
"(",
"1",
"+",
"cold",
"factor",
")",
"*",
"warmup",
"permits",
"*",
"stable",
"interval",
"/",
"2",
"long",
"warmup",
"millis",
"=",
"(",
"long",
")",
"(",
"(",
"1",
"+",
"cold",
"factor",
")",
"*",
"warmup",
"permits",
"/",
"(",
"2",
"0",
"*",
"qps",
")",
"*",
"1000",
"0",
")",
";",
"rate",
"limiter",
"rate",
"limiter",
"=",
"rate",
"limiter",
"create",
"(",
"qps",
",",
"warmup",
"millis",
",",
"milliseconds",
",",
"cold",
"factor",
",",
"stopwatch",
")",
";",
"assert",
"equals",
"(",
"warmup",
"millis",
",",
"measure",
"total",
"time",
"millis",
"(",
"rate",
"limiter",
",",
"warmup",
"permits",
",",
"random",
")",
")",
";",
"}",
"}",
"}",
"}"
] |
[
"find",
"pet",
"by",
"id",
"returns",
"a",
"single",
"pet"
] |
[
"public",
"pet",
"get",
"pet",
"by",
"id",
"(",
"@",
"path",
"param",
"(",
"\"",
"pet",
"id",
"\"",
")",
"long",
"pet",
"id",
")",
";"
] |
[
"gets",
"the",
"low",
"state",
"value",
"of",
"the",
"try",
",",
"if",
"there",
"is",
"one",
",",
"in",
"the",
"try",
"block",
"map",
"entry",
"indicated",
"by",
"the",
"ordinal"
] |
[
"public",
"int",
"get",
"try",
"low",
"(",
"int",
"try",
"block",
"ordinal",
")",
"throws",
"invalid",
"data",
"type",
"exception",
"{",
"check",
"validity",
"(",
"try",
"block",
"ordinal",
")",
";",
"data",
"type",
"dt",
"=",
"get",
"data",
"type",
"(",
")",
";",
"mem",
"buffer",
"specific",
"mem",
"buffer",
"=",
"get",
"specific",
"mem",
"buffer",
"(",
"try",
"block",
"ordinal",
",",
"dt",
")",
";",
"/",
"/",
"component",
"0",
"is",
"the",
"low",
"state",
"value",
"of",
"the",
"try",
"return",
"e",
"h",
"data",
"type",
"utilities",
"get",
"e",
"h",
"state",
"value",
"(",
"dt",
",",
"try",
"low",
"ordinal",
",",
"specific",
"mem",
"buffer",
")",
";",
"}"
] |
[
"creates",
"the",
"plan",
"with",
"which",
"the",
"system",
"will",
"execute",
"the",
"program",
",",
"and",
"returns",
"it",
"as",
"a",
"string",
"using",
"a",
"json",
"representation",
"of",
"the",
"execution",
"data",
"flow",
"graph",
"note",
"that",
"this",
"needs",
"to",
"be",
"called",
",",
"before",
"the",
"plan",
"is",
"executed"
] |
[
"public",
"string",
"get",
"execution",
"plan",
"(",
")",
"{",
"return",
"get",
"stream",
"graph",
"(",
"get",
"job",
"name",
"(",
")",
",",
"false",
")",
"get",
"streaming",
"plan",
"as",
"j",
"s",
"o",
"n",
"(",
")",
";",
"}"
] |
[
"take",
"a",
"snapshot",
"of",
"a",
"supplied",
"map",
",",
"where",
"the",
"copy",
"option",
"simply",
"uses",
"the",
"existing",
"value",
"for",
"this",
"to",
"be",
"safe",
",",
"the",
"map",
"must",
"refer",
"to",
"immutable",
"objects"
] |
[
"public",
"static",
"<",
"e",
"extends",
"serializable",
">",
"map",
"<",
"string",
",",
"e",
">",
"snapshot",
"map",
"(",
"map",
"<",
"string",
",",
"e",
">",
"source",
")",
"{",
"return",
"snapshot",
"map",
"(",
"source",
",",
"i",
"o",
"statistics",
"binding",
":",
":",
"passthrough",
"fn",
")",
";",
"}"
] |
[
"find",
"the",
"patterns",
"matching",
"the",
"given",
"lookup",
"path",
"invoking",
"this",
"method",
"should",
"yield",
"results",
"equivalent",
"to",
"those",
"of",
"calling",
"{",
"@",
"link",
"#",
"get",
"matching",
"condition",
"}",
"this",
"method",
"is",
"provided",
"as",
"an",
"alternative",
"to",
"be",
"used",
"if",
"no",
"request",
"is",
"available",
"(",
"e",
"g",
"introspection",
",",
"tooling",
",",
"etc",
")"
] |
[
"public",
"list",
"<",
"string",
">",
"get",
"matching",
"patterns",
"(",
"string",
"lookup",
"path",
")",
"{",
"list",
"<",
"string",
">",
"matches",
"=",
"null",
";",
"for",
"(",
"string",
"pattern",
":",
"this",
"patterns",
")",
"{",
"string",
"match",
"=",
"get",
"matching",
"pattern",
"(",
"pattern",
",",
"lookup",
"path",
")",
";",
"if",
"(",
"match",
"!",
"=",
"null",
")",
"{",
"matches",
"=",
"(",
"matches",
"!",
"=",
"null",
"?",
"matches",
":",
"new",
"array",
"list",
"<",
">",
"(",
")",
")",
";",
"matches",
"add",
"(",
"match",
")",
";",
"}",
"}",
"if",
"(",
"matches",
"=",
"=",
"null",
")",
"{",
"return",
"collections",
"empty",
"list",
"(",
")",
";",
"}",
"if",
"(",
"matches",
"size",
"(",
")",
">",
"1",
")",
"{",
"matches",
"sort",
"(",
"this",
"path",
"matcher",
"get",
"pattern",
"comparator",
"(",
"lookup",
"path",
")",
")",
";",
"}",
"return",
"matches",
";",
"}"
] |
[
"returns",
"a",
"mock",
"normal",
"handshaker",
"response"
] |
[
"static",
"handshaker",
"resp",
"get",
"ok",
"response",
"(",
"int",
"bytes",
"consumed",
")",
"{",
"handshaker",
"resp",
"builder",
"resp",
"=",
"handshaker",
"resp",
"new",
"builder",
"(",
")",
";",
"resp",
"set",
"out",
"frames",
"(",
"get",
"out",
"frame",
"(",
")",
")",
";",
"resp",
"set",
"bytes",
"consumed",
"(",
"bytes",
"consumed",
")",
";",
"resp",
"set",
"status",
"(",
"handshaker",
"status",
"new",
"builder",
"(",
")",
"set",
"code",
"(",
"status",
"code",
"ok",
"value",
"(",
")",
")",
"build",
"(",
")",
")",
";",
"return",
"resp",
"build",
"(",
")",
";",
"}"
] |
[
"this",
"is",
"a",
"main",
"function",
"for",
"testing",
"job",
"control",
"class",
"it",
"first",
"cleans",
"all",
"the",
"dirs",
"it",
"will",
"use",
"then",
"it",
"generates",
"some",
"random",
"text",
"data",
"in",
"test",
"job",
"control",
"dataindir",
"then",
"it",
"creates",
"4",
"jobs",
":",
"job",
"1",
":",
"copy",
"data",
"from",
"indir",
"to",
"outdir",
"1",
"job",
"2",
":",
"copy",
"data",
"from",
"indir",
"to",
"outdir",
"2",
"job",
"3",
":",
"copy",
"data",
"from",
"outdir",
"1",
"and",
"outdir",
"2",
"to",
"outdir",
"3",
"job",
"4",
":",
"copy",
"data",
"from",
"outdir",
"to",
"outdir",
"4",
"the",
"jobs",
"1",
"and",
"2",
"have",
"no",
"dependency",
"the",
"job",
"3",
"depends",
"on",
"jobs",
"1",
"and",
"2",
"the",
"job",
"4",
"depends",
"on",
"job",
"3",
"then",
"it",
"creates",
"a",
"job",
"control",
"object",
"and",
"add",
"the",
"4",
"jobs",
"to",
"the",
"job",
"control",
"object",
"finally",
",",
"it",
"creates",
"a",
"thread",
"to",
"run",
"the",
"job",
"control",
"object",
"and",
"monitorsreports",
"the",
"job",
"states"
] |
[
"public",
"void",
"test",
"local",
"job",
"control",
"data",
"copy",
"(",
")",
"throws",
"exception",
"{",
"file",
"system",
"fs",
"=",
"file",
"system",
"get",
"(",
"create",
"job",
"conf",
"(",
")",
")",
";",
"path",
"root",
"data",
"dir",
"=",
"new",
"path",
"(",
"system",
"get",
"property",
"(",
"\"",
"test",
"build",
"data",
"\"",
",",
"\"",
"\"",
")",
",",
"\"",
"test",
"local",
"job",
"control",
"data",
"\"",
")",
";",
"path",
"indir",
"=",
"new",
"path",
"(",
"root",
"data",
"dir",
",",
"\"",
"indir",
"\"",
")",
";",
"path",
"outdir",
"1",
"=",
"new",
"path",
"(",
"root",
"data",
"dir",
",",
"\"",
"outdir",
"1",
"\"",
")",
";",
"path",
"outdir",
"2",
"=",
"new",
"path",
"(",
"root",
"data",
"dir",
",",
"\"",
"outdir",
"2",
"\"",
")",
";",
"path",
"outdir",
"3",
"=",
"new",
"path",
"(",
"root",
"data",
"dir",
",",
"\"",
"outdir",
"3",
"\"",
")",
";",
"path",
"outdir",
"4",
"=",
"new",
"path",
"(",
"root",
"data",
"dir",
",",
"\"",
"outdir",
"4",
"\"",
")",
";",
"job",
"control",
"test",
"utils",
"clean",
"data",
"(",
"fs",
",",
"indir",
")",
";",
"job",
"control",
"test",
"utils",
"generate",
"data",
"(",
"fs",
",",
"indir",
")",
";",
"job",
"control",
"test",
"utils",
"clean",
"data",
"(",
"fs",
",",
"outdir",
"1",
")",
";",
"job",
"control",
"test",
"utils",
"clean",
"data",
"(",
"fs",
",",
"outdir",
"2",
")",
";",
"job",
"control",
"test",
"utils",
"clean",
"data",
"(",
"fs",
",",
"outdir",
"3",
")",
";",
"job",
"control",
"test",
"utils",
"clean",
"data",
"(",
"fs",
",",
"outdir",
"4",
")",
";",
"array",
"list",
"<",
"job",
">",
"depending",
"jobs",
"=",
"null",
";",
"array",
"list",
"<",
"path",
">",
"in",
"paths",
"1",
"=",
"new",
"array",
"list",
"<",
"path",
">",
"(",
")",
";",
"in",
"paths",
"1",
"add",
"(",
"indir",
")",
";",
"job",
"conf",
"job",
"conf",
"1",
"=",
"job",
"control",
"test",
"utils",
"create",
"copy",
"job",
"(",
"in",
"paths",
"1",
",",
"outdir",
"1",
")",
";",
"job",
"job",
"1",
"=",
"new",
"job",
"(",
"job",
"conf",
"1",
",",
"depending",
"jobs",
")",
";",
"array",
"list",
"<",
"path",
">",
"in",
"paths",
"2",
"=",
"new",
"array",
"list",
"<",
"path",
">",
"(",
")",
";",
"in",
"paths",
"2",
"add",
"(",
"indir",
")",
";",
"job",
"conf",
"job",
"conf",
"2",
"=",
"job",
"control",
"test",
"utils",
"create",
"copy",
"job",
"(",
"in",
"paths",
"2",
",",
"outdir",
"2",
")",
";",
"job",
"job",
"2",
"=",
"new",
"job",
"(",
"job",
"conf",
"2",
",",
"depending",
"jobs",
")",
";",
"array",
"list",
"<",
"path",
">",
"in",
"paths",
"3",
"=",
"new",
"array",
"list",
"<",
"path",
">",
"(",
")",
";",
"in",
"paths",
"3",
"add",
"(",
"outdir",
"1",
")",
";",
"in",
"paths",
"3",
"add",
"(",
"outdir",
"2",
")",
";",
"job",
"conf",
"job",
"conf",
"3",
"=",
"job",
"control",
"test",
"utils",
"create",
"copy",
"job",
"(",
"in",
"paths",
"3",
",",
"outdir",
"3",
")",
";",
"depending",
"jobs",
"=",
"new",
"array",
"list",
"<",
"job",
">",
"(",
")",
";",
"depending",
"jobs",
"add",
"(",
"job",
"1",
")",
";",
"depending",
"jobs",
"add",
"(",
"job",
"2",
")",
";",
"job",
"job",
"3",
"=",
"new",
"job",
"(",
"job",
"conf",
"3",
",",
"depending",
"jobs",
")",
";",
"array",
"list",
"<",
"path",
">",
"in",
"paths",
"4",
"=",
"new",
"array",
"list",
"<",
"path",
">",
"(",
")",
";",
"in",
"paths",
"4",
"add",
"(",
"outdir",
"3",
")",
";",
"job",
"conf",
"job",
"conf",
"4",
"=",
"job",
"control",
"test",
"utils",
"create",
"copy",
"job",
"(",
"in",
"paths",
"4",
",",
"outdir",
"4",
")",
";",
"depending",
"jobs",
"=",
"new",
"array",
"list",
"<",
"job",
">",
"(",
")",
";",
"depending",
"jobs",
"add",
"(",
"job",
"3",
")",
";",
"job",
"job",
"4",
"=",
"new",
"job",
"(",
"job",
"conf",
"4",
",",
"depending",
"jobs",
")",
";",
"job",
"control",
"the",
"control",
"=",
"new",
"job",
"control",
"(",
"\"",
"test",
"\"",
")",
";",
"the",
"control",
"add",
"job",
"(",
"job",
"1",
")",
";",
"the",
"control",
"add",
"job",
"(",
"job",
"2",
")",
";",
"the",
"control",
"add",
"job",
"(",
"job",
"3",
")",
";",
"the",
"control",
"add",
"job",
"(",
"job",
"4",
")",
";",
"thread",
"the",
"controller",
"=",
"new",
"thread",
"(",
"the",
"control",
")",
";",
"the",
"controller",
"start",
"(",
")",
";",
"while",
"(",
"!",
"the",
"control",
"all",
"finished",
"(",
")",
")",
"{",
"log",
"debug",
"(",
"\"",
"jobs",
"in",
"waiting",
"state",
":",
"\"",
"+",
"the",
"control",
"get",
"waiting",
"jobs",
"(",
")",
"size",
"(",
")",
")",
";",
"log",
"debug",
"(",
"\"",
"jobs",
"in",
"ready",
"state",
":",
"\"",
"+",
"the",
"control",
"get",
"ready",
"jobs",
"(",
")",
"size",
"(",
")",
")",
";",
"log",
"debug",
"(",
"\"",
"jobs",
"in",
"running",
"state",
":",
"\"",
"+",
"the",
"control",
"get",
"running",
"jobs",
"(",
")",
"size",
"(",
")",
")",
";",
"log",
"debug",
"(",
"\"",
"jobs",
"in",
"success",
"state",
":",
"\"",
"+",
"the",
"control",
"get",
"successful",
"jobs",
"(",
")",
"size",
"(",
")",
")",
";",
"log",
"debug",
"(",
"\"",
"jobs",
"in",
"failed",
"state",
":",
"\"",
"+",
"the",
"control",
"get",
"failed",
"jobs",
"(",
")",
"size",
"(",
")",
")",
";",
"log",
"debug",
"(",
"\"",
"\\",
"n",
"\"",
")",
";",
"try",
"{",
"thread",
"sleep",
"(",
"5000",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"}",
"}",
"assert",
"equals",
"(",
"\"",
"some",
"jobs",
"failed",
"\"",
",",
"0",
",",
"the",
"control",
"get",
"failed",
"jobs",
"(",
")",
"size",
"(",
")",
")",
";",
"the",
"control",
"stop",
"(",
")",
";",
"}"
] |
[
"assert",
"the",
"servlet",
"response",
"error",
"message",
"with",
"the",
"given",
"hamcrest",
"{",
"@",
"link",
"matcher",
"}"
] |
[
"public",
"result",
"matcher",
"reason",
"(",
"matcher",
"<",
"?",
"super",
"string",
">",
"matcher",
")",
"{",
"return",
"result",
"-",
">",
"assert",
"that",
"(",
"\"",
"response",
"status",
"reason",
"\"",
",",
"result",
"get",
"response",
"(",
")",
"get",
"error",
"message",
"(",
")",
",",
"matcher",
")",
";",
"}"
] |
[
"called",
"when",
"a",
"new",
"pointcut",
"expression",
"is",
"set",
"the",
"expression",
"should",
"be",
"parsed",
"at",
"this",
"point",
"if",
"possible",
"this",
"implementation",
"is",
"empty"
] |
[
"protected",
"void",
"on",
"set",
"expression",
"(",
"@",
"nullable",
"string",
"expression",
")",
"throws",
"illegal",
"argument",
"exception",
"{",
"}"
] |
[
"the",
"shard",
"routing",
"information",
"(",
"cluster",
"wide",
"shard",
"state",
")"
] |
[
"public",
"shard",
"routing",
"get",
"shard",
"routing",
"(",
")",
"{",
"return",
"this",
"shard",
"routing",
";",
"}"
] |
[
"creates",
"a",
"new",
"blaze",
"runtime",
",",
"given",
"the",
"install",
"and",
"output",
"base",
"directories",
"note",
":",
"this",
"method",
"can",
"and",
"should",
"only",
"be",
"called",
"once",
"per",
"startup",
",",
"as",
"it",
"also",
"creates",
"the",
"filesystem",
"object",
"that",
"will",
"be",
"used",
"for",
"the",
"runtime",
"so",
"it",
"should",
"only",
"ever",
"be",
"called",
"from",
"the",
"main",
"method",
"of",
"the",
"blaze",
"program"
] |
[
"private",
"static",
"blaze",
"runtime",
"new",
"runtime",
"(",
"iterable",
"<",
"blaze",
"module",
">",
"blaze",
"modules",
",",
"list",
"<",
"string",
">",
"args",
",",
"runnable",
"abrupt",
"shutdown",
"handler",
")",
"throws",
"abrupt",
"exit",
"exception",
",",
"options",
"parsing",
"exception",
"{",
"options",
"parsing",
"result",
"options",
"=",
"parse",
"startup",
"options",
"(",
"blaze",
"modules",
",",
"args",
")",
";",
"blaze",
"server",
"startup",
"options",
"startup",
"options",
"=",
"options",
"get",
"options",
"(",
"blaze",
"server",
"startup",
"options",
"class",
")",
";",
"/",
"/",
"set",
"up",
"the",
"failure",
"detail",
"path",
"first",
",",
"so",
"that",
"it",
"can",
"communicate",
"problems",
"with",
"other",
"flags",
"/",
"/",
"and",
"module",
"initialization",
"path",
"fragment",
"failure",
"detail",
"out",
"=",
"startup",
"options",
"failure",
"detail",
"out",
";",
"if",
"(",
"failure",
"detail",
"out",
"=",
"=",
"null",
"|",
"|",
"!",
"failure",
"detail",
"out",
"is",
"absolute",
"(",
")",
")",
"{",
"/",
"/",
"(",
"includes",
"\"",
"\"",
"default",
"case",
")",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"bad",
"-",
"-",
"failure",
"detail",
"out",
"option",
"specified",
":",
"'",
"\"",
"+",
"failure",
"detail",
"out",
"+",
"\"",
"'",
"\"",
")",
";",
"}",
"custom",
"failure",
"detail",
"publisher",
"set",
"failure",
"detail",
"file",
"path",
"(",
"failure",
"detail",
"out",
"get",
"path",
"string",
"(",
")",
")",
";",
"for",
"(",
"blaze",
"module",
"module",
":",
"blaze",
"modules",
")",
"{",
"module",
"global",
"init",
"(",
"options",
")",
";",
"}",
"string",
"product",
"name",
"=",
"startup",
"options",
"product",
"name",
"to",
"lower",
"case",
"(",
"locale",
"us",
")",
";",
"path",
"fragment",
"workspace",
"directory",
"=",
"startup",
"options",
"workspace",
"directory",
";",
"path",
"fragment",
"default",
"system",
"javabase",
"=",
"startup",
"options",
"default",
"system",
"javabase",
";",
"path",
"fragment",
"output",
"user",
"root",
"=",
"startup",
"options",
"output",
"user",
"root",
";",
"path",
"fragment",
"install",
"base",
"=",
"startup",
"options",
"install",
"base",
";",
"path",
"fragment",
"output",
"base",
"=",
"startup",
"options",
"output",
"base",
";",
"maybe",
"force",
"j",
"n",
"i",
"by",
"getting",
"pid",
"(",
"install",
"base",
")",
";",
"/",
"/",
"must",
"be",
"before",
"first",
"use",
"of",
"jni",
"/",
"/",
"from",
"the",
"point",
"of",
"view",
"of",
"the",
"java",
"program",
"-",
"-",
"install",
"base",
",",
"-",
"-",
"output",
"base",
",",
"-",
"-",
"output",
"user",
"root",
",",
"/",
"/",
"and",
"-",
"-",
"failure",
"detail",
"out",
"are",
"mandatory",
"options",
",",
"despite",
"the",
"comment",
"in",
"their",
"declarations",
"if",
"(",
"install",
"base",
"=",
"=",
"null",
"|",
"|",
"!",
"install",
"base",
"is",
"absolute",
"(",
")",
")",
"{",
"/",
"/",
"(",
"includes",
"\"",
"\"",
"default",
"case",
")",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"bad",
"-",
"-",
"install",
"base",
"option",
"specified",
":",
"'",
"\"",
"+",
"install",
"base",
"+",
"\"",
"'",
"\"",
")",
";",
"}",
"if",
"(",
"output",
"user",
"root",
"!",
"=",
"null",
"&",
"&",
"!",
"output",
"user",
"root",
"is",
"absolute",
"(",
")",
")",
"{",
"/",
"/",
"(",
"includes",
"\"",
"\"",
"default",
"case",
")",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"bad",
"-",
"-",
"output",
"user",
"root",
"option",
"specified",
":",
"'",
"\"",
"+",
"output",
"user",
"root",
"+",
"\"",
"'",
"\"",
")",
";",
"}",
"if",
"(",
"output",
"base",
"!",
"=",
"null",
"&",
"&",
"!",
"output",
"base",
"is",
"absolute",
"(",
")",
")",
"{",
"/",
"/",
"(",
"includes",
"\"",
"\"",
"default",
"case",
")",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"bad",
"-",
"-",
"output",
"base",
"option",
"specified",
":",
"'",
"\"",
"+",
"output",
"base",
"+",
"\"",
"'",
"\"",
")",
";",
"}",
"file",
"system",
"fs",
"=",
"null",
";",
"path",
"exec",
"root",
"base",
"path",
"=",
"null",
";",
"for",
"(",
"blaze",
"module",
"module",
":",
"blaze",
"modules",
")",
"{",
"blaze",
"module",
"module",
"file",
"system",
"module",
"fs",
"=",
"module",
"get",
"file",
"system",
"(",
"options",
",",
"output",
"base",
"get",
"relative",
"(",
"server",
"directories",
"execroot",
")",
")",
";",
"if",
"(",
"module",
"fs",
"!",
"=",
"null",
")",
"{",
"exec",
"root",
"base",
"path",
"=",
"module",
"fs",
"virtual",
"exec",
"root",
"base",
"(",
")",
";",
"preconditions",
"check",
"state",
"(",
"fs",
"=",
"=",
"null",
",",
"\"",
"more",
"than",
"one",
"module",
"returns",
"a",
"file",
"system",
"\"",
")",
";",
"fs",
"=",
"module",
"fs",
"file",
"system",
"(",
")",
";",
"}",
"}",
"preconditions",
"check",
"not",
"null",
"(",
"fs",
",",
"\"",
"no",
"module",
"set",
"the",
"file",
"system",
"\"",
")",
";",
"subscriber",
"exception",
"handler",
"current",
"handler",
"value",
"=",
"null",
";",
"for",
"(",
"blaze",
"module",
"module",
":",
"blaze",
"modules",
")",
"{",
"subscriber",
"exception",
"handler",
"new",
"handler",
"=",
"module",
"get",
"event",
"bus",
"and",
"async",
"exception",
"handler",
"(",
")",
";",
"if",
"(",
"new",
"handler",
"!",
"=",
"null",
")",
"{",
"preconditions",
"check",
"state",
"(",
"current",
"handler",
"value",
"=",
"=",
"null",
",",
"\"",
"two",
"handlers",
"given",
"last",
"module",
":",
"%",
"s",
"\"",
",",
"module",
")",
";",
"current",
"handler",
"value",
"=",
"new",
"handler",
";",
"}",
"}",
"if",
"(",
"current",
"handler",
"value",
"=",
"=",
"null",
")",
"{",
"if",
"(",
"startup",
"options",
"fatal",
"event",
"bus",
"exceptions",
")",
"{",
"current",
"handler",
"value",
"=",
"(",
"exception",
",",
"context",
")",
"-",
">",
"bug",
"report",
"handle",
"crash",
"(",
"exception",
")",
";",
"}",
"else",
"{",
"current",
"handler",
"value",
"=",
"(",
"exception",
",",
"context",
")",
"-",
">",
"{",
"if",
"(",
"context",
"=",
"=",
"null",
")",
"{",
"bug",
"report",
"handle",
"crash",
"(",
"exception",
")",
";",
"}",
"else",
"{",
"bug",
"report",
"send",
"bug",
"report",
"(",
"exception",
",",
"immutable",
"list",
"of",
"(",
")",
",",
"\"",
"failure",
"in",
"event",
"bus",
"subscriber",
"\"",
")",
";",
"}",
"}",
";",
"}",
"}",
"subscriber",
"exception",
"handler",
"subscriber",
"exception",
"handler",
"=",
"current",
"handler",
"value",
";",
"thread",
"set",
"default",
"uncaught",
"exception",
"handler",
"(",
"(",
"thread",
",",
"throwable",
")",
"-",
">",
"subscriber",
"exception",
"handler",
"handle",
"exception",
"(",
"throwable",
",",
"null",
")",
")",
";",
"path",
"set",
"file",
"system",
"for",
"serialization",
"(",
"fs",
")",
";",
"/",
"/",
"set",
"the",
"hook",
"used",
"to",
"display",
"starlark",
"source",
"lines",
"in",
"a",
"stack",
"trace",
"final",
"file",
"system",
"final",
"f",
"s",
"=",
"fs",
";",
"eval",
"exception",
"set",
"source",
"reader",
"supplier",
"(",
"(",
")",
"-",
">",
"loc",
"-",
">",
"{",
"try",
"{",
"/",
"/",
"todo",
"(",
"adonovan",
")",
":",
"opt",
":",
"cache",
"seen",
"files",
",",
"as",
"the",
"stack",
"often",
"repeats",
"the",
"same",
"files",
"path",
"path",
"=",
"final",
"f",
"s",
"get",
"path",
"(",
"path",
"fragment",
"create",
"(",
"loc",
"file",
"(",
")",
")",
")",
";",
"list",
"<",
"string",
">",
"lines",
"=",
"file",
"system",
"utils",
"read",
"lines",
"(",
"path",
",",
"utf",
"8",
")",
";",
"return",
"lines",
"size",
"(",
")",
">",
"=",
"loc",
"line",
"(",
")",
"?",
"lines",
"get",
"(",
"loc",
"line",
"(",
")",
"-",
"1",
")",
":",
"null",
";",
"}",
"catch",
"(",
"throwable",
"unused",
")",
"{",
"/",
"/",
"ignore",
"any",
"failure",
"(",
"e",
"g",
"enoent",
",",
"security",
"manager",
"rejecting",
"i",
"/",
"o",
")",
"}",
"return",
"null",
";",
"}",
")",
";",
"subprocess",
"builder",
"set",
"default",
"subprocess",
"factory",
"(",
"subprocess",
"factory",
"implementation",
"(",
")",
")",
";",
"path",
"output",
"user",
"root",
"path",
"=",
"fs",
"get",
"path",
"(",
"output",
"user",
"root",
")",
";",
"path",
"install",
"base",
"path",
"=",
"fs",
"get",
"path",
"(",
"install",
"base",
")",
";",
"path",
"output",
"base",
"path",
"=",
"fs",
"get",
"path",
"(",
"output",
"base",
")",
";",
"if",
"(",
"exec",
"root",
"base",
"path",
"=",
"=",
"null",
")",
"{",
"exec",
"root",
"base",
"path",
"=",
"output",
"base",
"path",
"get",
"relative",
"(",
"server",
"directories",
"execroot",
")",
";",
"}",
"path",
"workspace",
"directory",
"path",
"=",
"null",
";",
"if",
"(",
"!",
"workspace",
"directory",
"equals",
"(",
"path",
"fragment",
"empty",
"fragment",
")",
")",
"{",
"workspace",
"directory",
"path",
"=",
"fs",
"get",
"path",
"(",
"workspace",
"directory",
")",
";",
"}",
"path",
"default",
"system",
"javabase",
"path",
"=",
"null",
";",
"if",
"(",
"!",
"default",
"system",
"javabase",
"equals",
"(",
"path",
"fragment",
"empty",
"fragment",
")",
")",
"{",
"default",
"system",
"javabase",
"path",
"=",
"fs",
"get",
"path",
"(",
"default",
"system",
"javabase",
")",
";",
"}",
"server",
"directories",
"server",
"directories",
"=",
"new",
"server",
"directories",
"(",
"install",
"base",
"path",
",",
"output",
"base",
"path",
",",
"output",
"user",
"root",
"path",
",",
"exec",
"root",
"base",
"path",
",",
"startup",
"options",
"install",
"m",
"d",
"5",
")",
";",
"clock",
"clock",
"=",
"blaze",
"clock",
"instance",
"(",
")",
";",
"blaze",
"runtime",
"builder",
"runtime",
"builder",
"=",
"new",
"blaze",
"runtime",
"builder",
"(",
")",
"set",
"product",
"name",
"(",
"product",
"name",
")",
"set",
"file",
"system",
"(",
"fs",
")",
"set",
"server",
"directories",
"(",
"server",
"directories",
")",
"set",
"action",
"key",
"context",
"(",
"new",
"action",
"key",
"context",
"(",
")",
")",
"set",
"startup",
"options",
"provider",
"(",
"options",
")",
"set",
"clock",
"(",
"clock",
")",
"set",
"abrupt",
"shutdown",
"handler",
"(",
"abrupt",
"shutdown",
"handler",
")",
"set",
"event",
"bus",
"exception",
"handler",
"(",
"subscriber",
"exception",
"handler",
")",
";",
"if",
"(",
"test",
"type",
"is",
"in",
"test",
"(",
")",
"&",
"&",
"system",
"getenv",
"(",
"\"",
"no",
"crash",
"on",
"logging",
"in",
"test",
"\"",
")",
"=",
"=",
"null",
")",
"{",
"logging",
"util",
"install",
"remote",
"logger",
"(",
"get",
"test",
"crash",
"logger",
"(",
")",
")",
";",
"}",
"for",
"(",
"blaze",
"module",
"blaze",
"module",
":",
"blaze",
"modules",
")",
"{",
"runtime",
"builder",
"add",
"blaze",
"module",
"(",
"blaze",
"module",
")",
";",
"}",
"blaze",
"runtime",
"runtime",
"=",
"runtime",
"builder",
"build",
"(",
")",
";",
"custom",
"exit",
"code",
"publisher",
"set",
"abrupt",
"exit",
"status",
"file",
"dir",
"(",
"server",
"directories",
"get",
"output",
"base",
"(",
")",
"get",
"path",
"string",
"(",
")",
")",
";",
"blaze",
"directories",
"directories",
"=",
"new",
"blaze",
"directories",
"(",
"server",
"directories",
",",
"workspace",
"directory",
"path",
",",
"default",
"system",
"javabase",
"path",
",",
"product",
"name",
")",
";",
"bin",
"tools",
"bin",
"tools",
";",
"try",
"{",
"bin",
"tools",
"=",
"bin",
"tools",
"for",
"production",
"(",
"directories",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"throw",
"create",
"filesystem",
"exit",
"exception",
"(",
"\"",
"cannot",
"enumerate",
"embedded",
"binaries",
":",
"\"",
"+",
"e",
"get",
"message",
"(",
")",
",",
"filesystem",
"code",
"embedded",
"binaries",
"enumeration",
"failure",
",",
"e",
")",
";",
"}",
"/",
"/",
"keep",
"this",
"line",
"last",
"in",
"this",
"method",
",",
"so",
"that",
"all",
"other",
"initialization",
"is",
"available",
"to",
"it",
"runtime",
"init",
"workspace",
"(",
"directories",
",",
"bin",
"tools",
")",
";",
"return",
"runtime",
";",
"}"
] |
[
"return",
"the",
"persistent",
"instance",
"of",
"the",
"given",
"entity",
"class",
"with",
"the",
"given",
"identifier",
",",
"or",
"{",
"@",
"code",
"null",
"}",
"if",
"not",
"found",
"this",
"method",
"is",
"a",
"thin",
"wrapper",
"around",
"{",
"@",
"link",
"org",
"hibernate",
"session",
"#",
"get",
"(",
"string",
",",
"serializable",
")",
"}",
"for",
"convenience",
"for",
"an",
"explanation",
"of",
"the",
"exact",
"semantics",
"of",
"this",
"method",
",",
"please",
"do",
"refer",
"to",
"the",
"hibernate",
"api",
"documentation",
"in",
"the",
"first",
"instance"
] |
[
"object",
"get",
"(",
"string",
"entity",
"name",
",",
"serializable",
"id",
")",
"throws",
"data",
"access",
"exception",
";"
] |
[
"unmounts",
"a",
"component",
"tree",
"from",
"a",
"component",
"view"
] |
[
"public",
"static",
"void",
"unmount",
"component",
"(",
"litho",
"view",
"litho",
"view",
")",
"{",
"if",
"(",
"!",
"litho",
"view",
"is",
"incremental",
"mount",
"enabled",
"(",
")",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"in",
"order",
"to",
"test",
"unmounting",
"a",
"component",
",",
"it",
"needs",
"to",
"be",
"mounted",
"with",
"\"",
"+",
"\"",
"incremental",
"mount",
"enabled",
"please",
"use",
"a",
"mount",
"component",
"(",
")",
"variation",
"that",
"\"",
"+",
"\"",
"accepts",
"an",
"incremental",
"mount",
"enabled",
"argument",
"\"",
")",
";",
"}",
"/",
"/",
"unmounting",
"the",
"component",
"by",
"running",
"incremental",
"mount",
"to",
"a",
"rect",
"that",
"we",
"certain",
"won",
"'",
"t",
"/",
"/",
"contain",
"the",
"component",
"rect",
"rect",
"=",
"new",
"rect",
"(",
"99999",
",",
"99999",
",",
"999999",
",",
"999999",
")",
";",
"litho",
"view",
"notify",
"visible",
"bounds",
"changed",
"(",
"rect",
",",
"true",
")",
";",
"}"
] |
[
"get",
"the",
"base",
"data",
"type",
"for",
"the",
"specified",
"data",
"type",
"<",
"br",
">",
"for",
"example",
",",
"the",
"base",
"data",
"type",
"for",
"word",
"[",
"5",
"]",
"is",
"word",
"for",
"a",
"pointer",
",",
"the",
"base",
"data",
"type",
"is",
"the",
"type",
"being",
"pointed",
"to",
"or",
"the",
"pointer",
"itself",
"if",
"it",
"is",
"pointing",
"at",
"nothing",
"<",
"br",
">",
"if",
"\"",
"int",
"\"",
"is",
"a",
"typedef",
"on",
"a",
"\"",
"dword",
"\"",
"then",
"int",
"[",
"7",
"]",
"[",
"3",
"]",
"would",
"have",
"a",
"base",
"data",
"type",
"of",
"dword",
"if",
"you",
"wanted",
"to",
"get",
"the",
"int",
"from",
"int",
"[",
"7",
"]",
"[",
"3",
"]",
"you",
"should",
"call",
"get",
"named",
"based",
"data",
"type",
"(",
"data",
"type",
")",
"instead"
] |
[
"public",
"static",
"data",
"type",
"get",
"base",
"data",
"type",
"(",
"data",
"type",
"dt",
")",
"{",
"data",
"type",
"base",
"data",
"type",
"=",
"dt",
";",
"while",
"(",
"(",
"base",
"data",
"type",
"instanceof",
"pointer",
")",
"|",
"|",
"(",
"base",
"data",
"type",
"instanceof",
"array",
")",
"|",
"|",
"(",
"base",
"data",
"type",
"instanceof",
"type",
"def",
")",
")",
"{",
"if",
"(",
"base",
"data",
"type",
"instanceof",
"pointer",
")",
"{",
"data",
"type",
"inner",
"dt",
"=",
"(",
"(",
"pointer",
")",
"base",
"data",
"type",
")",
"get",
"data",
"type",
"(",
")",
";",
"if",
"(",
"inner",
"dt",
"!",
"=",
"null",
")",
"{",
"base",
"data",
"type",
"=",
"inner",
"dt",
";",
"}",
"else",
"{",
"return",
"base",
"data",
"type",
";",
"}",
"}",
"else",
"if",
"(",
"base",
"data",
"type",
"instanceof",
"array",
")",
"{",
"base",
"data",
"type",
"=",
"(",
"(",
"array",
")",
"base",
"data",
"type",
")",
"get",
"data",
"type",
"(",
")",
";",
"}",
"else",
"{",
"base",
"data",
"type",
"=",
"(",
"(",
"type",
"def",
")",
"base",
"data",
"type",
")",
"get",
"data",
"type",
"(",
")",
";",
"}",
"}",
"return",
"base",
"data",
"type",
";",
"}"
] |
[
"creates",
"a",
"search",
"scroll",
"request",
"allowing",
"to",
"continue",
"searching",
"a",
"previous",
"search",
"request"
] |
[
"public",
"static",
"search",
"scroll",
"request",
"search",
"scroll",
"request",
"(",
"string",
"scroll",
"id",
")",
"{",
"return",
"new",
"search",
"scroll",
"request",
"(",
"scroll",
"id",
")",
";",
"}"
] |
[
"set",
"the",
"data",
"of",
"the",
"vector",
"the",
"same",
"as",
"those",
"of",
"another",
"vector"
] |
[
"public",
"void",
"set",
"equal",
"(",
"dense",
"vector",
"other",
")",
"{",
"assert",
"this",
"size",
"(",
")",
"=",
"=",
"other",
"size",
"(",
")",
":",
"\"",
"size",
"of",
"the",
"two",
"vectors",
"mismatched",
"\"",
";",
"system",
"arraycopy",
"(",
"other",
"data",
",",
"0",
",",
"this",
"data",
",",
"0",
",",
"this",
"size",
"(",
")",
")",
";",
"}"
] |
[
"retrieve",
"the",
"value",
"from",
"this",
"iterator",
"this",
"method",
"is",
"idempotent",
"it",
"is",
"illegal",
"to",
"call",
"this",
"method",
"after",
"{",
"@",
"link",
"#",
"advance",
"next",
"(",
")",
"}",
"has",
"returned",
"{",
"@",
"code",
"false",
"}"
] |
[
"v",
"get",
"value",
"(",
")",
";"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"return",
"the",
"name",
"for",
"the",
"selector",
"header",
"name"
] |
[
"public",
"string",
"get",
"selector",
"header",
"name",
"(",
")",
"{",
"return",
"this",
"selector",
"header",
"name",
";",
"}"
] |
[
"returns",
"when",
"the",
"current",
"number",
"of",
"seconds",
"from",
"the",
"epoch",
"equals",
"the",
"command",
"line",
"argument",
"given",
"by",
"<",
"code",
">",
"-",
"start",
"time",
"<",
"code",
">",
"this",
"allows",
"multiple",
"instances",
"of",
"this",
"program",
",",
"running",
"on",
"clock",
"synchronized",
"nodes",
",",
"to",
"start",
"at",
"roughly",
"the",
"same",
"time"
] |
[
"static",
"void",
"barrier",
"(",
")",
"{",
"long",
"sleep",
"time",
";",
"while",
"(",
"(",
"sleep",
"time",
"=",
"start",
"time",
"-",
"system",
"current",
"time",
"millis",
"(",
")",
")",
">",
"0",
")",
"{",
"try",
"{",
"thread",
"sleep",
"(",
"sleep",
"time",
")",
";",
"}",
"catch",
"(",
"interrupted",
"exception",
"ex",
")",
"{",
"/",
"/",
"this",
"left",
"empty",
"on",
"purpose",
"}",
"}",
"}"
] |
[
"sets",
"the",
"provider",
"that",
"should",
"get",
"the",
"default",
"focus",
"when",
"no",
"component",
"has",
"focus"
] |
[
"public",
"void",
"set",
"default",
"component",
"(",
"component",
"provider",
"provider",
")",
"{",
"default",
"provider",
"=",
"provider",
";",
"}"
] |
[
"list",
"the",
"statuses",
"of",
"the",
"filesdirectories",
"in",
"the",
"given",
"path",
"if",
"the",
"path",
"is",
"a",
"directory",
"return",
"the",
"file",
"'",
"s",
"status",
"and",
"block",
"locations",
"if",
"the",
"path",
"is",
"a",
"file",
"if",
"a",
"returned",
"status",
"is",
"a",
"file",
",",
"it",
"contains",
"the",
"file",
"'",
"s",
"block",
"locations"
] |
[
"public",
"remote",
"iterator",
"<",
"located",
"file",
"status",
">",
"list",
"located",
"status",
"(",
"final",
"path",
"f",
")",
"throws",
"access",
"control",
"exception",
",",
"file",
"not",
"found",
"exception",
",",
"unsupported",
"file",
"system",
"exception",
",",
"i",
"o",
"exception",
"{",
"final",
"path",
"abs",
"f",
"=",
"fix",
"relative",
"part",
"(",
"f",
")",
";",
"return",
"new",
"f",
"s",
"link",
"resolver",
"<",
"remote",
"iterator",
"<",
"located",
"file",
"status",
">",
">",
"(",
")",
"{",
"@",
"override",
"public",
"remote",
"iterator",
"<",
"located",
"file",
"status",
">",
"next",
"(",
"final",
"abstract",
"file",
"system",
"fs",
",",
"final",
"path",
"p",
")",
"throws",
"i",
"o",
"exception",
",",
"unresolved",
"link",
"exception",
"{",
"return",
"fs",
"list",
"located",
"status",
"(",
"p",
")",
";",
"}",
"}",
"resolve",
"(",
"this",
",",
"abs",
"f",
")",
";",
"}"
] |
[
"copy",
"bytes",
"of",
"segments",
"to",
"output",
"view",
"note",
":",
"it",
"just",
"copies",
"the",
"data",
"in",
",",
"not",
"include",
"the",
"length"
] |
[
"public",
"static",
"void",
"copy",
"to",
"view",
"(",
"memory",
"segment",
"[",
"]",
"segments",
",",
"int",
"offset",
",",
"int",
"size",
"in",
"bytes",
",",
"data",
"output",
"view",
"target",
")",
"throws",
"i",
"o",
"exception",
"{",
"for",
"(",
"memory",
"segment",
"source",
"segment",
":",
"segments",
")",
"{",
"int",
"cur",
"seg",
"remain",
"=",
"source",
"segment",
"size",
"(",
")",
"-",
"offset",
";",
"if",
"(",
"cur",
"seg",
"remain",
">",
"0",
")",
"{",
"int",
"copy",
"size",
"=",
"math",
"min",
"(",
"cur",
"seg",
"remain",
",",
"size",
"in",
"bytes",
")",
";",
"byte",
"[",
"]",
"bytes",
"=",
"allocate",
"reuse",
"bytes",
"(",
"copy",
"size",
")",
";",
"source",
"segment",
"get",
"(",
"offset",
",",
"bytes",
",",
"0",
",",
"copy",
"size",
")",
";",
"target",
"write",
"(",
"bytes",
",",
"0",
",",
"copy",
"size",
")",
";",
"size",
"in",
"bytes",
"-",
"=",
"copy",
"size",
";",
"offset",
"=",
"0",
";",
"}",
"else",
"{",
"offset",
"-",
"=",
"source",
"segment",
"size",
"(",
")",
";",
"}",
"if",
"(",
"size",
"in",
"bytes",
"=",
"=",
"0",
")",
"{",
"return",
";",
"}",
"}",
"if",
"(",
"size",
"in",
"bytes",
"!",
"=",
"0",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"no",
"copy",
"finished",
",",
"this",
"should",
"be",
"a",
"bug",
",",
"\"",
"+",
"\"",
"the",
"remaining",
"length",
"is",
":",
"\"",
"+",
"size",
"in",
"bytes",
")",
";",
"}",
"}"
] |
[
"get",
"the",
"configured",
"number",
"of",
"reduce",
"tasks",
"for",
"this",
"job",
"defaults",
"to",
"<",
"code",
">",
"1",
"<",
"code",
">"
] |
[
"public",
"int",
"get",
"num",
"reduce",
"tasks",
"(",
")",
"{",
"return",
"get",
"int",
"(",
"job",
"context",
"num",
"reduces",
",",
"1",
")",
";",
"}"
] |
[
"convenient",
"method",
"to",
"run",
"the",
"function",
"with",
"a",
"single",
"int",
"argument"
] |
[
"public",
"int",
"run",
"(",
"int",
"parameter",
")",
"{",
"return",
"run",
"(",
"new",
"object",
"[",
"]",
"{",
"parameter",
"}",
")",
";",
"}"
] |
[
"set",
"part",
"of",
"the",
"matrix",
"values",
"from",
"the",
"values",
"of",
"another",
"matrix"
] |
[
"public",
"void",
"set",
"sub",
"matrix",
"(",
"dense",
"matrix",
"sub",
",",
"int",
"m",
"0",
",",
"int",
"m",
"1",
",",
"int",
"n",
"0",
",",
"int",
"n",
"1",
")",
"{",
"assert",
"(",
"m",
"0",
">",
"=",
"0",
"&",
"&",
"m",
"1",
"<",
"=",
"m",
")",
"&",
"&",
"(",
"n",
"0",
">",
"=",
"0",
"&",
"&",
"n",
"1",
"<",
"=",
"n",
")",
":",
"\"",
"invalid",
"index",
"range",
"\"",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"sub",
"m",
";",
"i",
"+",
"+",
")",
"{",
"for",
"(",
"int",
"j",
"=",
"0",
";",
"j",
"<",
"sub",
"n",
";",
"j",
"+",
"+",
")",
"{",
"this",
"set",
"(",
"m",
"0",
"+",
"i",
",",
"n",
"0",
"+",
"j",
",",
"sub",
"get",
"(",
"i",
",",
"j",
")",
")",
";",
"}",
"}",
"}"
] |
[
"adds",
"the",
"given",
"value"
] |
[
"public",
"void",
"add",
"(",
"long",
"x",
")",
"{",
"cell",
"[",
"]",
"as",
";",
"long",
"b",
",",
"v",
";",
"int",
"[",
"]",
"hc",
";",
"cell",
"a",
";",
"int",
"n",
";",
"if",
"(",
"(",
"as",
"=",
"cells",
")",
"!",
"=",
"null",
"|",
"|",
"!",
"cas",
"base",
"(",
"b",
"=",
"base",
",",
"b",
"+",
"x",
")",
")",
"{",
"boolean",
"uncontended",
"=",
"true",
";",
"if",
"(",
"(",
"hc",
"=",
"thread",
"hash",
"code",
"get",
"(",
")",
")",
"=",
"=",
"null",
"|",
"|",
"as",
"=",
"=",
"null",
"|",
"|",
"(",
"n",
"=",
"as",
"length",
")",
"<",
"1",
"|",
"|",
"(",
"a",
"=",
"as",
"[",
"(",
"n",
"-",
"1",
")",
"&",
"hc",
"[",
"0",
"]",
"]",
")",
"=",
"=",
"null",
"|",
"|",
"!",
"(",
"uncontended",
"=",
"a",
"cas",
"(",
"v",
"=",
"a",
"value",
",",
"v",
"+",
"x",
")",
")",
")",
"retry",
"update",
"(",
"x",
",",
"hc",
",",
"uncontended",
")",
";",
"}",
"}"
] |
[
"validate",
"any",
"jaas",
"entry",
"referenced",
"in",
"the",
"{",
"@",
"link",
"#",
"sun",
"security",
"jaas",
"file",
"}",
"property"
] |
[
"private",
"void",
"validate",
"j",
"a",
"a",
"s",
"(",
"boolean",
"jaas",
"required",
")",
"throws",
"i",
"o",
"exception",
"{",
"string",
"jaas",
"filename",
"=",
"system",
"get",
"property",
"(",
"sun",
"security",
"jaas",
"file",
")",
";",
"if",
"(",
"jaas",
"required",
")",
"{",
"verify",
"(",
"jaas",
"filename",
"!",
"=",
"null",
",",
"cat",
"jaas",
",",
"\"",
"no",
"jaas",
"file",
"specified",
"in",
"\"",
"+",
"sun",
"security",
"jaas",
"file",
")",
";",
"}",
"if",
"(",
"jaas",
"filename",
"!",
"=",
"null",
")",
"{",
"title",
"(",
"\"",
"jaas",
"\"",
")",
";",
"file",
"jaas",
"file",
"=",
"new",
"file",
"(",
"jaas",
"filename",
")",
";",
"println",
"(",
"\"",
"jaas",
"file",
"is",
"defined",
"in",
"%",
"s",
":",
"%",
"s",
"\"",
",",
"sun",
"security",
"jaas",
"file",
",",
"jaas",
"file",
")",
";",
"verify",
"file",
"is",
"valid",
"(",
"jaas",
"file",
",",
"cat",
"jaas",
",",
"\"",
"jaas",
"file",
"defined",
"in",
"\"",
"+",
"sun",
"security",
"jaas",
"file",
")",
";",
"dump",
"(",
"jaas",
"file",
")",
";",
"endln",
"(",
")",
";",
"}",
"}"
] |
[
"is",
"the",
"process",
"with",
"pid",
"pid",
"still",
"alive",
"?",
"this",
"method",
"assumes",
"that",
"is",
"alive",
"is",
"called",
"on",
"a",
"pid",
"that",
"was",
"alive",
"not",
"too",
"long",
"ago",
",",
"and",
"hence",
"assumes",
"no",
"chance",
"of",
"pid",
"-",
"wrapping",
"-",
"around"
] |
[
"public",
"static",
"boolean",
"is",
"alive",
"(",
"string",
"pid",
")",
"{",
"shell",
"command",
"executor",
"shexec",
"=",
"null",
";",
"try",
"{",
"string",
"[",
"]",
"args",
"=",
"{",
"\"",
"kill",
"\"",
",",
"\"",
"-",
"0",
"\"",
",",
"pid",
"}",
";",
"shexec",
"=",
"new",
"shell",
"command",
"executor",
"(",
"args",
")",
";",
"shexec",
"execute",
"(",
")",
";",
"}",
"catch",
"(",
"exit",
"code",
"exception",
"ee",
")",
"{",
"return",
"false",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"ioe",
")",
"{",
"log",
"warn",
"(",
"\"",
"error",
"executing",
"shell",
"command",
"\"",
"+",
"shexec",
"to",
"string",
"(",
")",
"+",
"ioe",
")",
";",
"return",
"false",
";",
"}",
"return",
"(",
"shexec",
"get",
"exit",
"code",
"(",
")",
"=",
"=",
"0",
"?",
"true",
":",
"false",
")",
";",
"}"
] |
[
"stop",
"rpc",
"server"
] |
[
"void",
"stop",
"(",
")",
"{",
"if",
"(",
"rpc",
"server",
"!",
"=",
"null",
")",
"rpc",
"server",
"stop",
"(",
")",
";",
"rpc",
"server",
"=",
"null",
";",
"}"
] |
[
"configure",
"the",
"{",
"@",
"code",
"http",
"message",
"reader",
"}",
"to",
"use",
"for",
"multipart",
"requests",
"by",
"default",
",",
"if",
"<",
"a",
"href",
"=",
"\"",
"https",
":",
"github",
"comsynchronossnio",
"-",
"multipart",
"\"",
">",
"synchronoss",
"nio",
"multipart",
"is",
"present",
",",
"this",
"is",
"set",
"to",
"{",
"@",
"link",
"org",
"springframework",
"http",
"codec",
"multipart",
"multipart",
"http",
"message",
"reader",
"multipart",
"http",
"message",
"reader",
"}",
"created",
"with",
"an",
"instance",
"of",
"{",
"@",
"link",
"org",
"springframework",
"http",
"codec",
"multipart",
"synchronoss",
"part",
"http",
"message",
"reader",
"synchronoss",
"part",
"http",
"message",
"reader",
"}",
"note",
"that",
"{",
"@",
"link",
"#",
"max",
"in",
"memory",
"size",
"(",
"int",
")",
"}",
"andor",
"{",
"@",
"link",
"#",
"enable",
"logging",
"request",
"details",
"(",
"boolean",
")",
"}",
",",
"if",
"configured",
",",
"will",
"be",
"applied",
"to",
"the",
"given",
"reader",
",",
"if",
"applicable"
] |
[
"void",
"multipart",
"reader",
"(",
"http",
"message",
"reader",
"<",
"?",
">",
"reader",
")",
";"
] |
[
"return",
"a",
"thread",
"pool",
"that",
"creates",
"(",
"2",
"cpu",
"count",
"+",
"1",
")",
"threads",
"operating",
"off",
"a",
"queue",
"which",
"size",
"is",
"128"
] |
[
"public",
"static",
"executor",
"service",
"get",
"io",
"pool",
"(",
"@",
"int",
"range",
"(",
"from",
"=",
"1",
",",
"to",
"=",
"10",
")",
"final",
"int",
"priority",
")",
"{",
"return",
"get",
"pool",
"by",
"type",
"and",
"priority",
"(",
"type",
"io",
",",
"priority",
")",
";",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.