docstring_tokens
list | code_tokens
list |
|---|---|
[
"helper",
"method",
"for",
"creating",
"a",
"static",
"provider"
] |
[
"static",
"<",
"t",
">",
"async",
"table",
"function",
"provider",
"<",
"t",
">",
"of",
"(",
"async",
"table",
"function",
"<",
"t",
">",
"async",
"table",
"function",
")",
"{",
"return",
"(",
")",
"-",
">",
"async",
"table",
"function",
";",
"}"
] |
[
"creates",
"python",
"dependency",
"info",
"from",
"global",
"job",
"parameters",
"and",
"distributed",
"cache"
] |
[
"public",
"static",
"python",
"dependency",
"info",
"create",
"(",
"python",
"config",
"python",
"config",
",",
"distributed",
"cache",
"distributed",
"cache",
")",
"{",
"map",
"<",
"string",
",",
"string",
">",
"python",
"files",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"for",
"(",
"map",
"entry",
"<",
"string",
",",
"string",
">",
"entry",
":",
"python",
"config",
"get",
"python",
"files",
"info",
"(",
")",
"entry",
"set",
"(",
")",
")",
"{",
"file",
"python",
"file",
"=",
"distributed",
"cache",
"get",
"file",
"(",
"entry",
"get",
"key",
"(",
")",
")",
";",
"string",
"file",
"path",
"=",
"python",
"file",
"get",
"absolute",
"path",
"(",
")",
";",
"python",
"files",
"put",
"(",
"file",
"path",
",",
"entry",
"get",
"value",
"(",
")",
")",
";",
"}",
"string",
"requirements",
"file",
"path",
"=",
"null",
";",
"string",
"requirements",
"cache",
"dir",
"=",
"null",
";",
"if",
"(",
"python",
"config",
"get",
"python",
"requirements",
"file",
"info",
"(",
")",
"is",
"present",
"(",
")",
")",
"{",
"requirements",
"file",
"path",
"=",
"distributed",
"cache",
"get",
"file",
"(",
"python",
"config",
"get",
"python",
"requirements",
"file",
"info",
"(",
")",
"get",
"(",
")",
")",
"get",
"absolute",
"path",
"(",
")",
";",
"if",
"(",
"python",
"config",
"get",
"python",
"requirements",
"cache",
"dir",
"info",
"(",
")",
"is",
"present",
"(",
")",
")",
"{",
"requirements",
"cache",
"dir",
"=",
"distributed",
"cache",
"get",
"file",
"(",
"python",
"config",
"get",
"python",
"requirements",
"cache",
"dir",
"info",
"(",
")",
"get",
"(",
")",
")",
"get",
"absolute",
"path",
"(",
")",
";",
"}",
"}",
"map",
"<",
"string",
",",
"string",
">",
"archives",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"for",
"(",
"map",
"entry",
"<",
"string",
",",
"string",
">",
"entry",
":",
"python",
"config",
"get",
"python",
"archives",
"info",
"(",
")",
"entry",
"set",
"(",
")",
")",
"{",
"string",
"archive",
"file",
"path",
"=",
"distributed",
"cache",
"get",
"file",
"(",
"entry",
"get",
"key",
"(",
")",
")",
"get",
"absolute",
"path",
"(",
")",
";",
"string",
"target",
"path",
"=",
"entry",
"get",
"value",
"(",
")",
";",
"archives",
"put",
"(",
"archive",
"file",
"path",
",",
"target",
"path",
")",
";",
"}",
"string",
"python",
"exec",
"=",
"python",
"config",
"get",
"python",
"exec",
"(",
")",
";",
"return",
"new",
"python",
"dependency",
"info",
"(",
"python",
"files",
",",
"requirements",
"file",
"path",
",",
"requirements",
"cache",
"dir",
",",
"archives",
",",
"python",
"exec",
")",
";",
"}"
] |
[
"when",
"generic",
"fields",
"are",
"no",
"longer",
"exist",
"in",
"the",
"class",
"models",
",",
"the",
"generic",
"tables",
"should",
"be",
"dropped",
"from",
"database",
"this",
"method",
"helps",
"find",
"out",
"those",
"generic",
"tables",
"which",
"should",
"be",
"dropped",
"cause",
"their",
"generic",
"fields",
"in",
"classes",
"are",
"removed"
] |
[
"private",
"list",
"<",
"string",
">",
"find",
"generic",
"tables",
"to",
"drop",
"(",
")",
"{",
"list",
"<",
"string",
">",
"generic",
"tables",
"to",
"drop",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"for",
"(",
"string",
"table",
"name",
":",
"d",
"b",
"utility",
"find",
"all",
"table",
"names",
"(",
"m",
"db",
")",
")",
"{",
"if",
"(",
"d",
"b",
"utility",
"is",
"generic",
"table",
"(",
"table",
"name",
",",
"m",
"db",
")",
")",
"{",
"boolean",
"drop",
"generic",
"table",
"=",
"true",
";",
"for",
"(",
"generic",
"model",
"generic",
"model",
":",
"get",
"generic",
"models",
"(",
")",
")",
"{",
"string",
"generic",
"table",
"name",
"=",
"generic",
"model",
"get",
"table",
"name",
"(",
")",
";",
"if",
"(",
"table",
"name",
"equals",
"ignore",
"case",
"(",
"generic",
"table",
"name",
")",
")",
"{",
"drop",
"generic",
"table",
"=",
"false",
";",
"break",
";",
"}",
"}",
"if",
"(",
"drop",
"generic",
"table",
")",
"{",
"/",
"/",
"drop",
"the",
"generic",
"table",
"generic",
"tables",
"to",
"drop",
"add",
"(",
"table",
"name",
")",
";",
"}",
"}",
"}",
"return",
"generic",
"tables",
"to",
"drop",
";",
"}"
] |
[
"a",
"sensible",
"definition",
"of",
"{",
"@",
"link",
"#",
"equals",
"}",
"in",
"terms",
"of",
"the",
"{",
"@",
"code",
"equals",
"}",
"method",
"of",
"{",
"@",
"link",
"#",
"entry",
"set",
"}",
"if",
"you",
"override",
"{",
"@",
"link",
"#",
"entry",
"set",
"}",
",",
"you",
"may",
"wish",
"to",
"override",
"{",
"@",
"link",
"#",
"equals",
"}",
"to",
"forward",
"to",
"this",
"implementation"
] |
[
"protected",
"boolean",
"standard",
"equals",
"(",
"@",
"nullable",
"object",
"object",
")",
"{",
"return",
"maps",
"equals",
"impl",
"(",
"this",
",",
"object",
")",
";",
"}"
] |
[
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"we",
"adjusted",
"the",
"{",
"@",
"link",
"#",
"num",
"files",
"contributing",
"}",
"value",
"from",
"{",
"@",
"code",
"0",
"}",
"to",
"{",
"@",
"code",
"1",
"}",
"suspect",
"this",
"is",
"an",
"issue",
"with",
"a",
"particular",
"non",
"-",
"msft",
"compiler",
"tool",
"chain"
] |
[
"public",
"boolean",
"is",
"adjusted",
"num",
"files",
"contributing",
"(",
")",
"{",
"return",
"adjusted",
"numb",
"files",
"contributing",
";",
"}"
] |
[
"opens",
"scheduler",
"settings"
] |
[
"d",
"b",
"t",
"scheduler",
"external",
"settings",
"open",
"scheduler",
"settings",
"(",
")",
"throws",
"d",
"b",
"exception",
";"
] |
[
"get",
"the",
"actual",
"instance",
",",
"which",
"can",
"be",
"the",
"following",
":",
"apple",
",",
"banana"
] |
[
"public",
"object",
"get",
"actual",
"instance",
"(",
")",
"{",
"return",
"super",
"get",
"actual",
"instance",
"(",
")",
";",
"}"
] |
[
"get",
"the",
"current",
"layout",
"version"
] |
[
"public",
"static",
"int",
"get",
"current",
"layout",
"version",
"(",
"layout",
"feature",
"[",
"]",
"features",
")",
"{",
"return",
"get",
"last",
"non",
"reserved",
"feature",
"(",
"features",
")",
"get",
"info",
"(",
")",
"get",
"layout",
"version",
"(",
")",
";",
"}"
] |
[
"returns",
"whether",
"unaligned",
"checkpoints",
"are",
"enabled"
] |
[
"public",
"boolean",
"is",
"unaligned",
"checkpoints",
"enabled",
"(",
")",
"{",
"return",
"checkpoint",
"cfg",
"is",
"unaligned",
"checkpoints",
"enabled",
"(",
")",
";",
"}"
] |
[
"returns",
"whether",
"the",
"decoder",
"is",
"known",
"to",
"fail",
"when",
"flushed",
"if",
"true",
"is",
"returned",
",",
"the",
"renderer",
"will",
"work",
"around",
"the",
"issue",
"by",
"releasing",
"the",
"decoder",
"and",
"instantiating",
"a",
"new",
"one",
"rather",
"than",
"flushing",
"the",
"current",
"instance",
"see",
"[",
"internal",
":",
"b",
"8",
"3",
"4",
"7",
"9",
"5",
"8",
",",
"b",
"8",
"5",
"4",
"3",
"3",
"6",
"6",
"]"
] |
[
"private",
"static",
"boolean",
"codec",
"needs",
"flush",
"workaround",
"(",
"string",
"name",
")",
"{",
"return",
"util",
"sdk",
"int",
"<",
"18",
"|",
"|",
"(",
"util",
"sdk",
"int",
"=",
"=",
"18",
"&",
"&",
"(",
"\"",
"omx",
"sec",
"avc",
"dec",
"\"",
"equals",
"(",
"name",
")",
"|",
"|",
"\"",
"omx",
"sec",
"avc",
"dec",
"secure",
"\"",
"equals",
"(",
"name",
")",
")",
")",
"|",
"|",
"(",
"util",
"sdk",
"int",
"=",
"=",
"19",
"&",
"&",
"util",
"model",
"starts",
"with",
"(",
"\"",
"sm",
"-",
"g800",
"\"",
")",
"&",
"&",
"(",
"\"",
"omx",
"exynos",
"avc",
"dec",
"\"",
"equals",
"(",
"name",
")",
"|",
"|",
"\"",
"omx",
"exynos",
"avc",
"dec",
"secure",
"\"",
"equals",
"(",
"name",
")",
")",
")",
";",
"}"
] |
[
"the",
"status",
"applied",
"to",
"the",
"markup",
"item",
"when",
"{",
"@",
"link",
"v",
"t",
"markup",
"item",
"#",
"set",
"considered",
"(",
"v",
"t",
"markup",
"item",
"considered",
"status",
")",
"}",
"is",
"called"
] |
[
"public",
"v",
"t",
"markup",
"item",
"status",
"get",
"markup",
"item",
"status",
"(",
")",
"{",
"return",
"status",
";",
"}"
] |
[
"blocking",
"server",
"-",
"streaming",
"example",
"calls",
"list",
"features",
"with",
"a",
"rectangle",
"of",
"interest",
"prints",
"each",
"response",
"feature",
"as",
"it",
"arrives"
] |
[
"private",
"string",
"list",
"features",
"(",
"int",
"low",
"lat",
",",
"int",
"low",
"lon",
",",
"int",
"hi",
"lat",
",",
"int",
"hi",
"lon",
",",
"route",
"guide",
"blocking",
"stub",
"blocking",
"stub",
")",
"throws",
"status",
"runtime",
"exception",
"{",
"string",
"buffer",
"logs",
"=",
"new",
"string",
"buffer",
"(",
"\"",
"result",
":",
"\"",
")",
";",
"append",
"logs",
"(",
"logs",
",",
"\"",
"*",
"*",
"*",
"list",
"features",
":",
"low",
"lat",
"=",
"{",
"0",
"}",
"low",
"lon",
"=",
"{",
"1",
"}",
"hi",
"lat",
"=",
"{",
"2",
"}",
"hi",
"lon",
"=",
"{",
"3",
"}",
"\"",
",",
"low",
"lat",
",",
"low",
"lon",
",",
"hi",
"lat",
",",
"hi",
"lon",
")",
";",
"rectangle",
"request",
"=",
"rectangle",
"new",
"builder",
"(",
")",
"set",
"lo",
"(",
"point",
"new",
"builder",
"(",
")",
"set",
"latitude",
"(",
"low",
"lat",
")",
"set",
"longitude",
"(",
"low",
"lon",
")",
"build",
"(",
")",
")",
"set",
"hi",
"(",
"point",
"new",
"builder",
"(",
")",
"set",
"latitude",
"(",
"hi",
"lat",
")",
"set",
"longitude",
"(",
"hi",
"lon",
")",
"build",
"(",
")",
")",
"build",
"(",
")",
";",
"iterator",
"<",
"feature",
">",
"features",
";",
"features",
"=",
"blocking",
"stub",
"list",
"features",
"(",
"request",
")",
";",
"while",
"(",
"features",
"has",
"next",
"(",
")",
")",
"{",
"feature",
"feature",
"=",
"features",
"next",
"(",
")",
";",
"append",
"logs",
"(",
"logs",
",",
"feature",
"to",
"string",
"(",
")",
")",
";",
"}",
"return",
"logs",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"how",
"\"",
"offset",
"\"",
"this",
"rounding",
"is",
"from",
"the",
"traditional",
"\"",
"start",
"\"",
"of",
"the",
"period"
] |
[
"public",
"abstract",
"long",
"offset",
"(",
")",
";"
] |
[
"get",
"namespace",
"boolean"
] |
[
"public",
"boolean",
"get",
"namespace",
"boolean",
"(",
")",
"{",
"return",
"namespace",
"boolean",
";",
"}"
] |
[
"dump",
"the",
"given",
"subtrees"
] |
[
"public",
"static",
"void",
"dump",
"tree",
"recursively",
"(",
"print",
"writer",
"out",
",",
"string",
"builder",
"prefix",
",",
"iterable",
"<",
"snapshot",
"and",
"i",
"node",
">",
"subs",
")",
"{",
"if",
"(",
"subs",
"!",
"=",
"null",
")",
"{",
"for",
"(",
"final",
"iterator",
"<",
"snapshot",
"and",
"i",
"node",
">",
"i",
"=",
"subs",
"iterator",
"(",
")",
";",
"i",
"has",
"next",
"(",
")",
";",
")",
"{",
"final",
"snapshot",
"and",
"i",
"node",
"pair",
"=",
"i",
"next",
"(",
")",
";",
"prefix",
"append",
"(",
"i",
"has",
"next",
"(",
")",
"?",
"dumptree",
"except",
"last",
"item",
":",
"dumptree",
"last",
"item",
")",
";",
"pair",
"inode",
"dump",
"tree",
"recursively",
"(",
"out",
",",
"prefix",
",",
"pair",
"snapshot",
"id",
")",
";",
"prefix",
"set",
"length",
"(",
"prefix",
"length",
"(",
")",
"-",
"2",
")",
";",
"}",
"}",
"}"
] |
[
"returns",
"the",
"stats",
"object"
] |
[
"listenable",
"future",
"<",
"t",
">",
"get",
"stats",
"(",
")",
";"
] |
[
"<",
"code",
">",
"optional",
"aapt",
"pb",
"string",
"str",
"=",
"2",
";",
"<",
"code",
">"
] |
[
"private",
"void",
"clear",
"str",
"(",
")",
"{",
"str",
"=",
"null",
";",
"bit",
"field",
"0",
"=",
"(",
"bit",
"field",
"0",
"&",
"~",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"2",
")",
";",
"}"
] |
[
"create",
"a",
"builder",
"with",
"a",
"{",
"@",
"linkplain",
"http",
"status",
"#",
"no",
"content",
"204",
"no",
"content",
"}",
"status"
] |
[
"static",
"headers",
"builder",
"<",
"?",
">",
"no",
"content",
"(",
")",
"{",
"return",
"status",
"(",
"http",
"status",
"no",
"content",
")",
";",
"}"
] |
[
"get",
"namespace",
"array"
] |
[
"public",
"list",
"<",
"integer",
">",
"get",
"namespace",
"array",
"(",
")",
"{",
"return",
"namespace",
"array",
";",
"}"
] |
[
"returns",
"true",
"if",
"this",
"test",
"subscriber",
"received",
"a",
"subscription"
] |
[
"public",
"final",
"boolean",
"has",
"subscription",
"(",
")",
"{",
"return",
"upstream",
"get",
"(",
")",
"!",
"=",
"null",
";",
"}"
] |
[
"makes",
"sure",
"that",
"the",
"byte",
"array",
"deserializer",
"is",
"registered",
"in",
"the",
"kafka",
"properties"
] |
[
"private",
"static",
"void",
"set",
"deserializer",
"(",
"properties",
"props",
")",
"{",
"final",
"string",
"de",
"ser",
"name",
"=",
"byte",
"array",
"deserializer",
"class",
"get",
"name",
"(",
")",
";",
"object",
"key",
"de",
"ser",
"=",
"props",
"get",
"(",
"consumer",
"config",
"key",
"deserializer",
"class",
"config",
")",
";",
"object",
"val",
"de",
"ser",
"=",
"props",
"get",
"(",
"consumer",
"config",
"value",
"deserializer",
"class",
"config",
")",
";",
"if",
"(",
"key",
"de",
"ser",
"!",
"=",
"null",
"&",
"&",
"!",
"key",
"de",
"ser",
"equals",
"(",
"de",
"ser",
"name",
")",
")",
"{",
"log",
"warn",
"(",
"\"",
"ignoring",
"configured",
"key",
"de",
"serializer",
"(",
"{",
"}",
")",
"\"",
",",
"consumer",
"config",
"key",
"deserializer",
"class",
"config",
")",
";",
"}",
"if",
"(",
"val",
"de",
"ser",
"!",
"=",
"null",
"&",
"&",
"!",
"val",
"de",
"ser",
"equals",
"(",
"de",
"ser",
"name",
")",
")",
"{",
"log",
"warn",
"(",
"\"",
"ignoring",
"configured",
"value",
"de",
"serializer",
"(",
"{",
"}",
")",
"\"",
",",
"consumer",
"config",
"value",
"deserializer",
"class",
"config",
")",
";",
"}",
"props",
"put",
"(",
"consumer",
"config",
"key",
"deserializer",
"class",
"config",
",",
"de",
"ser",
"name",
")",
";",
"props",
"put",
"(",
"consumer",
"config",
"value",
"deserializer",
"class",
"config",
",",
"de",
"ser",
"name",
")",
";",
"}"
] |
[
"removes",
"the",
"{",
"@",
"link",
"channel",
"outbound",
"handler",
"}",
"that",
"was",
"combined",
"in",
"this",
"{",
"@",
"link",
"combined",
"channel",
"duplex",
"handler",
"}"
] |
[
"public",
"final",
"void",
"remove",
"outbound",
"handler",
"(",
")",
"{",
"check",
"added",
"(",
")",
";",
"outbound",
"ctx",
"remove",
"(",
")",
";",
"}"
] |
[
"strategy",
"for",
"a",
"named",
"function",
"signature",
"like",
"{",
"@",
"code",
"f",
"(",
"s",
"string",
",",
"n",
"numeric",
")",
"}",
"using",
"a",
"sequence",
"of",
"{",
"@",
"link",
"argument",
"type",
"strategy",
"}",
"s"
] |
[
"public",
"static",
"input",
"type",
"strategy",
"sequence",
"(",
"string",
"[",
"]",
"argument",
"names",
",",
"argument",
"type",
"strategy",
"[",
"]",
"strategies",
")",
"{",
"return",
"new",
"sequence",
"input",
"type",
"strategy",
"(",
"arrays",
"as",
"list",
"(",
"strategies",
")",
",",
"arrays",
"as",
"list",
"(",
"argument",
"names",
")",
")",
";",
"}"
] |
[
"model",
"tests",
"for",
"big",
"cat"
] |
[
"public",
"void",
"test",
"big",
"cat",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"big",
"cat",
"}"
] |
[
"headroom",
"depends",
"on",
"resources",
"in",
"the",
"cluster",
",",
"current",
"usage",
"of",
"the",
"queue",
",",
"queue",
"'",
"s",
"fair",
"-",
"share",
"and",
"queue",
"'",
"s",
"max",
"-",
"resources"
] |
[
"public",
"resource",
"get",
"headroom",
"(",
")",
"{",
"final",
"f",
"s",
"queue",
"fs",
"queue",
"=",
"get",
"queue",
"(",
")",
";",
"scheduling",
"policy",
"policy",
"=",
"fs",
"queue",
"get",
"policy",
"(",
")",
";",
"resource",
"queue",
"fair",
"share",
"=",
"fs",
"queue",
"get",
"fair",
"share",
"(",
")",
";",
"resource",
"queue",
"usage",
"=",
"fs",
"queue",
"get",
"resource",
"usage",
"(",
")",
";",
"resource",
"cluster",
"resource",
"=",
"this",
"scheduler",
"get",
"cluster",
"resource",
"(",
")",
";",
"resource",
"cluster",
"usage",
"=",
"this",
"scheduler",
"get",
"root",
"queue",
"metrics",
"(",
")",
"get",
"allocated",
"resources",
"(",
")",
";",
"resource",
"cluster",
"available",
"resources",
"=",
"resources",
"subtract",
"(",
"cluster",
"resource",
",",
"cluster",
"usage",
")",
";",
"subtract",
"resources",
"on",
"blacklisted",
"nodes",
"(",
"cluster",
"available",
"resources",
")",
";",
"resource",
"queue",
"max",
"available",
"resources",
"=",
"resources",
"subtract",
"(",
"fs",
"queue",
"get",
"max",
"share",
"(",
")",
",",
"queue",
"usage",
")",
";",
"resource",
"max",
"available",
"resource",
"=",
"resources",
"componentwise",
"min",
"(",
"cluster",
"available",
"resources",
",",
"queue",
"max",
"available",
"resources",
")",
";",
"resource",
"headroom",
"=",
"policy",
"get",
"headroom",
"(",
"queue",
"fair",
"share",
",",
"queue",
"usage",
",",
"max",
"available",
"resource",
")",
";",
"log",
"debug",
"(",
"\"",
"headroom",
"calculation",
"for",
"{",
"}",
":",
"min",
"(",
"(",
"queue",
"fair",
"share",
"=",
"{",
"}",
"-",
"\"",
"+",
"\"",
"queue",
"usage",
"=",
"{",
"}",
")",
",",
"max",
"available",
"resource",
"=",
"{",
"}",
"headroom",
"=",
"{",
"}",
"\"",
",",
"this",
"get",
"name",
"(",
")",
",",
"queue",
"fair",
"share",
",",
"queue",
"usage",
",",
"max",
"available",
"resource",
",",
"headroom",
")",
";",
"return",
"headroom",
";",
"}"
] |
[
"return",
"a",
"list",
"of",
"children",
"that",
"are",
"of",
"a",
"specific",
"dwarf",
"type"
] |
[
"public",
"list",
"<",
"debug",
"info",
"entry",
">",
"get",
"children",
"(",
"int",
"child",
"tag",
")",
"{",
"list",
"<",
"debug",
"info",
"entry",
">",
"result",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"for",
"(",
"debug",
"info",
"entry",
"child",
":",
"get",
"children",
"(",
")",
")",
"{",
"if",
"(",
"child",
"get",
"tag",
"(",
")",
"=",
"=",
"child",
"tag",
")",
"{",
"result",
"add",
"(",
"child",
")",
";",
"}",
"}",
"return",
"result",
";",
"}"
] |
[
"async",
"observable",
"and",
"semaphore",
"isolation",
"with",
"functioning",
"request",
"context",
"use",
"hystrix",
"context",
"scheduler",
"to",
"make",
"the",
"user",
"provided",
"scheduler",
"capture",
"context"
] |
[
"public",
"void",
"test",
"rejection",
"with",
"fallback",
"request",
"context",
"with",
"semaphore",
"isolated",
"asynchronous",
"observable",
"and",
"captured",
"context",
"scheduler",
"(",
")",
"{",
"request",
"context",
"test",
"results",
"results",
"=",
"test",
"request",
"context",
"on",
"rejection",
"with",
"fallback",
"(",
"execution",
"isolation",
"strategy",
"semaphore",
",",
"new",
"hystrix",
"context",
"scheduler",
"(",
"schedulers",
"new",
"thread",
"(",
")",
")",
")",
";",
"assert",
"true",
"(",
"results",
"is",
"context",
"initialized",
"get",
"(",
")",
")",
";",
"/",
"/",
"the",
"user",
"scheduler",
"captures",
"context",
"assert",
"true",
"(",
"results",
"origin",
"thread",
"get",
"(",
")",
"get",
"name",
"(",
")",
"starts",
"with",
"(",
"\"",
"rx",
"new",
"thread",
"\"",
")",
")",
";",
"/",
"/",
"the",
"user",
"provided",
"thread",
"/",
"scheduler",
"assert",
"true",
"(",
"results",
"is",
"context",
"initialized",
"observe",
"on",
"get",
"(",
")",
")",
";",
"/",
"/",
"the",
"user",
"scheduler",
"captures",
"context",
"assert",
"true",
"(",
"results",
"observe",
"on",
"thread",
"get",
"(",
")",
"get",
"name",
"(",
")",
"starts",
"with",
"(",
"\"",
"rx",
"new",
"thread",
"\"",
")",
")",
";",
"/",
"/",
"the",
"user",
"provided",
"thread",
"/",
"scheduler",
"/",
"/",
"semaphore",
"isolated",
"assert",
"false",
"(",
"results",
"command",
"is",
"executed",
"in",
"thread",
"(",
")",
")",
";",
"}"
] |
[
"start",
"multiple",
"n",
"ns",
"and",
"single",
"dn",
"and",
"verifies",
"per",
"bp",
"registrations",
"and",
"handshakes"
] |
[
"public",
"void",
"test",
"2",
"n",
"n",
"registration",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"mini",
"d",
"f",
"s",
"cluster",
"cluster",
"=",
"new",
"mini",
"d",
"f",
"s",
"cluster",
"builder",
"(",
"conf",
")",
"nn",
"topology",
"(",
"mini",
"d",
"f",
"s",
"n",
"n",
"topology",
"simple",
"federated",
"topology",
"(",
"2",
")",
")",
"build",
"(",
")",
";",
"try",
"{",
"cluster",
"wait",
"active",
"(",
")",
";",
"name",
"node",
"nn",
"1",
"=",
"cluster",
"get",
"name",
"node",
"(",
"0",
")",
";",
"name",
"node",
"nn",
"2",
"=",
"cluster",
"get",
"name",
"node",
"(",
"1",
")",
";",
"assert",
"not",
"null",
"(",
"\"",
"cannot",
"create",
"nn",
"1",
"\"",
",",
"nn",
"1",
")",
";",
"assert",
"not",
"null",
"(",
"\"",
"cannot",
"create",
"nn",
"2",
"\"",
",",
"nn",
"2",
")",
";",
"string",
"bpid",
"1",
"=",
"f",
"s",
"image",
"test",
"util",
"get",
"f",
"s",
"image",
"(",
"nn",
"1",
")",
"get",
"block",
"pool",
"i",
"d",
"(",
")",
";",
"string",
"bpid",
"2",
"=",
"f",
"s",
"image",
"test",
"util",
"get",
"f",
"s",
"image",
"(",
"nn",
"2",
")",
"get",
"block",
"pool",
"i",
"d",
"(",
")",
";",
"string",
"cid",
"1",
"=",
"f",
"s",
"image",
"test",
"util",
"get",
"f",
"s",
"image",
"(",
"nn",
"1",
")",
"get",
"cluster",
"i",
"d",
"(",
")",
";",
"string",
"cid",
"2",
"=",
"f",
"s",
"image",
"test",
"util",
"get",
"f",
"s",
"image",
"(",
"nn",
"2",
")",
"get",
"cluster",
"i",
"d",
"(",
")",
";",
"int",
"lv",
"1",
"=",
"f",
"s",
"image",
"test",
"util",
"get",
"f",
"s",
"image",
"(",
"nn",
"1",
")",
"get",
"layout",
"version",
"(",
")",
";",
"int",
"lv",
"2",
"=",
"f",
"s",
"image",
"test",
"util",
"get",
"f",
"s",
"image",
"(",
"nn",
"2",
")",
"get",
"layout",
"version",
"(",
")",
";",
"int",
"ns",
"1",
"=",
"f",
"s",
"image",
"test",
"util",
"get",
"f",
"s",
"image",
"(",
"nn",
"1",
")",
"get",
"namespace",
"i",
"d",
"(",
")",
";",
"int",
"ns",
"2",
"=",
"f",
"s",
"image",
"test",
"util",
"get",
"f",
"s",
"image",
"(",
"nn",
"2",
")",
"get",
"namespace",
"i",
"d",
"(",
")",
";",
"assert",
"not",
"same",
"(",
"\"",
"namespace",
"ids",
"should",
"be",
"different",
"\"",
",",
"ns",
"1",
",",
"ns",
"2",
")",
";",
"log",
"info",
"(",
"\"",
"nn",
"1",
":",
"lv",
"=",
"\"",
"+",
"lv",
"1",
"+",
"\"",
";",
"cid",
"=",
"\"",
"+",
"cid",
"1",
"+",
"\"",
";",
"bpid",
"=",
"\"",
"+",
"bpid",
"1",
"+",
"\"",
";",
"uri",
"=",
"\"",
"+",
"nn",
"1",
"get",
"name",
"node",
"address",
"(",
")",
")",
";",
"log",
"info",
"(",
"\"",
"nn",
"2",
":",
"lv",
"=",
"\"",
"+",
"lv",
"2",
"+",
"\"",
";",
"cid",
"=",
"\"",
"+",
"cid",
"2",
"+",
"\"",
";",
"bpid",
"=",
"\"",
"+",
"bpid",
"2",
"+",
"\"",
";",
"uri",
"=",
"\"",
"+",
"nn",
"2",
"get",
"name",
"node",
"address",
"(",
")",
")",
";",
"/",
"/",
"check",
"number",
"of",
"volumes",
"in",
"fsdataset",
"data",
"node",
"dn",
"=",
"cluster",
"get",
"data",
"nodes",
"(",
")",
"get",
"(",
"0",
")",
";",
"final",
"map",
"<",
"string",
",",
"object",
">",
"vol",
"infos",
"=",
"dn",
"data",
"get",
"volume",
"info",
"map",
"(",
")",
";",
"assert",
"assert",
"true",
"(",
"\"",
"no",
"volumes",
"in",
"the",
"fsdataset",
"\"",
",",
"vol",
"infos",
"size",
"(",
")",
">",
"0",
")",
";",
"int",
"i",
"=",
"0",
";",
"for",
"(",
"map",
"entry",
"<",
"string",
",",
"object",
">",
"e",
":",
"vol",
"infos",
"entry",
"set",
"(",
")",
")",
"{",
"log",
"info",
"(",
"\"",
"vol",
"\"",
"+",
"i",
"+",
"+",
"+",
"\"",
")",
"\"",
"+",
"e",
"get",
"key",
"(",
")",
"+",
"\"",
":",
"\"",
"+",
"e",
"get",
"value",
"(",
")",
")",
";",
"}",
"/",
"/",
"number",
"of",
"volumes",
"should",
"be",
"2",
"-",
"[",
"data",
"1",
",",
"data",
"2",
"]",
"assert",
"equals",
"(",
"\"",
"number",
"of",
"volumes",
"is",
"wrong",
"\"",
",",
"cluster",
"get",
"fs",
"dataset",
"test",
"utils",
"(",
"0",
")",
"get",
"default",
"num",
"of",
"data",
"dirs",
"(",
")",
",",
"vol",
"infos",
"size",
"(",
")",
")",
";",
"for",
"(",
"b",
"p",
"offer",
"service",
"bpos",
":",
"dn",
"get",
"all",
"bp",
"os",
"(",
")",
")",
"{",
"log",
"info",
"(",
"\"",
"bp",
":",
"\"",
"+",
"bpos",
")",
";",
"}",
"b",
"p",
"offer",
"service",
"bpos",
"1",
"=",
"dn",
"get",
"all",
"bp",
"os",
"(",
")",
"get",
"(",
"0",
")",
";",
"b",
"p",
"offer",
"service",
"bpos",
"2",
"=",
"dn",
"get",
"all",
"bp",
"os",
"(",
")",
"get",
"(",
"1",
")",
";",
"/",
"/",
"the",
"order",
"of",
"bpos",
"is",
"not",
"guaranteed",
",",
"so",
"fix",
"the",
"order",
"if",
"(",
"get",
"n",
"n",
"socket",
"address",
"(",
"bpos",
"1",
")",
"equals",
"(",
"nn",
"2",
"get",
"name",
"node",
"address",
"(",
")",
")",
")",
"{",
"b",
"p",
"offer",
"service",
"tmp",
"=",
"bpos",
"1",
";",
"bpos",
"1",
"=",
"bpos",
"2",
";",
"bpos",
"2",
"=",
"tmp",
";",
"}",
"assert",
"equals",
"(",
"\"",
"wrong",
"nn",
"address",
"\"",
",",
"get",
"n",
"n",
"socket",
"address",
"(",
"bpos",
"1",
")",
",",
"nn",
"1",
"get",
"name",
"node",
"address",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"wrong",
"nn",
"address",
"\"",
",",
"get",
"n",
"n",
"socket",
"address",
"(",
"bpos",
"2",
")",
",",
"nn",
"2",
"get",
"name",
"node",
"address",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"wrong",
"bpid",
"\"",
",",
"bpos",
"1",
"get",
"block",
"pool",
"id",
"(",
")",
",",
"bpid",
"1",
")",
";",
"assert",
"equals",
"(",
"\"",
"wrong",
"bpid",
"\"",
",",
"bpos",
"2",
"get",
"block",
"pool",
"id",
"(",
")",
",",
"bpid",
"2",
")",
";",
"assert",
"equals",
"(",
"\"",
"wrong",
"cid",
"\"",
",",
"dn",
"get",
"cluster",
"id",
"(",
")",
",",
"cid",
"1",
")",
";",
"assert",
"equals",
"(",
"\"",
"cid",
"should",
"be",
"same",
"\"",
",",
"cid",
"2",
",",
"cid",
"1",
")",
";",
"assert",
"equals",
"(",
"\"",
"namespace",
"should",
"be",
"same",
"\"",
",",
"bpos",
"1",
"bp",
"n",
"s",
"info",
"namespace",
"i",
"d",
",",
"ns",
"1",
")",
";",
"assert",
"equals",
"(",
"\"",
"namespace",
"should",
"be",
"same",
"\"",
",",
"bpos",
"2",
"bp",
"n",
"s",
"info",
"namespace",
"i",
"d",
",",
"ns",
"2",
")",
";",
"}",
"finally",
"{",
"cluster",
"shutdown",
"(",
")",
";",
"}",
"}"
] |
[
"constructs",
"the",
"appropriate",
"\"",
"tc",
"\"",
"commands",
"to",
"apply",
"latency",
"and",
"rate",
"limiting",
",",
"if",
"they",
"are",
"non",
"zero"
] |
[
"private",
"void",
"enable",
"traffic",
"control",
"(",
"platform",
"platform",
",",
"string",
"network",
"device",
",",
"int",
"delay",
"ms",
",",
"int",
"rate",
"limit",
"kbps",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"delay",
"ms",
">",
"0",
")",
"{",
"int",
"deviation",
"ms",
"=",
"math",
"max",
"(",
"1",
",",
"(",
"int",
")",
"math",
"sqrt",
"(",
"delay",
"ms",
")",
")",
";",
"list",
"<",
"string",
">",
"delay",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"root",
"handler",
"(",
"network",
"device",
",",
"delay",
":",
":",
"add",
")",
";",
"netem",
"delay",
"(",
"delay",
"ms",
",",
"deviation",
"ms",
",",
"delay",
":",
":",
"add",
")",
";",
"platform",
"run",
"command",
"(",
"delay",
"to",
"array",
"(",
"new",
"string",
"[",
"0",
"]",
")",
")",
";",
"if",
"(",
"rate",
"limit",
"kbps",
">",
"0",
")",
"{",
"list",
"<",
"string",
">",
"rate",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"child",
"handler",
"(",
"network",
"device",
",",
"rate",
":",
":",
"add",
")",
";",
"tbf",
"rate",
"(",
"rate",
"limit",
"kbps",
",",
"rate",
":",
":",
"add",
")",
";",
"platform",
"run",
"command",
"(",
"rate",
"to",
"array",
"(",
"new",
"string",
"[",
"0",
"]",
")",
")",
";",
"}",
"}",
"else",
"if",
"(",
"rate",
"limit",
"kbps",
">",
"0",
")",
"{",
"list",
"<",
"string",
">",
"rate",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"root",
"handler",
"(",
"network",
"device",
",",
"rate",
":",
":",
"add",
")",
";",
"tbf",
"rate",
"(",
"rate",
"limit",
"kbps",
",",
"rate",
":",
":",
"add",
")",
";",
"platform",
"run",
"command",
"(",
"rate",
"to",
"array",
"(",
"new",
"string",
"[",
"0",
"]",
")",
")",
";",
"}",
"else",
"{",
"log",
"warn",
"(",
"\"",
"not",
"applying",
"any",
"rate",
"limiting",
"or",
"latency",
"\"",
")",
";",
"}",
"}"
] |
[
"returns",
"the",
"quotient",
"of",
"the",
"given",
"particular",
"double",
"value",
"and",
"this",
"double",
"value"
] |
[
"public",
"double",
"value",
"divide",
"of",
"(",
"particular",
"double",
"value",
"other",
")",
"{",
"return",
"divide",
"of",
"(",
"(",
"specific",
"double",
"value",
")",
"other",
")",
";",
"}"
] |
[
"used",
"by",
"media",
"player",
"g",
"i",
"fs",
"contain",
"no",
"sound",
",",
"so",
"0",
"is",
"always",
"returned"
] |
[
"public",
"int",
"get",
"audio",
"session",
"id",
"(",
")",
"{",
"return",
"0",
";",
"}"
] |
[
"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",
"snake",
"case"
] |
[
"public",
"integer",
"get",
"snake",
"case",
"(",
")",
"{",
"return",
"snake",
"case",
";",
"}"
] |
[
"returns",
"all",
"{",
"@",
"code",
"block",
"}",
"directives"
] |
[
"public",
"set",
"<",
"string",
">",
"get",
"block",
"list",
"(",
")",
"{",
"return",
"block",
"list",
";",
"}"
] |
[
"gets",
"the",
"attached",
"exception",
",",
"which",
"is",
"in",
"serialized",
"form",
"returns",
"null",
",",
"if",
"the",
"status",
"update",
"is",
"no",
"failure",
"with",
"an",
"associated",
"exception"
] |
[
"public",
"throwable",
"get",
"error",
"(",
"class",
"loader",
"user",
"code",
"classloader",
")",
"{",
"if",
"(",
"this",
"throwable",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"else",
"{",
"return",
"this",
"throwable",
"deserialize",
"error",
"(",
"user",
"code",
"classloader",
")",
";",
"}",
"}"
] |
[
"reset",
"state",
"and",
"release",
"resources",
"in",
"use",
"(",
"such",
"as",
"thread",
"-",
"pools",
")",
"note",
":",
"this",
"can",
"result",
"in",
"race",
"conditions",
"if",
"hystrix",
"commands",
"are",
"concurrently",
"being",
"executed"
] |
[
"public",
"static",
"void",
"reset",
"(",
")",
"{",
"/",
"/",
"shutdown",
"thread",
"-",
"pools",
"hystrix",
"thread",
"pool",
"factory",
"shutdown",
"(",
")",
";",
"reset",
"(",
")",
";",
"}"
] |
[
"tests",
"for",
"a",
"given",
"volumes",
"to",
"be",
"tolerated",
"and",
"volumes",
"failed"
] |
[
"private",
"void",
"test",
"volume",
"config",
"(",
"int",
"volumes",
"tolerated",
",",
"int",
"volumes",
"failed",
",",
"boolean",
"expected",
"b",
"p",
"service",
"state",
",",
"boolean",
"manage",
"dfs",
"dirs",
")",
"throws",
"i",
"o",
"exception",
",",
"interrupted",
"exception",
"{",
"assume",
"not",
"windows",
"(",
")",
";",
"final",
"int",
"dn",
"index",
"=",
"0",
";",
"/",
"/",
"fail",
"the",
"current",
"directory",
"since",
"invalid",
"storage",
"directory",
"perms",
"/",
"/",
"get",
"fixed",
"up",
"automatically",
"on",
"datanode",
"startup",
"file",
"[",
"]",
"dirs",
"=",
"{",
"new",
"file",
"(",
"cluster",
"get",
"instance",
"storage",
"dir",
"(",
"dn",
"index",
",",
"0",
")",
",",
"\"",
"current",
"\"",
")",
",",
"new",
"file",
"(",
"cluster",
"get",
"instance",
"storage",
"dir",
"(",
"dn",
"index",
",",
"1",
")",
",",
"\"",
"current",
"\"",
")",
"}",
";",
"try",
"{",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"volumes",
"failed",
";",
"i",
"+",
"+",
")",
"{",
"prepare",
"dir",
"to",
"fail",
"(",
"dirs",
"[",
"i",
"]",
")",
";",
"}",
"restart",
"datanodes",
"(",
"volumes",
"tolerated",
",",
"manage",
"dfs",
"dirs",
")",
";",
"}",
"catch",
"(",
"hadoop",
"illegal",
"argument",
"exception",
"e",
")",
"{",
"generic",
"test",
"utils",
"assert",
"exception",
"contains",
"(",
"\"",
"invalid",
"value",
"configured",
"for",
"\"",
"+",
"\"",
"dfs",
"datanode",
"failed",
"volumes",
"tolerated",
"\"",
",",
"e",
")",
";",
"}",
"finally",
"{",
"for",
"(",
"file",
"dir",
":",
"dirs",
")",
"{",
"file",
"util",
"chmod",
"(",
"dir",
"to",
"string",
"(",
")",
",",
"\"",
"755",
"\"",
")",
";",
"}",
"boolean",
"bp",
"service",
"state",
";",
"/",
"/",
"if",
"the",
"datanode",
"not",
"registered",
"successfully",
",",
"/",
"/",
"because",
"the",
"invalid",
"value",
"configured",
"for",
"tolerated",
"volumes",
"if",
"(",
"cluster",
"get",
"data",
"nodes",
"(",
")",
"size",
"(",
")",
"=",
"=",
"0",
")",
"{",
"bp",
"service",
"state",
"=",
"false",
";",
"}",
"else",
"{",
"bp",
"service",
"state",
"=",
"cluster",
"get",
"data",
"nodes",
"(",
")",
"get",
"(",
"0",
")",
"is",
"b",
"p",
"service",
"alive",
"(",
"cluster",
"get",
"namesystem",
"(",
")",
"get",
"block",
"pool",
"id",
"(",
")",
")",
";",
"}",
"assert",
"equals",
"(",
"expected",
"b",
"p",
"service",
"state",
",",
"bp",
"service",
"state",
")",
";",
"}",
"}"
] |
[
"gets",
"the",
"number",
"of",
"listing",
"conflicts",
"to",
"resolve",
"at",
"the",
"indicated",
"address"
] |
[
"private",
"int",
"get",
"total",
"num",
"conflicts",
"(",
"listing",
"merger",
"[",
"]",
"mergers",
",",
"address",
"addr",
")",
"{",
"int",
"total",
"conflicts",
"=",
"0",
";",
"for",
"(",
"listing",
"merger",
"merger",
":",
"mergers",
")",
"{",
"total",
"conflicts",
"+",
"=",
"merger",
"get",
"conflict",
"count",
"(",
"addr",
")",
";",
"}",
"return",
"total",
"conflicts",
";",
"}"
] |
[
"get",
"string",
"item"
] |
[
"public",
"string",
"get",
"string",
"item",
"(",
")",
"{",
"return",
"string",
"item",
";",
"}"
] |
[
"return",
"the",
"unique",
"device",
"id",
"{",
"1",
"}",
"{",
"uuid",
"(",
"mac",
"address",
")",
"}",
"{",
"2",
"}",
"{",
"uuid",
"(",
"android",
"id",
")",
"}",
"{",
"9",
"}",
"{",
"uuid",
"(",
"random",
")",
"}"
] |
[
"public",
"static",
"string",
"get",
"unique",
"device",
"id",
"(",
"boolean",
"use",
"cache",
")",
"{",
"return",
"get",
"unique",
"device",
"id",
"(",
"\"",
"\"",
",",
"use",
"cache",
")",
";",
"}"
] |
[
"returns",
"the",
"size",
"(",
"in",
"bytes",
")",
"of",
"this",
"coff",
"file",
"header"
] |
[
"public",
"int",
"sizeof",
"(",
")",
"{",
"if",
"(",
"is",
"coff",
"level",
"one",
"or",
"two",
"(",
")",
")",
"{",
"return",
"22",
";",
"}",
"return",
"20",
";",
"}"
] |
[
"only",
"select",
"deployments",
"where",
"the",
"deployment",
"version",
"is",
"the",
"latest",
"value"
] |
[
"deployment",
"query",
"latest",
"version",
"(",
")",
";",
"/",
"/",
"sorting",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/",
"/"
] |
[
"get",
"the",
"int",
"value",
"of",
"a",
"transaction",
"isolation",
"level",
"by",
"name"
] |
[
"public",
"static",
"int",
"get",
"transaction",
"isolation",
"(",
"final",
"string",
"transaction",
"isolation",
"name",
")",
"{",
"if",
"(",
"transaction",
"isolation",
"name",
"!",
"=",
"null",
")",
"{",
"try",
"{",
"/",
"/",
"use",
"the",
"english",
"locale",
"to",
"avoid",
"the",
"infamous",
"turkish",
"locale",
"bug",
"final",
"string",
"upper",
"case",
"isolation",
"level",
"name",
"=",
"transaction",
"isolation",
"name",
"to",
"upper",
"case",
"(",
"locale",
"english",
")",
";",
"return",
"isolation",
"level",
"value",
"of",
"(",
"upper",
"case",
"isolation",
"level",
"name",
")",
"get",
"level",
"id",
"(",
")",
";",
"}",
"catch",
"(",
"illegal",
"argument",
"exception",
"e",
")",
"{",
"/",
"/",
"legacy",
"support",
"for",
"passing",
"an",
"integer",
"version",
"of",
"the",
"isolation",
"level",
"try",
"{",
"final",
"int",
"level",
"=",
"integer",
"parse",
"int",
"(",
"transaction",
"isolation",
"name",
")",
";",
"for",
"(",
"isolation",
"level",
"iso",
":",
"isolation",
"level",
"values",
"(",
")",
")",
"{",
"if",
"(",
"iso",
"get",
"level",
"id",
"(",
")",
"=",
"=",
"level",
")",
"{",
"return",
"iso",
"get",
"level",
"id",
"(",
")",
";",
"}",
"}",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"invalid",
"transaction",
"isolation",
"value",
":",
"\"",
"+",
"transaction",
"isolation",
"name",
")",
";",
"}",
"catch",
"(",
"number",
"format",
"exception",
"nfe",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"invalid",
"transaction",
"isolation",
"value",
":",
"\"",
"+",
"transaction",
"isolation",
"name",
",",
"nfe",
")",
";",
"}",
"}",
"}",
"return",
"-",
"1",
";",
"}"
] |
[
"closes",
"all",
"the",
"opened",
"named",
"outputs",
"if",
"overriden",
"subclasses",
"must",
"invoke",
"<",
"code",
">",
"super",
"close",
"(",
")",
"<",
"code",
">",
"at",
"the",
"end",
"of",
"their",
"<",
"code",
">",
"close",
"(",
")",
"<",
"code",
">"
] |
[
"public",
"void",
"close",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"for",
"(",
"record",
"writer",
"writer",
":",
"record",
"writers",
"values",
"(",
")",
")",
"{",
"writer",
"close",
"(",
"null",
")",
";",
"}",
"}"
] |
[
"this",
"method",
"returns",
"a",
"{",
"@",
"code",
"immutable",
"sorted",
"map",
"}",
",",
"consisting",
"of",
"the",
"entries",
"whose",
"keys",
"are",
"greater",
"than",
"or",
"equals",
"to",
"{",
"@",
"code",
"from",
"key",
"}",
"the",
"{",
"@",
"link",
"sorted",
"map",
"#",
"tail",
"map",
"}",
"documentation",
"states",
"that",
"a",
"submap",
"of",
"a",
"submap",
"throws",
"an",
"{",
"@",
"link",
"illegal",
"argument",
"exception",
"}",
"if",
"passed",
"a",
"{",
"@",
"code",
"from",
"key",
"}",
"less",
"than",
"an",
"earlier",
"{",
"@",
"code",
"from",
"key",
"}",
"however",
",",
"this",
"method",
"doesn",
"'",
"t",
"throw",
"an",
"exception",
"in",
"that",
"situation",
",",
"but",
"instead",
"keeps",
"the",
"original",
"{",
"@",
"code",
"from",
"key",
"}"
] |
[
"public",
"immutable",
"sorted",
"map",
"<",
"k",
",",
"v",
">",
"tail",
"map",
"(",
"k",
"from",
"key",
")",
"{",
"return",
"tail",
"map",
"(",
"from",
"key",
",",
"true",
")",
";",
"}"
] |
[
"get",
"length",
"cm"
] |
[
"public",
"big",
"decimal",
"get",
"length",
"cm",
"(",
")",
"{",
"return",
"length",
"cm",
";",
"}"
] |
[
"returns",
"the",
"{",
"@",
"code",
"boolean",
"}",
"value",
"that",
"corresponds",
"to",
"this",
"{",
"@",
"link",
"tri",
"state",
"}",
",",
"if",
"appropriate"
] |
[
"public",
"@",
"nullable",
"boolean",
"as",
"boolean",
"object",
"(",
")",
"{",
"switch",
"(",
"this",
")",
"{",
"case",
"yes",
":",
"return",
"boolean",
"true",
";",
"case",
"no",
":",
"return",
"boolean",
"false",
";",
"case",
"unset",
":",
"return",
"null",
";",
"default",
":",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"unrecognized",
"tri",
"state",
"value",
":",
"\"",
"+",
"this",
")",
";",
"}",
"}"
] |
[
"returns",
"whether",
"or",
"not",
"all",
"of",
"the",
"choices",
"(",
"conflicts",
")",
"have",
"been",
"resolved",
"by",
"the",
"user",
"making",
"selections",
"and",
"the",
"user",
"made",
"the",
"same",
"choice",
"for",
"all",
"the",
"conflicts"
] |
[
"public",
"abstract",
"boolean",
"all",
"choices",
"are",
"same",
"(",
")",
";"
] |
[
"create",
"rel",
"node",
"tree",
"that",
"produces",
"a",
"list",
"of",
"correlated",
"variables"
] |
[
"private",
"rel",
"node",
"create",
"value",
"generator",
"(",
"iterable",
"<",
"cor",
"ref",
">",
"correlations",
",",
"int",
"value",
"gen",
"field",
"offset",
",",
"sorted",
"map",
"<",
"cor",
"def",
",",
"integer",
">",
"cor",
"def",
"outputs",
")",
"{",
"final",
"map",
"<",
"rel",
"node",
",",
"list",
"<",
"integer",
">",
">",
"map",
"new",
"input",
"to",
"outputs",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"final",
"map",
"<",
"rel",
"node",
",",
"integer",
">",
"map",
"new",
"input",
"to",
"new",
"offset",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"/",
"/",
"input",
"provides",
"the",
"definition",
"of",
"a",
"correlated",
"variable",
"/",
"/",
"add",
"to",
"map",
"all",
"the",
"referenced",
"positions",
"(",
"relative",
"to",
"each",
"input",
"rel",
")",
"for",
"(",
"cor",
"ref",
"cor",
"var",
":",
"correlations",
")",
"{",
"final",
"int",
"old",
"cor",
"var",
"offset",
"=",
"cor",
"var",
"field",
";",
"final",
"rel",
"node",
"old",
"input",
"=",
"get",
"cor",
"rel",
"(",
"cor",
"var",
")",
";",
"assert",
"old",
"input",
"!",
"=",
"null",
";",
"final",
"frame",
"frame",
"=",
"get",
"frame",
"(",
"old",
"input",
",",
"true",
")",
";",
"assert",
"frame",
"!",
"=",
"null",
";",
"final",
"rel",
"node",
"new",
"input",
"=",
"frame",
"r",
";",
"final",
"list",
"<",
"integer",
">",
"new",
"local",
"outputs",
";",
"if",
"(",
"!",
"map",
"new",
"input",
"to",
"outputs",
"contains",
"key",
"(",
"new",
"input",
")",
")",
"{",
"new",
"local",
"outputs",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"}",
"else",
"{",
"new",
"local",
"outputs",
"=",
"map",
"new",
"input",
"to",
"outputs",
"get",
"(",
"new",
"input",
")",
";",
"}",
"final",
"int",
"new",
"cor",
"var",
"offset",
"=",
"frame",
"old",
"to",
"new",
"outputs",
"get",
"(",
"old",
"cor",
"var",
"offset",
")",
";",
"/",
"/",
"add",
"all",
"unique",
"positions",
"referenced",
"if",
"(",
"!",
"new",
"local",
"outputs",
"contains",
"(",
"new",
"cor",
"var",
"offset",
")",
")",
"{",
"new",
"local",
"outputs",
"add",
"(",
"new",
"cor",
"var",
"offset",
")",
";",
"}",
"map",
"new",
"input",
"to",
"outputs",
"put",
"(",
"new",
"input",
",",
"new",
"local",
"outputs",
")",
";",
"}",
"int",
"offset",
"=",
"0",
";",
"/",
"/",
"project",
"only",
"the",
"correlated",
"fields",
"out",
"of",
"each",
"input",
"/",
"/",
"and",
"join",
"the",
"project",
"together",
"/",
"/",
"to",
"make",
"sure",
"the",
"plan",
"does",
"not",
"change",
"in",
"terms",
"of",
"join",
"order",
",",
"/",
"/",
"join",
"these",
"rels",
"based",
"on",
"their",
"occurrence",
"in",
"cor",
"var",
"list",
"which",
"/",
"/",
"is",
"sorted",
"final",
"set",
"<",
"rel",
"node",
">",
"joined",
"inputs",
"=",
"new",
"hash",
"set",
"<",
">",
"(",
")",
";",
"rel",
"node",
"r",
"=",
"null",
";",
"for",
"(",
"cor",
"ref",
"cor",
"var",
":",
"correlations",
")",
"{",
"final",
"rel",
"node",
"old",
"input",
"=",
"get",
"cor",
"rel",
"(",
"cor",
"var",
")",
";",
"assert",
"old",
"input",
"!",
"=",
"null",
";",
"final",
"rel",
"node",
"new",
"input",
"=",
"get",
"frame",
"(",
"old",
"input",
",",
"true",
")",
"r",
";",
"assert",
"new",
"input",
"!",
"=",
"null",
";",
"if",
"(",
"!",
"joined",
"inputs",
"contains",
"(",
"new",
"input",
")",
")",
"{",
"final",
"list",
"<",
"integer",
">",
"positions",
"=",
"map",
"new",
"input",
"to",
"outputs",
"get",
"(",
"new",
"input",
")",
";",
"final",
"list",
"<",
"string",
">",
"field",
"names",
"=",
"new",
"input",
"get",
"row",
"type",
"(",
")",
"get",
"field",
"names",
"(",
")",
";",
"rel",
"node",
"distinct",
"=",
"rel",
"builder",
"push",
"(",
"new",
"input",
")",
"project",
"(",
"rel",
"builder",
"fields",
"(",
"positions",
")",
")",
"distinct",
"(",
")",
"build",
"(",
")",
";",
"rel",
"opt",
"cluster",
"cluster",
"=",
"distinct",
"get",
"cluster",
"(",
")",
";",
"joined",
"inputs",
"add",
"(",
"new",
"input",
")",
";",
"map",
"new",
"input",
"to",
"new",
"offset",
"put",
"(",
"new",
"input",
",",
"offset",
")",
";",
"offset",
"+",
"=",
"distinct",
"get",
"row",
"type",
"(",
")",
"get",
"field",
"count",
"(",
")",
";",
"if",
"(",
"r",
"=",
"=",
"null",
")",
"{",
"r",
"=",
"distinct",
";",
"}",
"else",
"{",
"r",
"=",
"rel",
"builder",
"push",
"(",
"r",
")",
"push",
"(",
"distinct",
")",
"join",
"(",
"join",
"rel",
"type",
"inner",
",",
"cluster",
"get",
"rex",
"builder",
"(",
")",
"make",
"literal",
"(",
"true",
")",
")",
"build",
"(",
")",
";",
"}",
"}",
"}",
"/",
"/",
"translate",
"the",
"positions",
"of",
"correlated",
"variables",
"to",
"be",
"relative",
"to",
"/",
"/",
"the",
"join",
"output",
",",
"leaving",
"room",
"for",
"value",
"gen",
"field",
"offset",
"because",
"/",
"/",
"value",
"generators",
"are",
"joined",
"with",
"the",
"original",
"left",
"input",
"of",
"the",
"rel",
"/",
"/",
"referencing",
"correlated",
"variables",
"for",
"(",
"cor",
"ref",
"cor",
"ref",
":",
"correlations",
")",
"{",
"/",
"/",
"the",
"first",
"input",
"of",
"a",
"correlate",
"is",
"always",
"the",
"rel",
"defining",
"/",
"/",
"the",
"correlated",
"variables",
"final",
"rel",
"node",
"old",
"input",
"=",
"get",
"cor",
"rel",
"(",
"cor",
"ref",
")",
";",
"assert",
"old",
"input",
"!",
"=",
"null",
";",
"final",
"frame",
"frame",
"=",
"get",
"frame",
"(",
"old",
"input",
",",
"true",
")",
";",
"final",
"rel",
"node",
"new",
"input",
"=",
"frame",
"r",
";",
"assert",
"new",
"input",
"!",
"=",
"null",
";",
"final",
"list",
"<",
"integer",
">",
"new",
"local",
"outputs",
"=",
"map",
"new",
"input",
"to",
"outputs",
"get",
"(",
"new",
"input",
")",
";",
"final",
"int",
"new",
"local",
"output",
"=",
"frame",
"old",
"to",
"new",
"outputs",
"get",
"(",
"cor",
"ref",
"field",
")",
";",
"/",
"/",
"new",
"output",
"is",
"the",
"index",
"of",
"the",
"cor",
"var",
"in",
"the",
"referenced",
"/",
"/",
"position",
"list",
"plus",
"the",
"offset",
"of",
"referenced",
"position",
"list",
"of",
"/",
"/",
"each",
"new",
"input",
"final",
"int",
"new",
"output",
"=",
"new",
"local",
"outputs",
"index",
"of",
"(",
"new",
"local",
"output",
")",
"+",
"map",
"new",
"input",
"to",
"new",
"offset",
"get",
"(",
"new",
"input",
")",
"+",
"value",
"gen",
"field",
"offset",
";",
"cor",
"def",
"outputs",
"put",
"(",
"cor",
"ref",
"def",
"(",
")",
",",
"new",
"output",
")",
";",
"}",
"return",
"r",
";",
"}"
] |
[
"set",
"if",
"the",
"logs",
"print",
"log",
"or",
"not"
] |
[
"public",
"static",
"void",
"sets",
"is",
"log",
"enabled",
"(",
"boolean",
"s",
"is",
"log",
"enabled",
")",
"{",
"u",
"r",
"logs",
"s",
"is",
"log",
"enabled",
"=",
"s",
"is",
"log",
"enabled",
";",
"}"
] |
[
"returns",
"an",
"immutable",
"list",
"of",
"the",
"resolved",
"types"
] |
[
"private",
"list",
"<",
"type",
"literal",
"<",
"?",
">",
">",
"resolve",
"all",
"(",
"type",
"[",
"]",
"types",
")",
"{",
"type",
"literal",
"<",
"?",
">",
"[",
"]",
"result",
"=",
"new",
"type",
"literal",
"<",
"?",
">",
"[",
"types",
"length",
"]",
";",
"for",
"(",
"int",
"t",
"=",
"0",
";",
"t",
"<",
"types",
"length",
";",
"t",
"+",
"+",
")",
"{",
"result",
"[",
"t",
"]",
"=",
"resolve",
"(",
"types",
"[",
"t",
"]",
")",
";",
"}",
"return",
"arrays",
"as",
"list",
"(",
"result",
")",
";",
"}"
] |
[
"registers",
"a",
"keyer",
"under",
"a",
"code",
"name"
] |
[
"public",
"static",
"void",
"put",
"(",
"string",
"name",
",",
"keyer",
"keyer",
")",
"{",
"keyers",
"put",
"(",
"name",
",",
"keyer",
")",
";",
"keyer",
"names",
"add",
"(",
"name",
")",
";",
"}"
] |
[
"close",
"the",
"plugin",
"this",
"is",
"when",
"the",
"plugin",
"should",
"release",
"resources",
",",
"such",
"as",
"those",
"from",
"other",
"services",
"this",
"method",
"should",
"not",
"close",
"resources",
"being",
"used",
"by",
"others",
"(",
"that",
"should",
"happen",
"in",
"dispose",
"(",
")",
")",
"this",
"method",
"will",
"be",
"called",
"before",
"{",
"@",
"link",
"#",
"dispose",
"(",
")",
"}"
] |
[
"protected",
"void",
"close",
"(",
")",
"{",
"/",
"/",
"do",
"nothing",
"by",
"default",
";",
"subclasses",
"should",
"override",
"as",
"needed",
"}"
] |
[
"make",
"sure",
"replica",
"is",
"highly",
"available",
"it",
"will",
"avoid",
"setting",
"replication",
",",
"if",
"the",
"value",
"configured",
"for",
"{",
"@",
"link",
"yarn",
"configuration",
"#",
"fs",
"store",
"file",
"replication",
"}",
"is",
"0"
] |
[
"private",
"void",
"check",
"availability",
"(",
"path",
"file",
")",
"throws",
"i",
"o",
"exception",
"{",
"try",
"{",
"if",
"(",
"replication",
"!",
"=",
"0",
"&",
"&",
"fs",
"get",
"file",
"status",
"(",
"file",
")",
"get",
"replication",
"(",
")",
"<",
"replication",
")",
"{",
"fs",
"set",
"replication",
"(",
"file",
",",
"(",
"short",
")",
"replication",
")",
";",
"}",
"}",
"catch",
"(",
"unsupported",
"operation",
"exception",
"e",
")",
"{",
"log",
"error",
"(",
"\"",
"failed",
"set",
"replication",
"for",
"a",
"file",
":",
"{",
"}",
"\"",
",",
"file",
")",
";",
"}",
"}"
] |
[
"extracts",
"all",
"module",
"(",
"pcm",
")",
"files",
"from",
"potential",
"modules",
"and",
"returns",
"a",
"variables",
"object",
"where",
"their",
"exec",
"paths",
"are",
"added",
"to",
"the",
"value",
"\"",
"module",
"files",
"\""
] |
[
"private",
"static",
"cc",
"toolchain",
"variables",
"calculate",
"module",
"variable",
"(",
"nested",
"set",
"<",
"artifact",
">",
"potential",
"modules",
")",
"{",
"immutable",
"list",
"builder",
"<",
"string",
">",
"used",
"module",
"paths",
"=",
"immutable",
"list",
"builder",
"(",
")",
";",
"for",
"(",
"artifact",
"input",
":",
"potential",
"modules",
"to",
"list",
"(",
")",
")",
"{",
"if",
"(",
"input",
"is",
"file",
"type",
"(",
"cpp",
"file",
"types",
"cpp",
"module",
")",
")",
"{",
"used",
"module",
"paths",
"add",
"(",
"input",
"get",
"exec",
"path",
"string",
"(",
")",
")",
";",
"}",
"}",
"cc",
"toolchain",
"variables",
"builder",
"variable",
"builder",
"=",
"cc",
"toolchain",
"variables",
"builder",
"(",
")",
";",
"variable",
"builder",
"add",
"string",
"sequence",
"variable",
"(",
"compile",
"build",
"variables",
"module",
"files",
"get",
"variable",
"name",
"(",
")",
",",
"used",
"module",
"paths",
"build",
"(",
")",
")",
";",
"return",
"variable",
"builder",
"build",
"(",
")",
";",
"}"
] |
[
"returns",
"the",
"code",
"of",
"this",
"status"
] |
[
"public",
"int",
"code",
"(",
")",
"{",
"return",
"code",
";",
"}"
] |
[
"generate",
"the",
"requested",
"number",
"of",
"file",
"splits",
",",
"with",
"the",
"filename",
"set",
"to",
"the",
"filename",
"of",
"the",
"output",
"file"
] |
[
"public",
"list",
"<",
"input",
"split",
">",
"get",
"splits",
"(",
"job",
"context",
"job",
")",
"throws",
"i",
"o",
"exception",
"{",
"list",
"<",
"input",
"split",
">",
"result",
"=",
"new",
"array",
"list",
"<",
"input",
"split",
">",
"(",
")",
";",
"path",
"out",
"dir",
"=",
"file",
"output",
"format",
"get",
"output",
"path",
"(",
"job",
")",
";",
"int",
"num",
"splits",
"=",
"job",
"get",
"configuration",
"(",
")",
"get",
"int",
"(",
"m",
"r",
"job",
"config",
"num",
"maps",
",",
"1",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"num",
"splits",
";",
"+",
"+",
"i",
")",
"{",
"result",
"add",
"(",
"new",
"file",
"split",
"(",
"new",
"path",
"(",
"out",
"dir",
",",
"\"",
"dummy",
"-",
"split",
"-",
"\"",
"+",
"i",
")",
",",
"0",
",",
"1",
",",
"(",
"string",
"[",
"]",
")",
"null",
")",
")",
";",
"}",
"return",
"result",
";",
"}"
] |
[
"returns",
"an",
"array",
"of",
"class",
"objects",
"that",
"represent",
"the",
"formal",
"parameter",
"types",
",",
"in",
"declaration",
"order",
",",
"of",
"the",
"method"
] |
[
"public",
"class",
"[",
"]",
"get",
"parameter",
"types",
"(",
")",
"{",
"return",
"method",
"get",
"parameter",
"types",
"(",
")",
";",
"}"
] |
[
"get",
"or",
"create",
"a",
"sensor",
"with",
"the",
"given",
"unique",
"name",
"and",
"no",
"parent",
"sensors",
"this",
"uses",
"a",
"default",
"recording",
"level",
"of",
"info"
] |
[
"public",
"sensor",
"sensor",
"(",
"string",
"name",
")",
"{",
"return",
"sensor",
"(",
"name",
",",
"null",
",",
"sensor",
"recording",
"level",
"info",
")",
";",
"}"
] |
[
"subclasses",
"should",
"implement",
"this",
"method",
"to",
"test",
"{",
"@",
"link",
"decoder",
"#",
"can",
"decode",
"}"
] |
[
"public",
"abstract",
"void",
"can",
"decode",
"(",
")",
"throws",
"exception",
";"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"notifies",
"the",
"potential",
"segment",
"consumer",
"of",
"the",
"new",
"available",
"segments",
"by",
"completing",
"the",
"previous",
"uncompleted",
"future"
] |
[
"private",
"void",
"may",
"notify",
"available",
"(",
"@",
"nullable",
"completable",
"future",
"<",
"?",
">",
"to",
"notify",
")",
"{",
"if",
"(",
"to",
"notify",
"!",
"=",
"null",
")",
"{",
"to",
"notify",
"complete",
"(",
"null",
")",
";",
"}",
"}"
] |
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
] |
[
"private",
"string",
"to",
"indented",
"string",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
] |
[
"test",
"restored",
"from",
"file",
"rollback",
"retry"
] |
[
"public",
"void",
"test",
"restored",
"from",
"file",
"rollback",
"retry",
"(",
")",
"throws",
"exception",
"{",
"try",
"{",
"session",
"holder",
"init",
"(",
"\"",
"file",
"\"",
")",
";",
"global",
"session",
"global",
"session",
"=",
"new",
"global",
"session",
"(",
"\"",
"demo",
"-",
"app",
"\"",
",",
"\"",
"my",
"test",
"tx",
"group",
"\"",
",",
"\"",
"test",
"\"",
",",
"6000",
")",
";",
"string",
"xid",
"=",
"xid",
"generate",
"x",
"i",
"d",
"(",
"global",
"session",
"get",
"transaction",
"id",
"(",
")",
")",
";",
"global",
"session",
"set",
"xid",
"(",
"xid",
")",
";",
"global",
"session",
"add",
"session",
"lifecycle",
"listener",
"(",
"session",
"holder",
"get",
"root",
"session",
"manager",
"(",
")",
")",
";",
"global",
"session",
"begin",
"(",
")",
";",
"branch",
"session",
"branch",
"session",
"1",
"=",
"session",
"helper",
"new",
"branch",
"by",
"global",
"(",
"global",
"session",
",",
"branch",
"type",
"at",
",",
"resource",
"id",
",",
"\"",
"ta",
":",
"1",
"\"",
",",
"\"",
"xxx",
"\"",
")",
";",
"branch",
"session",
"1",
"lock",
"(",
")",
";",
"global",
"session",
"add",
"branch",
"(",
"branch",
"session",
"1",
")",
";",
"lock",
"manager",
"lock",
"manager",
"=",
"new",
"file",
"lock",
"manager",
"for",
"test",
"(",
")",
";",
"string",
"other",
"x",
"i",
"d",
"=",
"xid",
"generate",
"x",
"i",
"d",
"(",
"0l",
")",
";",
"assertions",
"assert",
"false",
"(",
"lock",
"manager",
"is",
"lockable",
"(",
"other",
"x",
"i",
"d",
",",
"resource",
"id",
",",
"\"",
"ta",
":",
"1",
"\"",
")",
")",
";",
"global",
"session",
"change",
"status",
"(",
"global",
"status",
"rollbacking",
")",
";",
"global",
"session",
"change",
"branch",
"status",
"(",
"branch",
"session",
"1",
",",
"branch",
"status",
"phase",
"two",
"rollback",
"failed",
"retryable",
")",
";",
"global",
"session",
"change",
"status",
"(",
"global",
"status",
"rollback",
"retrying",
")",
";",
"lock",
"manager",
"clean",
"all",
"locks",
"(",
")",
";",
"assertions",
"assert",
"true",
"(",
"lock",
"manager",
"is",
"lockable",
"(",
"other",
"x",
"i",
"d",
",",
"resource",
"id",
",",
"\"",
"ta",
":",
"1",
"\"",
")",
")",
";",
"/",
"/",
"re",
"-",
"init",
"session",
"holder",
":",
"restore",
"sessions",
"from",
"file",
"session",
"holder",
"init",
"(",
"\"",
"file",
"\"",
")",
";",
"long",
"tid",
"=",
"global",
"session",
"get",
"transaction",
"id",
"(",
")",
";",
"global",
"session",
"reload",
"session",
"=",
"session",
"holder",
"find",
"global",
"session",
"(",
"global",
"session",
"get",
"xid",
"(",
")",
")",
";",
"assertions",
"assert",
"equals",
"(",
"reload",
"session",
"get",
"status",
"(",
")",
",",
"global",
"status",
"rollback",
"retrying",
")",
";",
"global",
"session",
"session",
"in",
"retry",
"rollbacking",
"queue",
"=",
"session",
"holder",
"get",
"retry",
"rollbacking",
"session",
"manager",
"(",
")",
"find",
"global",
"session",
"(",
"global",
"session",
"get",
"xid",
"(",
")",
")",
";",
"assertions",
"assert",
"true",
"(",
"reload",
"session",
"=",
"=",
"session",
"in",
"retry",
"rollbacking",
"queue",
")",
";",
"branch",
"session",
"reload",
"branch",
"session",
"=",
"reload",
"session",
"get",
"branch",
"(",
"branch",
"session",
"1",
"get",
"branch",
"id",
"(",
")",
")",
";",
"assertions",
"assert",
"equals",
"(",
"reload",
"branch",
"session",
"get",
"status",
"(",
")",
",",
"branch",
"status",
"phase",
"two",
"rollback",
"failed",
"retryable",
")",
";",
"/",
"/",
"lock",
"is",
"held",
"by",
"session",
"in",
"rollback",
"retrying",
"status",
"assertions",
"assert",
"false",
"(",
"lock",
"manager",
"is",
"lockable",
"(",
"other",
"x",
"i",
"d",
",",
"resource",
"id",
",",
"\"",
"ta",
":",
"1",
"\"",
")",
")",
";",
"/",
"/",
"clear",
"reload",
"session",
"add",
"session",
"lifecycle",
"listener",
"(",
"session",
"holder",
"get",
"root",
"session",
"manager",
"(",
")",
")",
";",
"reload",
"session",
"end",
"(",
")",
";",
"}",
"finally",
"{",
"session",
"holder",
"destroy",
"(",
")",
";",
"}",
"}"
] |
[
"returns",
"the",
"exception",
"handler",
"types",
"associated",
"with",
"this",
"block",
",",
"if",
"any",
"this",
"is",
"just",
"a",
"shorthand",
"for",
"inspecting",
"the",
"last",
"instruction",
"in",
"the",
"block",
"to",
"see",
"if",
"it",
"could",
"throw",
",",
"and",
"if",
"so",
",",
"grabbing",
"the",
"catch",
"list",
"out",
"of",
"it",
"if",
"not",
",",
"this",
"returns",
"an",
"empty",
"list",
"(",
"not",
"{",
"@",
"code",
"null",
"}",
")"
] |
[
"public",
"type",
"list",
"get",
"exception",
"handler",
"types",
"(",
")",
"{",
"insn",
"last",
"insn",
"=",
"insns",
"get",
"last",
"(",
")",
";",
"return",
"last",
"insn",
"get",
"catches",
"(",
")",
";",
"}"
] |
[
"returns",
"a",
"builder",
"that",
"creates",
"immutable",
"sorted",
"maps",
"with",
"an",
"explicit",
"comparator",
"if",
"the",
"comparator",
"has",
"a",
"more",
"general",
"type",
"than",
"the",
"map",
"'",
"s",
"keys",
",",
"such",
"as",
"creating",
"a",
"{",
"@",
"code",
"sorted",
"map",
"<",
"integer",
",",
"string",
">",
"}",
"with",
"a",
"{",
"@",
"code",
"comparator",
"<",
"number",
">",
"}",
",",
"use",
"the",
"{",
"@",
"link",
"builder",
"}",
"constructor",
"instead"
] |
[
"public",
"static",
"<",
"k",
",",
"v",
">",
"builder",
"<",
"k",
",",
"v",
">",
"ordered",
"by",
"(",
"comparator",
"<",
"k",
">",
"comparator",
")",
"{",
"return",
"new",
"builder",
"<",
">",
"(",
"comparator",
")",
";",
"}"
] |
[
"creates",
"{",
"@",
"link",
"temporal",
"table",
"function",
"}",
"backed",
"up",
"by",
"this",
"table",
"as",
"a",
"history",
"table",
"temporal",
"tables",
"represent",
"a",
"concept",
"of",
"a",
"table",
"that",
"changes",
"over",
"time",
"and",
"for",
"which",
"flink",
"keeps",
"track",
"of",
"those",
"changes",
"{",
"@",
"link",
"temporal",
"table",
"function",
"}",
"provides",
"a",
"way",
"how",
"to",
"access",
"those",
"data",
"for",
"more",
"information",
"please",
"check",
"flink",
"'",
"s",
"documentation",
"on",
"temporal",
"tables",
"currently",
"{",
"@",
"link",
"temporal",
"table",
"function",
"}",
"s",
"are",
"only",
"supported",
"in",
"streaming"
] |
[
"temporal",
"table",
"function",
"create",
"temporal",
"table",
"function",
"(",
"expression",
"time",
"attribute",
",",
"expression",
"primary",
"key",
")",
";"
] |
[
"is",
"this",
"logger",
"instance",
"enabled",
"for",
"the",
"finest",
"level",
"?"
] |
[
"public",
"boolean",
"is",
"trace",
"enabled",
"(",
")",
"{",
"return",
"logger",
"is",
"loggable",
"(",
"level",
"finest",
")",
";",
"}"
] |
[
"returns",
"the",
"profile",
"name",
"if",
"this",
"line",
"indicates",
"the",
"beginning",
"of",
"a",
"new",
"profile",
"section",
"otherwise",
",",
"returns",
"null"
] |
[
"private",
"static",
"string",
"parse",
"profile",
"name",
"(",
"string",
"trimmed",
"line",
")",
"{",
"if",
"(",
"trimmed",
"line",
"starts",
"with",
"(",
"\"",
"[",
"\"",
")",
"&",
"&",
"trimmed",
"line",
"ends",
"with",
"(",
"\"",
"]",
"\"",
")",
")",
"{",
"string",
"profile",
"name",
"=",
"trimmed",
"line",
"substring",
"(",
"1",
",",
"trimmed",
"line",
"length",
"(",
")",
"-",
"1",
")",
";",
"return",
"profile",
"name",
"trim",
"(",
")",
";",
"}",
"return",
"null",
";",
"}"
] |
[
"specify",
"the",
"timeout",
"value",
"to",
"use",
"for",
"send",
"operations",
"(",
"in",
"milliseconds",
")"
] |
[
"public",
"void",
"set",
"send",
"timeout",
"(",
"long",
"send",
"timeout",
")",
"{",
"this",
"send",
"timeout",
"=",
"send",
"timeout",
";",
"}"
] |
[
"parse",
"a",
"pre",
"0",
"21",
"counters",
"string",
"into",
"a",
"counter",
"object"
] |
[
"public",
"static",
"<",
"c",
"extends",
"counter",
",",
"g",
"extends",
"counter",
"group",
"base",
"<",
"c",
">",
",",
"t",
"extends",
"abstract",
"counters",
"<",
"c",
",",
"g",
">",
">",
"t",
"parse",
"escaped",
"compact",
"string",
"(",
"string",
"compact",
"string",
",",
"t",
"counters",
")",
"throws",
"parse",
"exception",
"{",
"int",
"writable",
"index",
"=",
"new",
"int",
"writable",
"(",
"0",
")",
";",
"/",
"/",
"get",
"the",
"group",
"to",
"work",
"on",
"string",
"group",
"string",
"=",
"get",
"block",
"(",
"compact",
"string",
",",
"group",
"open",
",",
"group",
"close",
",",
"index",
")",
";",
"while",
"(",
"group",
"string",
"!",
"=",
"null",
")",
"{",
"int",
"writable",
"group",
"index",
"=",
"new",
"int",
"writable",
"(",
"0",
")",
";",
"/",
"/",
"get",
"the",
"actual",
"name",
"string",
"group",
"name",
"=",
"string",
"interner",
"weak",
"intern",
"(",
"get",
"block",
"(",
"group",
"string",
",",
"unit",
"open",
",",
"unit",
"close",
",",
"group",
"index",
")",
")",
";",
"group",
"name",
"=",
"string",
"interner",
"weak",
"intern",
"(",
"unescape",
"(",
"group",
"name",
")",
")",
";",
"/",
"/",
"get",
"the",
"display",
"name",
"string",
"group",
"display",
"name",
"=",
"string",
"interner",
"weak",
"intern",
"(",
"get",
"block",
"(",
"group",
"string",
",",
"unit",
"open",
",",
"unit",
"close",
",",
"group",
"index",
")",
")",
";",
"group",
"display",
"name",
"=",
"string",
"interner",
"weak",
"intern",
"(",
"unescape",
"(",
"group",
"display",
"name",
")",
")",
";",
"/",
"/",
"get",
"the",
"counters",
"g",
"group",
"=",
"counters",
"get",
"group",
"(",
"group",
"name",
")",
";",
"group",
"set",
"display",
"name",
"(",
"group",
"display",
"name",
")",
";",
"string",
"counter",
"string",
"=",
"get",
"block",
"(",
"group",
"string",
",",
"counter",
"open",
",",
"counter",
"close",
",",
"group",
"index",
")",
";",
"while",
"(",
"counter",
"string",
"!",
"=",
"null",
")",
"{",
"int",
"writable",
"counter",
"index",
"=",
"new",
"int",
"writable",
"(",
"0",
")",
";",
"/",
"/",
"get",
"the",
"actual",
"name",
"string",
"counter",
"name",
"=",
"string",
"interner",
"weak",
"intern",
"(",
"get",
"block",
"(",
"counter",
"string",
",",
"unit",
"open",
",",
"unit",
"close",
",",
"counter",
"index",
")",
")",
";",
"counter",
"name",
"=",
"string",
"interner",
"weak",
"intern",
"(",
"unescape",
"(",
"counter",
"name",
")",
")",
";",
"/",
"/",
"get",
"the",
"display",
"name",
"string",
"counter",
"display",
"name",
"=",
"string",
"interner",
"weak",
"intern",
"(",
"get",
"block",
"(",
"counter",
"string",
",",
"unit",
"open",
",",
"unit",
"close",
",",
"counter",
"index",
")",
")",
";",
"counter",
"display",
"name",
"=",
"string",
"interner",
"weak",
"intern",
"(",
"unescape",
"(",
"counter",
"display",
"name",
")",
")",
";",
"/",
"/",
"get",
"the",
"value",
"long",
"value",
"=",
"long",
"parse",
"long",
"(",
"get",
"block",
"(",
"counter",
"string",
",",
"unit",
"open",
",",
"unit",
"close",
",",
"counter",
"index",
")",
")",
";",
"/",
"/",
"add",
"the",
"counter",
"counter",
"counter",
"=",
"group",
"find",
"counter",
"(",
"counter",
"name",
")",
";",
"counter",
"set",
"display",
"name",
"(",
"counter",
"display",
"name",
")",
";",
"counter",
"increment",
"(",
"value",
")",
";",
"/",
"/",
"get",
"the",
"next",
"counter",
"counter",
"string",
"=",
"get",
"block",
"(",
"group",
"string",
",",
"counter",
"open",
",",
"counter",
"close",
",",
"group",
"index",
")",
";",
"}",
"group",
"string",
"=",
"get",
"block",
"(",
"compact",
"string",
",",
"group",
"open",
",",
"group",
"close",
",",
"index",
")",
";",
"}",
"return",
"counters",
";",
"}"
] |
[
"skip",
"to",
"dial"
] |
[
"public",
"static",
"void",
"dial",
"(",
"final",
"string",
"phone",
"number",
")",
"{",
"utils",
"get",
"app",
"(",
")",
"start",
"activity",
"(",
"utils",
"bridge",
"get",
"dial",
"intent",
"(",
"phone",
"number",
")",
")",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"kind",
"'"
] |
[
"public",
"void",
"kind",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"kind",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] |
[
"public",
"long",
"execute",
"large",
"update",
"(",
"string",
"sql",
",",
"int",
"[",
"]",
"column",
"indexes",
")",
"throws",
"s",
"q",
"l",
"exception",
"{",
"connection",
"mark",
"commit",
"state",
"dirty",
"(",
")",
";",
"return",
"delegate",
"execute",
"large",
"update",
"(",
"sql",
",",
"column",
"indexes",
")",
";",
"}"
] |
[
"an",
"integer",
"containing",
"the",
"byte",
"offset",
"from",
"the",
"start",
"of",
"the",
"image",
"to",
"the",
"location",
"of",
"the",
"string",
"table"
] |
[
"public",
"int",
"get",
"string",
"table",
"offset",
"(",
")",
"{",
"return",
"stroff",
";",
"}"
] |
[
"delegate",
"to",
"all",
"contained",
"conditions",
"to",
"match",
"the",
"request",
"and",
"return",
"the",
"resulting",
"\"",
"matching",
"\"",
"condition",
"instances",
"an",
"empty",
"{",
"@",
"code",
"composite",
"request",
"condition",
"}",
"matches",
"to",
"all",
"requests"
] |
[
"public",
"composite",
"request",
"condition",
"get",
"matching",
"condition",
"(",
"http",
"servlet",
"request",
"request",
")",
"{",
"if",
"(",
"is",
"empty",
"(",
")",
")",
"{",
"return",
"this",
";",
"}",
"request",
"condition",
"holder",
"[",
"]",
"matching",
"conditions",
"=",
"new",
"request",
"condition",
"holder",
"[",
"get",
"length",
"(",
")",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"get",
"length",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"matching",
"conditions",
"[",
"i",
"]",
"=",
"this",
"request",
"conditions",
"[",
"i",
"]",
"get",
"matching",
"condition",
"(",
"request",
")",
";",
"if",
"(",
"matching",
"conditions",
"[",
"i",
"]",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"}",
"return",
"new",
"composite",
"request",
"condition",
"(",
"matching",
"conditions",
")",
";",
"}"
] |
[
"creates",
"a",
"new",
"instance",
"of",
"this",
"{",
"@",
"code",
"fragment",
"options",
"}",
"with",
"all",
"flags",
"set",
"to",
"their",
"default",
"values"
] |
[
"public",
"fragment",
"options",
"get",
"default",
"(",
")",
"{",
"return",
"options",
"get",
"defaults",
"(",
"get",
"class",
"(",
")",
")",
";",
"}"
] |
[
"visit",
"the",
"specified",
"labels",
"and",
"follow",
"the",
"transitive",
"closure",
"of",
"their",
"outbound",
"dependencies"
] |
[
"public",
"void",
"visit",
"targets",
"(",
"iterable",
"<",
"target",
">",
"targets",
")",
"throws",
"interrupted",
"exception",
"{",
"for",
"(",
"target",
"target",
":",
"targets",
")",
"{",
"visit",
"(",
"null",
",",
"null",
",",
"target",
",",
"0",
",",
"0",
")",
";",
"}",
"}"
] |
[
"https",
":",
"github",
"comsquareokhttpissues",
"4",
"9",
"1",
"5"
] |
[
"@",
"test",
"@",
"disabled",
"public",
"void",
"proxy",
"disconnects",
"after",
"request",
"(",
")",
"throws",
"exception",
"{",
"server",
"use",
"https",
"(",
"handshake",
"certificates",
"ssl",
"socket",
"factory",
"(",
")",
",",
"true",
")",
";",
"server",
"enqueue",
"(",
"new",
"mock",
"response",
"(",
")",
"set",
"socket",
"policy",
"(",
"socket",
"policy",
"disconnect",
"after",
"request",
")",
")",
";",
"client",
"=",
"client",
"new",
"builder",
"(",
")",
"ssl",
"socket",
"factory",
"(",
"handshake",
"certificates",
"ssl",
"socket",
"factory",
"(",
")",
",",
"handshake",
"certificates",
"trust",
"manager",
"(",
")",
")",
"proxy",
"(",
"server",
"to",
"proxy",
"address",
"(",
")",
")",
"build",
"(",
")",
";",
"request",
"request",
"=",
"new",
"request",
"builder",
"(",
")",
"url",
"(",
"server",
"url",
"(",
"\"",
"/",
"\"",
")",
")",
"build",
"(",
")",
";",
"try",
"{",
"client",
"new",
"call",
"(",
"request",
")",
"execute",
"(",
")",
";",
"fail",
"(",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"expected",
")",
"{",
"}",
"}"
] |
[
"create",
"an",
"entry",
"point",
"function",
"note",
":",
"entries",
"in",
"the",
"dynamic",
"table",
"appear",
"to",
"have",
"any",
"pre",
"-",
"link",
"adjustment",
"already",
"applied"
] |
[
"private",
"address",
"create",
"entry",
"function",
"(",
"string",
"name",
",",
"long",
"entry",
"addr",
",",
"task",
"monitor",
"monitor",
")",
"{",
"entry",
"addr",
"+",
"=",
"get",
"image",
"base",
"word",
"adjustment",
"offset",
"(",
")",
";",
"/",
"/",
"word",
"offset",
"address",
"entry",
"address",
"=",
"get",
"default",
"address",
"space",
"(",
")",
"get",
"truncated",
"address",
"(",
"entry",
"addr",
",",
"true",
")",
";",
"/",
"/",
"todo",
":",
"entry",
"may",
"refer",
"to",
"a",
"pointer",
"-",
"make",
"sure",
"we",
"have",
"execute",
"permission",
"memory",
"block",
"block",
"=",
"memory",
"get",
"block",
"(",
"entry",
"address",
")",
";",
"if",
"(",
"block",
"=",
"=",
"null",
"|",
"|",
"!",
"block",
"is",
"execute",
"(",
")",
")",
"{",
"return",
"entry",
"address",
";",
"}",
"entry",
"address",
"=",
"elf",
"get",
"load",
"adapter",
"(",
")",
"creating",
"function",
"(",
"this",
",",
"entry",
"address",
")",
";",
"function",
"function",
"=",
"program",
"get",
"function",
"manager",
"(",
")",
"get",
"function",
"at",
"(",
"entry",
"address",
")",
";",
"if",
"(",
"function",
"!",
"=",
"null",
")",
"{",
"program",
"get",
"symbol",
"table",
"(",
")",
"add",
"external",
"entry",
"point",
"(",
"entry",
"address",
")",
";",
"return",
"entry",
"address",
";",
"/",
"/",
"symbol",
"-",
"based",
"function",
"already",
"created",
"}",
"try",
"{",
"create",
"one",
"byte",
"function",
"(",
"name",
",",
"entry",
"address",
",",
"true",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"log",
"(",
"\"",
"could",
"not",
"create",
"symbol",
"at",
"entry",
"point",
":",
"\"",
"+",
"get",
"message",
"(",
"e",
")",
")",
";",
"}",
"return",
"entry",
"address",
";",
"}"
] |
[
"extract",
"a",
"claim",
"in",
"its",
"raw",
"form"
] |
[
"public",
"object",
"raw",
"claim",
"(",
"string",
"claim",
"name",
")",
"{",
"return",
"claims",
"(",
")",
"get",
"(",
"objects",
"require",
"non",
"null",
"(",
"claim",
"name",
")",
")",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] |
[
"public",
"callable",
"statement",
"prepare",
"call",
"(",
"string",
"sql",
")",
"throws",
"s",
"q",
"l",
"exception",
"{",
"if",
"(",
"throw",
"exception",
")",
"{",
"throw",
"new",
"s",
"q",
"l",
"exception",
"(",
")",
";",
"}",
"return",
"null",
";",
"}"
] |
[
"returns",
"1",
"if",
"{",
"@",
"code",
"x",
"<",
"y",
"}",
"as",
"unsigned",
"integers",
",",
"and",
"0",
"otherwise",
"assumes",
"that",
"x",
"-",
"y",
"fits",
"into",
"a",
"signed",
"int",
"the",
"implementation",
"is",
"branch",
"-",
"free",
",",
"and",
"benchmarks",
"suggest",
"it",
"is",
"measurably",
"(",
"if",
"narrowly",
")",
"faster",
"than",
"the",
"straightforward",
"ternary",
"expression"
] |
[
"static",
"int",
"less",
"than",
"branch",
"free",
"(",
"int",
"x",
",",
"int",
"y",
")",
"{",
"/",
"/",
"the",
"double",
"negation",
"is",
"optimized",
"away",
"by",
"normal",
"java",
",",
"but",
"is",
"necessary",
"for",
"gwt",
"/",
"/",
"to",
"make",
"sure",
"bit",
"twiddling",
"works",
"as",
"expected",
"return",
"~",
"~",
"(",
"x",
"-",
"y",
")",
">",
">",
">",
"(",
"integer",
"size",
"-",
"1",
")",
";",
"}"
] |
[
"add",
"an",
"attribute",
"for",
"a",
"transactional",
"method"
] |
[
"public",
"void",
"add",
"transactional",
"method",
"(",
"method",
"method",
",",
"transaction",
"attribute",
"attr",
")",
"{",
"assert",
"not",
"null",
"(",
"method",
",",
"\"",
"method",
"must",
"not",
"be",
"null",
"\"",
")",
";",
"assert",
"not",
"null",
"(",
"attr",
",",
"\"",
"transaction",
"attribute",
"must",
"not",
"be",
"null",
"\"",
")",
";",
"if",
"(",
"logger",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"logger",
"debug",
"(",
"\"",
"adding",
"transactional",
"method",
"[",
"\"",
"+",
"method",
"+",
"\"",
"]",
"with",
"attribute",
"[",
"\"",
"+",
"attr",
"+",
"\"",
"]",
"\"",
")",
";",
"}",
"if",
"(",
"this",
"embedded",
"value",
"resolver",
"!",
"=",
"null",
"&",
"&",
"attr",
"instanceof",
"default",
"transaction",
"attribute",
")",
"{",
"(",
"(",
"default",
"transaction",
"attribute",
")",
"attr",
")",
"resolve",
"attribute",
"strings",
"(",
"this",
"embedded",
"value",
"resolver",
")",
";",
"}",
"this",
"transaction",
"attribute",
"map",
"put",
"(",
"method",
",",
"attr",
")",
";",
"}"
] |
[
"creates",
"a",
"completion",
"suggestion",
"lookup",
"query",
"with",
"the",
"provided",
"<",
"code",
">",
"field",
"<",
"code",
">"
] |
[
"public",
"static",
"completion",
"suggestion",
"builder",
"completion",
"suggestion",
"(",
"string",
"fieldname",
")",
"{",
"return",
"new",
"completion",
"suggestion",
"builder",
"(",
"fieldname",
")",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"color",
"'"
] |
[
"public",
"void",
"color",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"color",
"}"
] |
[
"add",
"a",
"method",
"to",
"be",
"supported",
"by",
"the",
"service"
] |
[
"public",
"<",
"req",
"t",
",",
"resp",
"t",
">",
"builder",
"add",
"method",
"(",
"method",
"descriptor",
"<",
"req",
"t",
",",
"resp",
"t",
">",
"method",
",",
"server",
"call",
"handler",
"<",
"req",
"t",
",",
"resp",
"t",
">",
"handler",
")",
"{",
"return",
"add",
"method",
"(",
"server",
"method",
"definition",
"create",
"(",
"check",
"not",
"null",
"(",
"method",
",",
"\"",
"method",
"must",
"not",
"be",
"null",
"\"",
")",
",",
"check",
"not",
"null",
"(",
"handler",
",",
"\"",
"handler",
"must",
"not",
"be",
"null",
"\"",
")",
")",
")",
";",
"}"
] |
[
"compare",
"two",
"doubles",
"if",
"either",
"is",
"na",
"n",
"comparison",
"is",
"-",
"1"
] |
[
"public",
"bytecode",
"block",
"double",
"compare",
"nan",
"less",
"(",
")",
"{",
"nodes",
"add",
"(",
"op",
"code",
"dcmpl",
")",
";",
"return",
"this",
";",
"}"
] |
[
"sets",
"a",
"listener",
"that",
"allows",
"clients",
"to",
"be",
"notified",
"of",
"vertex",
"double",
"-",
"clicks",
"normal",
"mouse",
"processing",
"is",
"handled",
"by",
"the",
"{",
"@",
"link",
"visual",
"graph",
"mouse",
"plugin",
"}",
"class",
"this",
"is",
"a",
"convenience",
"method",
"so",
"that",
"clients",
"do",
"not",
"have",
"to",
"deal",
"with",
"the",
"mouse",
"plugin"
] |
[
"public",
"void",
"set",
"vertex",
"click",
"listener",
"(",
"vertex",
"click",
"listener",
"<",
"v",
",",
"e",
">",
"l",
")",
"{",
"client",
"vertex",
"click",
"listener",
"=",
"optional",
"of",
"nullable",
"(",
"l",
")",
";",
"}"
] |
[
"test",
"structure",
"definition",
"when",
"the",
"same",
"structure",
"is",
"defined",
"in",
"two",
"different",
"c",
"us"
] |
[
"public",
"void",
"test",
"struct",
"dup",
"(",
")",
"throws",
"cancelled",
"exception",
",",
"i",
"o",
"exception",
",",
"d",
"w",
"a",
"r",
"f",
"exception",
"{",
"/",
"/",
"cu1",
"debug",
"info",
"entry",
"int",
"d",
"i",
"e",
"1",
"=",
"add",
"int",
"(",
"cu",
")",
";",
"debug",
"info",
"entry",
"float",
"d",
"i",
"e",
"1",
"=",
"add",
"float",
"(",
"cu",
")",
";",
"debug",
"info",
"entry",
"struct",
"d",
"i",
"e",
"1",
"=",
"new",
"struct",
"(",
"\"",
"mystruct",
"\"",
",",
"100",
")",
"create",
"(",
"cu",
")",
";",
"new",
"member",
"(",
"struct",
"d",
"i",
"e",
"1",
",",
"\"",
"f",
"1",
"\"",
",",
"int",
"d",
"i",
"e",
"1",
",",
"0",
")",
"create",
"(",
"cu",
")",
";",
"new",
"member",
"(",
"struct",
"d",
"i",
"e",
"1",
",",
"\"",
"f",
"2",
"\"",
",",
"float",
"d",
"i",
"e",
"1",
",",
"10",
")",
"create",
"(",
"cu",
")",
";",
"/",
"/",
"cu2",
"debug",
"info",
"entry",
"int",
"d",
"i",
"e",
"2",
"=",
"add",
"int",
"(",
"cu",
"2",
")",
";",
"debug",
"info",
"entry",
"float",
"d",
"i",
"e",
"2",
"=",
"add",
"float",
"(",
"cu",
"2",
")",
";",
"debug",
"info",
"entry",
"struct",
"d",
"i",
"e",
"2",
"=",
"new",
"struct",
"(",
"\"",
"mystruct",
"\"",
",",
"100",
")",
"create",
"(",
"cu",
"2",
")",
";",
"new",
"member",
"(",
"struct",
"d",
"i",
"e",
"2",
",",
"\"",
"f",
"1",
"\"",
",",
"int",
"d",
"i",
"e",
"2",
",",
"0",
")",
"create",
"(",
"cu",
"2",
")",
";",
"new",
"member",
"(",
"struct",
"d",
"i",
"e",
"2",
",",
"\"",
"f",
"2",
"\"",
",",
"float",
"d",
"i",
"e",
"2",
",",
"10",
")",
"create",
"(",
"cu",
"2",
")",
";",
"import",
"all",
"data",
"types",
"(",
")",
";",
"data",
"type",
"structdt",
"=",
"data",
"mgr",
"get",
"data",
"type",
"(",
"root",
"c",
"p",
",",
"\"",
"mystruct",
"\"",
")",
";",
"data",
"type",
"structdt",
"2",
"=",
"data",
"mgr",
"get",
"data",
"type",
"(",
"root",
"c",
"p",
",",
"\"",
"mystruct",
"conflict",
"\"",
")",
";",
"assert",
"equals",
"(",
"100",
",",
"structdt",
"get",
"length",
"(",
")",
")",
";",
"assert",
"null",
"(",
"structdt",
"2",
")",
";",
"}"
] |
[
"on",
"a",
"type",
"variable",
"(",
"type",
"var",
"extends",
"c",
"0",
"&",
"i",
"1",
"&",
"i",
"2",
"&",
"etc",
")",
",",
"will",
"return",
"an",
"array",
"containing",
"i",
"1",
"and",
"i",
"2"
] |
[
"public",
"type",
"[",
"]",
"interface",
"bounds",
"(",
")",
"{",
"type",
"[",
"]",
"interface",
"bounds",
"=",
"new",
"type",
"[",
"type",
"variable",
"get",
"bounds",
"(",
")",
"length",
"-",
"1",
"]",
";",
"system",
"arraycopy",
"(",
"type",
"variable",
"get",
"bounds",
"(",
")",
",",
"1",
",",
"interface",
"bounds",
",",
"0",
",",
"type",
"variable",
"get",
"bounds",
"(",
")",
"length",
"-",
"1",
")",
";",
"return",
"interface",
"bounds",
";",
"}"
] |
[
"specify",
"a",
"database",
"catalog",
"to",
"be",
"applied",
"to",
"each",
"retrieved",
"connection"
] |
[
"public",
"void",
"set",
"catalog",
"(",
"string",
"catalog",
")",
"{",
"this",
"catalog",
"=",
"catalog",
";",
"}"
] |
[
"invokes",
"{",
"@",
"code",
"consumer",
"}",
"for",
"each",
"value",
"contained",
"in",
"this",
"array",
",",
"in",
"order"
] |
[
"public",
"void",
"for",
"each",
"(",
"int",
"consumer",
"consumer",
")",
"{",
"check",
"not",
"null",
"(",
"consumer",
")",
";",
"for",
"(",
"int",
"i",
"=",
"start",
";",
"i",
"<",
"end",
";",
"i",
"+",
"+",
")",
"{",
"consumer",
"accept",
"(",
"array",
"[",
"i",
"]",
")",
";",
"}",
"}"
] |
[
"returns",
"the",
"{",
"@",
"code",
"boolean",
"}",
"value",
"of",
"a",
"header",
"with",
"the",
"specified",
"name",
"if",
"there",
"is",
"more",
"than",
"one",
"value",
"for",
"the",
"specified",
"name",
",",
"the",
"first",
"value",
"in",
"insertion",
"order",
"is",
"returned"
] |
[
"boolean",
"get",
"boolean",
"(",
"k",
"name",
",",
"boolean",
"default",
"value",
")",
";"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] |
[
"public",
"boolean",
"is",
"compatible",
"(",
"dalv",
"insn",
"insn",
")",
"{",
"register",
"spec",
"list",
"regs",
"=",
"insn",
"get",
"registers",
"(",
")",
";",
"if",
"(",
"!",
"(",
"(",
"insn",
"instanceof",
"target",
"insn",
")",
"&",
"&",
"(",
"regs",
"size",
"(",
")",
"=",
"=",
"1",
")",
"&",
"&",
"unsigned",
"fits",
"in",
"byte",
"(",
"regs",
"get",
"(",
"0",
")",
"get",
"reg",
"(",
")",
")",
")",
")",
"{",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}"
] |
[
"selects",
"the",
"last",
"tab"
] |
[
"public",
"void",
"last",
"(",
")",
"{",
"card",
"layout",
"last",
"(",
"card",
"panel",
")",
";",
"update",
"button",
"selection",
"(",
")",
";",
"}"
] |
[
"set",
"whether",
"the",
"e",
"tag",
"value",
"written",
"to",
"the",
"response",
"should",
"be",
"weak",
",",
"as",
"per",
"rfc",
"7232",
"should",
"be",
"configured",
"using",
"an",
"{",
"@",
"code",
"<",
"init",
"-",
"param",
">",
"}",
"for",
"parameter",
"name",
"\"",
"write",
"weak",
"e",
"tag",
"\"",
"in",
"the",
"filter",
"definition",
"in",
"{",
"@",
"code",
"web",
"xml",
"}"
] |
[
"public",
"void",
"set",
"write",
"weak",
"e",
"tag",
"(",
"boolean",
"write",
"weak",
"e",
"tag",
")",
"{",
"this",
"write",
"weak",
"e",
"tag",
"=",
"write",
"weak",
"e",
"tag",
";",
"}"
] |
[
"execute",
"an",
"asynchronous",
"piece",
"of",
"java",
"script",
"in",
"the",
"context",
"of",
"the",
"currently",
"selected",
"frame",
"or",
"window",
"unlike",
"executing",
"{",
"@",
"link",
"#",
"execute",
"script",
"(",
"string",
",",
"object",
")",
"synchronous",
"java",
"script",
"}",
",",
"scripts",
"executed",
"with",
"this",
"method",
"must",
"explicitly",
"signal",
"they",
"are",
"finished",
"by",
"invoking",
"the",
"provided",
"callback",
"this",
"callback",
"is",
"always",
"injected",
"into",
"the",
"executed",
"function",
"as",
"the",
"last",
"argument",
"the",
"first",
"argument",
"passed",
"to",
"the",
"callback",
"function",
"will",
"be",
"used",
"as",
"the",
"script",
"'",
"s",
"result",
"this",
"value",
"will",
"be",
"handled",
"as",
"follows",
":",
"for",
"an",
"html",
"element",
",",
"this",
"method",
"returns",
"a",
"web",
"element",
"for",
"a",
"number",
",",
"a",
"long",
"is",
"returned",
"for",
"a",
"boolean",
",",
"a",
"boolean",
"is",
"returned",
"for",
"all",
"other",
"cases",
",",
"a",
"string",
"is",
"returned",
"for",
"an",
"array",
",",
"return",
"a",
"list",
"&",
"lt",
";",
"object",
"&",
"gt",
";",
"with",
"each",
"object",
"following",
"the",
"rules",
"above",
"we",
"support",
"nested",
"lists",
"for",
"a",
"map",
",",
"return",
"a",
"map",
"&",
"lt",
";",
"string",
",",
"object",
"&",
"gt",
";",
"with",
"values",
"following",
"the",
"rules",
"above",
"unless",
"the",
"value",
"is",
"null",
"or",
"there",
"is",
"no",
"return",
"value",
",",
"in",
"which",
"null",
"is",
"returned",
"the",
"default",
"timeout",
"for",
"a",
"script",
"to",
"be",
"executed",
"is",
"0ms",
"in",
"most",
"cases",
",",
"including",
"the",
"examples",
"below",
",",
"one",
"must",
"set",
"the",
"script",
"timeout",
"{",
"@",
"link",
"web",
"driver",
"timeouts",
"#",
"set",
"script",
"timeout",
"(",
"java",
"time",
"duration",
")",
"}",
"beforehand",
"to",
"a",
"value",
"sufficiently",
"large",
"enough",
"example",
"#",
"1",
":",
"performing",
"a",
"sleep",
"in",
"the",
"browser",
"under",
"test",
"{",
"@",
"code",
"long",
"start",
"=",
"system",
"current",
"time",
"millis",
"(",
")",
";",
"(",
"(",
"javascript",
"executor",
")",
"driver",
")",
"execute",
"async",
"script",
"(",
"\"",
"window",
"set",
"timeout",
"(",
"arguments",
"[",
"arguments",
"length",
"-",
"1",
"]",
",",
"500",
")",
";",
"\"",
")",
";",
"system",
"out",
"println",
"(",
"\"",
"elapsed",
"time",
":",
"\"",
"+",
"system",
"current",
"time",
"millis",
"(",
")",
"-",
"start",
")",
";",
"}",
"example",
"#",
"2",
":",
"synchronizing",
"a",
"test",
"with",
"an",
"ajax",
"application",
":",
"{",
"@",
"code",
"web",
"element",
"compose",
"button",
"=",
"driver",
"find",
"element",
"(",
"by",
"id",
"(",
"\"",
"compose",
"-",
"button",
"\"",
")",
")",
";",
"compose",
"button",
"click",
"(",
")",
";",
"(",
"(",
"javascript",
"executor",
")",
"driver",
")",
"execute",
"async",
"script",
"(",
"\"",
"var",
"callback",
"=",
"arguments",
"[",
"arguments",
"length",
"-",
"1",
"]",
";",
"\"",
"+",
"\"",
"mail",
"client",
"get",
"compose",
"window",
"widget",
"(",
")",
"onload",
"(",
"callback",
")",
";",
"\"",
")",
";",
"driver",
"switch",
"to",
"(",
")",
"frame",
"(",
"\"",
"compose",
"widget",
"\"",
")",
";",
"driver",
"find",
"element",
"(",
"by",
"id",
"(",
"\"",
"to",
"\"",
")",
")",
"send",
"keys",
"(",
"\"",
"bog",
"@",
"example",
"com",
"\"",
")",
";",
"}",
"example",
"#",
"3",
":",
"injecting",
"a",
"x",
"m",
"l",
"http",
"request",
"and",
"waiting",
"for",
"the",
"result",
":",
"{",
"@",
"code",
"object",
"response",
"=",
"(",
"(",
"javascript",
"executor",
")",
"driver",
")",
"execute",
"async",
"script",
"(",
"\"",
"var",
"callback",
"=",
"arguments",
"[",
"arguments",
"length",
"-",
"1",
"]",
";",
"\"",
"+",
"\"",
"var",
"xhr",
"=",
"new",
"x",
"m",
"l",
"http",
"request",
"(",
")",
";",
"\"",
"+",
"\"",
"xhr",
"open",
"(",
"'",
"get",
"'",
",",
"'",
"resourcedata",
"json",
"'",
",",
"true",
")",
";",
"\"",
"+",
"\"",
"xhr",
"onreadystatechange",
"=",
"function",
"(",
")",
"{",
"\"",
"+",
"\"",
"if",
"(",
"xhr",
"ready",
"state",
"=",
"=",
"4",
")",
"{",
"\"",
"+",
"\"",
"callback",
"(",
"xhr",
"response",
"text",
")",
";",
"\"",
"+",
"\"",
"}",
"\"",
"+",
"\"",
"}",
";",
"\"",
"+",
"\"",
"xhr",
"send",
"(",
")",
";",
"\"",
")",
";",
"json",
"object",
"json",
"=",
"new",
"json",
"parser",
"(",
")",
"parse",
"(",
"(",
"string",
")",
"response",
")",
";",
"assert",
"equals",
"(",
"\"",
"cheese",
"\"",
",",
"json",
"get",
"(",
"\"",
"food",
"\"",
")",
"get",
"as",
"string",
"(",
")",
")",
";",
"}",
"script",
"arguments",
"must",
"be",
"a",
"number",
",",
"a",
"boolean",
",",
"a",
"string",
",",
"web",
"element",
",",
"or",
"a",
"list",
"of",
"any",
"combination",
"of",
"the",
"above",
"an",
"exception",
"will",
"be",
"thrown",
"if",
"the",
"arguments",
"do",
"not",
"meet",
"these",
"criteria",
"the",
"arguments",
"will",
"be",
"made",
"available",
"to",
"the",
"java",
"script",
"via",
"the",
"\"",
"arguments",
"\"",
"variable"
] |
[
"object",
"execute",
"async",
"script",
"(",
"string",
"script",
",",
"object",
"args",
")",
";"
] |
[
"list",
"children",
"of",
"a",
"directory",
"and",
"retrieve",
"their",
"{",
"@",
"link",
"registry",
"path",
"status",
"}",
"values",
"this",
"is",
"not",
"an",
"atomic",
"operation",
";",
"a",
"child",
"may",
"be",
"deleted",
"during",
"the",
"iteration",
"through",
"the",
"child",
"entries",
"if",
"this",
"happens",
",",
"the",
"<",
"code",
">",
"path",
"not",
"found",
"exception",
"<",
"code",
">",
"is",
"caught",
"and",
"that",
"child",
"entry",
"ommitted"
] |
[
"public",
"static",
"map",
"<",
"string",
",",
"registry",
"path",
"status",
">",
"stat",
"children",
"(",
"registry",
"operations",
"registry",
"operations",
",",
"string",
"path",
")",
"throws",
"path",
"not",
"found",
"exception",
",",
"invalid",
"pathname",
"exception",
",",
"i",
"o",
"exception",
"{",
"list",
"<",
"string",
">",
"child",
"names",
"=",
"registry",
"operations",
"list",
"(",
"path",
")",
";",
"map",
"<",
"string",
",",
"registry",
"path",
"status",
">",
"results",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"registry",
"path",
"status",
">",
"(",
")",
";",
"for",
"(",
"string",
"child",
"name",
":",
"child",
"names",
")",
"{",
"string",
"child",
"=",
"join",
"(",
"path",
",",
"child",
"name",
")",
";",
"try",
"{",
"registry",
"path",
"status",
"stat",
"=",
"registry",
"operations",
"stat",
"(",
"child",
")",
";",
"results",
"put",
"(",
"child",
"name",
",",
"stat",
")",
";",
"}",
"catch",
"(",
"path",
"not",
"found",
"exception",
"pnfe",
")",
"{",
"if",
"(",
"log",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"log",
"debug",
"(",
"\"",
"stat",
"failed",
"on",
"{",
"}",
":",
"moved",
"?",
"{",
"}",
"\"",
",",
"child",
",",
"pnfe",
",",
"pnfe",
")",
";",
"}",
"/",
"/",
"and",
"continue",
"}",
"}",
"return",
"results",
";",
"}"
] |
[
"fake",
"endpoint",
"to",
"test",
"group",
"parameters",
"(",
"optional",
")",
"fake",
"endpoint",
"to",
"test",
"group",
"parameters",
"(",
"optional",
")"
] |
[
"public",
"void",
"test",
"group",
"parameters",
"test",
"(",
")",
"throws",
"api",
"exception",
"{",
"integer",
"required",
"string",
"group",
"=",
"null",
";",
"boolean",
"required",
"boolean",
"group",
"=",
"null",
";",
"long",
"required",
"int",
"6",
"4",
"group",
"=",
"null",
";",
"integer",
"string",
"group",
"=",
"null",
";",
"boolean",
"boolean",
"group",
"=",
"null",
";",
"long",
"int",
"6",
"4",
"group",
"=",
"null",
";",
"fake",
"api",
"a",
"p",
"itest",
"group",
"parameters",
"request",
"request",
"=",
"fake",
"api",
"a",
"p",
"itest",
"group",
"parameters",
"request",
"new",
"builder",
"(",
")",
"required",
"string",
"group",
"(",
"required",
"string",
"group",
")",
"required",
"boolean",
"group",
"(",
"required",
"boolean",
"group",
")",
"required",
"int",
"6",
"4",
"group",
"(",
"required",
"int",
"6",
"4",
"group",
")",
"string",
"group",
"(",
"string",
"group",
")",
"boolean",
"group",
"(",
"boolean",
"group",
")",
"int",
"6",
"4",
"group",
"(",
"int",
"6",
"4",
"group",
")",
"build",
"(",
")",
";",
"api",
"test",
"group",
"parameters",
"(",
"request",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.