docstring_tokens
sequence | code_tokens
sequence |
|---|---|
[
"makes",
"sure",
"that",
"the",
"given",
"info",
"collection",
"has",
"a",
"{",
"@",
"link",
"cc",
"toolchain",
"provider",
"}",
"(",
"gives",
"an",
"error",
"otherwise",
")",
",",
"and",
"returns",
"a",
"reference",
"to",
"that",
"{",
"@",
"link",
"cc",
"toolchain",
"provider",
"}",
"the",
"method",
"will",
"only",
"return",
"{",
"@",
"code",
"null",
"}",
",",
"if",
"the",
"toolchain",
"attribute",
"is",
"undefined",
"for",
"the",
"rule",
"class"
] | [
"public",
"static",
"cc",
"toolchain",
"provider",
"get",
"toolchain",
"(",
"rule",
"context",
"rule",
"context",
",",
"string",
"toolchain",
"attribute",
")",
"{",
"if",
"(",
"!",
"rule",
"context",
"is",
"attr",
"defined",
"(",
"toolchain",
"attribute",
",",
"label",
")",
")",
"{",
"/",
"/",
"todo",
"(",
"bazel",
"-",
"team",
")",
":",
"report",
"an",
"error",
"or",
"throw",
"an",
"exception",
"in",
"this",
"case",
"return",
"null",
";",
"}",
"transitive",
"info",
"collection",
"dep",
"=",
"rule",
"context",
"get",
"prerequisite",
"(",
"toolchain",
"attribute",
")",
";",
"return",
"get",
"toolchain",
"(",
"rule",
"context",
",",
"dep",
")",
";",
"}"
] |
[
"tries",
"to",
"copy",
"the",
"given",
"record",
"from",
"using",
"the",
"provided",
"kryo",
"instance",
"if",
"this",
"fails",
",",
"then",
"the",
"record",
"from",
"is",
"copied",
"by",
"serializing",
"it",
"into",
"a",
"byte",
"buffer",
"and",
"deserializing",
"it",
"from",
"there"
] | [
"public",
"static",
"<",
"t",
">",
"t",
"copy",
"(",
"t",
"from",
",",
"t",
"reuse",
",",
"kryo",
"kryo",
",",
"type",
"serializer",
"<",
"t",
">",
"serializer",
")",
"{",
"try",
"{",
"return",
"kryo",
"copy",
"(",
"from",
")",
";",
"}",
"catch",
"(",
"kryo",
"exception",
"ke",
")",
"{",
"/",
"/",
"kryo",
"could",
"not",
"copy",
"the",
"object",
"-",
"-",
">",
"try",
"to",
"serialize",
"/",
"deserialize",
"the",
"object",
"try",
"{",
"byte",
"[",
"]",
"byte",
"array",
"=",
"instantiation",
"util",
"serialize",
"to",
"byte",
"array",
"(",
"serializer",
",",
"from",
")",
";",
"return",
"instantiation",
"util",
"deserialize",
"from",
"byte",
"array",
"(",
"serializer",
",",
"reuse",
",",
"byte",
"array",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"ioe",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"could",
"not",
"copy",
"object",
"by",
"serializing",
"/",
"deserializing",
"\"",
"+",
"\"",
"it",
"\"",
",",
"ioe",
")",
";",
"}",
"}",
"}"
] |
[
"an",
"alternative",
"to",
"{",
"@",
"link",
"#",
"from",
"method",
"(",
"class",
",",
"method",
",",
"object",
")",
"}",
"that",
"accepts",
"a",
"{",
"@",
"code",
"uri",
"components",
"builder",
"}",
"representing",
"the",
"base",
"url",
"this",
"is",
"useful",
"when",
"using",
"mvc",
"uri",
"components",
"builder",
"outside",
"the",
"context",
"of",
"processing",
"a",
"request",
"or",
"to",
"apply",
"a",
"custom",
"base",
"url",
"not",
"matching",
"the",
"current",
"request",
"note",
":",
"this",
"method",
"extracts",
"values",
"from",
"\"",
"forwarded",
"\"",
"and",
"\"",
"x",
"-",
"forwarded",
"-",
"\"",
"headers",
"if",
"found",
"see",
"class",
"-",
"level",
"docs"
] | [
"public",
"static",
"uri",
"components",
"builder",
"from",
"method",
"(",
"uri",
"components",
"builder",
"base",
"url",
",",
"@",
"nullable",
"class",
"<",
"?",
">",
"controller",
"type",
",",
"method",
"method",
",",
"object",
"args",
")",
"{",
"return",
"from",
"method",
"internal",
"(",
"base",
"url",
",",
"(",
"controller",
"type",
"!",
"=",
"null",
"?",
"controller",
"type",
":",
"method",
"get",
"declaring",
"class",
"(",
")",
")",
",",
"method",
",",
"args",
")",
";",
"}"
] |
[
"set",
"the",
"scripts",
"to",
"be",
"loaded",
"by",
"the",
"script",
"engine",
"(",
"library",
"or",
"user",
"provided",
")",
"since",
"{",
"@",
"code",
"resource",
"loader",
"path",
"}",
"default",
"value",
"is",
"\"",
"classpath",
":",
"\"",
",",
"you",
"can",
"load",
"easily",
"any",
"script",
"available",
"on",
"the",
"classpath",
"for",
"example",
",",
"in",
"order",
"to",
"use",
"a",
"java",
"script",
"library",
"available",
"as",
"a",
"web",
"jars",
"dependency",
"and",
"a",
"custom",
"\"",
"render",
"js",
"\"",
"file",
",",
"you",
"should",
"call",
"{",
"@",
"code",
"configurer",
"set",
"scripts",
"(",
"\"",
"meta",
"-",
"i",
"n",
"fresourceswebjarslibraryversionlibrary",
"js",
"\"",
",",
"\"",
"commyprojectscriptrender",
"js",
"\"",
")",
";",
"}"
] | [
"public",
"void",
"set",
"scripts",
"(",
"@",
"nullable",
"string",
"script",
"names",
")",
"{",
"this",
"scripts",
"=",
"script",
"names",
";",
"}"
] |
[
"test",
"that",
"server",
"default",
"values",
"are",
"cached",
"on",
"the",
"client",
"size",
"and",
"are",
"stale",
"after",
"namenode",
"update"
] | [
"public",
"void",
"test",
"server",
"defaults",
"with",
"caching",
"(",
")",
"throws",
"i",
"o",
"exception",
",",
"interrupted",
"exception",
"{",
"/",
"/",
"create",
"cluster",
"with",
"an",
"explicit",
"block",
"size",
"param",
"configuration",
"cluster",
"conf",
"=",
"new",
"hdfs",
"configuration",
"(",
")",
";",
"long",
"original",
"block",
"size",
"=",
"dfs",
"block",
"size",
"default",
"*",
"2",
";",
"cluster",
"conf",
"set",
"long",
"(",
"dfs",
"block",
"size",
"key",
",",
"original",
"block",
"size",
")",
";",
"mini",
"d",
"f",
"s",
"cluster",
"cluster",
"=",
"new",
"mini",
"d",
"f",
"s",
"cluster",
"builder",
"(",
"cluster",
"conf",
")",
"num",
"data",
"nodes",
"(",
"0",
")",
"build",
"(",
")",
";",
"cluster",
"wait",
"active",
"(",
")",
";",
"/",
"/",
"set",
"a",
"spy",
"namesystem",
"inside",
"the",
"namenode",
"and",
"return",
"it",
"f",
"s",
"namesystem",
"spy",
"namesystem",
"=",
"name",
"node",
"adapter",
"spy",
"on",
"namesystem",
"(",
"cluster",
"get",
"name",
"node",
"(",
")",
")",
";",
"inet",
"socket",
"address",
"name",
"node",
"addr",
"=",
"cluster",
"get",
"name",
"node",
"(",
")",
"get",
"name",
"node",
"address",
"(",
")",
";",
"try",
"{",
"/",
"/",
"create",
"a",
"dfs",
"client",
"and",
"set",
"a",
"long",
"enough",
"validity",
"interval",
"configuration",
"client",
"conf",
"=",
"new",
"hdfs",
"configuration",
"(",
")",
";",
"client",
"conf",
"set",
"long",
"(",
"dfs",
"client",
"server",
"defaults",
"validity",
"period",
"ms",
"key",
",",
"time",
"unit",
"minutes",
"to",
"millis",
"(",
"1",
")",
")",
";",
"d",
"f",
"s",
"client",
"dfs",
"client",
"=",
"new",
"d",
"f",
"s",
"client",
"(",
"name",
"node",
"addr",
",",
"client",
"conf",
")",
";",
"fs",
"server",
"defaults",
"defaults",
"=",
"dfs",
"client",
"get",
"server",
"defaults",
"(",
")",
";",
"assert",
"equals",
"(",
"original",
"block",
"size",
",",
"defaults",
"get",
"block",
"size",
"(",
")",
")",
";",
"/",
"/",
"update",
"the",
"namenode",
"with",
"a",
"new",
"parameter",
"long",
"updated",
"default",
"block",
"size",
"=",
"dfs",
"block",
"size",
"default",
"*",
"3",
";",
"fs",
"server",
"defaults",
"new",
"defaults",
"=",
"new",
"fs",
"server",
"defaults",
"(",
"updated",
"default",
"block",
"size",
",",
"defaults",
"get",
"bytes",
"per",
"checksum",
"(",
")",
",",
"defaults",
"get",
"write",
"packet",
"size",
"(",
")",
",",
"defaults",
"get",
"replication",
"(",
")",
",",
"defaults",
"get",
"file",
"buffer",
"size",
"(",
")",
",",
"defaults",
"get",
"encrypt",
"data",
"transfer",
"(",
")",
",",
"defaults",
"get",
"trash",
"interval",
"(",
")",
",",
"defaults",
"get",
"checksum",
"type",
"(",
")",
",",
"defaults",
"get",
"key",
"provider",
"uri",
"(",
")",
",",
"defaults",
"get",
"default",
"storage",
"policy",
"id",
"(",
")",
")",
";",
"do",
"return",
"(",
"new",
"defaults",
")",
"when",
"(",
"spy",
"namesystem",
")",
"get",
"server",
"defaults",
"(",
")",
";",
"/",
"/",
"the",
"value",
"is",
"stale",
"thread",
"sleep",
"(",
"1",
")",
";",
"defaults",
"=",
"dfs",
"client",
"get",
"server",
"defaults",
"(",
")",
";",
"assert",
"equals",
"(",
"original",
"block",
"size",
",",
"defaults",
"get",
"block",
"size",
"(",
")",
")",
";",
"/",
"/",
"another",
"client",
"reads",
"the",
"updated",
"value",
"correctly",
"d",
"f",
"s",
"client",
"new",
"dfs",
"client",
"=",
"new",
"d",
"f",
"s",
"client",
"(",
"name",
"node",
"addr",
",",
"client",
"conf",
")",
";",
"defaults",
"=",
"new",
"dfs",
"client",
"get",
"server",
"defaults",
"(",
")",
";",
"assert",
"equals",
"(",
"updated",
"default",
"block",
"size",
",",
"defaults",
"get",
"block",
"size",
"(",
")",
")",
";",
"}",
"finally",
"{",
"cluster",
"shutdown",
"(",
")",
";",
"}",
"}"
] |
[
"adds",
"a",
"range",
"of",
"addresses",
"to",
"this",
"set"
] | [
"public",
"void",
"add",
"range",
"(",
"program",
"program",
",",
"address",
"start",
",",
"address",
"end",
")",
"{",
"if",
"(",
"start",
"get",
"address",
"space",
"(",
")",
"equals",
"(",
"end",
"get",
"address",
"space",
"(",
")",
")",
")",
"{",
"add",
"range",
"(",
"start",
",",
"end",
")",
";",
"return",
";",
"}",
"address",
"factory",
"address",
"factory",
"=",
"program",
"get",
"address",
"factory",
"(",
")",
";",
"add",
"(",
"address",
"factory",
"get",
"address",
"set",
"(",
"start",
",",
"end",
")",
")",
";",
"}"
] |
[
"get",
"the",
"number",
"of",
"lines",
"per",
"split"
] | [
"public",
"static",
"int",
"get",
"num",
"lines",
"per",
"split",
"(",
"job",
"context",
"job",
")",
"{",
"return",
"job",
"get",
"configuration",
"(",
")",
"get",
"int",
"(",
"lines",
"per",
"map",
",",
"1",
")",
";",
"}"
] |
[
"calculates",
"the",
"delay",
"in",
"millis",
"between",
"\"",
"now",
"\"",
"and",
"the",
"next",
"execution"
] | [
"time",
"value",
"next",
"execution",
"delay",
"(",
"zoned",
"date",
"time",
"now",
")",
";"
] |
[
"tests",
"that",
"the",
"last",
"heartbeat",
"from",
"an",
"unregistered",
"target",
"equals",
"-",
"1"
] | [
"public",
"void",
"test",
"last",
"heartbeat",
"from",
"unregistered",
"target",
"(",
")",
"{",
"final",
"long",
"heartbeat",
"timeout",
"=",
"100l",
";",
"final",
"resource",
"i",
"d",
"resource",
"id",
"=",
"resource",
"i",
"d",
"generate",
"(",
")",
";",
"@",
"suppress",
"warnings",
"(",
"\"",
"unchecked",
"\"",
")",
"final",
"heartbeat",
"listener",
"<",
"object",
",",
"object",
">",
"heartbeat",
"listener",
"=",
"mock",
"(",
"heartbeat",
"listener",
"class",
")",
";",
"heartbeat",
"manager",
"<",
"?",
",",
"?",
">",
"heartbeat",
"manager",
"=",
"new",
"heartbeat",
"manager",
"impl",
"<",
">",
"(",
"heartbeat",
"timeout",
",",
"resource",
"id",
",",
"heartbeat",
"listener",
",",
"mock",
"(",
"scheduled",
"executor",
"class",
")",
",",
"log",
")",
";",
"try",
"{",
"assert",
"equals",
"(",
"-",
"1l",
",",
"heartbeat",
"manager",
"get",
"last",
"heartbeat",
"from",
"(",
"resource",
"i",
"d",
"generate",
"(",
")",
")",
")",
";",
"}",
"finally",
"{",
"heartbeat",
"manager",
"stop",
"(",
")",
";",
"}",
"}"
] |
[
"put",
"fakebody",
"-",
"with",
"-",
"file",
"-",
"schema"
] | [
"public",
"<",
"t",
">",
"t",
"execute",
"(",
"function",
"<",
"response",
",",
"t",
">",
"handler",
")",
"{",
"return",
"handler",
"apply",
"(",
"rest",
"assured",
"given",
"(",
")",
"spec",
"(",
"req",
"spec",
"build",
"(",
")",
")",
"expect",
"(",
")",
"spec",
"(",
"resp",
"spec",
"build",
"(",
")",
")",
"when",
"(",
")",
"request",
"(",
"req",
"method",
",",
"req",
"uri",
")",
")",
";",
"}"
] |
[
"synchronously",
"get",
"application",
"privilege",
"(",
"s",
")",
"see",
"<",
"a",
"href",
"=",
"\"",
"https",
":",
"www",
"elastic",
"coguideenelasticsearchreferencecurrentsecurity",
"-",
"api",
"-",
"get",
"-",
"privileges",
"html",
"\"",
">",
"the",
"docs",
"for",
"more"
] | [
"public",
"get",
"privileges",
"response",
"get",
"privileges",
"(",
"final",
"get",
"privileges",
"request",
"request",
",",
"final",
"request",
"options",
"options",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"rest",
"high",
"level",
"client",
"perform",
"request",
"and",
"parse",
"entity",
"(",
"request",
",",
"security",
"request",
"converters",
":",
":",
"get",
"privileges",
",",
"options",
",",
"get",
"privileges",
"response",
":",
":",
"from",
"x",
"content",
",",
"empty",
"set",
"(",
")",
")",
";",
"}"
] |
[
"log",
"a",
"message",
"object",
"at",
"the",
"info",
"level"
] | [
"public",
"void",
"info",
"(",
"string",
"msg",
")",
"{",
"if",
"(",
"logger",
"is",
"loggable",
"(",
"level",
"info",
")",
")",
"{",
"log",
"(",
"self",
",",
"level",
"info",
",",
"msg",
",",
"null",
")",
";",
"}",
"}"
] |
[
"tests",
"that",
"savepoint",
"loading",
"fails",
"when",
"there",
"is",
"non",
"-",
"restored",
"state",
",",
"but",
"it",
"is",
"not",
"allowed"
] | [
"public",
"void",
"test",
"non",
"restored",
"state",
"when",
"disallowed",
"(",
")",
"throws",
"exception",
"{",
"final",
"operator",
"i",
"d",
"operator",
"id",
"=",
"new",
"operator",
"i",
"d",
"(",
")",
";",
"final",
"int",
"parallelism",
"=",
"9",
";",
"final",
"completed",
"checkpoint",
"storage",
"location",
"test",
"savepoint",
"=",
"create",
"savepoint",
"with",
"operator",
"subtask",
"state",
"(",
"242l",
",",
"operator",
"id",
",",
"parallelism",
")",
";",
"final",
"map",
"<",
"job",
"vertex",
"i",
"d",
",",
"execution",
"job",
"vertex",
">",
"tasks",
"=",
"collections",
"empty",
"map",
"(",
")",
";",
"try",
"{",
"checkpoints",
"load",
"and",
"validate",
"checkpoint",
"(",
"new",
"job",
"i",
"d",
"(",
")",
",",
"tasks",
",",
"test",
"savepoint",
",",
"cl",
",",
"false",
")",
";",
"fail",
"(",
"\"",
"did",
"not",
"throw",
"expected",
"exception",
"\"",
")",
";",
"}",
"catch",
"(",
"illegal",
"state",
"exception",
"expected",
")",
"{",
"assert",
"true",
"(",
"expected",
"get",
"message",
"(",
")",
"contains",
"(",
"\"",
"allow",
"non",
"restored",
"state",
"\"",
")",
")",
";",
"}",
"}"
] |
[
"handle",
"the",
"split",
"changes",
"this",
"call",
"should",
"be",
"non",
"-",
"blocking"
] | [
"void",
"handle",
"splits",
"changes",
"(",
"splits",
"change",
"<",
"split",
"t",
">",
"splits",
"changes",
")",
";"
] |
[
"the",
"set",
"of",
"arityplural",
"mappings",
"<",
"code",
">",
"repeated",
"aapt",
"pb",
"plural",
"entry",
"entry",
"=",
"1",
";",
"<",
"code",
">"
] | [
"private",
"void",
"clear",
"entry",
"(",
")",
"{",
"entry",
"=",
"empty",
"protobuf",
"list",
"(",
")",
";",
"}"
] |
[
"records",
"cache",
"misses",
"this",
"should",
"be",
"called",
"when",
"a",
"cache",
"request",
"returns",
"a",
"value",
"that",
"was",
"not",
"found",
"in",
"the",
"cache",
"this",
"method",
"should",
"be",
"called",
"by",
"the",
"loading",
"thread",
",",
"as",
"well",
"as",
"by",
"threads",
"blocking",
"on",
"the",
"load",
"multiple",
"concurrent",
"calls",
"to",
"{",
"@",
"link",
"cache",
"}",
"lookup",
"methods",
"with",
"the",
"same",
"key",
"on",
"an",
"absent",
"value",
"should",
"result",
"in",
"a",
"single",
"call",
"to",
"either",
"{",
"@",
"code",
"record",
"load",
"success",
"}",
"or",
"{",
"@",
"code",
"record",
"load",
"exception",
"}",
"and",
"multiple",
"calls",
"to",
"this",
"method",
",",
"despite",
"all",
"being",
"served",
"by",
"the",
"results",
"of",
"a",
"single",
"load",
"operation"
] | [
"void",
"record",
"misses",
"(",
"int",
"count",
")",
";"
] |
[
"modify",
"the",
"application",
"context",
"'",
"s",
"internal",
"bean",
"definition",
"registry",
"after",
"its",
"standard",
"initialization",
"all",
"regular",
"bean",
"definitions",
"will",
"have",
"been",
"loaded",
",",
"but",
"no",
"beans",
"will",
"have",
"been",
"instantiated",
"yet",
"this",
"allows",
"for",
"adding",
"further",
"bean",
"definitions",
"before",
"the",
"next",
"post",
"-",
"processing",
"phase",
"kicks",
"in"
] | [
"void",
"post",
"process",
"bean",
"definition",
"registry",
"(",
"bean",
"definition",
"registry",
"registry",
")",
"throws",
"beans",
"exception",
";"
] |
[
"verify",
"quota",
"for",
"adding",
"or",
"moving",
"a",
"new",
"i",
"node",
"with",
"required",
"namespace",
"and",
"storagespace",
"to",
"a",
"given",
"position"
] | [
"static",
"void",
"verify",
"quota",
"(",
"i",
"nodes",
"in",
"path",
"iip",
",",
"int",
"pos",
",",
"quota",
"counts",
"deltas",
",",
"i",
"node",
"common",
"ancestor",
")",
"throws",
"quota",
"exceeded",
"exception",
"{",
"if",
"(",
"deltas",
"get",
"name",
"space",
"(",
")",
"<",
"=",
"0",
"&",
"&",
"deltas",
"get",
"storage",
"space",
"(",
")",
"<",
"=",
"0",
"&",
"&",
"deltas",
"get",
"type",
"spaces",
"(",
")",
"all",
"less",
"or",
"equal",
"(",
"0l",
")",
")",
"{",
"/",
"/",
"if",
"quota",
"is",
"being",
"freed",
"or",
"not",
"being",
"consumed",
"return",
";",
"}",
"/",
"/",
"check",
"existing",
"components",
"in",
"the",
"path",
"for",
"(",
"int",
"i",
"=",
"(",
"pos",
">",
"iip",
"length",
"(",
")",
"?",
"iip",
"length",
"(",
")",
":",
"pos",
")",
"-",
"1",
";",
"i",
">",
"=",
"0",
";",
"i",
"-",
"-",
")",
"{",
"if",
"(",
"common",
"ancestor",
"=",
"=",
"iip",
"get",
"i",
"node",
"(",
"i",
")",
"&",
"&",
"!",
"common",
"ancestor",
"is",
"in",
"latest",
"snapshot",
"(",
"iip",
"get",
"latest",
"snapshot",
"id",
"(",
")",
")",
")",
"{",
"/",
"/",
"stop",
"checking",
"for",
"quota",
"when",
"common",
"ancestor",
"is",
"reached",
"return",
";",
"}",
"final",
"directory",
"with",
"quota",
"feature",
"q",
"=",
"iip",
"get",
"i",
"node",
"(",
"i",
")",
"as",
"directory",
"(",
")",
"get",
"directory",
"with",
"quota",
"feature",
"(",
")",
";",
"if",
"(",
"q",
"!",
"=",
"null",
")",
"{",
"/",
"/",
"a",
"directory",
"with",
"quota",
"try",
"{",
"q",
"verify",
"quota",
"(",
"deltas",
")",
";",
"}",
"catch",
"(",
"quota",
"exceeded",
"exception",
"e",
")",
"{",
"e",
"set",
"path",
"name",
"(",
"iip",
"get",
"path",
"(",
"i",
")",
")",
";",
"throw",
"e",
";",
"}",
"}",
"}",
"}"
] |
[
"setter",
"for",
"y"
] | [
"public",
"void",
"set",
"i",
"(",
"integer",
"i",
")",
"{",
"this",
"i",
"=",
"i",
";",
"}"
] |
[
"returns",
"the",
"total",
"length",
"of",
"the",
"extra",
"data",
"record",
"in",
"bytes"
] | [
"public",
"int",
"get",
"length",
"(",
")",
"{",
"return",
"get",
"data",
"length",
"(",
")",
"+",
"fixed",
"data",
"size",
";",
"}"
] |
[
"format",
":",
"-",
"-",
"<",
"key",
">",
"=",
"<",
"value",
">"
] | [
"public",
"desugar",
"rule",
"builder",
"add",
"command",
"options",
"(",
"string",
"key",
",",
"string",
"value",
")",
"{",
"custom",
"command",
"options",
"put",
"(",
"key",
",",
"value",
")",
";",
"return",
"this",
";",
"}"
] |
[
"get",
"an",
"individual",
"field",
"in",
"the",
"composite"
] | [
"public",
"j",
"text",
"field",
"get",
"field",
"(",
"int",
"i",
")",
"{",
"return",
"linked",
"fields",
"get",
"(",
"i",
")",
"field",
";",
"}"
] |
[
"for",
"internal",
"usage",
"only",
"!",
"extracts",
"the",
"inner",
"hits",
"from",
"the",
"query",
"tree",
"while",
"it",
"extracts",
"inner",
"hits",
",",
"child",
"inner",
"hits",
"are",
"inlined",
"into",
"the",
"inner",
"hit",
"builder",
"they",
"belong",
"to"
] | [
"protected",
"void",
"extract",
"inner",
"hit",
"builders",
"(",
"map",
"<",
"string",
",",
"inner",
"hit",
"context",
"builder",
">",
"inner",
"hits",
")",
"{",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] | [
"public",
"int",
"hash",
"code",
"(",
")",
"{",
"return",
"string",
"hash",
"code",
"(",
")",
";",
"}"
] |
[
"returns",
"whether",
"configurations",
"should",
"trim",
"their",
"fragments",
"to",
"only",
"those",
"needed",
"by",
"targets",
"and",
"their",
"transitive",
"dependencies"
] | [
"private",
"static",
"boolean",
"use",
"untrimmed",
"configs",
"(",
"build",
"options",
"options",
")",
"{",
"return",
"options",
"get",
"(",
"core",
"options",
"class",
")",
"configs",
"mode",
"=",
"=",
"core",
"options",
"configs",
"mode",
"notrim",
";",
"}",
"/",
"/",
"keep",
"in",
"sync",
"with",
"{",
"@",
"link",
"skyframe",
"executor",
"#",
"get",
"configurations",
"}"
] |
[
"green",
"channel",
",",
"it",
"will",
"skip",
"all",
"of",
"interceptors"
] | [
"public",
"postcard",
"green",
"channel",
"(",
")",
"{",
"this",
"green",
"channel",
"=",
"true",
";",
"return",
"this",
";",
"}"
] |
[
"shallow",
"tuple",
"copy"
] | [
"public",
"tuple",
"1",
"2",
"<",
"t0",
",",
"t1",
",",
"t2",
",",
"t3",
",",
"t4",
",",
"t5",
",",
"t6",
",",
"t7",
",",
"t8",
",",
"t9",
",",
"t10",
",",
"t11",
">",
"copy",
"(",
")",
"{",
"return",
"new",
"tuple",
"1",
"2",
"<",
">",
"(",
"this",
"f",
"0",
",",
"this",
"f",
"1",
",",
"this",
"f",
"2",
",",
"this",
"f",
"3",
",",
"this",
"f",
"4",
",",
"this",
"f",
"5",
",",
"this",
"f",
"6",
",",
"this",
"f",
"7",
",",
"this",
"f",
"8",
",",
"this",
"f",
"9",
",",
"this",
"f",
"1",
"0",
",",
"this",
"f",
"1",
"1",
")",
";",
"}"
] |
[
"，",
"，",
"。"
] | [
"public",
"static",
"rate",
"limiter",
"rate",
"limiter",
"(",
"int",
"permits",
"per",
"second",
")",
"{",
"return",
"rate",
"limiter",
"create",
"(",
"permits",
"per",
"second",
")",
";",
"}"
] |
[
"return",
"the",
"type",
"of",
"the",
"newly",
"created",
"array"
] | [
"public",
"constant",
"get",
"constant",
"(",
")",
"{",
"return",
"array",
"type",
";",
"}"
] |
[
"sets",
"extra",
"data"
] | [
"public",
"void",
"set",
"extra",
"data",
"(",
"string",
"extra",
"data",
")",
"{",
"this",
"extra",
"data",
"=",
"extra",
"data",
";",
"}"
] |
[
"deserialize",
"the",
"fields",
"of",
"this",
"object",
"from",
"<",
"code",
">",
"in",
"<",
"code",
">",
"for",
"efficiency",
",",
"implementations",
"should",
"attempt",
"to",
"re",
"-",
"use",
"storage",
"in",
"the",
"existing",
"object",
"where",
"possible"
] | [
"void",
"read",
"fields",
"(",
"data",
"input",
"in",
")",
"throws",
"i",
"o",
"exception",
";"
] |
[
"returns",
"the",
"base",
"url",
"(",
"schema",
":",
"host",
":",
"port",
")",
"of",
"the",
"test",
"jetty",
"server",
"(",
"see",
"{",
"@",
"link",
"#",
"get",
"jetty",
"server",
"(",
")",
"}",
")",
"once",
"started"
] | [
"public",
"static",
"url",
"get",
"jetty",
"u",
"r",
"l",
"(",
")",
"{",
"test",
"jetty",
"helper",
"helper",
"=",
"test",
"jetty",
"tl",
"get",
"(",
")",
";",
"if",
"(",
"helper",
"=",
"=",
"null",
"|",
"|",
"helper",
"server",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"this",
"test",
"does",
"not",
"use",
"@",
"test",
"jetty",
"\"",
")",
";",
"}",
"try",
"{",
"string",
"scheme",
"=",
"(",
"helper",
"ssl",
")",
"?",
"\"",
"https",
"\"",
":",
"\"",
"http",
"\"",
";",
"return",
"new",
"url",
"(",
"scheme",
"+",
"\"",
":",
"/",
"/",
"\"",
"+",
"(",
"(",
"server",
"connector",
")",
"helper",
"server",
"get",
"connectors",
"(",
")",
"[",
"0",
"]",
")",
"get",
"host",
"(",
")",
"+",
"\"",
":",
"\"",
"+",
"(",
"(",
"server",
"connector",
")",
"helper",
"server",
"get",
"connectors",
"(",
")",
"[",
"0",
"]",
")",
"get",
"port",
"(",
")",
")",
";",
"}",
"catch",
"(",
"malformed",
"u",
"r",
"l",
"exception",
"ex",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"it",
"should",
"never",
"happen",
",",
"\"",
"+",
"ex",
"get",
"message",
"(",
")",
",",
"ex",
")",
";",
"}",
"}"
] |
[
"destroy",
"all",
"the",
"resources",
",",
"including",
"registries",
"and",
"protocols"
] | [
"public",
"void",
"do",
"destroy",
"(",
")",
"{",
"/",
"/",
"dispatch",
"the",
"dubbo",
"destroyed",
"event",
"@",
"since",
"2",
"7",
"5",
"dispatch",
"(",
"new",
"dubbo",
"service",
"destroyed",
"event",
"(",
"this",
")",
")",
";",
"}"
] |
[
"get",
"all",
"of",
"the",
"applications",
"'",
"s",
"settings",
"directories",
"(",
"<",
"tt",
">",
"application",
"name",
"version",
"<",
"tt",
">",
")",
"for",
"various",
"versions",
"in",
"descending",
"order",
"by",
"the",
"modification",
"time",
"in",
"other",
"words",
",",
"<",
"tt",
">",
"list",
"get",
"(",
"0",
")",
"<",
"tt",
">",
"will",
"be",
"the",
"directory",
"with",
"the",
"most",
"recent",
"modification",
"time",
"if",
"two",
"directories",
"have",
"the",
"same",
"time",
"then",
"the",
"directories",
"will",
"simply",
"be",
"sorted",
"based",
"on",
"their",
"pathnames",
"as",
"a",
"string",
"<",
"b",
">",
"note",
":",
"<",
"b",
">",
"this",
"method",
"ignores",
"test",
"directories"
] | [
"private",
"static",
"list",
"<",
"file",
">",
"get",
"user",
"settings",
"dirs",
"by",
"time",
"(",
")",
"{",
"file",
"user",
"data",
"directory",
"=",
"application",
"get",
"user",
"settings",
"directory",
"(",
")",
";",
"file",
"user",
"data",
"dir",
"parent",
"file",
"=",
"user",
"data",
"directory",
"get",
"parent",
"file",
"(",
")",
";",
"list",
"<",
"file",
">",
"app",
"dirs",
"=",
"collect",
"all",
"application",
"directories",
"(",
"user",
"data",
"dir",
"parent",
"file",
")",
";",
"comparator",
"<",
"file",
">",
"modify",
"time",
"comparator",
"=",
"(",
"f",
"1",
",",
"f",
"2",
")",
"-",
">",
"{",
"/",
"/",
"/",
"/",
"we",
"want",
"to",
"use",
"a",
"real",
"file",
"to",
"tell",
"the",
"last",
"time",
"ghidra",
"was",
"run",
",",
"as",
"we",
"cannot",
"/",
"/",
"trust",
"the",
"directory",
"'",
"s",
"last",
"modified",
"time",
"on",
"all",
"platforms",
"/",
"/",
"file",
"prefs",
"1",
"=",
"new",
"file",
"(",
"f",
"1",
",",
"preferences",
"application",
"preferences",
"filename",
")",
";",
"file",
"prefs",
"2",
"=",
"new",
"file",
"(",
"f",
"2",
",",
"preferences",
"application",
"preferences",
"filename",
")",
";",
"if",
"(",
"!",
"prefs",
"1",
"exists",
"(",
")",
"|",
"|",
"!",
"prefs",
"2",
"exists",
"(",
")",
")",
"{",
"if",
"(",
"!",
"prefs",
"1",
"exists",
"(",
")",
")",
"{",
"if",
"(",
"!",
"prefs",
"2",
"exists",
"(",
")",
")",
"{",
"return",
"0",
";",
"/",
"/",
"neither",
"file",
"exists",
"(",
"user",
"deleted",
"?",
")",
"}",
"return",
"1",
";",
"/",
"/",
"prefs",
"1",
"doesn",
"'",
"t",
"exist",
",",
"but",
"prefs",
"2",
"does",
"-",
"-",
"prefer",
"prefs",
"2",
"}",
"return",
"-",
"1",
";",
"/",
"/",
"prefs",
"1",
"exists",
"-",
"-",
"prefer",
"prefs",
"1",
"}",
"long",
"modify",
"1",
"=",
"prefs",
"1",
"last",
"modified",
"(",
")",
";",
"long",
"modify",
"2",
"=",
"prefs",
"2",
"last",
"modified",
"(",
")",
";",
"if",
"(",
"modify",
"1",
"=",
"=",
"modify",
"2",
")",
"{",
"/",
"/",
"if",
"same",
"time",
",",
"compare",
"parent",
"dir",
"names",
",",
"which",
"contain",
"their",
"version",
"return",
"f",
"1",
"get",
"name",
"(",
")",
"compare",
"to",
"(",
"f",
"2",
"get",
"name",
"(",
")",
")",
";",
"}",
"return",
"(",
"modify",
"1",
"<",
"modify",
"2",
")",
"?",
"1",
":",
"-",
"1",
";",
"}",
";",
"collections",
"sort",
"(",
"app",
"dirs",
",",
"modify",
"time",
"comparator",
")",
";",
"return",
"app",
"dirs",
";",
"}"
] |
[
"return",
"if",
"a",
"c",
"ls",
"are",
"enabled",
"for",
"the",
"map",
"reduce",
"system"
] | [
"boolean",
"are",
"acls",
"enabled",
"(",
")",
"{",
"return",
"are",
"acls",
"enabled",
";",
"}"
] |
[
"returns",
"an",
"instance",
"which",
"specifies",
"that",
"ordering",
"is",
"guaranteed",
"to",
"be",
"always",
"be",
"the",
"same",
"across",
"iterations",
",",
"and",
"across",
"releases",
"some",
"methods",
"may",
"have",
"stronger",
"guarantees",
"this",
"instance",
"is",
"only",
"useful",
"in",
"combination",
"with",
"{",
"@",
"code",
"incident",
"edge",
"order",
"}",
",",
"e",
"g",
"{",
"@",
"code",
"graph",
"builder",
"incident",
"edge",
"order",
"(",
"element",
"order",
"stable",
"(",
")",
")",
"}",
"<",
"h",
"3",
">",
"in",
"combination",
"with",
"{",
"@",
"code",
"incident",
"edge",
"order",
"}",
"<",
"h",
"3",
">",
"{",
"@",
"code",
"incident",
"edge",
"order",
"(",
"element",
"order",
"stable",
"(",
")",
")",
"}",
"guarantees",
"the",
"ordering",
"of",
"the",
"returned",
"collections",
"of",
"the",
"following",
"methods",
":",
"for",
"{",
"@",
"link",
"graph",
"}",
"and",
"{",
"@",
"link",
"value",
"graph",
"}",
":",
"{",
"@",
"code",
"edges",
"(",
")",
"}",
":",
"stable",
"order",
"{",
"@",
"code",
"adjacent",
"nodes",
"(",
"node",
")",
"}",
":",
"connecting",
"edge",
"insertion",
"order",
"{",
"@",
"code",
"predecessors",
"(",
"node",
")",
"}",
":",
"connecting",
"edge",
"insertion",
"order",
"{",
"@",
"code",
"successors",
"(",
"node",
")",
"}",
":",
"connecting",
"edge",
"insertion",
"order",
"{",
"@",
"code",
"incident",
"edges",
"(",
"node",
")",
"}",
":",
"edge",
"insertion",
"order",
"for",
"{",
"@",
"link",
"network",
"}",
":",
"{",
"@",
"code",
"adjacent",
"nodes",
"(",
"node",
")",
"}",
":",
"stable",
"order",
"{",
"@",
"code",
"predecessors",
"(",
"node",
")",
"}",
":",
"connecting",
"edge",
"insertion",
"order",
"{",
"@",
"code",
"successors",
"(",
"node",
")",
"}",
":",
"connecting",
"edge",
"insertion",
"order",
"{",
"@",
"code",
"incident",
"edges",
"(",
"node",
")",
"}",
":",
"stable",
"order",
"{",
"@",
"code",
"in",
"edges",
"(",
"node",
")",
"}",
":",
"edge",
"insertion",
"order",
"{",
"@",
"code",
"out",
"edges",
"(",
"node",
")",
"}",
":",
"edge",
"insertion",
"order",
"{",
"@",
"code",
"adjacent",
"edges",
"(",
"edge",
")",
"}",
":",
"stable",
"order",
"{",
"@",
"code",
"edges",
"connecting",
"(",
"node",
"u",
",",
"node",
"v",
")",
"}",
":",
"edge",
"insertion",
"order"
] | [
"public",
"static",
"<",
"s",
">",
"element",
"order",
"<",
"s",
">",
"stable",
"(",
")",
"{",
"return",
"new",
"element",
"order",
"<",
"s",
">",
"(",
"type",
"stable",
",",
"null",
")",
";",
"}"
] |
[
"model",
"tests",
"for",
"map",
"test"
] | [
"public",
"void",
"test",
"map",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"map",
"test",
"}"
] |
[
"for",
"the",
"purposes",
"of",
"unit",
"tests",
",",
"we",
"want",
"to",
"test",
"login",
"from",
"keytab",
"and",
"don",
"'",
"t",
"want",
"to",
"wait",
"until",
"the",
"renew",
"window",
"(",
"controlled",
"by",
"ticket",
"renew",
"window",
")"
] | [
"public",
"static",
"void",
"set",
"should",
"renew",
"immediately",
"for",
"tests",
"(",
"boolean",
"immediate",
")",
"{",
"should",
"renew",
"immediately",
"for",
"tests",
"=",
"immediate",
";",
"}"
] |
[
"determine",
"if",
"this",
"instance",
"only",
"contains",
"a",
"single",
"attribute",
"named",
"{",
"@",
"code",
"value",
"}"
] | [
"boolean",
"has",
"only",
"value",
"attribute",
"(",
")",
"{",
"return",
"(",
"this",
"attribute",
"methods",
"length",
"=",
"=",
"1",
"&",
"&",
"merged",
"annotation",
"value",
"equals",
"(",
"this",
"attribute",
"methods",
"[",
"0",
"]",
"get",
"name",
"(",
")",
")",
")",
";",
"}"
] |
[
"puts",
"some",
"abstract",
"types",
"of",
"{",
"@",
"link",
"#",
"current",
"frame",
"}",
"in",
"{",
"@",
"link",
"#",
"stack",
"map",
"table",
"entries",
"}",
",",
"using",
"the",
"jvms",
"verification",
"type",
"info",
"format",
"used",
"in",
"stack",
"map",
"table",
"attributes"
] | [
"private",
"void",
"put",
"abstract",
"types",
"(",
"final",
"int",
"start",
",",
"final",
"int",
"end",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"start",
";",
"i",
"<",
"end",
";",
"+",
"+",
"i",
")",
"{",
"frame",
"put",
"abstract",
"type",
"(",
"symbol",
"table",
",",
"current",
"frame",
"[",
"i",
"]",
",",
"stack",
"map",
"table",
"entries",
")",
";",
"}",
"}"
] |
[
"set",
"symlink",
"bytes",
"for",
"this",
"entity",
"(",
"default",
"=",
"null",
")"
] | [
"public",
"builder",
"symlink",
"(",
"byte",
"[",
"]",
"symlink",
")",
"{",
"this",
"symlink",
"=",
"null",
"=",
"=",
"symlink",
"?",
"null",
":",
"arrays",
"copy",
"of",
"(",
"symlink",
",",
"symlink",
"length",
")",
";",
"return",
"this",
";",
"}"
] |
[
"the",
"set",
"of",
"attribute",
"declarations",
"<",
"code",
">",
"repeated",
"aapt",
"pb",
"styleable",
"entry",
"entry",
"=",
"1",
";",
"<",
"code",
">"
] | [
"private",
"void",
"set",
"entry",
"(",
"int",
"index",
",",
"com",
"android",
"aapt",
"resources",
"styleable",
"entry",
"builder",
"builder",
"for",
"value",
")",
"{",
"ensure",
"entry",
"is",
"mutable",
"(",
")",
";",
"entry",
"set",
"(",
"index",
",",
"builder",
"for",
"value",
"build",
"(",
")",
")",
";",
"}"
] |
[
"apply",
"a",
"force",
"to",
"the",
"center",
"of",
"mass",
"this",
"wakes",
"up",
"the",
"body"
] | [
"public",
"void",
"apply",
"force",
"to",
"center",
"(",
"float",
"force",
"x",
",",
"float",
"force",
"y",
",",
"boolean",
"wake",
")",
"{",
"tmp",
"set",
"(",
"force",
"x",
",",
"force",
"y",
")",
";",
"body",
"apply",
"force",
"to",
"center",
"(",
"tmp",
")",
";",
"}"
] |
[
"this",
"is",
"a",
"test",
"-",
"only",
"back",
"door",
"which",
"resets",
"the",
"state",
"and",
"binds",
"to",
"a",
"token",
"again",
"this",
"allows",
"an",
"instance",
"of",
"this",
"class",
"to",
"be",
"bonded",
"to",
"a",
"dt",
"after",
"being",
"started",
",",
"so",
"avoids",
"the",
"need",
"to",
"have",
"the",
"token",
"in",
"the",
"current",
"user",
"credentials",
"it",
"is",
"package",
"scoped",
"so",
"as",
"to",
"only",
"be",
"usable",
"in",
"tests",
"in",
"the",
"same",
"package",
"yes",
",",
"this",
"is",
"ugly",
",",
"but",
"there",
"is",
"no",
"obviouseasy",
"way",
"to",
"test",
"token",
"binding",
"without",
"kerberos",
"getting",
"involved"
] | [
"void",
"reset",
"token",
"binding",
"to",
"d",
"t",
"(",
"final",
"token",
"<",
"abstract",
"s",
"3",
"a",
"token",
"identifier",
">",
"token",
")",
"throws",
"i",
"o",
"exception",
"{",
"credential",
"providers",
"=",
"optional",
"empty",
"(",
")",
";",
"bind",
"to",
"delegation",
"token",
"(",
"token",
")",
";",
"}"
] |
[
"tests",
"that",
"a",
"non",
"existing",
"path",
"throws",
"an",
"exception"
] | [
"public",
"void",
"test",
"get",
"non",
"existing",
"path",
"(",
")",
"throws",
"exception",
"{",
"final",
"testing",
"long",
"state",
"handle",
"helper",
"state",
"handle",
"provider",
"=",
"new",
"testing",
"long",
"state",
"handle",
"helper",
"(",
")",
";",
"zoo",
"keeper",
"state",
"handle",
"store",
"<",
"long",
">",
"store",
"=",
"new",
"zoo",
"keeper",
"state",
"handle",
"store",
"<",
">",
"(",
"zookeeper",
"get",
"client",
"(",
")",
",",
"state",
"handle",
"provider",
")",
";",
"store",
"get",
"and",
"lock",
"(",
"\"",
"/",
"test",
"get",
"non",
"existing",
"path",
"\"",
")",
";",
"}"
] |
[
"is",
"reference",
"bean",
"?"
] | [
"public",
"boolean",
"is",
"reference",
"(",
"object",
"bean",
",",
"string",
"bean",
"name",
")",
"throws",
"framework",
"exception",
"{",
"string",
"bean",
"class",
"name",
"=",
"bean",
"get",
"class",
"(",
")",
"get",
"name",
"(",
")",
";",
"return",
"\"",
"com",
"alipay",
"sofa",
"runtime",
"spring",
"factory",
"reference",
"factory",
"bean",
"\"",
"equals",
"(",
"bean",
"class",
"name",
")",
";",
"}"
] |
[
"recover",
"resource",
"request",
"back",
"from",
"r",
"m",
"container",
"when",
"a",
"container",
"is",
"preempted",
"before",
"am",
"pulled",
"the",
"same",
"if",
"container",
"is",
"pulled",
"by",
"am",
",",
"then",
"r",
"m",
"container",
"will",
"not",
"have",
"resource",
"request",
"to",
"recover"
] | [
"private",
"void",
"recover",
"resource",
"request",
"for",
"container",
"(",
"r",
"m",
"container",
"rm",
"container",
")",
"{",
"container",
"request",
"container",
"request",
"=",
"rm",
"container",
"get",
"container",
"request",
"(",
")",
";",
"/",
"/",
"if",
"container",
"state",
"is",
"moved",
"to",
"acquired",
",",
"request",
"will",
"be",
"empty",
"if",
"(",
"container",
"request",
"=",
"=",
"null",
")",
"{",
"return",
";",
"}",
"/",
"/",
"add",
"resource",
"request",
"back",
"to",
"scheduler",
"application",
"attempt",
"/",
"/",
"we",
"lookup",
"the",
"application",
"-",
"attempt",
"here",
"again",
"using",
"/",
"/",
"get",
"current",
"application",
"attempt",
"(",
")",
"because",
"there",
"is",
"only",
"one",
"app",
"-",
"attempt",
"at",
"/",
"/",
"any",
"point",
"in",
"the",
"scheduler",
"but",
"in",
"corner",
"cases",
",",
"a",
"ms",
"can",
"crash",
",",
"/",
"/",
"corresponding",
"containers",
"get",
"killed",
"and",
"recovered",
"to",
"the",
"same",
"-",
"attempt",
",",
"/",
"/",
"but",
"because",
"the",
"app",
"-",
"attempt",
"is",
"extinguished",
"right",
"after",
",",
"the",
"recovered",
"/",
"/",
"requests",
"don",
"'",
"t",
"serve",
"any",
"purpose",
",",
"but",
"that",
"'",
"s",
"okay",
"scheduler",
"application",
"attempt",
"scheduler",
"attempt",
"=",
"get",
"current",
"attempt",
"for",
"container",
"(",
"rm",
"container",
"get",
"container",
"id",
"(",
")",
")",
";",
"if",
"(",
"scheduler",
"attempt",
"!",
"=",
"null",
")",
"{",
"scheduler",
"attempt",
"recover",
"resource",
"requests",
"for",
"container",
"(",
"container",
"request",
")",
";",
"}",
"}"
] |
[
"shuts",
"down",
"the",
"mini",
"cluster",
",",
"failing",
"all",
"currently",
"executing",
"jobs",
"the",
"mini",
"cluster",
"can",
"be",
"started",
"again",
"by",
"calling",
"the",
"{",
"@",
"link",
"#",
"start",
"(",
")",
"}",
"method",
"again",
"this",
"method",
"shuts",
"down",
"all",
"started",
"services",
"and",
"components",
",",
"even",
"if",
"an",
"exception",
"occurs",
"in",
"the",
"process",
"of",
"shutting",
"down",
"some",
"component"
] | [
"public",
"completable",
"future",
"<",
"void",
">",
"close",
"async",
"(",
")",
"{",
"synchronized",
"(",
"lock",
")",
"{",
"if",
"(",
"running",
")",
"{",
"log",
"info",
"(",
"\"",
"shutting",
"down",
"flink",
"mini",
"cluster",
"\"",
")",
";",
"try",
"{",
"final",
"long",
"shutdown",
"timeout",
"millis",
"=",
"mini",
"cluster",
"configuration",
"get",
"configuration",
"(",
")",
"get",
"long",
"(",
"cluster",
"options",
"cluster",
"services",
"shutdown",
"timeout",
")",
";",
"final",
"int",
"num",
"components",
"=",
"2",
"+",
"mini",
"cluster",
"configuration",
"get",
"num",
"task",
"managers",
"(",
")",
";",
"final",
"collection",
"<",
"completable",
"future",
"<",
"void",
">",
">",
"component",
"termination",
"futures",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"num",
"components",
")",
";",
"component",
"termination",
"futures",
"add",
"all",
"(",
"terminate",
"task",
"managers",
"(",
")",
")",
";",
"component",
"termination",
"futures",
"add",
"(",
"shut",
"down",
"resource",
"manager",
"components",
"(",
")",
")",
";",
"final",
"future",
"utils",
"conjunct",
"future",
"<",
"void",
">",
"components",
"termination",
"future",
"=",
"future",
"utils",
"complete",
"all",
"(",
"component",
"termination",
"futures",
")",
";",
"final",
"completable",
"future",
"<",
"void",
">",
"metric",
"system",
"termination",
"future",
"=",
"future",
"utils",
"compose",
"afterwards",
"(",
"components",
"termination",
"future",
",",
"this",
":",
":",
"close",
"metric",
"system",
")",
";",
"final",
"completable",
"future",
"<",
"void",
">",
"rpc",
"services",
"termination",
"future",
"=",
"future",
"utils",
"compose",
"afterwards",
"(",
"metric",
"system",
"termination",
"future",
",",
"this",
":",
":",
"terminate",
"rpc",
"services",
")",
";",
"final",
"completable",
"future",
"<",
"void",
">",
"remaining",
"services",
"termination",
"future",
"=",
"future",
"utils",
"run",
"afterwards",
"(",
"rpc",
"services",
"termination",
"future",
",",
"this",
":",
":",
"terminate",
"mini",
"cluster",
"services",
")",
";",
"final",
"completable",
"future",
"<",
"void",
">",
"executors",
"termination",
"future",
"=",
"future",
"utils",
"compose",
"afterwards",
"(",
"remaining",
"services",
"termination",
"future",
",",
"(",
")",
"-",
">",
"terminate",
"executors",
"(",
"shutdown",
"timeout",
"millis",
")",
")",
";",
"executors",
"termination",
"future",
"when",
"complete",
"(",
"(",
"void",
"ignored",
",",
"throwable",
"throwable",
")",
"-",
">",
"{",
"if",
"(",
"throwable",
"!",
"=",
"null",
")",
"{",
"termination",
"future",
"complete",
"exceptionally",
"(",
"exception",
"utils",
"strip",
"completion",
"exception",
"(",
"throwable",
")",
")",
";",
"}",
"else",
"{",
"termination",
"future",
"complete",
"(",
"null",
")",
";",
"}",
"}",
")",
";",
"}",
"finally",
"{",
"running",
"=",
"false",
";",
"}",
"}",
"return",
"termination",
"future",
";",
"}",
"}"
] |
[
"returns",
"the",
"byte",
"value",
"of",
"this",
"transport",
"protocol"
] | [
"public",
"byte",
"byte",
"value",
"(",
")",
"{",
"return",
"transport",
"byte",
";",
"}"
] |
[
"get",
"datetime",
"prop"
] | [
"public",
"offset",
"date",
"time",
"get",
"datetime",
"prop",
"(",
")",
"{",
"return",
"datetime",
"prop",
"or",
"else",
"(",
"null",
")",
";",
"}"
] |
[
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"{",
"@",
"code",
"object",
"}",
"is",
"a",
"{",
"@",
"link",
"hash",
"code",
"}",
"instance",
"with",
"the",
"identical",
"byte",
"representation",
"to",
"this",
"hash",
"code",
"<",
"b",
">",
"security",
"note",
":",
"<",
"b",
">",
"this",
"method",
"uses",
"a",
"constant",
"-",
"time",
"(",
"not",
"short",
"-",
"circuiting",
")",
"implementation",
"to",
"protect",
"against",
"<",
"a",
"href",
"=",
"\"",
"http",
":",
"en",
"wikipedia",
"orgwiki",
"timing",
"attack",
"\"",
">",
"timing",
"attacks"
] | [
"public",
"final",
"boolean",
"equals",
"(",
"@",
"nullable",
"decl",
"object",
"object",
")",
"{",
"if",
"(",
"object",
"instanceof",
"hash",
"code",
")",
"{",
"hash",
"code",
"that",
"=",
"(",
"hash",
"code",
")",
"object",
";",
"return",
"bits",
"(",
")",
"=",
"=",
"that",
"bits",
"(",
")",
"&",
"&",
"equals",
"same",
"bits",
"(",
"that",
")",
";",
"}",
"return",
"false",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"breed",
"'"
] | [
"public",
"void",
"breed",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"breed",
"}"
] |
[
"test",
"the",
"property",
"'",
"array",
"enum",
"'"
] | [
"public",
"void",
"array",
"enum",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"array",
"enum",
"}"
] |
[
"clears",
"disk",
"cache"
] | [
"public",
"void",
"clear",
"disk",
"cache",
"(",
")",
"{",
"check",
"configuration",
"(",
")",
";",
"configuration",
"disk",
"cache",
"clear",
"(",
")",
";",
"}"
] |
[
"returns",
"the",
"java",
"command",
"it",
"can",
"use",
"to",
"launch",
"the",
"decompilers"
] | [
"public",
"static",
"synchronized",
"string",
"get",
"java",
"command",
"(",
")",
"{",
"try",
"{",
"sm",
"stop",
"blocking",
"(",
")",
";",
"process",
"builder",
"pb",
"=",
"new",
"process",
"builder",
"(",
"\"",
"java",
"\"",
",",
"\"",
"-",
"version",
"\"",
")",
";",
"process",
"p",
"=",
"pb",
"start",
"(",
")",
";",
"sm",
"set",
"blocking",
"(",
")",
";",
"if",
"(",
"p",
"!",
"=",
"null",
")",
"return",
"\"",
"java",
"\"",
";",
"/",
"/",
"java",
"is",
"set",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"/",
"/",
"ignore",
"sm",
"set",
"blocking",
"(",
")",
";",
"boolean",
"empty",
"=",
"java",
"is",
"empty",
"(",
")",
";",
"while",
"(",
"empty",
")",
"{",
"show",
"message",
"(",
"\"",
"you",
"need",
"to",
"set",
"your",
"java",
"path",
",",
"this",
"requires",
"the",
"jre",
"to",
"be",
"downloaded",
"\"",
"+",
"bytecode",
"viewer",
"nl",
"+",
"\"",
"(",
"c",
":",
"/",
"programfiles",
"/",
"java",
"/",
"jdk",
"xx",
"/",
"bin",
"/",
"java",
"exe",
")",
"\"",
")",
";",
"viewer",
"java",
"(",
")",
";",
"empty",
"=",
"java",
"is",
"empty",
"(",
")",
";",
"}",
"}",
"return",
"java",
";",
"}"
] |
[
"creates",
"an",
"instance",
"of",
"an",
"{",
"@",
"link",
"invalid",
"}",
"validation",
"state"
] | [
"public",
"static",
"validated",
"invalid",
"(",
"validation",
"rule",
"rule",
",",
"string",
"message",
")",
"{",
"return",
"new",
"invalid",
"(",
"rule",
",",
"message",
")",
";",
"}"
] |
[
"illustrates",
"the",
"somewhat",
"bizarre",
"behavior",
"when",
"a",
"null",
"is",
"passed",
"in"
] | [
"public",
"void",
"test",
"concat",
"containing",
"null",
"(",
")",
"{",
"@",
"suppress",
"warnings",
"(",
"\"",
"unchecked",
"\"",
")",
"iterator",
"<",
"iterator",
"<",
"integer",
">",
">",
"input",
"=",
"as",
"list",
"(",
"iterate",
"over",
"(",
"1",
",",
"2",
")",
",",
"null",
",",
"iterate",
"over",
"(",
"3",
")",
")",
"iterator",
"(",
")",
";",
"iterator",
"<",
"integer",
">",
"result",
"=",
"iterators",
"concat",
"(",
"input",
")",
";",
"assert",
"equals",
"(",
"1",
",",
"(",
"int",
")",
"result",
"next",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"2",
",",
"(",
"int",
")",
"result",
"next",
"(",
")",
")",
";",
"try",
"{",
"result",
"has",
"next",
"(",
")",
";",
"fail",
"(",
"\"",
"no",
"exception",
"thrown",
"\"",
")",
";",
"}",
"catch",
"(",
"null",
"pointer",
"exception",
"e",
")",
"{",
"}",
"try",
"{",
"result",
"next",
"(",
")",
";",
"fail",
"(",
"\"",
"no",
"exception",
"thrown",
"\"",
")",
";",
"}",
"catch",
"(",
"null",
"pointer",
"exception",
"e",
")",
"{",
"}",
"/",
"/",
"there",
"is",
"no",
"way",
"to",
"get",
"\"",
"through",
"\"",
"to",
"the",
"3",
"buh",
"-",
"bye",
"}"
] |
[
"indicates",
"whether",
"{",
"@",
"code",
"buffered",
"input",
"stream",
"}",
"supports",
"the",
"{",
"@",
"link",
"#",
"mark",
"(",
"int",
")",
"}",
"and",
"{",
"@",
"link",
"#",
"reset",
"(",
")",
"}",
"methods"
] | [
"public",
"boolean",
"mark",
"supported",
"(",
")",
"{",
"return",
"true",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"declawed",
"'"
] | [
"public",
"void",
"declawed",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"declawed",
"}"
] |
[
"default",
":",
"true",
"when",
"true",
",",
"we",
"skip",
"fsync",
"(",
")",
"calls",
"for",
"speed",
"improvements"
] | [
"public",
"builder",
"skip",
"fsync",
"for",
"testing",
"(",
"boolean",
"val",
")",
"{",
"this",
"skip",
"fsync",
"for",
"testing",
"=",
"val",
";",
"return",
"this",
";",
"}"
] |
[
"tests",
"that",
"the",
"kryo",
"output",
"buffer",
"is",
"cleared",
"in",
"case",
"of",
"an",
"exception",
"flink",
"uses",
"the",
"e",
"o",
"f",
"exception",
"to",
"signal",
"that",
"a",
"buffer",
"is",
"full",
"in",
"such",
"a",
"case",
",",
"the",
"record",
"which",
"was",
"tried",
"to",
"be",
"written",
"will",
"be",
"rewritten",
"therefore",
",",
"eventually",
"buffered",
"data",
"of",
"this",
"record",
"has",
"to",
"be",
"cleared"
] | [
"public",
"void",
"test",
"output",
"buffered",
"being",
"cleared",
"in",
"case",
"of",
"exception",
"(",
")",
"throws",
"exception",
"{",
"execution",
"config",
"execution",
"config",
"=",
"new",
"execution",
"config",
"(",
")",
";",
"execution",
"config",
"register",
"type",
"with",
"kryo",
"serializer",
"(",
"test",
"record",
"class",
",",
"new",
"test",
"record",
"serializer",
"(",
")",
")",
";",
"execution",
"config",
"register",
"kryo",
"type",
"(",
"test",
"record",
"class",
")",
";",
"kryo",
"serializer",
"<",
"test",
"record",
">",
"kryo",
"serializer",
"=",
"new",
"kryo",
"serializer",
"<",
"test",
"record",
">",
"(",
"test",
"record",
"class",
",",
"execution",
"config",
")",
";",
"int",
"size",
"=",
"94",
";",
"int",
"buffer",
"size",
"=",
"150",
";",
"test",
"record",
"test",
"record",
"=",
"new",
"test",
"record",
"(",
"size",
")",
";",
"test",
"data",
"output",
"view",
"target",
"=",
"new",
"test",
"data",
"output",
"view",
"(",
"buffer",
"size",
")",
";",
"kryo",
"serializer",
"serialize",
"(",
"test",
"record",
",",
"target",
")",
";",
"try",
"{",
"kryo",
"serializer",
"serialize",
"(",
"test",
"record",
",",
"target",
")",
";",
"assert",
"fail",
"(",
"\"",
"expected",
"an",
"e",
"o",
"f",
"exception",
"\"",
")",
";",
"}",
"catch",
"(",
"e",
"o",
"f",
"exception",
"eof",
"exception",
")",
"{",
"/",
"/",
"expected",
"exception",
"/",
"/",
"now",
"the",
"kryo",
"output",
"should",
"have",
"been",
"cleared",
"}",
"test",
"record",
"actual",
"record",
"=",
"kryo",
"serializer",
"deserialize",
"(",
"new",
"data",
"input",
"view",
"stream",
"wrapper",
"(",
"new",
"byte",
"array",
"input",
"stream",
"(",
"target",
"get",
"buffer",
"(",
")",
")",
")",
")",
";",
"assert",
"assert",
"equals",
"(",
"test",
"record",
",",
"actual",
"record",
")",
";",
"target",
"clear",
"(",
")",
";",
"/",
"/",
"if",
"the",
"kryo",
"output",
"has",
"been",
"cleared",
"then",
"we",
"can",
"serialize",
"our",
"test",
"record",
"into",
"the",
"target",
"/",
"/",
"because",
"the",
"target",
"buffer",
"150",
"bytes",
"can",
"host",
"one",
"test",
"record",
"(",
"total",
"serialization",
"size",
"/",
"/",
"100",
")",
"kryo",
"serializer",
"serialize",
"(",
"test",
"record",
",",
"target",
")",
";",
"byte",
"[",
"]",
"buffer",
"=",
"target",
"get",
"buffer",
"(",
")",
";",
"int",
"counter",
"=",
"0",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"buffer",
"length",
";",
"i",
"+",
"+",
")",
"{",
"if",
"(",
"buffer",
"[",
"i",
"]",
"=",
"=",
"42",
")",
"{",
"counter",
"+",
"+",
";",
"}",
"}",
"assert",
"assert",
"equals",
"(",
"size",
",",
"counter",
")",
";",
"}"
] |
[
"sets",
"the",
"<",
"code",
">",
"name",
"integer",
"<",
"code",
">",
"property"
] | [
"public",
"void",
"set",
"name",
"integer",
"(",
"integer",
"name",
"integer",
")",
"{",
"this",
"name",
"integer",
"=",
"name",
"integer",
";",
"}"
] |
[
"returns",
"whether",
"the",
"flag",
"{",
"@",
"code",
"acc",
"enum",
"}",
"is",
"on",
"in",
"the",
"given",
"flags"
] | [
"public",
"static",
"boolean",
"is",
"enum",
"(",
"int",
"flags",
")",
"{",
"return",
"(",
"flags",
"&",
"acc",
"enum",
")",
"!",
"=",
"0",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"kind",
"'"
] | [
"public",
"void",
"kind",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"kind",
"}"
] |
[
"this",
"command",
"uses",
"post",
"(",
"probably",
"to",
"allow",
"for",
"larger",
"parameters",
")",
"but",
"does",
"not",
"actually",
"modify",
"any",
"state",
"so",
"we",
"do",
"not",
"add",
"csrf",
"protection",
"to",
"it"
] | [
"public",
"void",
"do",
"post",
"(",
"http",
"servlet",
"request",
"request",
",",
"http",
"servlet",
"response",
"response",
")",
"throws",
"servlet",
"exception",
",",
"i",
"o",
"exception",
"{",
"try",
"{",
"long",
"start",
"=",
"system",
"current",
"time",
"millis",
"(",
")",
";",
"project",
"project",
"=",
"get",
"project",
"(",
"request",
")",
";",
"engine",
"engine",
"=",
"get",
"engine",
"(",
"request",
",",
"project",
")",
";",
"string",
"clusterer",
"conf",
"=",
"request",
"get",
"parameter",
"(",
"\"",
"clusterer",
"\"",
")",
";",
"clusterer",
"config",
"clusterer",
"config",
"=",
"parsing",
"utilities",
"mapper",
"read",
"value",
"(",
"clusterer",
"conf",
",",
"clusterer",
"config",
"class",
")",
";",
"clusterer",
"clusterer",
"=",
"clusterer",
"config",
"apply",
"(",
"project",
")",
";",
"clusterer",
"compute",
"clusters",
"(",
"engine",
")",
";",
"respond",
"j",
"s",
"o",
"n",
"(",
"response",
",",
"clusterer",
")",
";",
"logger",
"info",
"(",
"\"",
"computed",
"clusters",
"[",
"{",
"}",
"]",
"in",
"{",
"}",
"ms",
"\"",
",",
"new",
"object",
"[",
"]",
"{",
"clusterer",
"config",
"get",
"type",
"(",
")",
",",
"long",
"to",
"string",
"(",
"system",
"current",
"time",
"millis",
"(",
")",
"-",
"start",
")",
"}",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"respond",
"exception",
"(",
"response",
",",
"e",
")",
";",
"}",
"}"
] |
[
"get",
"local",
"address"
] | [
"public",
"inet",
"socket",
"address",
"get",
"local",
"address",
"(",
")",
"{",
"return",
"new",
"rpc",
"context",
"get",
"local",
"address",
"(",
")",
";",
"}"
] |
[
"print",
"a",
"message",
"as",
"an",
"warning"
] | [
"private",
"void",
"warn",
"(",
"string",
"category",
",",
"string",
"message",
",",
"object",
"args",
")",
"{",
"println",
"(",
"\"",
"warning",
":",
"%",
"s",
":",
"%",
"s",
"\"",
",",
"category",
",",
"string",
"format",
"(",
"message",
",",
"args",
")",
")",
";",
"}"
] |
[
"launches",
"a",
"single",
"html",
"selenium",
"test",
"suite"
] | [
"public",
"string",
"run",
"h",
"t",
"m",
"l",
"suite",
"(",
"string",
"browser",
",",
"string",
"start",
"u",
"r",
"l",
",",
"string",
"suite",
"u",
"r",
"l",
",",
"file",
"output",
"file",
",",
"long",
"timeout",
"in",
"seconds",
",",
"string",
"user",
"extensions",
")",
"throws",
"i",
"o",
"exception",
"{",
"file",
"parent",
"=",
"output",
"file",
"get",
"parent",
"file",
"(",
")",
";",
"if",
"(",
"parent",
"!",
"=",
"null",
"&",
"&",
"!",
"parent",
"exists",
"(",
")",
")",
"{",
"if",
"(",
"!",
"parent",
"mkdirs",
"(",
")",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"unable",
"to",
"create",
"directory",
"to",
"store",
"outputs",
":",
"\"",
"+",
"parent",
")",
";",
"}",
"}",
"if",
"(",
"output",
"file",
"exists",
"(",
")",
"&",
"&",
"!",
"output",
"file",
"can",
"write",
"(",
")",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"can",
"'",
"t",
"write",
"to",
"output",
"file",
":",
"\"",
"+",
"output",
"file",
"get",
"absolute",
"path",
"(",
")",
")",
";",
"}",
"long",
"timeout",
"in",
"ms",
"=",
"1000l",
"*",
"timeout",
"in",
"seconds",
";",
"if",
"(",
"timeout",
"in",
"ms",
"<",
"0",
")",
"{",
"log",
"warning",
"(",
"\"",
"looks",
"like",
"the",
"timeout",
"overflowed",
",",
"so",
"resetting",
"it",
"to",
"the",
"maximum",
"\"",
")",
";",
"timeout",
"in",
"ms",
"=",
"long",
"max",
"value",
";",
"}",
"web",
"driver",
"driver",
"=",
"null",
";",
"try",
"{",
"driver",
"=",
"create",
"driver",
"(",
"browser",
")",
";",
"url",
"suite",
"url",
"=",
"determine",
"suite",
"url",
"(",
"start",
"u",
"r",
"l",
",",
"suite",
"u",
"r",
"l",
")",
";",
"driver",
"get",
"(",
"suite",
"url",
"to",
"string",
"(",
")",
")",
";",
"selenium",
"selenium",
"=",
"new",
"web",
"driver",
"backed",
"selenium",
"(",
"driver",
",",
"start",
"u",
"r",
"l",
")",
";",
"selenium",
"set",
"timeout",
"(",
"string",
"value",
"of",
"(",
"timeout",
"in",
"ms",
")",
")",
";",
"if",
"(",
"user",
"extensions",
"!",
"=",
"null",
")",
"{",
"selenium",
"set",
"extension",
"js",
"(",
"user",
"extensions",
")",
";",
"}",
"list",
"<",
"web",
"element",
">",
"all",
"tables",
"=",
"driver",
"find",
"elements",
"(",
"by",
"id",
"(",
"\"",
"suite",
"table",
"\"",
")",
")",
";",
"if",
"(",
"all",
"tables",
"is",
"empty",
"(",
")",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"unable",
"to",
"find",
"suite",
"table",
":",
"\"",
"+",
"driver",
"get",
"page",
"source",
"(",
")",
")",
";",
"}",
"results",
"results",
"=",
"new",
"core",
"test",
"suite",
"(",
"suite",
"url",
"to",
"string",
"(",
")",
")",
"run",
"(",
"driver",
",",
"selenium",
",",
"new",
"url",
"(",
"start",
"u",
"r",
"l",
")",
")",
";",
"h",
"t",
"m",
"l",
"test",
"results",
"html",
"results",
"=",
"results",
"to",
"suite",
"result",
"(",
")",
";",
"try",
"(",
"writer",
"writer",
"=",
"files",
"new",
"buffered",
"writer",
"(",
"output",
"file",
"to",
"path",
"(",
")",
")",
")",
"{",
"html",
"results",
"write",
"(",
"writer",
")",
";",
"}",
"return",
"results",
"is",
"successful",
"(",
")",
"?",
"\"",
"passed",
"\"",
":",
"\"",
"failed",
"\"",
";",
"}",
"finally",
"{",
"if",
"(",
"server",
"!",
"=",
"null",
")",
"{",
"try",
"{",
"server",
"stop",
"(",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"/",
"/",
"nothing",
"sane",
"to",
"do",
"log",
"the",
"error",
"and",
"carry",
"on",
"log",
"log",
"(",
"level",
"info",
",",
"\"",
"exception",
"shutting",
"down",
"server",
"you",
"may",
"ignore",
"this",
"\"",
",",
"e",
")",
";",
"}",
"}",
"if",
"(",
"driver",
"!",
"=",
"null",
")",
"{",
"driver",
"quit",
"(",
")",
";",
"}",
"}",
"}"
] |
[
"test",
"a",
"command",
"execution",
"timeout",
"where",
"the",
"command",
"implemented",
"get",
"fallback"
] | [
"public",
"void",
"test",
"execution",
"timeout",
"with",
"fallback",
"using",
"semaphore",
"isolation",
"(",
")",
"{",
"test",
"hystrix",
"observable",
"command",
"<",
"integer",
">",
"command",
"=",
"get",
"command",
"(",
"execution",
"isolation",
"strategy",
"semaphore",
",",
"abstract",
"test",
"hystrix",
"command",
"execution",
"result",
"success",
",",
"200",
",",
"abstract",
"test",
"hystrix",
"command",
"fallback",
"result",
"success",
",",
"50",
")",
";",
"try",
"{",
"assert",
"equals",
"(",
"flexible",
"test",
"hystrix",
"observable",
"command",
"fallback",
"value",
",",
"command",
"observe",
"(",
")",
"to",
"blocking",
"(",
")",
"single",
"(",
")",
")",
";",
"/",
"/",
"the",
"time",
"should",
"be",
"50",
"+",
"since",
"we",
"timeout",
"at",
"5",
"0ms",
"assert",
"true",
"(",
"\"",
"execution",
"time",
"is",
":",
"\"",
"+",
"command",
"get",
"execution",
"time",
"in",
"milliseconds",
"(",
")",
",",
"command",
"get",
"execution",
"time",
"in",
"milliseconds",
"(",
")",
">",
"=",
"50",
")",
";",
"assert",
"true",
"(",
"command",
"is",
"response",
"timed",
"out",
"(",
")",
")",
";",
"assert",
"true",
"(",
"command",
"is",
"response",
"from",
"fallback",
"(",
")",
")",
";",
"assert",
"not",
"null",
"(",
"command",
"get",
"execution",
"exception",
"(",
")",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"e",
"print",
"stack",
"trace",
"(",
")",
";",
"fail",
"(",
"\"",
"we",
"should",
"have",
"received",
"a",
"response",
"from",
"the",
"fallback",
"\"",
")",
";",
"}",
"assert",
"command",
"execution",
"events",
"(",
"command",
",",
"hystrix",
"event",
"type",
"timeout",
",",
"hystrix",
"event",
"type",
"fallback",
"emit",
",",
"hystrix",
"event",
"type",
"fallback",
"success",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"command",
"metrics",
"get",
"current",
"concurrent",
"execution",
"count",
"(",
")",
")",
";",
"assert",
"sane",
"hystrix",
"request",
"log",
"(",
"1",
")",
";",
"/",
"/",
"semaphore",
"isolated",
"assert",
"false",
"(",
"command",
"is",
"executed",
"in",
"thread",
"(",
")",
")",
";",
"}"
] |
[
"return",
"an",
"iterable",
"of",
"sky",
"keys",
"corresponding",
"to",
"the",
"aspect",
"-",
"related",
"dependencies",
"of",
"target",
"this",
"method",
"may",
"return",
"a",
"precise",
"set",
"of",
"aspect",
"keys",
",",
"but",
"may",
"need",
"to",
"request",
"additional",
"dependencies",
"from",
"the",
"env",
"to",
"do",
"so"
] | [
"private",
"iterable",
"<",
"sky",
"key",
">",
"get",
"strict",
"label",
"aspect",
"keys",
"(",
"target",
"target",
",",
"map",
"<",
"sky",
"key",
",",
"value",
"or",
"exception",
"2",
"<",
"no",
"such",
"package",
"exception",
",",
"no",
"such",
"target",
"exception",
">",
">",
"dep",
"map",
",",
"environment",
"env",
")",
"throws",
"interrupted",
"exception",
"{",
"if",
"(",
"!",
"(",
"target",
"instanceof",
"rule",
")",
")",
"{",
"/",
"/",
"aspects",
"can",
"be",
"declared",
"only",
"for",
"rules",
"return",
"immutable",
"list",
"of",
"(",
")",
";",
"}",
"rule",
"rule",
"=",
"(",
"rule",
")",
"target",
";",
"if",
"(",
"!",
"rule",
"has",
"aspects",
"(",
")",
")",
"{",
"return",
"immutable",
"list",
"of",
"(",
")",
";",
"}",
"list",
"<",
"sky",
"key",
">",
"dep",
"keys",
"=",
"lists",
"new",
"array",
"list",
"(",
")",
";",
"multimap",
"<",
"attribute",
",",
"label",
">",
"transitions",
"=",
"rule",
"get",
"transitions",
"(",
"dependency",
"filter",
"no",
"nodep",
"attributes",
")",
";",
"for",
"(",
"attribute",
"attribute",
":",
"transitions",
"key",
"set",
"(",
")",
")",
"{",
"for",
"(",
"aspect",
"aspect",
":",
"attribute",
"get",
"aspects",
"(",
"rule",
")",
")",
"{",
"if",
"(",
"has",
"dep",
"that",
"satisfies",
"(",
"aspect",
",",
"transitions",
"get",
"(",
"attribute",
")",
",",
"dep",
"map",
",",
"env",
")",
")",
"{",
"aspect",
"definition",
"for",
"each",
"label",
"dep",
"from",
"all",
"attributes",
"of",
"aspect",
"(",
"rule",
",",
"aspect",
",",
"dependency",
"filter",
"all",
"deps",
",",
"(",
"aspect",
"attribute",
",",
"aspect",
"label",
")",
"-",
">",
"dep",
"keys",
"add",
"(",
"get",
"key",
"(",
"aspect",
"label",
")",
")",
")",
";",
"}",
"}",
"}",
"return",
"dep",
"keys",
";",
"}"
] |
[
"model",
"tests",
"for",
"class",
"model"
] | [
"public",
"void",
"test",
"class",
"model",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"class",
"model",
"}"
] |
[
"starts",
"an",
"instance",
"of",
"data",
"node"
] | [
"public",
"void",
"start",
"up",
"(",
")",
"throws",
"i",
"o",
"exception",
",",
"u",
"r",
"i",
"syntax",
"exception",
"{",
"tear",
"down",
"done",
"=",
"false",
";",
"conf",
"=",
"new",
"hdfs",
"configuration",
"(",
")",
";",
"conf",
"set",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"datanode",
"data",
"dir",
"key",
",",
"data",
"dir",
")",
";",
"conf",
"set",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"datanode",
"address",
"key",
",",
"\"",
"0",
"0",
"0",
"0",
":",
"0",
"\"",
")",
";",
"conf",
"set",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"datanode",
"http",
"address",
"key",
",",
"\"",
"0",
"0",
"0",
"0",
":",
"0",
"\"",
")",
";",
"conf",
"set",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"datanode",
"ipc",
"address",
"key",
",",
"\"",
"0",
"0",
"0",
"0",
":",
"0",
"\"",
")",
";",
"if",
"(",
"current",
"test",
"name",
"get",
"method",
"name",
"(",
")",
"contains",
"(",
"\"",
"does",
"not",
"hold",
"lock",
"\"",
")",
")",
"{",
"/",
"/",
"this",
"test",
"requires",
"a",
"very",
"long",
"value",
"for",
"the",
"xceiver",
"stop",
"timeout",
"conf",
"set",
"long",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"datanode",
"xceiver",
"stop",
"timeout",
"millis",
"key",
",",
"test",
"stop",
"worker",
"xceiver",
"stop",
"timeout",
"millis",
")",
";",
"}",
"conf",
"set",
"int",
"(",
"common",
"configuration",
"keys",
"ipc",
"client",
"connect",
"max",
"retries",
"key",
",",
"0",
")",
";",
"file",
"system",
"set",
"default",
"uri",
"(",
"conf",
",",
"\"",
"hdfs",
":",
"/",
"/",
"\"",
"+",
"nn",
"addr",
"get",
"host",
"name",
"(",
")",
"+",
"\"",
":",
"\"",
"+",
"nn",
"addr",
"get",
"port",
"(",
")",
")",
";",
"array",
"list",
"<",
"storage",
"location",
">",
"locations",
"=",
"new",
"array",
"list",
"<",
"storage",
"location",
">",
"(",
")",
";",
"file",
"data",
"dir",
"=",
"new",
"file",
"(",
"data",
"dir",
")",
";",
"file",
"util",
"fully",
"delete",
"(",
"data",
"dir",
")",
";",
"data",
"dir",
"mkdirs",
"(",
")",
";",
"storage",
"location",
"location",
"=",
"storage",
"location",
"parse",
"(",
"data",
"dir",
"get",
"path",
"(",
")",
")",
";",
"locations",
"add",
"(",
"location",
")",
";",
"final",
"datanode",
"protocol",
"client",
"side",
"translator",
"p",
"b",
"namenode",
"=",
"mock",
"(",
"datanode",
"protocol",
"client",
"side",
"translator",
"p",
"b",
"class",
")",
";",
"mockito",
"do",
"answer",
"(",
"new",
"answer",
"<",
"datanode",
"registration",
">",
"(",
")",
"{",
"@",
"override",
"public",
"datanode",
"registration",
"answer",
"(",
"invocation",
"on",
"mock",
"invocation",
")",
"throws",
"throwable",
"{",
"return",
"(",
"datanode",
"registration",
")",
"invocation",
"get",
"arguments",
"(",
")",
"[",
"0",
"]",
";",
"}",
"}",
")",
"when",
"(",
"namenode",
")",
"register",
"datanode",
"(",
"mockito",
"any",
"(",
"datanode",
"registration",
"class",
")",
")",
";",
"when",
"(",
"namenode",
"version",
"request",
"(",
")",
")",
"then",
"return",
"(",
"new",
"namespace",
"info",
"(",
"1",
",",
"cluster",
"id",
",",
"pool",
"id",
",",
"1l",
")",
")",
";",
"when",
"(",
"namenode",
"send",
"heartbeat",
"(",
"mockito",
"any",
"(",
")",
",",
"mockito",
"any",
"(",
")",
",",
"mockito",
"any",
"long",
"(",
")",
",",
"mockito",
"any",
"long",
"(",
")",
",",
"mockito",
"any",
"int",
"(",
")",
",",
"mockito",
"any",
"int",
"(",
")",
",",
"mockito",
"any",
"int",
"(",
")",
",",
"mockito",
"any",
"(",
")",
",",
"mockito",
"any",
"boolean",
"(",
")",
",",
"mockito",
"any",
"(",
")",
",",
"mockito",
"any",
"(",
")",
")",
")",
"then",
"return",
"(",
"new",
"heartbeat",
"response",
"(",
"new",
"datanode",
"command",
"[",
"0",
"]",
",",
"new",
"n",
"n",
"h",
"a",
"status",
"heartbeat",
"(",
"h",
"a",
"service",
"state",
"active",
",",
"1",
")",
",",
"null",
",",
"thread",
"local",
"random",
"current",
"(",
")",
"next",
"long",
"(",
")",
"|",
"1l",
")",
")",
";",
"dn",
"=",
"new",
"data",
"node",
"(",
"conf",
",",
"locations",
",",
"null",
",",
"null",
")",
"{",
"@",
"override",
"datanode",
"protocol",
"client",
"side",
"translator",
"p",
"b",
"connect",
"to",
"n",
"n",
"(",
"inet",
"socket",
"address",
"nn",
"addr",
")",
"throws",
"i",
"o",
"exception",
"{",
"assert",
"assert",
"equals",
"(",
"nn",
"addr",
",",
"nn",
"addr",
")",
";",
"return",
"namenode",
";",
"}",
"}",
";",
"/",
"/",
"trigger",
"a",
"heartbeat",
"so",
"that",
"it",
"acknowledges",
"the",
"nn",
"as",
"active",
"dn",
"get",
"all",
"bp",
"os",
"(",
")",
"get",
"(",
"0",
")",
"trigger",
"heartbeat",
"for",
"tests",
"(",
")",
";",
"wait",
"for",
"active",
"n",
"n",
"(",
")",
";",
"spy",
"d",
"n",
"=",
"spy",
"(",
"dn",
")",
";",
"recovery",
"worker",
"=",
"new",
"block",
"recovery",
"worker",
"(",
"spy",
"d",
"n",
")",
";",
"}"
] |
[
"sets",
"the",
"number",
"of",
"audio",
"frames",
"to",
"trim",
"from",
"the",
"start",
"and",
"end",
"of",
"audio",
"passed",
"to",
"this",
"processor",
"after",
"calling",
"this",
"method",
",",
"call",
"{",
"@",
"link",
"#",
"configure",
"(",
"audio",
"format",
")",
"}",
"to",
"apply",
"the",
"new",
"trimming",
"frame",
"counts"
] | [
"public",
"void",
"set",
"trim",
"frame",
"count",
"(",
"int",
"trim",
"start",
"frames",
",",
"int",
"trim",
"end",
"frames",
")",
"{",
"this",
"trim",
"start",
"frames",
"=",
"trim",
"start",
"frames",
";",
"this",
"trim",
"end",
"frames",
"=",
"trim",
"end",
"frames",
";",
"}"
] |
[
"replace",
"an",
"inode",
"of",
"the",
"given",
"i",
"nodes",
"in",
"path",
"in",
"the",
"given",
"position",
"we",
"do",
"a",
"deep",
"copy",
"of",
"the",
"i",
"node",
"array"
] | [
"public",
"static",
"i",
"nodes",
"in",
"path",
"replace",
"(",
"i",
"nodes",
"in",
"path",
"iip",
",",
"int",
"pos",
",",
"i",
"node",
"inode",
")",
"{",
"preconditions",
"check",
"argument",
"(",
"iip",
"length",
"(",
")",
">",
"0",
"&",
"&",
"pos",
">",
"0",
"/",
"/",
"no",
"for",
"root",
"&",
"&",
"pos",
"<",
"iip",
"length",
"(",
")",
")",
";",
"if",
"(",
"iip",
"get",
"i",
"node",
"(",
"pos",
")",
"=",
"=",
"null",
")",
"{",
"preconditions",
"check",
"state",
"(",
"iip",
"get",
"i",
"node",
"(",
"pos",
"-",
"1",
")",
"!",
"=",
"null",
")",
";",
"}",
"i",
"node",
"[",
"]",
"inodes",
"=",
"new",
"i",
"node",
"[",
"iip",
"inodes",
"length",
"]",
";",
"system",
"arraycopy",
"(",
"iip",
"inodes",
",",
"0",
",",
"inodes",
",",
"0",
",",
"inodes",
"length",
")",
";",
"inodes",
"[",
"pos",
"]",
"=",
"inode",
";",
"return",
"new",
"i",
"nodes",
"in",
"path",
"(",
"inodes",
",",
"iip",
"path",
",",
"iip",
"is",
"raw",
",",
"iip",
"is",
"snapshot",
",",
"iip",
"snapshot",
"id",
")",
";",
"}"
] |
[
"check",
"that",
"no",
"edits",
"files",
"are",
"present",
"in",
"the",
"given",
"storage",
"dirs"
] | [
"private",
"void",
"assert",
"no",
"edit",
"files",
"(",
"iterable",
"<",
"uri",
">",
"dirs",
")",
"throws",
"i",
"o",
"exception",
"{",
"assert",
"edit",
"files",
"(",
"dirs",
",",
"new",
"string",
"[",
"]",
"{",
"}",
")",
";",
"}"
] |
[
"<",
"code",
">",
"optional",
"string",
"value",
"=",
"1",
";",
"<",
"code",
">"
] | [
"private",
"void",
"set",
"value",
"bytes",
"(",
"com",
"google",
"protobuf",
"byte",
"string",
"value",
")",
"{",
"if",
"(",
"value",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"null",
"pointer",
"exception",
"(",
")",
";",
"}",
"bit",
"field",
"0",
"|",
"=",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"1",
";",
"value",
"=",
"value",
"to",
"string",
"utf",
"8",
"(",
")",
";",
"}"
] |
[
"report",
"1",
"byte",
"read"
] | [
"public",
"int",
"read",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"int",
"read",
"=",
"in",
"read",
"(",
")",
";",
"data",
"counts",
"reporter",
"report",
"bytes",
"read",
"(",
"read",
"<",
"0",
"?",
"0",
":",
"1",
")",
";",
"current",
"position",
"+",
"=",
"read",
"<",
"0",
"?",
"0",
":",
"1",
";",
"return",
"read",
";",
"}"
] |
[
"obtains",
"a",
"byte",
"buffer",
"at",
"a",
"given",
"offset"
] | [
"private",
"byte",
"buffer",
"get",
"data",
"(",
"long",
"offset",
",",
"int",
"size",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"buffered",
"file",
"get",
"buffer",
"(",
"offset",
",",
"size",
")",
"order",
"(",
"byte",
"order",
"little",
"endian",
")",
";",
"}"
] |
[
"test",
"that",
"program",
"diff",
"recognizes",
"that",
"the",
"2",
"programs",
"have",
"the",
"same",
"address",
"spaces"
] | [
"public",
"void",
"test",
"compare",
"same",
"address",
"spaces",
"(",
")",
"throws",
"exception",
"{",
"program",
"builder",
"1",
"create",
"memory",
"(",
"\"",
"d",
"1",
"\"",
",",
"\"",
"0x",
"1",
"0",
"0",
"\"",
",",
"0x",
"1",
"0",
"0",
",",
"null",
",",
"(",
"byte",
")",
"0x",
"a",
"c",
")",
";",
"program",
"builder",
"1",
"create",
"memory",
"(",
"\"",
"d",
"2",
"\"",
",",
"\"",
"0x",
"2",
"0",
"0",
"\"",
",",
"0x",
"1",
"0",
"0",
")",
";",
"program",
"builder",
"2",
"create",
"memory",
"(",
"\"",
"d",
"1",
"\"",
",",
"\"",
"0x",
"1",
"0",
"0",
"\"",
",",
"0x",
"1",
"0",
"0",
",",
"null",
",",
"(",
"byte",
")",
"0x",
"a",
"f",
")",
";",
"program",
"builder",
"2",
"create",
"memory",
"(",
"\"",
"d",
"4",
"\"",
",",
"\"",
"0x",
"4",
"0",
"0",
"\"",
",",
"0x",
"1",
"0",
"0",
")",
";",
"try",
"{",
"program",
"diff",
"=",
"new",
"program",
"diff",
"(",
"p",
"1",
",",
"p",
"2",
")",
";",
"}",
"catch",
"(",
"program",
"conflict",
"exception",
"e",
")",
"{",
"assert",
"fail",
"(",
"\"",
"address",
"spaces",
"in",
"program",
"1",
"and",
"program",
"2",
"should",
"have",
"been",
"the",
"same",
"\"",
")",
";",
"}",
"}"
] |
[
"returns",
"an",
"immutable",
"sorted",
"set",
"containing",
"the",
"elements",
"of",
"a",
"sorted",
"set",
",",
"sorted",
"by",
"the",
"same",
"{",
"@",
"code",
"comparator",
"}",
"that",
"behavior",
"differs",
"from",
"{",
"@",
"link",
"#",
"copy",
"of",
"(",
"iterable",
")",
"}",
",",
"which",
"always",
"uses",
"the",
"natural",
"ordering",
"of",
"the",
"elements",
"despite",
"the",
"method",
"name",
",",
"this",
"method",
"attempts",
"to",
"avoid",
"actually",
"copying",
"the",
"data",
"when",
"it",
"is",
"safe",
"to",
"do",
"so",
"the",
"exact",
"circumstances",
"under",
"which",
"a",
"copy",
"will",
"or",
"will",
"not",
"be",
"performed",
"are",
"undocumented",
"and",
"subject",
"to",
"change",
"this",
"method",
"is",
"safe",
"to",
"use",
"even",
"when",
"{",
"@",
"code",
"sorted",
"set",
"}",
"is",
"a",
"synchronized",
"or",
"concurrent",
"collection",
"that",
"is",
"currently",
"being",
"modified",
"by",
"another",
"thread"
] | [
"public",
"static",
"<",
"e",
">",
"immutable",
"sorted",
"set",
"<",
"e",
">",
"copy",
"of",
"sorted",
"(",
"sorted",
"set",
"<",
"e",
">",
"sorted",
"set",
")",
"{",
"comparator",
"<",
"?",
"super",
"e",
">",
"comparator",
"=",
"sorted",
"iterables",
"comparator",
"(",
"sorted",
"set",
")",
";",
"immutable",
"list",
"<",
"e",
">",
"list",
"=",
"immutable",
"list",
"copy",
"of",
"(",
"sorted",
"set",
")",
";",
"if",
"(",
"list",
"is",
"empty",
"(",
")",
")",
"{",
"return",
"empty",
"set",
"(",
"comparator",
")",
";",
"}",
"else",
"{",
"return",
"new",
"regular",
"immutable",
"sorted",
"set",
"<",
"e",
">",
"(",
"list",
",",
"comparator",
")",
";",
"}",
"}"
] |
[
"get",
"integer",
"minimum",
":",
"10",
"maximum",
":",
"100"
] | [
"public",
"integer",
"get",
"integer",
"(",
")",
"{",
"return",
"integer",
";",
"}"
] |
[
"materialize",
"this",
"stream",
"to",
"a",
"topic",
"and",
"creates",
"a",
"new",
"{",
"@",
"code",
"k",
"stream",
"}",
"from",
"the",
"topic",
"using",
"the",
"{",
"@",
"link",
"produced",
"}",
"instance",
"for",
"configuration",
"of",
"the",
"{",
"@",
"link",
"serde",
"key",
"serde",
"}",
",",
"{",
"@",
"link",
"serde",
"value",
"serde",
"}",
",",
"and",
"{",
"@",
"link",
"stream",
"partitioner",
"}",
"the",
"specified",
"topic",
"should",
"be",
"manually",
"created",
"before",
"it",
"is",
"used",
"(",
"i",
"e",
",",
"before",
"the",
"kafka",
"streams",
"application",
"is",
"started",
")",
"this",
"is",
"similar",
"to",
"calling",
"{",
"@",
"link",
"#",
"to",
"(",
"string",
",",
"produced",
")",
"to",
"(",
"some",
"topic",
",",
"produced",
"with",
"(",
"key",
"serde",
",",
"value",
"serde",
")",
"}",
"and",
"{",
"@",
"link",
"streams",
"builder",
"#",
"stream",
"(",
"string",
",",
"consumed",
")",
"streams",
"builder",
"#",
"stream",
"(",
"some",
"topic",
"name",
",",
"consumed",
"with",
"(",
"key",
"serde",
",",
"value",
"serde",
")",
")",
"}",
"note",
"that",
"{",
"@",
"code",
"through",
"(",
")",
"}",
"uses",
"a",
"hard",
"coded",
"{",
"@",
"link",
"org",
"apache",
"kafka",
"streams",
"processor",
"fail",
"on",
"invalid",
"timestamp",
"timestamp",
"extractor",
"}",
"and",
"does",
"not",
"allow",
"to",
"customize",
"it",
",",
"to",
"ensure",
"correct",
"timestamp",
"propagation"
] | [
"k",
"stream",
"<",
"k",
",",
"v",
">",
"through",
"(",
"final",
"string",
"topic",
",",
"final",
"produced",
"<",
"k",
",",
"v",
">",
"produced",
")",
";"
] |
[
"returns",
"the",
"file",
"extensions",
"that",
"the",
"loader",
"supports",
"(",
"excluding",
"the",
"'",
"'",
")"
] | [
"public",
"string",
"[",
"]",
"get",
"file",
"extensions",
"(",
")",
"{",
"return",
"new",
"string",
"[",
"]",
"{",
"\"",
"json",
"\"",
"}",
";",
"}"
] |
[
"requires",
"{",
"@",
"link",
"feature",
"#",
"fake",
"}",
"to",
"be",
"understood",
"for",
"use",
"in",
"testing",
"consumers",
"of",
"this",
"credential"
] | [
"public",
"builder",
"require",
"fake",
"feature",
"(",
")",
"{",
"fake",
"feature",
"=",
"true",
";",
"return",
"this",
";",
"}"
] |
[
"catalog",
"cas",
"properties",
"container"
] | [
"public",
"static",
"cas",
"properties",
"container",
"query",
"(",
"final",
"configuration",
"metadata",
"catalog",
"query",
"query",
")",
"{",
"val",
"repo",
"=",
"new",
"cas",
"configuration",
"metadata",
"repository",
"(",
")",
";",
"val",
"all",
"properties",
"=",
"repo",
"get",
"repository",
"(",
")",
"get",
"all",
"properties",
"(",
")",
"entry",
"set",
"(",
")",
"stream",
"(",
")",
"filter",
"(",
"entry",
"-",
">",
"{",
"if",
"(",
"query",
"get",
"query",
"type",
"(",
")",
"=",
"=",
"configuration",
"metadata",
"catalog",
"query",
"query",
"types",
"cas",
")",
"{",
"return",
"cas",
"configuration",
"metadata",
"repository",
"is",
"cas",
"property",
"(",
"entry",
"get",
"value",
"(",
")",
")",
";",
"}",
"if",
"(",
"query",
"get",
"query",
"type",
"(",
")",
"=",
"=",
"configuration",
"metadata",
"catalog",
"query",
"query",
"types",
"third",
"party",
")",
"{",
"return",
"!",
"cas",
"configuration",
"metadata",
"repository",
"is",
"cas",
"property",
"(",
"entry",
"get",
"value",
"(",
")",
")",
";",
"}",
"return",
"true",
";",
"}",
")",
"collect",
"(",
"collectors",
"to",
"list",
"(",
")",
")",
";",
"val",
"properties",
"=",
"all",
"properties",
"stream",
"(",
")",
"filter",
"(",
"entry",
"-",
">",
"does",
"property",
"belong",
"to",
"module",
"(",
"entry",
"get",
"value",
"(",
")",
",",
"query",
")",
")",
"map",
"(",
"map",
"entry",
":",
":",
"get",
"value",
")",
"map",
"(",
"property",
"-",
">",
"collect",
"reference",
"property",
"(",
"property",
",",
"repo",
"get",
"repository",
"(",
")",
")",
")",
"filter",
"(",
"objects",
":",
":",
"non",
"null",
")",
"sorted",
"(",
"comparator",
"comparing",
"(",
"cas",
"reference",
"property",
":",
":",
"get",
"name",
")",
")",
"collect",
"(",
"collectors",
"to",
"collection",
"(",
"tree",
"set",
":",
":",
"new",
")",
")",
";",
"return",
"new",
"cas",
"properties",
"container",
"(",
"properties",
")",
";",
"}"
] |
[
"find",
"pet",
"by",
"id",
"returns",
"a",
"single",
"pet"
] | [
"public",
"void",
"get",
"pet",
"by",
"id",
"(",
"long",
"pet",
"id",
",",
"api",
"client",
"auth",
"info",
"auth",
"info",
",",
"handler",
"<",
"async",
"result",
"<",
"pet",
">",
">",
"result",
"handler",
")",
"{",
"object",
"local",
"var",
"body",
"=",
"null",
";",
"/",
"/",
"verify",
"the",
"required",
"parameter",
"'",
"pet",
"id",
"'",
"is",
"set",
"if",
"(",
"pet",
"id",
"=",
"=",
"null",
")",
"{",
"result",
"handler",
"handle",
"(",
"api",
"exception",
"fail",
"(",
"400",
",",
"\"",
"missing",
"the",
"required",
"parameter",
"'",
"pet",
"id",
"'",
"when",
"calling",
"get",
"pet",
"by",
"id",
"\"",
")",
")",
";",
"return",
";",
"}",
"/",
"/",
"create",
"path",
"and",
"map",
"variables",
"string",
"local",
"var",
"path",
"=",
"\"",
"/",
"pet",
"/",
"{",
"pet",
"id",
"}",
"\"",
"replace",
"all",
"(",
"\"",
"\\",
"\\",
"{",
"\"",
"+",
"\"",
"pet",
"id",
"\"",
"+",
"\"",
"\\",
"\\",
"}",
"\"",
",",
"encode",
"parameter",
"(",
"pet",
"id",
"to",
"string",
"(",
")",
")",
")",
";",
"/",
"/",
"query",
"params",
"list",
"<",
"pair",
">",
"local",
"var",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"/",
"/",
"header",
"params",
"multi",
"map",
"local",
"var",
"header",
"params",
"=",
"multi",
"map",
"case",
"insensitive",
"multi",
"map",
"(",
")",
";",
"/",
"/",
"cookie",
"params",
"multi",
"map",
"local",
"var",
"cookie",
"params",
"=",
"multi",
"map",
"case",
"insensitive",
"multi",
"map",
"(",
")",
";",
"/",
"/",
"form",
"params",
"/",
"/",
"todo",
":",
"sending",
"files",
"within",
"multipart",
"/",
"form",
"-",
"data",
"is",
"not",
"supported",
"yet",
"(",
"because",
"of",
"vertx",
"web",
"-",
"client",
")",
"map",
"<",
"string",
",",
"object",
">",
"local",
"var",
"form",
"params",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"string",
"[",
"]",
"local",
"var",
"accepts",
"=",
"{",
"\"",
"application",
"/",
"xml",
"\"",
",",
"\"",
"application",
"/",
"json",
"\"",
"}",
";",
"string",
"[",
"]",
"local",
"var",
"content",
"types",
"=",
"{",
"}",
";",
"string",
"[",
"]",
"local",
"var",
"auth",
"names",
"=",
"new",
"string",
"[",
"]",
"{",
"\"",
"api",
"key",
"\"",
"}",
";",
"type",
"reference",
"<",
"pet",
">",
"local",
"var",
"return",
"type",
"=",
"new",
"type",
"reference",
"<",
"pet",
">",
"(",
")",
"{",
"}",
";",
"api",
"client",
"invoke",
"a",
"p",
"i",
"(",
"local",
"var",
"path",
",",
"\"",
"get",
"\"",
",",
"local",
"var",
"query",
"params",
",",
"local",
"var",
"body",
",",
"local",
"var",
"header",
"params",
",",
"local",
"var",
"cookie",
"params",
",",
"local",
"var",
"form",
"params",
",",
"local",
"var",
"accepts",
",",
"local",
"var",
"content",
"types",
",",
"local",
"var",
"auth",
"names",
",",
"auth",
"info",
",",
"local",
"var",
"return",
"type",
",",
"result",
"handler",
")",
";",
"}"
] |
[
"look",
"up",
"a",
"handler",
"instance",
"for",
"the",
"given",
"url",
"path",
"this",
"method",
"is",
"used",
"when",
"parsed",
"{",
"@",
"code",
"path",
"pattern",
"}",
"s",
"are",
"{",
"@",
"link",
"#",
"uses",
"path",
"patterns",
"(",
")",
"enabled",
"}"
] | [
"protected",
"object",
"lookup",
"handler",
"(",
"request",
"path",
"path",
",",
"string",
"lookup",
"path",
",",
"http",
"servlet",
"request",
"request",
")",
"throws",
"exception",
"{",
"object",
"handler",
"=",
"get",
"direct",
"match",
"(",
"lookup",
"path",
",",
"request",
")",
";",
"if",
"(",
"handler",
"!",
"=",
"null",
")",
"{",
"return",
"handler",
";",
"}",
"/",
"/",
"pattern",
"match",
"?",
"list",
"<",
"path",
"pattern",
">",
"matches",
"=",
"null",
";",
"for",
"(",
"path",
"pattern",
"pattern",
":",
"this",
"path",
"pattern",
"handler",
"map",
"key",
"set",
"(",
")",
")",
"{",
"if",
"(",
"pattern",
"matches",
"(",
"path",
")",
")",
"{",
"matches",
"=",
"(",
"matches",
"!",
"=",
"null",
"?",
"matches",
":",
"new",
"array",
"list",
"<",
">",
"(",
")",
")",
";",
"matches",
"add",
"(",
"pattern",
")",
";",
"}",
"}",
"if",
"(",
"matches",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"if",
"(",
"matches",
"size",
"(",
")",
">",
"1",
")",
"{",
"matches",
"sort",
"(",
"path",
"pattern",
"specificity",
"comparator",
")",
";",
"if",
"(",
"logger",
"is",
"trace",
"enabled",
"(",
")",
")",
"{",
"logger",
"debug",
"(",
"\"",
"matching",
"patterns",
"\"",
"+",
"matches",
")",
";",
"}",
"}",
"path",
"pattern",
"pattern",
"=",
"matches",
"get",
"(",
"0",
")",
";",
"handler",
"=",
"this",
"path",
"pattern",
"handler",
"map",
"get",
"(",
"pattern",
")",
";",
"if",
"(",
"handler",
"instanceof",
"string",
")",
"{",
"string",
"handler",
"name",
"=",
"(",
"string",
")",
"handler",
";",
"handler",
"=",
"obtain",
"application",
"context",
"(",
")",
"get",
"bean",
"(",
"handler",
"name",
")",
";",
"}",
"validate",
"handler",
"(",
"handler",
",",
"request",
")",
";",
"path",
"container",
"path",
"within",
"mapping",
"=",
"pattern",
"extract",
"path",
"within",
"pattern",
"(",
"path",
")",
";",
"return",
"build",
"path",
"exposing",
"handler",
"(",
"handler",
",",
"pattern",
"get",
"pattern",
"string",
"(",
")",
",",
"path",
"within",
"mapping",
"value",
"(",
")",
",",
"null",
")",
";",
"}"
] |
[
"get",
"tag",
"value"
] | [
"public",
"string",
"get",
"tag",
"(",
"string",
"tag",
"key",
")",
"{",
"for",
"(",
"meter",
"tag",
"tag",
":",
"meter",
"id",
"get",
"tags",
"(",
")",
")",
"{",
"if",
"(",
"tag",
"get",
"key",
"(",
")",
"equals",
"(",
"tag",
"key",
")",
")",
"{",
"return",
"tag",
"get",
"value",
"(",
")",
";",
"}",
"}",
"return",
"null",
";",
"}"
] |
[
"try",
"to",
"call",
"{",
"@",
"link",
"reference",
"counted",
"#",
"retain",
"(",
"int",
")",
"}",
"if",
"the",
"specified",
"message",
"implements",
"{",
"@",
"link",
"reference",
"counted",
"}",
"if",
"the",
"specified",
"message",
"doesn",
"'",
"t",
"implement",
"{",
"@",
"link",
"reference",
"counted",
"}",
",",
"this",
"method",
"does",
"nothing"
] | [
"public",
"static",
"<",
"t",
">",
"t",
"retain",
"(",
"t",
"msg",
",",
"int",
"increment",
")",
"{",
"if",
"(",
"msg",
"instanceof",
"reference",
"counted",
")",
"{",
"return",
"(",
"t",
")",
"(",
"(",
"reference",
"counted",
")",
"msg",
")",
"retain",
"(",
"increment",
")",
";",
"}",
"return",
"msg",
";",
"}"
] |
[
"for",
"testing",
",",
"delete",
"all",
"application",
"records",
"in",
"registry"
] | [
"public",
"synchronized",
"void",
"clean",
"all",
"applications",
"(",
")",
"{",
"try",
"{",
"remove",
"key",
"registry",
"(",
"this",
"registry",
",",
"this",
"user",
",",
"get",
"registry",
"key",
"(",
"null",
",",
"null",
")",
",",
"true",
",",
"false",
")",
";",
"}",
"catch",
"(",
"yarn",
"exception",
"e",
")",
"{",
"log",
"warn",
"(",
"\"",
"unexpected",
"exception",
"from",
"remove",
"key",
"registry",
"\"",
",",
"e",
")",
";",
"}",
"}"
] |
[
"attempts",
"to",
"read",
"from",
"the",
"queue",
"{",
"@",
"link",
"format",
"formats",
"}",
"read",
"from",
"this",
"method",
"may",
"be",
"associated",
"to",
"a",
"{",
"@",
"link",
"drm",
"session",
"}",
"through",
"{",
"@",
"link",
"format",
"holder",
"#",
"drm",
"session",
"}"
] | [
"public",
"int",
"read",
"(",
"format",
"holder",
"format",
"holder",
",",
"decoder",
"input",
"buffer",
"buffer",
",",
"boolean",
"format",
"required",
",",
"boolean",
"loading",
"finished",
")",
"{",
"int",
"result",
"=",
"read",
"sample",
"metadata",
"(",
"format",
"holder",
",",
"buffer",
",",
"format",
"required",
",",
"loading",
"finished",
",",
"extras",
"holder",
")",
";",
"if",
"(",
"result",
"=",
"=",
"c",
"result",
"buffer",
"read",
"&",
"&",
"!",
"buffer",
"is",
"end",
"of",
"stream",
"(",
")",
"&",
"&",
"!",
"buffer",
"is",
"flags",
"only",
"(",
")",
")",
"{",
"sample",
"data",
"queue",
"read",
"to",
"buffer",
"(",
"buffer",
",",
"extras",
"holder",
")",
";",
"}",
"return",
"result",
";",
"}"
] |
[
"return",
"the",
"original",
"filename",
"in",
"the",
"client",
"'",
"s",
"filesystem",
"this",
"may",
"contain",
"path",
"information",
"depending",
"on",
"the",
"browser",
"used",
",",
"but",
"it",
"typically",
"will",
"not",
"with",
"any",
"other",
"than",
"opera",
"note",
":",
"please",
"keep",
"in",
"mind",
"this",
"filename",
"is",
"supplied",
"by",
"the",
"client",
"and",
"should",
"not",
"be",
"used",
"blindly",
"in",
"addition",
"to",
"not",
"using",
"the",
"directory",
"portion",
",",
"the",
"file",
"name",
"could",
"also",
"contain",
"characters",
"such",
"as",
"\"",
"\"",
"and",
"others",
"that",
"can",
"be",
"used",
"maliciously",
"it",
"is",
"recommended",
"to",
"not",
"use",
"this",
"filename",
"directly",
"preferably",
"generate",
"a",
"unique",
"one",
"and",
"save",
"this",
"one",
"one",
"somewhere",
"for",
"reference",
",",
"if",
"necessary"
] | [
"string",
"get",
"original",
"filename",
"(",
")",
";"
] |
[
"returns",
"true",
"if",
"there",
"are",
"pending",
"listeners"
] | [
"public",
"boolean",
"refresh",
"needed",
"(",
")",
"{",
"/",
"/",
"a",
"null",
"list",
"doesn",
"'",
"t",
"need",
"a",
"refresh",
"if",
"we",
"'",
"re",
"closed",
"we",
"don",
"'",
"t",
"need",
"a",
"refresh",
"either",
"return",
"refresh",
"listeners",
"!",
"=",
"null",
"&",
"&",
"false",
"=",
"=",
"closed",
";",
"}"
] |
[
"create",
"open",
"files"
] | [
"public",
"static",
"map",
"<",
"path",
",",
"f",
"s",
"data",
"output",
"stream",
">",
"create",
"open",
"files",
"(",
"file",
"system",
"fs",
",",
"path",
"base",
"dir",
",",
"string",
"file",
"prefix",
",",
"int",
"num",
"files",
"to",
"create",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"map",
"<",
"path",
",",
"f",
"s",
"data",
"output",
"stream",
">",
"files",
"created",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"final",
"byte",
"[",
"]",
"buffer",
"=",
"new",
"byte",
"[",
"(",
"int",
")",
"(",
"1024",
"*",
"1",
"75",
")",
"]",
";",
"final",
"random",
"rand",
"=",
"new",
"random",
"(",
"0x",
"f",
"e",
"e",
"d",
"0",
"b",
"a",
"c",
"l",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"num",
"files",
"to",
"create",
";",
"i",
"+",
"+",
")",
"{",
"path",
"file",
"=",
"new",
"path",
"(",
"base",
"dir",
",",
"file",
"prefix",
"+",
"\"",
"-",
"\"",
"+",
"i",
")",
";",
"f",
"s",
"data",
"output",
"stream",
"stm",
"=",
"fs",
"create",
"(",
"file",
",",
"true",
",",
"1024",
",",
"(",
"short",
")",
"1",
",",
"1024",
")",
";",
"rand",
"next",
"bytes",
"(",
"buffer",
")",
";",
"stm",
"write",
"(",
"buffer",
")",
";",
"files",
"created",
"put",
"(",
"file",
",",
"stm",
")",
";",
"}",
"return",
"files",
"created",
";",
"}"
] |
[
"add",
"a",
"{",
"@",
"link",
"weather",
"observer",
"}",
",",
"verify",
"if",
"it",
"gets",
"notified",
"of",
"a",
"weather",
"change",
",",
"remove",
"the",
"observer",
"again",
"and",
"verify",
"that",
"there",
"are",
"no",
"more",
"notifications"
] | [
"public",
"void",
"test",
"add",
"remove",
"observer",
"(",
")",
"{",
"final",
"var",
"observer",
"=",
"mock",
"(",
"race",
"class",
")",
";",
"final",
"var",
"weather",
"=",
"new",
"g",
"weather",
"(",
")",
";",
"weather",
"add",
"observer",
"(",
"observer",
")",
";",
"verify",
"zero",
"interactions",
"(",
"observer",
")",
";",
"weather",
"time",
"passes",
"(",
")",
";",
"assert",
"equals",
"(",
"\"",
"the",
"weather",
"changed",
"to",
"rainy",
"\"",
",",
"appender",
"get",
"last",
"message",
"(",
")",
")",
";",
"verify",
"(",
"observer",
")",
"update",
"(",
"weather",
",",
"weather",
"type",
"rainy",
")",
";",
"weather",
"remove",
"observer",
"(",
"observer",
")",
";",
"weather",
"time",
"passes",
"(",
")",
";",
"assert",
"equals",
"(",
"\"",
"the",
"weather",
"changed",
"to",
"windy",
"\"",
",",
"appender",
"get",
"last",
"message",
"(",
")",
")",
";",
"verify",
"no",
"more",
"interactions",
"(",
"observer",
")",
";",
"assert",
"equals",
"(",
"2",
",",
"appender",
"get",
"log",
"size",
"(",
")",
")",
";",
"}"
] |
[
"sets",
"the",
"quaternion",
"from",
"the",
"given",
"rotation",
"matrix",
",",
"which",
"must",
"not",
"contain",
"scaling"
] | [
"public",
"quaternion",
"set",
"from",
"matrix",
"(",
"matrix",
"4",
"matrix",
")",
"{",
"return",
"set",
"from",
"matrix",
"(",
"false",
",",
"matrix",
")",
";",
"}"
] |
[
"return",
"a",
"collection",
"of",
"action",
"values",
"which",
"have",
"output",
"files",
"that",
"are",
"not",
"in",
"-",
"sync",
"with",
"the",
"on",
"-",
"disk",
"file",
"value",
"(",
"were",
"modified",
"externally",
")"
] | [
"collection",
"<",
"sky",
"key",
">",
"get",
"dirty",
"action",
"values",
"(",
"map",
"<",
"sky",
"key",
",",
"sky",
"value",
">",
"values",
"map",
",",
"@",
"nullable",
"final",
"batch",
"stat",
"batch",
"statter",
",",
"modified",
"file",
"set",
"modified",
"output",
"files",
",",
"boolean",
"trust",
"remote",
"artifacts",
")",
"throws",
"interrupted",
"exception",
"{",
"if",
"(",
"modified",
"output",
"files",
"=",
"=",
"modified",
"file",
"set",
"nothing",
"modified",
")",
"{",
"logger",
"at",
"info",
"(",
")",
"log",
"(",
"\"",
"not",
"checking",
"for",
"dirty",
"actions",
"since",
"nothing",
"was",
"modified",
"\"",
")",
";",
"return",
"immutable",
"list",
"of",
"(",
")",
";",
"}",
"logger",
"at",
"info",
"(",
")",
"log",
"(",
"\"",
"accumulating",
"dirty",
"actions",
"\"",
")",
";",
"final",
"int",
"num",
"output",
"jobs",
"=",
"runtime",
"get",
"runtime",
"(",
")",
"available",
"processors",
"(",
")",
"*",
"4",
";",
"final",
"set",
"<",
"sky",
"key",
">",
"action",
"sky",
"keys",
"=",
"new",
"hash",
"set",
"<",
">",
"(",
")",
";",
"try",
"(",
"silent",
"closeable",
"c",
"=",
"profiler",
"instance",
"(",
")",
"profile",
"(",
"\"",
"get",
"dirty",
"action",
"values",
"filter",
"actions",
"\"",
")",
")",
"{",
"for",
"(",
"sky",
"key",
"key",
":",
"values",
"map",
"key",
"set",
"(",
")",
")",
"{",
"if",
"(",
"action",
"filter",
"apply",
"(",
"key",
")",
")",
"{",
"action",
"sky",
"keys",
"add",
"(",
"key",
")",
";",
"}",
"}",
"}",
"final",
"sharder",
"<",
"pair",
"<",
"sky",
"key",
",",
"action",
"execution",
"value",
">",
">",
"output",
"shards",
"=",
"new",
"sharder",
"<",
">",
"(",
"num",
"output",
"jobs",
",",
"action",
"sky",
"keys",
"size",
"(",
")",
")",
";",
"for",
"(",
"sky",
"key",
"key",
":",
"action",
"sky",
"keys",
")",
"{",
"output",
"shards",
"add",
"(",
"pair",
"of",
"(",
"key",
",",
"(",
"action",
"execution",
"value",
")",
"values",
"map",
"get",
"(",
"key",
")",
")",
")",
";",
"}",
"logger",
"at",
"info",
"(",
")",
"log",
"(",
"\"",
"sharded",
"action",
"values",
"for",
"batching",
"\"",
")",
";",
"executor",
"service",
"executor",
"=",
"executors",
"new",
"fixed",
"thread",
"pool",
"(",
"num",
"output",
"jobs",
",",
"new",
"thread",
"factory",
"builder",
"(",
")",
"set",
"name",
"format",
"(",
"\"",
"file",
"system",
"output",
"file",
"invalidator",
"%",
"d",
"\"",
")",
"build",
"(",
")",
")",
";",
"collection",
"<",
"sky",
"key",
">",
"dirty",
"keys",
"=",
"sets",
"new",
"concurrent",
"hash",
"set",
"(",
")",
";",
"throwable",
"recording",
"runnable",
"wrapper",
"wrapper",
"=",
"new",
"throwable",
"recording",
"runnable",
"wrapper",
"(",
"\"",
"file",
"system",
"value",
"checker",
"#",
"get",
"dirty",
"action",
"values",
"\"",
")",
";",
"modified",
"output",
"files",
"counter",
"set",
"(",
"0",
")",
";",
"modified",
"output",
"files",
"intra",
"build",
"counter",
"set",
"(",
"0",
")",
";",
"final",
"immutable",
"set",
"<",
"path",
"fragment",
">",
"known",
"modified",
"output",
"files",
"=",
"modified",
"output",
"files",
"=",
"=",
"modified",
"file",
"set",
"everything",
"modified",
"?",
"null",
":",
"modified",
"output",
"files",
"modified",
"source",
"files",
"(",
")",
";",
"/",
"/",
"initialized",
"lazily",
"through",
"a",
"supplier",
"because",
"it",
"is",
"only",
"used",
"to",
"check",
"modified",
"/",
"/",
"tree",
"artifacts",
",",
"which",
"are",
"not",
"frequently",
"used",
"in",
"builds",
"supplier",
"<",
"navigable",
"set",
"<",
"path",
"fragment",
">",
">",
"sorted",
"known",
"modified",
"output",
"files",
"=",
"suppliers",
"memoize",
"(",
"new",
"supplier",
"<",
"navigable",
"set",
"<",
"path",
"fragment",
">",
">",
"(",
")",
"{",
"@",
"override",
"public",
"navigable",
"set",
"<",
"path",
"fragment",
">",
"get",
"(",
")",
"{",
"if",
"(",
"known",
"modified",
"output",
"files",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"else",
"{",
"return",
"immutable",
"sorted",
"set",
"copy",
"of",
"(",
"known",
"modified",
"output",
"files",
")",
";",
"}",
"}",
"}",
")",
";",
"boolean",
"interrupted",
";",
"try",
"(",
"silent",
"closeable",
"c",
"=",
"profiler",
"instance",
"(",
")",
"profile",
"(",
"\"",
"get",
"dirty",
"action",
"values",
"stat",
"files",
"\"",
")",
")",
"{",
"for",
"(",
"list",
"<",
"pair",
"<",
"sky",
"key",
",",
"action",
"execution",
"value",
">",
">",
"shard",
":",
"output",
"shards",
")",
"{",
"runnable",
"job",
"=",
"(",
"batch",
"statter",
"=",
"=",
"null",
")",
"?",
"output",
"stat",
"job",
"(",
"dirty",
"keys",
",",
"shard",
",",
"known",
"modified",
"output",
"files",
",",
"sorted",
"known",
"modified",
"output",
"files",
",",
"trust",
"remote",
"artifacts",
")",
":",
"batch",
"stat",
"job",
"(",
"dirty",
"keys",
",",
"shard",
",",
"batch",
"statter",
",",
"known",
"modified",
"output",
"files",
",",
"sorted",
"known",
"modified",
"output",
"files",
",",
"trust",
"remote",
"artifacts",
")",
";",
"future",
"<",
"?",
">",
"unused",
"=",
"executor",
"submit",
"(",
"wrapper",
"wrap",
"(",
"job",
")",
")",
";",
"}",
"interrupted",
"=",
"executor",
"util",
"interruptible",
"shutdown",
"(",
"executor",
")",
";",
"}",
"throwables",
"propagate",
"if",
"possible",
"(",
"wrapper",
"get",
"first",
"thrown",
"error",
"(",
")",
")",
";",
"if",
"(",
"dirty",
"keys",
"is",
"empty",
"(",
")",
")",
"{",
"logger",
"at",
"info",
"(",
")",
"log",
"(",
"\"",
"completed",
"output",
"file",
"stat",
"checks",
",",
"no",
"modified",
"outputs",
"found",
"\"",
")",
";",
"}",
"else",
"{",
"logger",
"at",
"info",
"(",
")",
"log",
"(",
"\"",
"completed",
"output",
"file",
"stat",
"checks",
",",
"%",
"d",
"actions",
"'",
"outputs",
"changed",
",",
"first",
"few",
":",
"%",
"s",
"\"",
",",
"dirty",
"keys",
"size",
"(",
")",
",",
"iterables",
"limit",
"(",
"dirty",
"keys",
",",
"10",
")",
")",
";",
"}",
"if",
"(",
"interrupted",
")",
"{",
"throw",
"new",
"interrupted",
"exception",
"(",
")",
";",
"}",
"return",
"dirty",
"keys",
";",
"}"
] |
[
"set",
"the",
"angular",
"velocity"
] | [
"public",
"void",
"set",
"angular",
"velocity",
"(",
"float",
"omega",
")",
"{",
"jni",
"set",
"angular",
"velocity",
"(",
"addr",
",",
"omega",
")",
";",
"}"
] |
[
"release",
"the",
"given",
"array",
"back",
"to",
"the",
"pool"
] | [
"void",
"release",
"(",
"@",
"non",
"null",
"int",
"[",
"]",
"array",
")",
";"
] |
[
"the",
"{",
"@",
"link",
"channel",
"}",
"of",
"the",
"{",
"@",
"link",
"channel",
"handler",
"context",
"}",
"was",
"unregistered",
"from",
"its",
"{",
"@",
"link",
"event",
"loop",
"}"
] | [
"void",
"channel",
"unregistered",
"(",
"channel",
"handler",
"context",
"ctx",
")",
"throws",
"exception",
";"
] |