docstring_tokens
list | code_tokens
list |
|---|---|
[
"converts",
"this",
"config",
"into",
"an",
"html",
"list",
"that",
"can",
"be",
"embedded",
"into",
"docs",
"if",
"<",
"code",
">",
"dynamic",
"update",
"modes",
"<",
"code",
">",
"is",
"non",
"-",
"empty",
",",
"a",
"\"",
"dynamic",
"update",
"mode",
"\"",
"label",
"will",
"be",
"included",
"in",
"the",
"config",
"details",
"with",
"the",
"value",
"of",
"the",
"update",
"mode",
"default",
"mode",
"is",
"\"",
"read",
"-",
"only",
"\""
]
| [
"public",
"string",
"to",
"html",
"(",
"map",
"<",
"string",
",",
"string",
">",
"dynamic",
"update",
"modes",
")",
"{",
"return",
"to",
"html",
"(",
"4",
",",
"function",
"identity",
"(",
")",
",",
"dynamic",
"update",
"modes",
")",
";",
"}"
]
|
[
"leave",
"the",
"information",
"about",
"login",
"failure"
]
| [
"protected",
"void",
"unsuccessful",
"authentication",
"(",
"http",
"servlet",
"request",
"request",
",",
"http",
"servlet",
"response",
"response",
",",
"authentication",
"exception",
"failed",
")",
"throws",
"i",
"o",
"exception",
",",
"servlet",
"exception",
"{",
"super",
"unsuccessful",
"authentication",
"(",
"request",
",",
"response",
",",
"failed",
")",
";",
"logger",
"log",
"(",
"level",
"fine",
",",
"\"",
"login",
"attempt",
"failed",
"\"",
",",
"failed",
")",
";",
"/",
"*",
"todo",
"this",
"information",
"appears",
"to",
"have",
"been",
"deliberately",
"removed",
"from",
"spring",
"security",
":",
"authentication",
"auth",
"=",
"failed",
"get",
"authentication",
"(",
")",
";",
"if",
"(",
"auth",
"!",
"=",
"null",
")",
"{",
"security",
"listener",
"fire",
"failed",
"to",
"log",
"in",
"(",
"auth",
"get",
"name",
"(",
")",
")",
";",
"}",
"*",
"/",
"}"
]
|
[
"overridden",
"to",
"fix",
"a",
"'",
"bug",
"'",
"in",
"java",
"whereby",
"it",
"tries",
"to",
"render",
"columns",
"that",
"we",
"have",
"just",
"removed",
"when",
"editing",
"the",
"visible",
"columns"
]
| [
"public",
"table",
"column",
"get",
"dragged",
"column",
"(",
")",
"{",
"if",
"(",
"dragged",
"column",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"/",
"/",
"make",
"sure",
"the",
"column",
"has",
"not",
"been",
"invisible",
"-",
"ized",
"for",
"(",
"int",
"column",
"=",
"0",
";",
"column",
"<",
"column",
"model",
"get",
"column",
"count",
"(",
")",
";",
"column",
"+",
"+",
")",
"{",
"table",
"column",
"models",
"column",
"=",
"column",
"model",
"get",
"column",
"(",
"column",
")",
";",
"if",
"(",
"models",
"column",
"=",
"=",
"dragged",
"column",
")",
"{",
"return",
"dragged",
"column",
";",
"}",
"}",
"return",
"null",
";",
"}"
]
|
[
"constructs",
"an",
"event",
"with",
"kind",
"{",
"@",
"link",
"event",
"kind",
"#",
"debug",
"}",
",",
"with",
"an",
"optional",
"{",
"@",
"link",
"location",
"}"
]
| [
"public",
"static",
"event",
"debug",
"(",
"@",
"nullable",
"location",
"location",
",",
"string",
"message",
")",
"{",
"return",
"location",
"=",
"=",
"null",
"?",
"of",
"(",
"event",
"kind",
"debug",
",",
"message",
")",
":",
"of",
"(",
"event",
"kind",
"debug",
",",
"message",
",",
"location",
"class",
",",
"location",
")",
";",
"}"
]
|
[
"deletes",
"all",
"corruption",
"markers",
"from",
"this",
"store"
]
| [
"public",
"void",
"remove",
"corruption",
"marker",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"ensure",
"open",
"(",
")",
";",
"final",
"directory",
"directory",
"=",
"directory",
"(",
")",
";",
"i",
"o",
"exception",
"first",
"exception",
"=",
"null",
";",
"final",
"string",
"[",
"]",
"files",
"=",
"directory",
"list",
"all",
"(",
")",
";",
"for",
"(",
"string",
"file",
":",
"files",
")",
"{",
"if",
"(",
"file",
"starts",
"with",
"(",
"corrupted",
"marker",
"name",
"prefix",
")",
")",
"{",
"try",
"{",
"directory",
"delete",
"file",
"(",
"file",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"ex",
")",
"{",
"if",
"(",
"first",
"exception",
"=",
"=",
"null",
")",
"{",
"first",
"exception",
"=",
"ex",
";",
"}",
"else",
"{",
"first",
"exception",
"add",
"suppressed",
"(",
"ex",
")",
";",
"}",
"}",
"}",
"}",
"if",
"(",
"first",
"exception",
"!",
"=",
"null",
")",
"{",
"throw",
"first",
"exception",
";",
"}",
"}"
]
|
[
"test",
"the",
"property",
"'",
"class",
"name",
"'"
]
| [
"public",
"void",
"class",
"name",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"class",
"name",
"}"
]
|
[
"completes",
"the",
"join",
"operation",
"with",
"the",
"user",
"function",
"that",
"is",
"executed",
"for",
"each",
"combination",
"of",
"elements",
"with",
"the",
"same",
"key",
"in",
"a",
"window",
"note",
":",
"this",
"method",
"'",
"s",
"return",
"type",
"does",
"not",
"support",
"setting",
"an",
"operator",
"-",
"specific",
"parallelism",
"due",
"to",
"binary",
"backwards",
"compatibility",
",",
"this",
"cannot",
"be",
"altered",
"use",
"the",
"{",
"@",
"link",
"#",
"with",
"(",
"flat",
"join",
"function",
")",
"}",
",",
"method",
"to",
"set",
"an",
"operator",
"-",
"specific",
"parallelism"
]
| [
"public",
"<",
"t",
">",
"data",
"stream",
"<",
"t",
">",
"apply",
"(",
"flat",
"join",
"function",
"<",
"t1",
",",
"t2",
",",
"t",
">",
"function",
")",
"{",
"type",
"information",
"<",
"t",
">",
"result",
"type",
"=",
"type",
"extractor",
"get",
"binary",
"operator",
"return",
"type",
"(",
"function",
",",
"flat",
"join",
"function",
"class",
",",
"0",
",",
"1",
",",
"2",
",",
"new",
"int",
"[",
"]",
"{",
"2",
",",
"0",
"}",
",",
"input",
"1",
"get",
"type",
"(",
")",
",",
"input",
"2",
"get",
"type",
"(",
")",
",",
"\"",
"join",
"\"",
",",
"false",
")",
";",
"return",
"apply",
"(",
"function",
",",
"result",
"type",
")",
";",
"}"
]
|
[
"persist",
"timing",
"stats"
]
| [
"public",
"builder",
"persist",
"timing",
"stats",
"(",
"timing",
"stats",
"timing",
"stats",
")",
"{",
"index",
"result",
"(",
"timing",
"stats",
"document",
"id",
"(",
"timing",
"stats",
"get",
"job",
"id",
"(",
")",
")",
",",
"timing",
"stats",
",",
"new",
"to",
"x",
"content",
"map",
"params",
"(",
"collections",
"singleton",
"map",
"(",
"to",
"x",
"content",
"params",
"for",
"internal",
"storage",
",",
"\"",
"true",
"\"",
")",
")",
",",
"timing",
"stats",
"type",
"get",
"preferred",
"name",
"(",
")",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"set",
"the",
"actual",
"instance"
]
| [
"public",
"void",
"set",
"actual",
"instance",
"(",
"object",
"instance",
")",
"{",
"this",
"instance",
"=",
"instance",
";",
"}"
]
|
[
"verifies",
"that",
"we",
"can",
"recognize",
"when",
"a",
"directory",
"represents",
"an",
"extension",
"note",
":",
"the",
"presence",
"of",
"an",
"extensions",
"properties",
"file",
"is",
"the",
"difference"
]
| [
"public",
"void",
"test",
"is",
"extension",
"folder",
"(",
")",
"throws",
"i",
"o",
"exception",
",",
"extension",
"exception",
"{",
"file",
"ext",
"dir",
"=",
"create",
"temp",
"directory",
"(",
"\"",
"test",
"ext",
"folder",
"\"",
")",
";",
"new",
"file",
"(",
"ext",
"dir",
",",
"\"",
"extension",
"properties",
"\"",
")",
"create",
"new",
"file",
"(",
")",
";",
"assert",
"true",
"(",
"extension",
"utils",
"is",
"extension",
"(",
"new",
"resource",
"file",
"(",
"ext",
"dir",
")",
")",
")",
";",
"file",
"non",
"ext",
"dir",
"=",
"create",
"temp",
"directory",
"(",
"\"",
"test",
"non",
"ext",
"folder",
"\"",
")",
";",
"assert",
"true",
"(",
"!",
"extension",
"utils",
"is",
"extension",
"(",
"new",
"resource",
"file",
"(",
"non",
"ext",
"dir",
")",
")",
")",
";",
"}"
]
|
[
"returns",
"the",
"set",
"of",
"package",
"specifications",
"the",
"given",
"target",
"is",
"visible",
"from",
",",
"represented",
"as",
"{",
"@",
"link",
"query",
"visibility",
"}",
"s"
]
| [
"immutable",
"set",
"<",
"query",
"visibility",
"<",
"t",
">",
">",
"get",
"visibility",
"(",
"query",
"expression",
"caller",
",",
"t",
"from",
")",
"throws",
"query",
"exception",
",",
"interrupted",
"exception",
";"
]
|
[
"get",
"date",
"time"
]
| [
"public",
"offset",
"date",
"time",
"get",
"date",
"time",
"(",
")",
"{",
"return",
"date",
"time",
";",
"}"
]
|
[
"test",
"scenario",
"(",
"idle",
"timeout",
"=",
"100",
",",
"watermark",
"interval",
"=",
"40",
")",
":",
"(",
"1",
")",
"start",
"from",
"20",
"as",
"initial",
"time",
"(",
"2",
")",
"as",
"soon",
"as",
"time",
"reaches",
"120",
",",
"status",
"should",
"have",
"been",
"toggled",
"to",
"idle",
"(",
"3",
")",
"after",
"some",
"arbitrary",
"time",
"(",
"until",
"320",
")",
",",
"the",
"status",
"should",
"remain",
"idle",
",",
"and",
"no",
"watermarks",
"should",
"have",
"been",
"emitted",
"(",
"4",
")",
"emit",
"a",
"record",
"at",
"330",
"status",
"should",
"become",
"active",
"this",
"should",
"schedule",
"a",
"idleness",
"detection",
"to",
"be",
"fired",
"at",
"430",
"(",
"5",
")",
"emit",
"another",
"record",
"at",
"350",
"(",
"which",
"is",
"before",
"the",
"next",
"check",
")",
"this",
"should",
"make",
"the",
"idleness",
"check",
"pass",
"(",
"6",
")",
"advance",
"time",
"to",
"430",
"and",
"trigger",
"idleness",
"detection",
"the",
"status",
"should",
"still",
"be",
"active",
"due",
"to",
"step",
"(",
"5",
")",
"this",
"should",
"schedule",
"a",
"idleness",
"detection",
"to",
"be",
"fired",
"at",
"530",
"(",
"7",
")",
"advance",
"time",
"to",
"460",
",",
"in",
"which",
"a",
"watermark",
"emission",
"task",
"should",
"be",
"fired",
"idleness",
"detection",
"should",
"have",
"been",
"\"",
"piggy",
"-",
"backed",
"\"",
"in",
"the",
"task",
",",
"allowing",
"the",
"status",
"to",
"be",
"toggled",
"to",
"idle",
"before",
"the",
"next",
"actual",
"idle",
"detection",
"task",
"at",
"530",
"inline",
"comments",
"will",
"refer",
"to",
"the",
"corresponding",
"tested",
"steps",
"in",
"the",
"scenario"
]
| [
"public",
"void",
"test",
"automatic",
"watermark",
"context",
"(",
")",
"throws",
"exception",
"{",
"long",
"watermark",
"interval",
"=",
"40",
";",
"long",
"idle",
"timeout",
"=",
"100",
";",
"long",
"initial",
"time",
"=",
"20",
";",
"test",
"processing",
"time",
"service",
"processing",
"time",
"service",
"=",
"new",
"test",
"processing",
"time",
"service",
"(",
")",
";",
"processing",
"time",
"service",
"set",
"current",
"time",
"(",
"initial",
"time",
")",
";",
"mock",
"stream",
"status",
"maintainer",
"mock",
"stream",
"status",
"maintainer",
"=",
"new",
"mock",
"stream",
"status",
"maintainer",
"(",
")",
";",
"final",
"list",
"<",
"stream",
"element",
">",
"output",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"final",
"list",
"<",
"stream",
"element",
">",
"expected",
"output",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"source",
"function",
"source",
"context",
"<",
"string",
">",
"context",
"=",
"stream",
"source",
"contexts",
"get",
"source",
"context",
"(",
"time",
"characteristic",
"ingestion",
"time",
",",
"processing",
"time",
"service",
",",
"new",
"object",
"(",
")",
",",
"mock",
"stream",
"status",
"maintainer",
",",
"new",
"collector",
"output",
"<",
"string",
">",
"(",
"output",
")",
",",
"watermark",
"interval",
",",
"idle",
"timeout",
")",
";",
"/",
"/",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"begin",
"test",
"scenario",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"/",
"/",
"corresponds",
"to",
"step",
"(",
"2",
")",
"of",
"scenario",
"(",
"please",
"see",
"method",
"-",
"level",
"javadoc",
"comment",
")",
"processing",
"time",
"service",
"set",
"current",
"time",
"(",
"initial",
"time",
"+",
"watermark",
"interval",
")",
";",
"expected",
"output",
"add",
"(",
"new",
"watermark",
"(",
"processing",
"time",
"service",
"get",
"current",
"processing",
"time",
"(",
")",
"-",
"(",
"processing",
"time",
"service",
"get",
"current",
"processing",
"time",
"(",
")",
"%",
"watermark",
"interval",
")",
")",
")",
";",
"processing",
"time",
"service",
"set",
"current",
"time",
"(",
"initial",
"time",
"+",
"2",
"*",
"watermark",
"interval",
")",
";",
"expected",
"output",
"add",
"(",
"new",
"watermark",
"(",
"processing",
"time",
"service",
"get",
"current",
"processing",
"time",
"(",
")",
"-",
"(",
"processing",
"time",
"service",
"get",
"current",
"processing",
"time",
"(",
")",
"%",
"watermark",
"interval",
")",
")",
")",
";",
"processing",
"time",
"service",
"set",
"current",
"time",
"(",
"initial",
"time",
"+",
"idle",
"timeout",
")",
";",
"assert",
"true",
"(",
"mock",
"stream",
"status",
"maintainer",
"get",
"stream",
"status",
"(",
")",
"is",
"idle",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"expected",
"output",
",",
"output",
")",
";",
"/",
"/",
"corresponds",
"to",
"step",
"(",
"3",
")",
"of",
"scenario",
"(",
"please",
"see",
"method",
"-",
"level",
"javadoc",
"comment",
")",
"processing",
"time",
"service",
"set",
"current",
"time",
"(",
"initial",
"time",
"+",
"3",
"*",
"watermark",
"interval",
")",
";",
"processing",
"time",
"service",
"set",
"current",
"time",
"(",
"initial",
"time",
"+",
"4",
"*",
"watermark",
"interval",
")",
";",
"processing",
"time",
"service",
"set",
"current",
"time",
"(",
"initial",
"time",
"+",
"2",
"*",
"idle",
"timeout",
")",
";",
"processing",
"time",
"service",
"set",
"current",
"time",
"(",
"initial",
"time",
"+",
"6",
"*",
"watermark",
"interval",
")",
";",
"processing",
"time",
"service",
"set",
"current",
"time",
"(",
"initial",
"time",
"+",
"7",
"*",
"watermark",
"interval",
")",
";",
"processing",
"time",
"service",
"set",
"current",
"time",
"(",
"initial",
"time",
"+",
"3",
"*",
"idle",
"timeout",
")",
";",
"assert",
"true",
"(",
"mock",
"stream",
"status",
"maintainer",
"get",
"stream",
"status",
"(",
")",
"is",
"idle",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"expected",
"output",
",",
"output",
")",
";",
"/",
"/",
"corresponds",
"to",
"step",
"(",
"4",
")",
"of",
"scenario",
"(",
"please",
"see",
"method",
"-",
"level",
"javadoc",
"comment",
")",
"processing",
"time",
"service",
"set",
"current",
"time",
"(",
"initial",
"time",
"+",
"3",
"*",
"idle",
"timeout",
"+",
"idle",
"timeout",
"/",
"10",
")",
";",
"switch",
"(",
"test",
"method",
")",
"{",
"case",
"collect",
":",
"context",
"collect",
"(",
"\"",
"msg",
"\"",
")",
";",
"expected",
"output",
"add",
"(",
"new",
"stream",
"record",
"<",
">",
"(",
"\"",
"msg",
"\"",
",",
"processing",
"time",
"service",
"get",
"current",
"processing",
"time",
"(",
")",
")",
")",
";",
"expected",
"output",
"add",
"(",
"new",
"watermark",
"(",
"processing",
"time",
"service",
"get",
"current",
"processing",
"time",
"(",
")",
"-",
"(",
"processing",
"time",
"service",
"get",
"current",
"processing",
"time",
"(",
")",
"%",
"watermark",
"interval",
")",
")",
")",
";",
"assert",
"true",
"(",
"mock",
"stream",
"status",
"maintainer",
"get",
"stream",
"status",
"(",
")",
"is",
"active",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"expected",
"output",
",",
"output",
")",
";",
"break",
";",
"case",
"collect",
"with",
"timestamp",
":",
"context",
"collect",
"with",
"timestamp",
"(",
"\"",
"msg",
"\"",
",",
"processing",
"time",
"service",
"get",
"current",
"processing",
"time",
"(",
")",
")",
";",
"expected",
"output",
"add",
"(",
"new",
"stream",
"record",
"<",
">",
"(",
"\"",
"msg",
"\"",
",",
"processing",
"time",
"service",
"get",
"current",
"processing",
"time",
"(",
")",
")",
")",
";",
"expected",
"output",
"add",
"(",
"new",
"watermark",
"(",
"processing",
"time",
"service",
"get",
"current",
"processing",
"time",
"(",
")",
"-",
"(",
"processing",
"time",
"service",
"get",
"current",
"processing",
"time",
"(",
")",
"%",
"watermark",
"interval",
")",
")",
")",
";",
"assert",
"true",
"(",
"mock",
"stream",
"status",
"maintainer",
"get",
"stream",
"status",
"(",
")",
"is",
"active",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"expected",
"output",
",",
"output",
")",
";",
"break",
";",
"case",
"emit",
"watermark",
":",
"/",
"/",
"for",
"emit",
"watermark",
",",
"since",
"the",
"watermark",
"will",
"be",
"blocked",
",",
"/",
"/",
"it",
"should",
"not",
"make",
"the",
"status",
"become",
"active",
";",
"/",
"/",
"from",
"here",
"on",
",",
"the",
"status",
"should",
"remain",
"idle",
"for",
"the",
"emit",
"watermark",
"variant",
"test",
"context",
"emit",
"watermark",
"(",
"new",
"watermark",
"(",
"processing",
"time",
"service",
"get",
"current",
"processing",
"time",
"(",
")",
")",
")",
";",
"assert",
"true",
"(",
"mock",
"stream",
"status",
"maintainer",
"get",
"stream",
"status",
"(",
")",
"is",
"idle",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"expected",
"output",
",",
"output",
")",
";",
"}",
"/",
"/",
"corresponds",
"to",
"step",
"(",
"5",
")",
"of",
"scenario",
"(",
"please",
"see",
"method",
"-",
"level",
"javadoc",
"comment",
")",
"processing",
"time",
"service",
"set",
"current",
"time",
"(",
"initial",
"time",
"+",
"8",
"*",
"watermark",
"interval",
")",
";",
"processing",
"time",
"service",
"set",
"current",
"time",
"(",
"initial",
"time",
"+",
"3",
"*",
"idle",
"timeout",
"+",
"3",
"*",
"idle",
"timeout",
"/",
"10",
")",
";",
"switch",
"(",
"test",
"method",
")",
"{",
"case",
"collect",
":",
"context",
"collect",
"(",
"\"",
"msg",
"\"",
")",
";",
"expected",
"output",
"add",
"(",
"new",
"stream",
"record",
"<",
">",
"(",
"\"",
"msg",
"\"",
",",
"processing",
"time",
"service",
"get",
"current",
"processing",
"time",
"(",
")",
")",
")",
";",
"assert",
"true",
"(",
"mock",
"stream",
"status",
"maintainer",
"get",
"stream",
"status",
"(",
")",
"is",
"active",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"expected",
"output",
",",
"output",
")",
";",
"break",
";",
"case",
"collect",
"with",
"timestamp",
":",
"context",
"collect",
"with",
"timestamp",
"(",
"\"",
"msg",
"\"",
",",
"processing",
"time",
"service",
"get",
"current",
"processing",
"time",
"(",
")",
")",
";",
"expected",
"output",
"add",
"(",
"new",
"stream",
"record",
"<",
">",
"(",
"\"",
"msg",
"\"",
",",
"processing",
"time",
"service",
"get",
"current",
"processing",
"time",
"(",
")",
")",
")",
";",
"assert",
"true",
"(",
"mock",
"stream",
"status",
"maintainer",
"get",
"stream",
"status",
"(",
")",
"is",
"active",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"expected",
"output",
",",
"output",
")",
";",
"break",
";",
"case",
"emit",
"watermark",
":",
"context",
"emit",
"watermark",
"(",
"new",
"watermark",
"(",
"processing",
"time",
"service",
"get",
"current",
"processing",
"time",
"(",
")",
")",
")",
";",
"assert",
"true",
"(",
"mock",
"stream",
"status",
"maintainer",
"get",
"stream",
"status",
"(",
")",
"is",
"idle",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"expected",
"output",
",",
"output",
")",
";",
"}",
"processing",
"time",
"service",
"set",
"current",
"time",
"(",
"initial",
"time",
"+",
"9",
"*",
"watermark",
"interval",
")",
";",
"switch",
"(",
"test",
"method",
")",
"{",
"case",
"collect",
":",
"case",
"collect",
"with",
"timestamp",
":",
"expected",
"output",
"add",
"(",
"new",
"watermark",
"(",
"processing",
"time",
"service",
"get",
"current",
"processing",
"time",
"(",
")",
"-",
"(",
"processing",
"time",
"service",
"get",
"current",
"processing",
"time",
"(",
")",
"%",
"watermark",
"interval",
")",
")",
")",
";",
"assert",
"true",
"(",
"mock",
"stream",
"status",
"maintainer",
"get",
"stream",
"status",
"(",
")",
"is",
"active",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"expected",
"output",
",",
"output",
")",
";",
"break",
";",
"case",
"emit",
"watermark",
":",
"assert",
"true",
"(",
"mock",
"stream",
"status",
"maintainer",
"get",
"stream",
"status",
"(",
")",
"is",
"idle",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"expected",
"output",
",",
"output",
")",
";",
"}",
"processing",
"time",
"service",
"set",
"current",
"time",
"(",
"initial",
"time",
"+",
"10",
"*",
"watermark",
"interval",
")",
";",
"switch",
"(",
"test",
"method",
")",
"{",
"case",
"collect",
":",
"case",
"collect",
"with",
"timestamp",
":",
"expected",
"output",
"add",
"(",
"new",
"watermark",
"(",
"processing",
"time",
"service",
"get",
"current",
"processing",
"time",
"(",
")",
"-",
"(",
"processing",
"time",
"service",
"get",
"current",
"processing",
"time",
"(",
")",
"%",
"watermark",
"interval",
")",
")",
")",
";",
"assert",
"true",
"(",
"mock",
"stream",
"status",
"maintainer",
"get",
"stream",
"status",
"(",
")",
"is",
"active",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"expected",
"output",
",",
"output",
")",
";",
"break",
";",
"case",
"emit",
"watermark",
":",
"assert",
"true",
"(",
"mock",
"stream",
"status",
"maintainer",
"get",
"stream",
"status",
"(",
")",
"is",
"idle",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"expected",
"output",
",",
"output",
")",
";",
"}",
"/",
"/",
"corresponds",
"to",
"step",
"(",
"6",
")",
"of",
"scenario",
"(",
"please",
"see",
"method",
"-",
"level",
"javadoc",
"comment",
")",
"processing",
"time",
"service",
"set",
"current",
"time",
"(",
"initial",
"time",
"+",
"4",
"*",
"idle",
"timeout",
"+",
"idle",
"timeout",
"/",
"10",
")",
";",
"switch",
"(",
"test",
"method",
")",
"{",
"case",
"collect",
":",
"case",
"collect",
"with",
"timestamp",
":",
"assert",
"true",
"(",
"mock",
"stream",
"status",
"maintainer",
"get",
"stream",
"status",
"(",
")",
"is",
"active",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"expected",
"output",
",",
"output",
")",
";",
"break",
";",
"case",
"emit",
"watermark",
":",
"assert",
"true",
"(",
"mock",
"stream",
"status",
"maintainer",
"get",
"stream",
"status",
"(",
")",
"is",
"idle",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"expected",
"output",
",",
"output",
")",
";",
"}",
"/",
"/",
"corresponds",
"to",
"step",
"(",
"7",
")",
"of",
"scenario",
"(",
"please",
"see",
"method",
"-",
"level",
"javadoc",
"comment",
")",
"processing",
"time",
"service",
"set",
"current",
"time",
"(",
"initial",
"time",
"+",
"11",
"*",
"watermark",
"interval",
")",
";",
"assert",
"true",
"(",
"mock",
"stream",
"status",
"maintainer",
"get",
"stream",
"status",
"(",
")",
"is",
"idle",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"expected",
"output",
",",
"output",
")",
";",
"}",
"@",
"parameterized",
"parameters",
"(",
"name",
"=",
"\"",
"test",
"method",
"=",
"{",
"0",
"}"
]
|
[
"get",
"date",
"time"
]
| [
"public",
"offset",
"date",
"time",
"get",
"date",
"time",
"(",
")",
"{",
"return",
"date",
"time",
";",
"}"
]
|
[
"get",
"the",
"project",
"name",
"which",
"corresponds",
"to",
"the",
"specified",
"local",
"project",
"url"
]
| [
"public",
"static",
"string",
"get",
"project",
"name",
"(",
"url",
"local",
"project",
"u",
"r",
"l",
")",
"{",
"if",
"(",
"!",
"is",
"local",
"project",
"u",
"r",
"l",
"(",
"local",
"project",
"u",
"r",
"l",
")",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"invalid",
"local",
"ghidra",
"project",
"url",
"\"",
")",
";",
"}",
"string",
"path",
"=",
"local",
"project",
"u",
"r",
"l",
"get",
"path",
"(",
")",
";",
"int",
"index",
"=",
"path",
"last",
"index",
"of",
"(",
"'",
"/",
"'",
")",
";",
"return",
"path",
"substring",
"(",
"index",
"+",
"1",
")",
";",
"}"
]
|
[
"get",
"the",
"minimum",
"progress"
]
| [
"public",
"double",
"get",
"min",
"progress",
"(",
")",
"{",
"return",
"min",
"progress",
";",
"}"
]
|
[
"adds",
"a",
"new",
"constant",
"dynamic",
"info",
"or",
"constant",
"invoke",
"dynamic",
"info",
"to",
"the",
"constant",
"pool",
"of",
"this",
"symbol",
"table"
]
| [
"private",
"void",
"add",
"constant",
"dynamic",
"or",
"invoke",
"dynamic",
"reference",
"(",
"final",
"int",
"tag",
",",
"final",
"int",
"index",
",",
"final",
"string",
"name",
",",
"final",
"string",
"descriptor",
",",
"final",
"int",
"bootstrap",
"method",
"index",
")",
"{",
"int",
"hash",
"code",
"=",
"hash",
"(",
"tag",
",",
"name",
",",
"descriptor",
",",
"bootstrap",
"method",
"index",
")",
";",
"add",
"(",
"new",
"entry",
"(",
"index",
",",
"tag",
",",
"null",
",",
"name",
",",
"descriptor",
",",
"bootstrap",
"method",
"index",
",",
"hash",
"code",
")",
")",
";",
"}"
]
|
[
"the",
"background",
"color",
",",
"foreground",
"color",
",",
"and",
"font",
"are",
"already",
"set",
"to",
"the",
"defaults",
"from",
"the",
"defaults",
"table",
"before",
"this",
"method",
"is",
"called"
]
| [
"public",
"void",
"install",
"chooser",
"panel",
"(",
"j",
"color",
"chooser",
"enclosing",
"chooser",
")",
"{",
"super",
"install",
"chooser",
"panel",
"(",
"enclosing",
"chooser",
")",
";",
"}"
]
|
[
"obtain",
"a",
"temporary",
"{",
"@",
"link",
"matrix",
"4",
"}",
"object",
",",
"must",
"be",
"free",
"'",
"d",
"using",
"{",
"@",
"link",
"#",
"free",
"all",
"(",
")",
"}"
]
| [
"protected",
"static",
"matrix",
"4",
"obtain",
"m",
"4",
"(",
")",
"{",
"final",
"matrix",
"4",
"result",
"=",
"matrices",
"4",
"pool",
"obtain",
"(",
")",
";",
"return",
"result",
";",
"}"
]
|
[
"returns",
"the",
"value",
"the",
"specified",
"class",
"is",
"mapped",
"to",
",",
"or",
"{",
"@",
"code",
"null",
"}",
"if",
"no",
"entry",
"for",
"this",
"class",
"is",
"present",
"this",
"will",
"only",
"return",
"a",
"value",
"that",
"was",
"bound",
"to",
"this",
"specific",
"class",
",",
"not",
"a",
"value",
"that",
"may",
"have",
"been",
"bound",
"to",
"a",
"subtype"
]
| [
"<",
"t",
"extends",
"b",
">",
"t",
"get",
"instance",
"(",
"class",
"<",
"t",
">",
"type",
")",
";"
]
|
[
"method",
"to",
"set",
"the",
"action",
"'",
"s",
"enablement",
"based",
"on",
"the",
"associated",
"editor",
"model",
"'",
"s",
"current",
"state"
]
| [
"public",
"void",
"adjust",
"enablement",
"(",
")",
";"
]
|
[
"waits",
"for",
"a",
"single",
"response",
"from",
"sandboxfs",
"and",
"returns",
"it"
]
| [
"private",
"static",
"response",
"read",
"response",
"(",
"json",
"reader",
"input",
")",
"throws",
"i",
"o",
"exception",
"{",
"input",
"begin",
"object",
"(",
")",
";",
"string",
"id",
"=",
"null",
";",
"string",
"error",
"=",
"null",
";",
"while",
"(",
"input",
"has",
"next",
"(",
")",
")",
"{",
"string",
"name",
"=",
"input",
"next",
"name",
"(",
")",
";",
"switch",
"(",
"name",
")",
"{",
"case",
"\"",
"error",
"\"",
":",
"if",
"(",
"input",
"peek",
"(",
")",
"=",
"=",
"json",
"token",
"null",
")",
"{",
"input",
"next",
"null",
"(",
")",
";",
"}",
"else",
"{",
"check",
"state",
"(",
"error",
"=",
"=",
"null",
")",
";",
"error",
"=",
"input",
"next",
"string",
"(",
")",
";",
"}",
"break",
";",
"case",
"\"",
"id",
"\"",
":",
"if",
"(",
"input",
"peek",
"(",
")",
"=",
"=",
"json",
"token",
"null",
")",
"{",
"input",
"next",
"null",
"(",
")",
";",
"}",
"else",
"{",
"check",
"state",
"(",
"id",
"=",
"=",
"null",
")",
";",
"id",
"=",
"input",
"next",
"string",
"(",
")",
";",
"}",
"break",
";",
"default",
":",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"invalid",
"field",
"name",
"in",
"response",
":",
"\"",
"+",
"name",
")",
";",
"}",
"}",
"input",
"end",
"object",
"(",
")",
";",
"return",
"new",
"response",
"(",
"id",
",",
"error",
")",
";",
"}"
]
|
[
"test",
"that",
",",
"if",
"the",
"socket",
"factory",
"throws",
"an",
"ioe",
",",
"it",
"properly",
"propagates",
"to",
"the",
"client"
]
| [
"public",
"void",
"test",
"socket",
"factory",
"exception",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"socket",
"factory",
"mock",
"factory",
"=",
"mock",
"(",
"socket",
"factory",
"class",
")",
";",
"do",
"throw",
"(",
"new",
"i",
"o",
"exception",
"(",
"\"",
"injected",
"fault",
"\"",
")",
")",
"when",
"(",
"mock",
"factory",
")",
"create",
"socket",
"(",
")",
";",
"client",
"client",
"=",
"new",
"client",
"(",
"long",
"writable",
"class",
",",
"conf",
",",
"mock",
"factory",
")",
";",
"inet",
"socket",
"address",
"address",
"=",
"new",
"inet",
"socket",
"address",
"(",
"\"",
"127",
"0",
"0",
"1",
"\"",
",",
"10",
")",
";",
"try",
"{",
"call",
"(",
"client",
",",
"random",
"next",
"long",
"(",
")",
",",
"address",
",",
"conf",
")",
";",
"fail",
"(",
"\"",
"expected",
"an",
"exception",
"to",
"have",
"been",
"thrown",
"\"",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"assert",
"true",
"(",
"e",
"get",
"message",
"(",
")",
"contains",
"(",
"\"",
"injected",
"fault",
"\"",
")",
")",
";",
"}",
"finally",
"{",
"client",
"stop",
"(",
")",
";",
"}",
"}"
]
|
[
"<",
"code",
">",
"optional",
"org",
"apache",
"dubbo",
"metadata",
"definition",
"protobuf",
"model",
"phone",
"type",
"type",
"=",
"2",
"[",
"default",
"=",
"home",
"]",
";",
"<",
"code",
">"
]
| [
"public",
"builder",
"set",
"type",
"(",
"org",
"apache",
"dubbo",
"metadata",
"definition",
"protobuf",
"model",
"google",
"p",
"b",
"phone",
"type",
"value",
")",
"{",
"if",
"(",
"value",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"null",
"pointer",
"exception",
"(",
")",
";",
"}",
"bit",
"field",
"0",
"|",
"=",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"2",
";",
"type",
"=",
"value",
"get",
"number",
"(",
")",
";",
"on",
"changed",
"(",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"get",
"the",
"program"
]
| [
"public",
"program",
"get",
"program",
"(",
")",
"{",
"return",
"program",
";",
"}"
]
|
[
"run",
"file",
"operations",
"to",
"create",
"edits",
"for",
"all",
"op",
"codes",
"to",
"be",
"tested",
"the",
"following",
"op",
"codes",
"are",
"deprecated",
"and",
"therefore",
"not",
"tested",
":",
"op",
"datanode",
"add",
"(",
"5",
")",
"op",
"datanode",
"remove",
"(",
"6",
")",
"op",
"set",
"ns",
"quota",
"(",
"11",
")",
"op",
"clear",
"ns",
"quota",
"(",
"12",
")"
]
| [
"private",
"checkpoint",
"signature",
"run",
"operations",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"log",
"info",
"(",
"\"",
"creating",
"edits",
"by",
"performing",
"fs",
"operations",
"\"",
")",
";",
"/",
"/",
"no",
"check",
",",
"if",
"it",
"'",
"s",
"not",
"it",
"throws",
"an",
"exception",
"which",
"is",
"what",
"we",
"want",
"distributed",
"file",
"system",
"dfs",
"=",
"cluster",
"get",
"file",
"system",
"(",
")",
";",
"d",
"f",
"s",
"test",
"util",
"run",
"operations",
"(",
"cluster",
",",
"dfs",
",",
"cluster",
"get",
"configuration",
"(",
"0",
")",
",",
"dfs",
"get",
"default",
"block",
"size",
"(",
")",
",",
"0",
")",
";",
"/",
"/",
"op",
"rolling",
"upgrade",
"start",
"cluster",
"get",
"namesystem",
"(",
")",
"get",
"edit",
"log",
"(",
")",
"log",
"start",
"rolling",
"upgrade",
"(",
"time",
"now",
"(",
")",
")",
";",
"/",
"/",
"op",
"rolling",
"upgrade",
"finalize",
"cluster",
"get",
"namesystem",
"(",
")",
"get",
"edit",
"log",
"(",
")",
"log",
"finalize",
"rolling",
"upgrade",
"(",
"time",
"now",
"(",
")",
")",
";",
"/",
"/",
"force",
"a",
"roll",
"so",
"we",
"get",
"an",
"op",
"end",
"log",
"segment",
"txn",
"return",
"cluster",
"get",
"name",
"node",
"rpc",
"(",
")",
"roll",
"edit",
"log",
"(",
")",
";",
"}"
]
|
[
"filters",
"out",
"hash",
"code",
"from",
"the",
"text",
"useful",
"for",
"writing",
"assertions",
"that",
"contain",
"the",
"string",
"representation",
"of",
"mock",
"objects"
]
| [
"public",
"static",
"string",
"filter",
"hash",
"code",
"(",
"string",
"text",
")",
"{",
"return",
"text",
"replace",
"all",
"(",
"\"",
"hash",
"code",
":",
"(",
"\\",
"\\",
"d",
")",
"+",
"\\",
"\\",
"\"",
",",
"\"",
"hash",
"code",
":",
"xxx",
"\"",
")",
";",
"}"
]
|
[
"run",
"the",
"given",
"action",
"after",
"the",
"completion",
"of",
"the",
"given",
"future",
"the",
"given",
"future",
"can",
"be",
"completed",
"normally",
"or",
"exceptionally",
"in",
"case",
"of",
"an",
"exceptional",
"completion",
"the",
",",
"the",
"action",
"'",
"s",
"exception",
"will",
"be",
"added",
"to",
"the",
"initial",
"exception"
]
| [
"public",
"static",
"completable",
"future",
"<",
"void",
">",
"run",
"afterwards",
"async",
"(",
"completable",
"future",
"<",
"?",
">",
"future",
",",
"runnable",
"with",
"exception",
"runnable",
",",
"executor",
"executor",
")",
"{",
"final",
"completable",
"future",
"<",
"void",
">",
"result",
"future",
"=",
"new",
"completable",
"future",
"<",
">",
"(",
")",
";",
"future",
"when",
"complete",
"async",
"(",
"(",
"object",
"ignored",
",",
"throwable",
"throwable",
")",
"-",
">",
"{",
"try",
"{",
"runnable",
"run",
"(",
")",
";",
"}",
"catch",
"(",
"throwable",
"e",
")",
"{",
"throwable",
"=",
"exception",
"utils",
"first",
"or",
"suppressed",
"(",
"e",
",",
"throwable",
")",
";",
"}",
"if",
"(",
"throwable",
"!",
"=",
"null",
")",
"{",
"result",
"future",
"complete",
"exceptionally",
"(",
"throwable",
")",
";",
"}",
"else",
"{",
"result",
"future",
"complete",
"(",
"null",
")",
";",
"}",
"}",
",",
"executor",
")",
";",
"return",
"result",
"future",
";",
"}"
]
|
[
"collect",
"all",
"the",
"storage",
"movement",
"attempt",
"finished",
"blocks"
]
| [
"void",
"handle",
"(",
"block",
"movement",
"attempt",
"finished",
"move",
"attempt",
"finished",
"blk",
")",
";"
]
|
[
"removes",
"the",
"given",
"list",
"of",
"vertices",
"and",
"its",
"edges",
"from",
"the",
"graph"
]
| [
"public",
"graph",
"<",
"k",
",",
"vv",
",",
"ev",
">",
"remove",
"vertices",
"(",
"list",
"<",
"vertex",
"<",
"k",
",",
"vv",
">",
">",
"vertices",
"to",
"be",
"removed",
")",
"{",
"return",
"remove",
"vertices",
"(",
"this",
"context",
"from",
"collection",
"(",
"vertices",
"to",
"be",
"removed",
")",
")",
";",
"}"
]
|
[
"performs",
"operations",
"required",
"to",
"setup",
"the",
"dns",
"registry",
"instance",
"(",
"e",
"g",
"sets",
"up",
"a",
"path",
"listener",
"to",
"react",
"to",
"service",
"record",
"creationdeletion",
"and",
"invoke",
"the",
"appropriate",
"registry",
"method",
")"
]
| [
"private",
"void",
"manage",
"registry",
"d",
"n",
"s",
"(",
")",
"{",
"try",
"{",
"registry",
"operations",
"monitor",
"registry",
"entries",
"(",
")",
";",
"registry",
"operations",
"register",
"path",
"listener",
"(",
"new",
"path",
"listener",
"(",
")",
"{",
"private",
"string",
"registry",
"root",
"=",
"get",
"config",
"(",
")",
"get",
"(",
"registry",
"constants",
"key",
"registry",
"zk",
"root",
",",
"registry",
"constants",
"default",
"zk",
"registry",
"root",
")",
";",
"@",
"override",
"public",
"void",
"node",
"added",
"(",
"string",
"path",
")",
"throws",
"i",
"o",
"exception",
"{",
"/",
"/",
"get",
"a",
"listing",
"of",
"service",
"records",
"string",
"relative",
"path",
"=",
"get",
"path",
"relative",
"to",
"registry",
"root",
"(",
"path",
")",
";",
"string",
"child",
"=",
"registry",
"path",
"utils",
"last",
"path",
"entry",
"(",
"path",
")",
";",
"map",
"<",
"string",
",",
"registry",
"path",
"status",
">",
"map",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"map",
"put",
"(",
"child",
",",
"registry",
"operations",
"stat",
"(",
"relative",
"path",
")",
")",
";",
"map",
"<",
"string",
",",
"service",
"record",
">",
"records",
"=",
"registry",
"utils",
"extract",
"service",
"records",
"(",
"registry",
"operations",
",",
"get",
"adjusted",
"parent",
"path",
"(",
"path",
")",
",",
"map",
")",
";",
"process",
"service",
"records",
"(",
"records",
",",
"register",
")",
";",
"path",
"to",
"record",
"map",
"put",
"all",
"(",
"records",
")",
";",
"}",
"private",
"string",
"get",
"adjusted",
"parent",
"path",
"(",
"string",
"path",
")",
"{",
"preconditions",
"check",
"not",
"null",
"(",
"path",
")",
";",
"string",
"adjusted",
"path",
"=",
"null",
";",
"adjusted",
"path",
"=",
"get",
"path",
"relative",
"to",
"registry",
"root",
"(",
"path",
")",
";",
"try",
"{",
"return",
"registry",
"path",
"utils",
"parent",
"of",
"(",
"adjusted",
"path",
")",
";",
"}",
"catch",
"(",
"path",
"not",
"found",
"exception",
"e",
")",
"{",
"/",
"/",
"attempt",
"to",
"use",
"passed",
"in",
"path",
"return",
"path",
";",
"}",
"}",
"private",
"string",
"get",
"path",
"relative",
"to",
"registry",
"root",
"(",
"string",
"path",
")",
"{",
"string",
"adjusted",
"path",
";",
"if",
"(",
"path",
"equals",
"(",
"registry",
"root",
")",
")",
"{",
"adjusted",
"path",
"=",
"\"",
"/",
"\"",
";",
"}",
"else",
"{",
"adjusted",
"path",
"=",
"path",
"substring",
"(",
"registry",
"root",
"length",
"(",
")",
")",
";",
"}",
"return",
"adjusted",
"path",
";",
"}",
"@",
"override",
"public",
"void",
"node",
"removed",
"(",
"string",
"path",
")",
"throws",
"i",
"o",
"exception",
"{",
"service",
"record",
"record",
"=",
"path",
"to",
"record",
"map",
"remove",
"(",
"path",
"substring",
"(",
"registry",
"root",
"length",
"(",
")",
")",
")",
";",
"process",
"service",
"record",
"(",
"path",
",",
"record",
",",
"delete",
")",
";",
"}",
"}",
")",
";",
"/",
"/",
"create",
"listener",
"for",
"record",
"deletions",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"log",
"warn",
"(",
"\"",
"unable",
"to",
"monitor",
"the",
"registry",
"dns",
"support",
"disabled",
"\"",
",",
"e",
")",
";",
"}",
"}"
]
|
[
"writes",
"up",
"to",
"{",
"@",
"code",
"allowed",
"bytes",
"}",
"of",
"the",
"encapsulated",
"payload",
"to",
"the",
"stream",
"note",
"that",
"a",
"value",
"of",
"0",
"may",
"be",
"passed",
"which",
"will",
"allow",
"payloads",
"with",
"flow",
"-",
"control",
"size",
"=",
"=",
"0",
"to",
"be",
"written",
"the",
"flow",
"-",
"controller",
"may",
"call",
"this",
"method",
"multiple",
"times",
"with",
"different",
"values",
"until",
"the",
"payload",
"is",
"fully",
"written",
",",
"i",
"e",
"it",
"'",
"s",
"size",
"after",
"the",
"write",
"is",
"0",
"when",
"an",
"exception",
"is",
"thrown",
"the",
"{",
"@",
"link",
"http",
"2",
"remote",
"flow",
"controller",
"}",
"will",
"make",
"a",
"call",
"to",
"{",
"@",
"link",
"#",
"error",
"(",
"channel",
"handler",
"context",
",",
"throwable",
")",
"}"
]
| [
"void",
"write",
"(",
"channel",
"handler",
"context",
"ctx",
",",
"int",
"allowed",
"bytes",
")",
";"
]
|
[
"get",
"the",
"text",
"for",
"this",
"suggestion"
]
| [
"public",
"string",
"text",
"(",
")",
"{",
"return",
"this",
"text",
";",
"}"
]
|
[
"return",
"whether",
"this",
"parameter",
"is",
"declared",
"in",
"a",
"function"
]
| [
"public",
"boolean",
"is",
"function",
"(",
")",
"{",
"return",
"this",
"function",
";",
"}"
]
|
[
"analyzes",
"text",
"using",
"the",
"analyzer",
"defined",
"on",
"a",
"specific",
"field",
"within",
"an",
"index"
]
| [
"public",
"static",
"analyze",
"request",
"with",
"field",
"(",
"string",
"index",
",",
"string",
"field",
",",
"string",
"text",
")",
"{",
"return",
"new",
"analyze",
"request",
"(",
"index",
",",
"null",
",",
"null",
",",
"field",
",",
"text",
")",
";",
"}"
]
|
[
"set",
"owner",
"for",
"an",
"existing",
"file"
]
| [
"void",
"set",
"owner",
"(",
"string",
"src",
",",
"string",
"username",
",",
"string",
"group",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"string",
"operation",
"name",
"=",
"\"",
"set",
"owner",
"\"",
";",
"file",
"status",
"audit",
"stat",
"=",
"null",
";",
"check",
"operation",
"(",
"operation",
"category",
"write",
")",
";",
"final",
"f",
"s",
"permission",
"checker",
"pc",
"=",
"get",
"permission",
"checker",
"(",
")",
";",
"f",
"s",
"permission",
"checker",
"set",
"operation",
"type",
"(",
"operation",
"name",
")",
";",
"try",
"{",
"write",
"lock",
"(",
")",
";",
"try",
"{",
"check",
"operation",
"(",
"operation",
"category",
"write",
")",
";",
"check",
"name",
"node",
"safe",
"mode",
"(",
"\"",
"cannot",
"set",
"owner",
"for",
"\"",
"+",
"src",
")",
";",
"audit",
"stat",
"=",
"f",
"s",
"dir",
"attr",
"op",
"set",
"owner",
"(",
"dir",
",",
"pc",
",",
"src",
",",
"username",
",",
"group",
")",
";",
"}",
"finally",
"{",
"write",
"unlock",
"(",
"operation",
"name",
",",
"get",
"lock",
"report",
"info",
"supplier",
"(",
"src",
",",
"null",
",",
"audit",
"stat",
")",
")",
";",
"}",
"}",
"catch",
"(",
"access",
"control",
"exception",
"e",
")",
"{",
"log",
"audit",
"event",
"(",
"false",
",",
"operation",
"name",
",",
"src",
")",
";",
"throw",
"e",
";",
"}",
"get",
"edit",
"log",
"(",
")",
"log",
"sync",
"(",
")",
";",
"log",
"audit",
"event",
"(",
"true",
",",
"operation",
"name",
",",
"src",
",",
"null",
",",
"audit",
"stat",
")",
";",
"}"
]
|
[
"test",
"the",
"property",
"'",
"return",
"'"
]
| [
"public",
"void",
"return",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"return",
"}"
]
|
[
"moves",
"all",
"the",
"blocks",
"from",
"{",
"@",
"code",
"srcs",
"}",
"and",
"appends",
"them",
"to",
"{",
"@",
"code",
"target",
"}",
"to",
"avoid",
"rollbacks",
"we",
"will",
"verify",
"validity",
"of",
"all",
"of",
"the",
"args",
"before",
"we",
"start",
"actual",
"move",
"this",
"does",
"not",
"support",
"\"",
"inodes",
"\"",
"relative",
"path"
]
| [
"void",
"concat",
"(",
"string",
"target",
",",
"string",
"[",
"]",
"srcs",
",",
"boolean",
"log",
"retry",
"cache",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"string",
"operation",
"name",
"=",
"\"",
"concat",
"\"",
";",
"file",
"status",
"stat",
"=",
"null",
";",
"final",
"f",
"s",
"permission",
"checker",
"pc",
"=",
"get",
"permission",
"checker",
"(",
")",
";",
"f",
"s",
"permission",
"checker",
"set",
"operation",
"type",
"(",
"operation",
"name",
")",
";",
"check",
"operation",
"(",
"operation",
"category",
"write",
")",
";",
"string",
"srcs",
"str",
"=",
"arrays",
"to",
"string",
"(",
"srcs",
")",
";",
"try",
"{",
"write",
"lock",
"(",
")",
";",
"try",
"{",
"check",
"operation",
"(",
"operation",
"category",
"write",
")",
";",
"check",
"name",
"node",
"safe",
"mode",
"(",
"\"",
"cannot",
"concat",
"\"",
"+",
"target",
")",
";",
"stat",
"=",
"f",
"s",
"dir",
"concat",
"op",
"concat",
"(",
"dir",
",",
"pc",
",",
"target",
",",
"srcs",
",",
"log",
"retry",
"cache",
")",
";",
"}",
"finally",
"{",
"write",
"unlock",
"(",
"operation",
"name",
",",
"get",
"lock",
"report",
"info",
"supplier",
"(",
"srcs",
"str",
",",
"target",
",",
"stat",
")",
")",
";",
"}",
"}",
"catch",
"(",
"access",
"control",
"exception",
"ace",
")",
"{",
"log",
"audit",
"event",
"(",
"false",
",",
"operation",
"name",
",",
"srcs",
"str",
",",
"target",
",",
"stat",
")",
";",
"throw",
"ace",
";",
"}",
"get",
"edit",
"log",
"(",
")",
"log",
"sync",
"(",
")",
";",
"log",
"audit",
"event",
"(",
"true",
",",
"operation",
"name",
",",
"srcs",
"str",
",",
"target",
",",
"stat",
")",
";",
"}"
]
|
[
"builds",
"jts",
"shape",
"from",
"a",
"geometry",
"this",
"method",
"is",
"needed",
"to",
"handle",
"legacy",
"indices",
"and",
"will",
"be",
"removed",
"when",
"we",
"no",
"longer",
"need",
"to",
"build",
"jts",
"shapes"
]
| [
"private",
"static",
"shape",
"build",
"s",
"4",
"j",
"(",
"geometry",
"geometry",
")",
"{",
"return",
"geometry",
"to",
"shape",
"builder",
"(",
"geometry",
")",
"build",
"s",
"4",
"j",
"(",
")",
";",
"}"
]
|
[
"returns",
"pet",
"inventories",
"by",
"status",
"returns",
"a",
"map",
"of",
"status",
"codes",
"to",
"quantities"
]
| [
"public",
"api",
"response",
"<",
"map",
"<",
"string",
",",
"integer",
">",
">",
"get",
"inventory",
"with",
"http",
"info",
"(",
")",
"throws",
"api",
"exception",
"{",
"object",
"local",
"var",
"post",
"body",
"=",
"null",
";",
"/",
"/",
"create",
"path",
"and",
"map",
"variables",
"string",
"local",
"var",
"path",
"=",
"\"",
"/",
"store",
"/",
"inventory",
"\"",
";",
"/",
"/",
"query",
"params",
"list",
"<",
"pair",
">",
"local",
"var",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
"pair",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"header",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"cookie",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"object",
">",
"local",
"var",
"form",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"object",
">",
"(",
")",
";",
"final",
"string",
"[",
"]",
"local",
"var",
"accepts",
"=",
"{",
"\"",
"application",
"/",
"json",
"\"",
"}",
";",
"final",
"string",
"local",
"var",
"accept",
"=",
"api",
"client",
"select",
"header",
"accept",
"(",
"local",
"var",
"accepts",
")",
";",
"final",
"string",
"[",
"]",
"local",
"var",
"content",
"types",
"=",
"{",
"}",
";",
"final",
"string",
"local",
"var",
"content",
"type",
"=",
"api",
"client",
"select",
"header",
"content",
"type",
"(",
"local",
"var",
"content",
"types",
")",
";",
"string",
"[",
"]",
"local",
"var",
"auth",
"names",
"=",
"new",
"string",
"[",
"]",
"{",
"\"",
"api",
"key",
"\"",
"}",
";",
"generic",
"type",
"<",
"map",
"<",
"string",
",",
"integer",
">",
">",
"local",
"var",
"return",
"type",
"=",
"new",
"generic",
"type",
"<",
"map",
"<",
"string",
",",
"integer",
">",
">",
"(",
")",
"{",
"}",
";",
"return",
"api",
"client",
"invoke",
"a",
"p",
"i",
"(",
"\"",
"store",
"api",
"get",
"inventory",
"\"",
",",
"local",
"var",
"path",
",",
"\"",
"get",
"\"",
",",
"local",
"var",
"query",
"params",
",",
"local",
"var",
"post",
"body",
",",
"local",
"var",
"header",
"params",
",",
"local",
"var",
"cookie",
"params",
",",
"local",
"var",
"form",
"params",
",",
"local",
"var",
"accept",
",",
"local",
"var",
"content",
"type",
",",
"local",
"var",
"auth",
"names",
",",
"local",
"var",
"return",
"type",
",",
"false",
")",
";",
"}"
]
|
[
"tests",
"that",
"the",
"registered",
"classes",
"in",
"kryo",
"did",
"not",
"change",
"once",
"we",
"have",
"proper",
"serializer",
"versioning",
"this",
"test",
"will",
"become",
"obsolete",
"but",
"currently",
"a",
"change",
"in",
"the",
"serializers",
"can",
"break",
"savepoint",
"backwards",
"compatibility",
"between",
"flink",
"versions"
]
| [
"public",
"void",
"test",
"default",
"kryo",
"registered",
"classes",
"did",
"not",
"change",
"(",
")",
"throws",
"exception",
"{",
"final",
"kryo",
"kryo",
"=",
"new",
"kryo",
"serializer",
"<",
">",
"(",
"integer",
"class",
",",
"new",
"execution",
"config",
"(",
")",
")",
"get",
"kryo",
"(",
")",
";",
"try",
"(",
"buffered",
"reader",
"reader",
"=",
"new",
"buffered",
"reader",
"(",
"new",
"input",
"stream",
"reader",
"(",
"get",
"class",
"(",
")",
"get",
"class",
"loader",
"(",
")",
"get",
"resource",
"as",
"stream",
"(",
"\"",
"flink",
"11",
"-",
"kryo",
"registrations",
"\"",
")",
")",
")",
")",
"{",
"string",
"line",
";",
"while",
"(",
"(",
"line",
"=",
"reader",
"read",
"line",
"(",
")",
")",
"!",
"=",
"null",
")",
"{",
"string",
"[",
"]",
"split",
"=",
"line",
"split",
"(",
"\"",
",",
"\"",
")",
";",
"final",
"int",
"tag",
"=",
"integer",
"parse",
"int",
"(",
"split",
"[",
"0",
"]",
")",
";",
"final",
"string",
"registered",
"class",
"=",
"split",
"[",
"1",
"]",
";",
"registration",
"registration",
"=",
"kryo",
"get",
"registration",
"(",
"tag",
")",
";",
"if",
"(",
"registration",
"=",
"=",
"null",
")",
"{",
"fail",
"(",
"string",
"format",
"(",
"\"",
"registration",
"for",
"%",
"d",
"=",
"%",
"s",
"got",
"lost",
"\"",
",",
"tag",
",",
"registered",
"class",
")",
")",
";",
"}",
"else",
"if",
"(",
"!",
"registered",
"class",
"equals",
"(",
"registration",
"get",
"type",
"(",
")",
"get",
"name",
"(",
")",
")",
")",
"{",
"fail",
"(",
"string",
"format",
"(",
"\"",
"registration",
"for",
"%",
"d",
"=",
"%",
"s",
"changed",
"to",
"%",
"s",
"\"",
",",
"tag",
",",
"registered",
"class",
",",
"registration",
"get",
"type",
"(",
")",
"get",
"name",
"(",
")",
")",
")",
";",
"}",
"}",
"}",
"}"
]
|
[
"returns",
"the",
"string",
"str",
"right",
"-",
"padded",
"with",
"the",
"string",
"pad",
"to",
"a",
"length",
"of",
"len",
"characters",
"if",
"str",
"is",
"longer",
"than",
"len",
",",
"the",
"return",
"value",
"is",
"shortened",
"to",
"len",
"characters"
]
| [
"public",
"static",
"string",
"rpad",
"(",
"string",
"base",
",",
"int",
"len",
",",
"string",
"pad",
")",
"{",
"if",
"(",
"len",
"<",
"0",
"|",
"|",
"\"",
"\"",
"equals",
"(",
"pad",
")",
")",
"{",
"return",
"null",
";",
"}",
"else",
"if",
"(",
"len",
"=",
"=",
"0",
")",
"{",
"return",
"\"",
"\"",
";",
"}",
"char",
"[",
"]",
"data",
"=",
"new",
"char",
"[",
"len",
"]",
";",
"char",
"[",
"]",
"base",
"chars",
"=",
"base",
"to",
"char",
"array",
"(",
")",
";",
"char",
"[",
"]",
"pad",
"chars",
"=",
"pad",
"to",
"char",
"array",
"(",
")",
";",
"int",
"pos",
"=",
"0",
";",
"/",
"/",
"copy",
"the",
"base",
"while",
"(",
"pos",
"<",
"base",
"length",
"(",
")",
"&",
"&",
"pos",
"<",
"len",
")",
"{",
"data",
"[",
"pos",
"]",
"=",
"base",
"chars",
"[",
"pos",
"]",
";",
"pos",
"+",
"=",
"1",
";",
"}",
"/",
"/",
"copy",
"the",
"padding",
"while",
"(",
"pos",
"<",
"len",
")",
"{",
"int",
"i",
"=",
"0",
";",
"while",
"(",
"i",
"<",
"pad",
"length",
"(",
")",
"&",
"&",
"i",
"<",
"len",
"-",
"pos",
")",
"{",
"data",
"[",
"pos",
"+",
"i",
"]",
"=",
"pad",
"chars",
"[",
"i",
"]",
";",
"i",
"+",
"=",
"1",
";",
"}",
"pos",
"+",
"=",
"pad",
"length",
"(",
")",
";",
"}",
"return",
"new",
"string",
"(",
"data",
")",
";",
"}"
]
|
[
"decide",
"machine",
"compensate",
"status"
]
| [
"public",
"static",
"void",
"decide",
"machine",
"compensate",
"status",
"(",
"state",
"machine",
"instance",
"state",
"machine",
"instance",
",",
"compensation",
"holder",
"compensation",
"holder",
")",
"{",
"if",
"(",
"state",
"machine",
"instance",
"get",
"status",
"(",
")",
"=",
"=",
"null",
"|",
"|",
"execution",
"status",
"ru",
"equals",
"(",
"state",
"machine",
"instance",
"get",
"status",
"(",
")",
")",
")",
"{",
"state",
"machine",
"instance",
"set",
"status",
"(",
"execution",
"status",
"un",
")",
";",
"}",
"if",
"(",
"!",
"compensation",
"holder",
"get",
"state",
"stack",
"need",
"compensation",
"(",
")",
"is",
"empty",
"(",
")",
")",
"{",
"boolean",
"has",
"compensate",
"s",
"uor",
"u",
"n",
"=",
"false",
";",
"for",
"(",
"state",
"instance",
"for",
"compensate",
"state",
":",
"compensation",
"holder",
"get",
"states",
"for",
"compensation",
"(",
")",
"values",
"(",
")",
")",
"{",
"if",
"(",
"execution",
"status",
"un",
"equals",
"(",
"for",
"compensate",
"state",
"get",
"status",
"(",
")",
")",
"|",
"|",
"execution",
"status",
"su",
"equals",
"(",
"for",
"compensate",
"state",
"get",
"status",
"(",
")",
")",
")",
"{",
"has",
"compensate",
"s",
"uor",
"u",
"n",
"=",
"true",
";",
"break",
";",
"}",
"}",
"if",
"(",
"has",
"compensate",
"s",
"uor",
"u",
"n",
")",
"{",
"state",
"machine",
"instance",
"set",
"compensation",
"status",
"(",
"execution",
"status",
"un",
")",
";",
"}",
"else",
"{",
"state",
"machine",
"instance",
"set",
"compensation",
"status",
"(",
"execution",
"status",
"fa",
")",
";",
"}",
"}",
"else",
"{",
"boolean",
"has",
"compensate",
"error",
"=",
"false",
";",
"for",
"(",
"state",
"instance",
"for",
"compensate",
"state",
":",
"compensation",
"holder",
"get",
"states",
"for",
"compensation",
"(",
")",
"values",
"(",
")",
")",
"{",
"if",
"(",
"!",
"execution",
"status",
"su",
"equals",
"(",
"for",
"compensate",
"state",
"get",
"status",
"(",
")",
")",
")",
"{",
"has",
"compensate",
"error",
"=",
"true",
";",
"break",
";",
"}",
"}",
"if",
"(",
"has",
"compensate",
"error",
")",
"{",
"state",
"machine",
"instance",
"set",
"compensation",
"status",
"(",
"execution",
"status",
"un",
")",
";",
"}",
"else",
"{",
"state",
"machine",
"instance",
"set",
"compensation",
"status",
"(",
"execution",
"status",
"su",
")",
";",
"}",
"}",
"}"
]
|
[
"all",
"job",
"-",
"side",
"conflict",
"resolution",
"the",
"partition",
"path",
"conflict",
"resolution",
"actions",
"are",
":",
"fail",
":",
"assume",
"checking",
"has",
"taken",
"place",
"earlier",
";",
"no",
"more",
"checks",
"append",
":",
"allowed",
";",
"no",
"need",
"to",
"check",
"replace",
"deletes",
"all",
"existing",
"partitions"
]
| [
"public",
"void",
"pre",
"commit",
"job",
"(",
"final",
"job",
"context",
"context",
",",
"final",
"active",
"commit",
"pending",
")",
"throws",
"i",
"o",
"exception",
"{",
"file",
"system",
"fs",
"=",
"get",
"dest",
"f",
"s",
"(",
")",
";",
"/",
"/",
"enforce",
"conflict",
"resolution",
"configuration",
"fs",
"conf",
"=",
"fs",
"get",
"conf",
"(",
")",
";",
"boolean",
"should",
"precheck",
"pending",
"files",
"=",
"true",
";",
"switch",
"(",
"get",
"conflict",
"resolution",
"mode",
"(",
"context",
",",
"fs",
"conf",
")",
")",
"{",
"case",
"fail",
":",
"/",
"/",
"fail",
"checking",
"is",
"done",
"on",
"the",
"task",
"side",
",",
"so",
"this",
"does",
"nothing",
"break",
";",
"case",
"append",
":",
"/",
"/",
"no",
"check",
"is",
"needed",
"because",
"the",
"output",
"may",
"exist",
"for",
"appending",
"break",
";",
"case",
"replace",
":",
"/",
"/",
"identify",
"and",
"replace",
"the",
"destination",
"partitions",
"replace",
"partitions",
"(",
"context",
",",
"pending",
")",
";",
"/",
"/",
"and",
"so",
"there",
"is",
"no",
"need",
"to",
"do",
"another",
"check",
"should",
"precheck",
"pending",
"files",
"=",
"false",
";",
"break",
";",
"default",
":",
"throw",
"new",
"path",
"commit",
"exception",
"(",
"\"",
"\"",
",",
"get",
"role",
"(",
")",
"+",
"\"",
":",
"unknown",
"conflict",
"resolution",
"mode",
":",
"\"",
"+",
"get",
"conflict",
"resolution",
"mode",
"(",
"context",
",",
"fs",
"conf",
")",
")",
";",
"}",
"if",
"(",
"should",
"precheck",
"pending",
"files",
")",
"{",
"precommit",
"check",
"pending",
"files",
"(",
"context",
",",
"pending",
")",
";",
"}",
"}"
]
|
[
"test",
"the",
"property",
"'",
"type",
"'"
]
| [
"public",
"void",
"type",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"type",
"}"
]
|
[
"handle",
"ticket",
"validation",
"model",
"and",
"view"
]
| [
"protected",
"model",
"and",
"view",
"handle",
"ticket",
"validation",
"(",
"final",
"http",
"servlet",
"request",
"request",
",",
"final",
"web",
"application",
"service",
"service",
",",
"final",
"string",
"service",
"ticket",
"id",
")",
"{",
"var",
"proxy",
"granting",
"ticket",
"id",
"=",
"(",
"proxy",
"granting",
"ticket",
")",
"null",
";",
"val",
"service",
"credential",
"=",
"get",
"service",
"credentials",
"from",
"request",
"(",
"service",
",",
"request",
")",
";",
"if",
"(",
"service",
"credential",
"!",
"=",
"null",
")",
"{",
"try",
"{",
"proxy",
"granting",
"ticket",
"id",
"=",
"handle",
"proxy",
"granting",
"ticket",
"delivery",
"(",
"service",
"ticket",
"id",
",",
"service",
"credential",
")",
";",
"}",
"catch",
"(",
"final",
"authentication",
"exception",
"e",
")",
"{",
"logger",
"warn",
"(",
"\"",
"failed",
"to",
"authenticate",
"service",
"credential",
"[",
"{",
"}",
"]",
"\"",
",",
"service",
"credential",
")",
";",
"val",
"description",
"=",
"get",
"ticket",
"validation",
"error",
"description",
"(",
"cas",
"protocol",
"constants",
"error",
"code",
"invalid",
"proxy",
"callback",
",",
"new",
"object",
"[",
"]",
"{",
"service",
"credential",
"get",
"id",
"(",
")",
"}",
",",
"request",
")",
";",
"return",
"generate",
"error",
"view",
"(",
"cas",
"protocol",
"constants",
"error",
"code",
"invalid",
"proxy",
"callback",
",",
"description",
",",
"request",
",",
"service",
")",
";",
"}",
"catch",
"(",
"final",
"invalid",
"ticket",
"exception",
"e",
")",
"{",
"logger",
"error",
"(",
"\"",
"failed",
"to",
"create",
"proxy",
"granting",
"ticket",
"due",
"to",
"an",
"invalid",
"ticket",
"for",
"[",
"{",
"}",
"]",
"\"",
",",
"service",
"credential",
")",
";",
"logging",
"utils",
"error",
"(",
"logger",
",",
"e",
")",
";",
"val",
"description",
"=",
"get",
"ticket",
"validation",
"error",
"description",
"(",
"e",
"get",
"code",
"(",
")",
",",
"new",
"object",
"[",
"]",
"{",
"service",
"ticket",
"id",
"}",
",",
"request",
")",
";",
"return",
"generate",
"error",
"view",
"(",
"e",
"get",
"code",
"(",
")",
",",
"description",
",",
"request",
",",
"service",
")",
";",
"}",
"catch",
"(",
"final",
"abstract",
"ticket",
"exception",
"e",
")",
"{",
"logger",
"error",
"(",
"\"",
"failed",
"to",
"create",
"proxy",
"granting",
"ticket",
"for",
"[",
"{",
"}",
"]",
"\"",
",",
"service",
"credential",
")",
";",
"logging",
"utils",
"error",
"(",
"logger",
",",
"e",
")",
";",
"val",
"description",
"=",
"get",
"ticket",
"validation",
"error",
"description",
"(",
"e",
"get",
"code",
"(",
")",
",",
"new",
"object",
"[",
"]",
"{",
"service",
"credential",
"get",
"id",
"(",
")",
"}",
",",
"request",
")",
";",
"return",
"generate",
"error",
"view",
"(",
"e",
"get",
"code",
"(",
")",
",",
"description",
",",
"request",
",",
"service",
")",
";",
"}",
"}",
"val",
"assertion",
"=",
"validate",
"service",
"ticket",
"(",
"service",
",",
"service",
"ticket",
"id",
")",
";",
"if",
"(",
"!",
"validate",
"assertion",
"(",
"request",
",",
"service",
"ticket",
"id",
",",
"assertion",
",",
"service",
")",
")",
"{",
"val",
"description",
"=",
"get",
"ticket",
"validation",
"error",
"description",
"(",
"cas",
"protocol",
"constants",
"error",
"code",
"invalid",
"ticket",
",",
"new",
"object",
"[",
"]",
"{",
"service",
"ticket",
"id",
"}",
",",
"request",
")",
";",
"return",
"generate",
"error",
"view",
"(",
"cas",
"protocol",
"constants",
"error",
"code",
"invalid",
"ticket",
",",
"description",
",",
"request",
",",
"service",
")",
";",
"}",
"val",
"ctx",
"result",
"=",
"service",
"validate",
"configuration",
"context",
"get",
"requested",
"context",
"validator",
"(",
")",
"validate",
"authentication",
"context",
"(",
"assertion",
",",
"request",
")",
";",
"if",
"(",
"!",
"ctx",
"result",
"get",
"key",
"(",
")",
")",
"{",
"throw",
"new",
"unsatisfied",
"authentication",
"context",
"ticket",
"validation",
"exception",
"(",
"assertion",
"get",
"service",
"(",
")",
")",
";",
"}",
"var",
"proxy",
"iou",
"=",
"string",
"utils",
"empty",
";",
"val",
"proxy",
"handler",
"=",
"service",
"validate",
"configuration",
"context",
"get",
"proxy",
"handler",
"(",
")",
";",
"if",
"(",
"service",
"credential",
"!",
"=",
"null",
"&",
"&",
"proxy",
"handler",
"!",
"=",
"null",
"&",
"&",
"proxy",
"handler",
"can",
"handle",
"(",
"service",
"credential",
")",
")",
"{",
"val",
"registered",
"service",
"=",
"(",
"(",
"http",
"based",
"service",
"credential",
")",
"service",
"credential",
")",
"get",
"service",
"(",
")",
";",
"val",
"authorized",
"to",
"release",
"proxy",
"granting",
"ticket",
"=",
"registered",
"service",
"get",
"attribute",
"release",
"policy",
"(",
")",
"is",
"authorized",
"to",
"release",
"proxy",
"granting",
"ticket",
"(",
")",
";",
"if",
"(",
"!",
"authorized",
"to",
"release",
"proxy",
"granting",
"ticket",
")",
"{",
"logger",
"debug",
"(",
"\"",
"service",
"[",
"{",
"}",
"]",
"is",
"not",
"authorized",
"to",
"release",
"the",
"pgt",
"directly",
",",
"make",
"a",
"proxy",
"callback",
"\"",
",",
"registered",
"service",
")",
";",
"proxy",
"iou",
"=",
"handle",
"proxy",
"iou",
"delivery",
"(",
"service",
"credential",
",",
"proxy",
"granting",
"ticket",
"id",
")",
";",
"if",
"(",
"string",
"utils",
"is",
"empty",
"(",
"proxy",
"iou",
")",
")",
"{",
"val",
"description",
"=",
"get",
"ticket",
"validation",
"error",
"description",
"(",
"cas",
"protocol",
"constants",
"error",
"code",
"invalid",
"proxy",
"callback",
",",
"new",
"object",
"[",
"]",
"{",
"service",
"credential",
"get",
"id",
"(",
")",
"}",
",",
"request",
")",
";",
"return",
"generate",
"error",
"view",
"(",
"cas",
"protocol",
"constants",
"error",
"code",
"invalid",
"proxy",
"callback",
",",
"description",
",",
"request",
",",
"service",
")",
";",
"}",
"}",
"else",
"{",
"logger",
"debug",
"(",
"\"",
"service",
"[",
"{",
"}",
"]",
"is",
"authorized",
"to",
"release",
"the",
"pgt",
"directly",
",",
"skip",
"the",
"proxy",
"callback",
"\"",
",",
"registered",
"service",
")",
";",
"}",
"}",
"else",
"{",
"logger",
"debug",
"(",
"\"",
"no",
"service",
"credentials",
"specified",
",",
"and",
"/",
"or",
"the",
"proxy",
"handler",
"[",
"{",
"}",
"]",
"cannot",
"handle",
"credentials",
"\"",
",",
"proxy",
"handler",
")",
";",
"}",
"on",
"successful",
"validation",
"(",
"service",
"ticket",
"id",
",",
"assertion",
")",
";",
"logger",
"debug",
"(",
"\"",
"successfully",
"validated",
"service",
"ticket",
"[",
"{",
"}",
"]",
"for",
"service",
"[",
"{",
"}",
"]",
"\"",
",",
"service",
"ticket",
"id",
",",
"service",
"get",
"id",
"(",
")",
")",
";",
"return",
"generate",
"success",
"view",
"(",
"assertion",
",",
"proxy",
"iou",
",",
"service",
",",
"request",
",",
"ctx",
"result",
"get",
"value",
"(",
")",
",",
"proxy",
"granting",
"ticket",
"id",
")",
";",
"}"
]
|
[
"an",
"array",
"of",
"service",
"components",
"which",
"should",
"be",
"in",
"ready",
"state",
"(",
"as",
"defined",
"by",
"readiness",
"check",
")",
",",
"before",
"this",
"component",
"can",
"be",
"started",
"the",
"dependencies",
"across",
"all",
"components",
"of",
"a",
"service",
"should",
"be",
"represented",
"as",
"a",
"dag"
]
| [
"public",
"component",
"dependencies",
"(",
"list",
"<",
"string",
">",
"dependencies",
")",
"{",
"this",
"dependencies",
"=",
"dependencies",
";",
"return",
"this",
";",
"}"
]
|
[
"remove",
"all",
"preferences",
"in",
"sp"
]
| [
"public",
"static",
"void",
"clear",
"(",
")",
"{",
"clear",
"(",
"get",
"default",
"s",
"p",
"utils",
"(",
")",
")",
";",
"}"
]
|
[
"add",
"an",
"attribute",
"with",
"the",
"given",
"name",
"and",
"value",
"to",
"the",
"last",
"route",
"built",
"with",
"this",
"builder"
]
| [
"builder",
"with",
"attribute",
"(",
"string",
"name",
",",
"object",
"value",
")",
";"
]
|
[
"set",
"the",
"names",
"of",
"the",
"columns",
"to",
"be",
"used"
]
| [
"public",
"void",
"set",
"column",
"names",
"(",
"list",
"<",
"string",
">",
"column",
"names",
")",
"{",
"check",
"if",
"configuration",
"modification",
"is",
"allowed",
"(",
")",
";",
"this",
"declared",
"columns",
"clear",
"(",
")",
";",
"this",
"declared",
"columns",
"add",
"all",
"(",
"column",
"names",
")",
";",
"}"
]
|
[
"get",
"the",
"instrumentation",
"'",
"s",
"i",
"o",
"statistics"
]
| [
"public",
"i",
"o",
"statistics",
"get",
"i",
"o",
"statistics",
"(",
")",
"{",
"return",
"instrumentation",
"!",
"=",
"null",
"?",
"instrumentation",
"get",
"i",
"o",
"statistics",
"(",
")",
":",
"null",
";",
"}"
]
|
[
"follow",
"code",
"back",
"follows",
"the",
"program",
"'",
"s",
"code",
"unit",
"(",
"instruction",
"or",
"data",
")",
"flow",
"backwards",
"and",
"adds",
"addresses",
"to",
"the",
"address",
"set",
"for",
"the",
"flow",
"to",
"the",
"indicated",
"code",
"unit",
"the",
"plugin",
"'",
"s",
"properties",
"indicate",
"which",
"flow",
"types",
"should",
"be",
"followed",
"for",
"code",
"units"
]
| [
"private",
"void",
"follow",
"code",
"back",
"(",
"task",
"monitor",
"monitor",
",",
"address",
"set",
"flow",
"address",
"set",
",",
"code",
"unit",
"code",
"unit",
",",
"address",
"data",
"address",
")",
"{",
"if",
"(",
"code",
"unit",
"=",
"=",
"null",
")",
"{",
"return",
";",
"}",
"stack",
"<",
"code",
"unit",
">",
"code",
"unit",
"stack",
"=",
"new",
"stack",
"<",
"code",
"unit",
">",
"(",
")",
";",
"/",
"/",
"additional",
"code",
"to",
"be",
"processed",
"if",
"(",
"code",
"unit",
"instanceof",
"data",
")",
"{",
"follow",
"data",
"back",
"(",
"code",
"unit",
"stack",
",",
"flow",
"address",
"set",
",",
"(",
"data",
")",
"code",
"unit",
",",
"data",
"address",
")",
";",
"/",
"/",
"make",
"sure",
"we",
"don",
"'",
"t",
"lose",
"the",
"data",
"address",
"from",
"the",
"original",
"selection",
",",
"/",
"/",
"if",
"follow",
"data",
"back",
"didn",
"'",
"t",
"put",
"a",
"pointer",
"in",
"the",
"flow",
"if",
"(",
"data",
"address",
"!",
"=",
"null",
"&",
"&",
"!",
"flow",
"address",
"set",
"contains",
"(",
"data",
"address",
")",
")",
"{",
"flow",
"address",
"set",
"add",
"(",
"data",
"address",
")",
";",
"}",
"}",
"else",
"{",
"code",
"unit",
"stack",
"push",
"(",
"code",
"unit",
")",
";",
"}",
"while",
"(",
"!",
"monitor",
"is",
"cancelled",
"(",
")",
"&",
"&",
"!",
"code",
"unit",
"stack",
"is",
"empty",
"(",
")",
")",
"{",
"code",
"unit",
"=",
"code",
"unit",
"stack",
"pop",
"(",
")",
";",
"if",
"(",
"code",
"unit",
"instanceof",
"instruction",
")",
"{",
"/",
"/",
"get",
"adjusted",
"instruction",
"(",
")",
"will",
"add",
"the",
"instruction",
"and",
"any",
"delay",
"slots",
"to",
"the",
"/",
"/",
"flow",
"address",
"set",
"and",
"then",
"return",
"the",
"instruction",
"to",
"flow",
"backwards",
"from",
"instruction",
"current",
"instr",
"=",
"get",
"adjusted",
"instruction",
"(",
"(",
"instruction",
")",
"code",
"unit",
",",
"flow",
"address",
"set",
")",
";",
"if",
"(",
"current",
"instr",
"!",
"=",
"null",
")",
"{",
"follow",
"instruction",
"back",
"(",
"code",
"unit",
"stack",
",",
"flow",
"address",
"set",
",",
"current",
"instr",
")",
";",
"}",
"}",
"else",
"if",
"(",
"code",
"unit",
"instanceof",
"data",
")",
"{",
"follow",
"data",
"back",
"(",
"code",
"unit",
"stack",
",",
"flow",
"address",
"set",
",",
"(",
"data",
")",
"code",
"unit",
",",
"data",
"address",
")",
";",
"}",
"}",
"}"
]
|
[
"returns",
"a",
"new",
"array",
"of",
"the",
"given",
"length",
"with",
"the",
"same",
"type",
"as",
"a",
"reference",
"array"
]
| [
"public",
"static",
"<",
"t",
">",
"t",
"[",
"]",
"new",
"array",
"(",
"t",
"[",
"]",
"reference",
",",
"int",
"length",
")",
"{",
"return",
"platform",
"new",
"array",
"(",
"reference",
",",
"length",
")",
";",
"}"
]
|
[
"removes",
"prefix",
"from",
"class",
"names"
]
| [
"public",
"string",
"unprefix",
"(",
"string",
"type",
"name",
")",
"{",
"if",
"(",
"prefix",
"is",
"empty",
"(",
")",
"|",
"|",
"!",
"type",
"name",
"starts",
"with",
"(",
"prefix",
")",
")",
"{",
"return",
"type",
"name",
";",
"}",
"return",
"type",
"name",
"substring",
"(",
"prefix",
"length",
"(",
")",
")",
";",
"}"
]
|
[
"gets",
"information",
"about",
"the",
"number",
"of",
"total",
",",
"successful",
"and",
"failed",
"nodes",
"the",
"request",
"was",
"run",
"on",
"also",
"includes",
"exceptions",
"if",
"relevant"
]
| [
"public",
"nodes",
"response",
"header",
"get",
"header",
"(",
")",
"{",
"return",
"header",
";",
"}"
]
|
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
]
| [
"private",
"string",
"to",
"indented",
"string",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
]
|
[
"gets",
"the",
"flags"
]
| [
"public",
"int",
"get",
"flags",
"(",
")",
"{",
"return",
"flags",
";",
"}"
]
|
[
"the",
"dll",
"table",
"looks",
"like",
"this",
":",
"dll",
"table",
"{",
"string",
"comdlg32",
"string",
"shell32",
"string",
"msvcrt",
"string",
"advapi32",
"string",
"kernel32",
"string",
"gdi32",
"string",
"user32",
"string",
"winspool",
"}"
]
| [
"private",
"composite",
"get",
"dll",
"table",
"instance",
"(",
")",
"{",
"structure",
"data",
"type",
"structure",
"=",
"new",
"structure",
"data",
"type",
"(",
"\"",
"dll",
"table",
"\"",
",",
"0",
")",
";",
"category",
"path",
"path",
"=",
"new",
"category",
"path",
"(",
"\"",
"/",
"\"",
")",
";",
"try",
"{",
"structure",
"set",
"category",
"path",
"(",
"path",
")",
";",
"string",
"data",
"type",
"string",
"=",
"new",
"string",
"data",
"type",
"(",
")",
";",
"structure",
"add",
"(",
"string",
",",
"1",
",",
"\"",
"comdlg32",
"\"",
",",
"\"",
"\"",
")",
";",
"string",
"=",
"new",
"string",
"data",
"type",
"(",
")",
";",
"structure",
"add",
"(",
"string",
",",
"1",
",",
"\"",
"shell32",
"\"",
",",
"\"",
"\"",
")",
";",
"string",
"=",
"new",
"string",
"data",
"type",
"(",
")",
";",
"structure",
"add",
"(",
"string",
",",
"1",
",",
"\"",
"msvcrt",
"\"",
",",
"\"",
"\"",
")",
";",
"string",
"=",
"new",
"string",
"data",
"type",
"(",
")",
";",
"structure",
"add",
"(",
"string",
",",
"1",
",",
"\"",
"advapi32",
"\"",
",",
"\"",
"\"",
")",
";",
"string",
"=",
"new",
"string",
"data",
"type",
"(",
")",
";",
"structure",
"add",
"(",
"string",
",",
"1",
",",
"\"",
"kernel32",
"\"",
",",
"\"",
"\"",
")",
";",
"string",
"=",
"new",
"string",
"data",
"type",
"(",
")",
";",
"structure",
"add",
"(",
"string",
",",
"1",
",",
"\"",
"gdi32",
"\"",
",",
"\"",
"\"",
")",
";",
"string",
"=",
"new",
"string",
"data",
"type",
"(",
")",
";",
"structure",
"add",
"(",
"string",
",",
"1",
",",
"\"",
"user32",
"\"",
",",
"\"",
"\"",
")",
";",
"string",
"=",
"new",
"string",
"data",
"type",
"(",
")",
";",
"structure",
"add",
"(",
"string",
",",
"1",
",",
"\"",
"winspool",
"\"",
",",
"\"",
"\"",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"/",
"/",
"shouldn",
"'",
"t",
"happen",
"e",
"print",
"stack",
"trace",
"(",
")",
";",
"assert",
"fail",
"(",
"\"",
"somehow",
"we",
"have",
"an",
"unexpected",
"exception",
"in",
"our",
"environment",
"\"",
")",
";",
"}",
"return",
"structure",
";",
"}"
]
|
[
"test",
"that",
"a",
"hash",
"code",
"miscomputed",
"by",
"\"",
"input",
"hash",
"code",
"(",
")",
"too",
"far",
"value",
"2",
"\"",
"is",
"correct",
"under",
"our",
"{",
"@",
"code",
"hash",
"code",
"}",
"implementation"
]
| [
"public",
"void",
"test",
"power",
"set",
"hash",
"code",
"input",
"hash",
"code",
"times",
"too",
"far",
"value",
"is",
"zero",
"(",
")",
"{",
"set",
"<",
"object",
">",
"sum",
"to",
"eighth",
"max",
"int",
"elements",
"=",
"new",
"hash",
"set",
"(",
"object",
"with",
"hash",
"code",
"(",
"1",
"<",
"<",
"29",
")",
",",
"object",
"with",
"hash",
"code",
"(",
"0",
")",
")",
";",
"assert",
"power",
"set",
"hash",
"code",
"(",
"1",
"<",
"<",
"30",
",",
"sum",
"to",
"eighth",
"max",
"int",
"elements",
")",
";",
"set",
"<",
"object",
">",
"sum",
"to",
"quarter",
"max",
"int",
"elements",
"=",
"new",
"hash",
"set",
"(",
"object",
"with",
"hash",
"code",
"(",
"1",
"<",
"<",
"30",
")",
",",
"object",
"with",
"hash",
"code",
"(",
"0",
")",
")",
";",
"assert",
"power",
"set",
"hash",
"code",
"(",
"1",
"<",
"<",
"31",
",",
"sum",
"to",
"quarter",
"max",
"int",
"elements",
")",
";",
"}"
]
|
[
"accepts",
"a",
"new",
"incoming",
"connection",
"from",
"a",
"client",
"{",
"@",
"link",
"socket",
"}",
"the",
"given",
"hints",
"will",
"be",
"applied",
"to",
"the",
"accepted",
"socket",
"blocking",
",",
"call",
"on",
"a",
"separate",
"thread"
]
| [
"public",
"socket",
"accept",
"(",
"socket",
"hints",
"hints",
")",
";"
]
|
[
"executes",
"the",
"given",
"{",
"@",
"code",
"task",
"}",
"synchronously",
",",
"through",
"direct",
"invocation",
"of",
"it",
"'",
"s",
"{",
"@",
"link",
"runnable",
"#",
"run",
"(",
")",
"run",
"(",
")",
"}",
"method"
]
| [
"public",
"void",
"execute",
"(",
"runnable",
"task",
")",
"{",
"assert",
"not",
"null",
"(",
"task",
",",
"\"",
"runnable",
"must",
"not",
"be",
"null",
"\"",
")",
";",
"task",
"run",
"(",
")",
";",
"}"
]
|
[
"this",
"method",
"is",
"for",
"testing",
"only"
]
| [
"void",
"set",
"delegate",
"checker",
"(",
"async",
"checker",
"<",
"volume",
"check",
"context",
",",
"volume",
"check",
"result",
">",
"test",
"delegate",
")",
"{",
"delegate",
"checker",
"=",
"test",
"delegate",
";",
"}"
]
|
[
"creates",
"and",
"returns",
"a",
"new",
"{",
"@",
"link",
"rest",
"client",
"configuration",
"}",
"from",
"the",
"given",
"{",
"@",
"link",
"configuration",
"}"
]
| [
"public",
"static",
"rest",
"client",
"configuration",
"from",
"configuration",
"(",
"configuration",
"config",
")",
"throws",
"configuration",
"exception",
"{",
"preconditions",
"check",
"not",
"null",
"(",
"config",
")",
";",
"final",
"s",
"s",
"l",
"handler",
"factory",
"ssl",
"handler",
"factory",
";",
"if",
"(",
"s",
"s",
"l",
"utils",
"is",
"rest",
"s",
"s",
"l",
"enabled",
"(",
"config",
")",
")",
"{",
"try",
"{",
"ssl",
"handler",
"factory",
"=",
"s",
"s",
"l",
"utils",
"create",
"rest",
"client",
"s",
"s",
"l",
"engine",
"factory",
"(",
"config",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"throw",
"new",
"configuration",
"exception",
"(",
"\"",
"failed",
"to",
"initialize",
"s",
"s",
"l",
"context",
"for",
"the",
"rest",
"client",
"\"",
",",
"e",
")",
";",
"}",
"}",
"else",
"{",
"ssl",
"handler",
"factory",
"=",
"null",
";",
"}",
"final",
"long",
"connection",
"timeout",
"=",
"config",
"get",
"long",
"(",
"rest",
"options",
"connection",
"timeout",
")",
";",
"final",
"long",
"idleness",
"timeout",
"=",
"config",
"get",
"long",
"(",
"rest",
"options",
"idleness",
"timeout",
")",
";",
"int",
"max",
"content",
"length",
"=",
"config",
"get",
"integer",
"(",
"rest",
"options",
"client",
"max",
"content",
"length",
")",
";",
"return",
"new",
"rest",
"client",
"configuration",
"(",
"ssl",
"handler",
"factory",
",",
"connection",
"timeout",
",",
"idleness",
"timeout",
",",
"max",
"content",
"length",
")",
";",
"}"
]
|
[
"return",
"whether",
"it",
"is",
"am"
]
| [
"public",
"static",
"boolean",
"is",
"pm",
"(",
"final",
"long",
"millis",
")",
"{",
"return",
"!",
"is",
"am",
"(",
"millis",
")",
";",
"}"
]
|
[
"returns",
"true",
"if",
"a",
"given",
"feature",
"is",
"supported",
"in",
"the",
"given",
"layout",
"version"
]
| [
"public",
"static",
"boolean",
"supports",
"(",
"map",
"<",
"integer",
",",
"sorted",
"set",
"<",
"layout",
"feature",
">",
">",
"map",
",",
"final",
"layout",
"feature",
"f",
",",
"final",
"int",
"lv",
")",
"{",
"final",
"sorted",
"set",
"<",
"layout",
"feature",
">",
"set",
"=",
"map",
"get",
"(",
"lv",
")",
";",
"return",
"set",
"!",
"=",
"null",
"&",
"&",
"set",
"contains",
"(",
"f",
")",
";",
"}"
]
|
[
"returns",
"the",
"name",
"associated",
"with",
"this",
"configuration"
]
| [
"string",
"name",
"(",
")",
"{",
"return",
"name",
";",
"}"
]
|
[
"gets",
"actual",
"exception",
"if",
"it",
"'",
"s",
"wrapped",
"in",
"{",
"@",
"link",
"command",
"action",
"execution",
"exception",
"}",
"or",
"{",
"@",
"link",
"hystrix",
"bad",
"request",
"exception",
"}"
]
| [
"public",
"static",
"throwable",
"unwrap",
"cause",
"(",
"throwable",
"e",
")",
"{",
"if",
"(",
"e",
"instanceof",
"command",
"action",
"execution",
"exception",
")",
"{",
"return",
"e",
"get",
"cause",
"(",
")",
";",
"}",
"if",
"(",
"e",
"instanceof",
"hystrix",
"bad",
"request",
"exception",
")",
"{",
"return",
"e",
"get",
"cause",
"(",
")",
";",
"}",
"return",
"e",
";",
"}"
]
|
[
"return",
"whether",
"\"",
"auto",
"-",
"growing",
"\"",
"of",
"nested",
"paths",
"has",
"been",
"activated"
]
| [
"public",
"boolean",
"is",
"auto",
"grow",
"nested",
"paths",
"(",
")",
"{",
"return",
"this",
"auto",
"grow",
"nested",
"paths",
";",
"}"
]
|
[
"returns",
"a",
"copy",
"of",
"this",
"{",
"@",
"link",
"options",
"option",
"'",
"s",
"}",
"strings"
]
| [
"public",
"list",
"<",
"string",
">",
"strings",
"(",
")",
"{",
"return",
"unmodifiable",
"list",
"(",
"arrays",
"as",
"list",
"(",
"strings",
")",
")",
";",
"}"
]
|
[
"tests",
"whether",
"the",
"given",
"string",
"is",
"a",
"valid",
"rules",
":",
"all",
"characters",
"must",
"be",
"a",
"letter",
",",
"digit",
"(",
"0",
"9",
")",
",",
"period",
",",
"hyphen",
",",
"underscore",
"or",
"space",
"may",
"not",
"exceed",
"a",
"length",
"of",
"60",
"characters"
]
| [
"public",
"static",
"boolean",
"is",
"valid",
"name",
"(",
"string",
"name",
")",
"{",
"if",
"(",
"name",
"=",
"=",
"null",
")",
"{",
"return",
"false",
";",
"}",
"if",
"(",
"(",
"name",
"length",
"(",
")",
"<",
"1",
")",
"|",
"|",
"(",
"name",
"length",
"(",
")",
">",
"max",
"name",
"length",
")",
")",
"{",
"return",
"false",
";",
"}",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"name",
"length",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"char",
"c",
"=",
"name",
"char",
"at",
"(",
"i",
")",
";",
"if",
"(",
"!",
"character",
"is",
"letter",
"or",
"digit",
"(",
"c",
")",
"&",
"&",
"!",
"valid",
"name",
"set",
"contains",
"(",
"c",
")",
")",
"{",
"return",
"false",
";",
"}",
"}",
"return",
"true",
";",
"}"
]
|
[
"method",
"to",
"provide",
"the",
"warning",
"message",
"it",
"gives",
"the",
"custom",
"message",
"if",
"non",
"-",
"null",
",",
"and",
"default",
"message",
"otherwise"
]
| [
"private",
"final",
"string",
"get",
"warning",
"message",
"(",
"string",
"key",
")",
"{",
"string",
"warning",
"message",
";",
"if",
"(",
"custom",
"message",
"=",
"=",
"null",
")",
"{",
"string",
"builder",
"message",
"=",
"new",
"string",
"builder",
"(",
"key",
")",
";",
"string",
"deprecated",
"key",
"suffix",
"=",
"\"",
"is",
"deprecated",
"instead",
",",
"use",
"\"",
";",
"message",
"append",
"(",
"deprecated",
"key",
"suffix",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"new",
"keys",
"length",
";",
"i",
"+",
"+",
")",
"{",
"message",
"append",
"(",
"new",
"keys",
"[",
"i",
"]",
")",
";",
"if",
"(",
"i",
"!",
"=",
"new",
"keys",
"length",
"-",
"1",
")",
"{",
"message",
"append",
"(",
"\"",
",",
"\"",
")",
";",
"}",
"}",
"warning",
"message",
"=",
"message",
"to",
"string",
"(",
")",
";",
"}",
"else",
"{",
"warning",
"message",
"=",
"custom",
"message",
";",
"}",
"return",
"warning",
"message",
";",
"}"
]
|
[
"get",
"the",
"terminals"
]
| [
"public",
"collection",
"<",
"assembly",
"terminal",
">",
"terminals",
"(",
")",
"{",
"return",
"collections",
"unmodifiable",
"collection",
"(",
"terminals",
"values",
"(",
")",
")",
";",
"}"
]
|
[
"query",
"given",
"sql",
"to",
"create",
"a",
"prepared",
"statement",
"from",
"sql",
"and",
"a",
"list",
"of",
"arguments",
"to",
"bind",
"to",
"the",
"query",
",",
"mapping",
"a",
"single",
"result",
"row",
"to",
"a",
"java",
"object",
"via",
"a",
"row",
"mapper"
]
| [
"<",
"t",
">",
"t",
"query",
"for",
"object",
"(",
"string",
"sql",
",",
"map",
"<",
"string",
",",
"?",
">",
"param",
"map",
",",
"row",
"mapper",
"<",
"t",
">",
"row",
"mapper",
")",
"throws",
"data",
"access",
"exception",
";"
]
|
[
"parses",
"pts",
"time",
"from",
"splice",
"time",
"(",
")",
",",
"defined",
"in",
"section",
"9",
"4",
"1",
"returns",
"{",
"@",
"link",
"c",
"#",
"time",
"unset",
"}",
",",
"if",
"time",
"specified",
"flag",
"is",
"false"
]
| [
"/",
"*",
"package",
"*",
"/",
"static",
"long",
"parse",
"splice",
"time",
"(",
"parsable",
"byte",
"array",
"section",
"data",
",",
"long",
"pts",
"adjustment",
")",
"{",
"long",
"first",
"byte",
"=",
"section",
"data",
"read",
"unsigned",
"byte",
"(",
")",
";",
"long",
"pts",
"time",
"=",
"c",
"time",
"unset",
";",
"if",
"(",
"(",
"first",
"byte",
"&",
"0x",
"8",
"0",
")",
"!",
"=",
"0",
"/",
"*",
"time",
"specified",
"flag",
"*",
"/",
")",
"{",
"/",
"/",
"see",
"scte35",
"9",
"2",
"1",
"for",
"more",
"information",
"about",
"pts",
"adjustment",
"pts",
"time",
"=",
"(",
"first",
"byte",
"&",
"0x",
"0",
"1",
")",
"<",
"<",
"32",
"|",
"section",
"data",
"read",
"unsigned",
"int",
"(",
")",
";",
"pts",
"time",
"+",
"=",
"pts",
"adjustment",
";",
"pts",
"time",
"&",
"=",
"0x",
"1",
"f",
"f",
"f",
"f",
"f",
"f",
"f",
"f",
"l",
";",
"}",
"return",
"pts",
"time",
";",
"}"
]
|
[
"returns",
"the",
"fully",
"marked",
"-",
"up",
"text"
]
| [
"public",
"string",
"to",
"string",
"(",
"boolean",
"pre",
"escape",
")",
"{",
"if",
"(",
"tags",
"is",
"empty",
"(",
")",
")",
"return",
"pre",
"escape",
"?",
"util",
"xml",
"escape",
"(",
"text",
")",
":",
"util",
"escape",
"(",
"text",
")",
";",
"/",
"/",
"the",
"most",
"common",
"case",
"collections",
"sort",
"(",
"tags",
")",
";",
"string",
"builder",
"buf",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"int",
"copied",
"=",
"0",
";",
"/",
"/",
"#",
"of",
"chars",
"already",
"copied",
"from",
"text",
"to",
"buf",
"for",
"(",
"tag",
"tag",
":",
"tags",
")",
"{",
"if",
"(",
"copied",
"<",
"tag",
"pos",
")",
"{",
"string",
"portion",
"=",
"text",
"substring",
"(",
"copied",
",",
"tag",
"pos",
")",
";",
"buf",
"append",
"(",
"pre",
"escape",
"?",
"util",
"xml",
"escape",
"(",
"portion",
")",
":",
"util",
"escape",
"(",
"portion",
")",
")",
";",
"copied",
"=",
"tag",
"pos",
";",
"}",
"buf",
"append",
"(",
"tag",
"markup",
")",
";",
"}",
"if",
"(",
"copied",
"<",
"text",
"length",
"(",
")",
")",
"{",
"string",
"portion",
"=",
"text",
"substring",
"(",
"copied",
")",
";",
"buf",
"append",
"(",
"pre",
"escape",
"?",
"util",
"xml",
"escape",
"(",
"portion",
")",
":",
"util",
"escape",
"(",
"portion",
")",
")",
";",
"}",
"return",
"buf",
"to",
"string",
"(",
")",
";",
"}"
]
|
[
"create",
"and",
"initialize",
"a",
"new",
"filesystem",
"this",
"filesystem",
"must",
"be",
"closed",
"in",
"test",
"teardown"
]
| [
"private",
"s",
"3",
"a",
"file",
"system",
"create",
"f",
"s",
"(",
"final",
"uri",
"uri",
",",
"final",
"configuration",
"config",
")",
"throws",
"i",
"o",
"exception",
"{",
"s",
"3",
"a",
"file",
"system",
"fs",
"2",
"=",
"new",
"s",
"3",
"a",
"file",
"system",
"(",
")",
";",
"fs",
"2",
"initialize",
"(",
"uri",
",",
"config",
")",
";",
"return",
"fs",
"2",
";",
"}"
]
|
[
"check",
"if",
"this",
"extension",
"can",
"handle",
"the",
"specified",
"elf",
"header",
"if",
"this",
"method",
"returns",
"true",
",",
"this",
"extension",
"will",
"be",
"used",
"to",
"obtain",
"extended",
"types",
"definitions",
"and",
"to",
"perform",
"additional",
"load",
"processing"
]
| [
"public",
"boolean",
"can",
"handle",
"(",
"elf",
"header",
"elf",
")",
"{",
"return",
"false",
";",
"}"
]
|
[
"loads",
"the",
"libgdx",
"native",
"libraries",
"if",
"they",
"have",
"not",
"already",
"been",
"loaded"
]
| [
"static",
"public",
"synchronized",
"void",
"load",
"(",
")",
"{",
"if",
"(",
"natives",
"loaded",
")",
"return",
";",
"natives",
"loaded",
"=",
"true",
";",
"if",
"(",
"disable",
"natives",
"loading",
")",
"return",
";",
"new",
"shared",
"library",
"loader",
"(",
")",
"load",
"(",
"\"",
"gdx",
"\"",
")",
";",
"}"
]
|
[
"returns",
"whether",
"or",
"not",
"the",
"checkbox",
"is",
"selected"
]
| [
"boolean",
"get",
"use",
"for",
"all",
"(",
")",
"{",
"return",
"use",
"for",
"all",
"c",
"b",
"is",
"selected",
"(",
")",
";",
"}"
]
|
[
"return",
"a",
"snapshot",
"of",
"the",
"configuration",
"progress",
"as",
"human",
"-",
"readable",
"description",
"of",
"the",
"number",
"of",
"targets",
"configured",
"so",
"far"
]
| [
"public",
"string",
"get",
"progress",
"string",
"(",
")",
"{",
"string",
"progress",
"=",
"\"",
"\"",
"+",
"configured",
"targets",
"completed",
"+",
"\"",
"\"",
";",
"progress",
"+",
"=",
"(",
"configured",
"targets",
"completed",
"get",
"(",
")",
"!",
"=",
"1",
")",
"?",
"\"",
"targets",
"\"",
":",
"\"",
"target",
"\"",
";",
"progress",
"+",
"=",
"\"",
"configured",
"\"",
";",
"return",
"progress",
";",
"}"
]
|
[
"resets",
"blocks",
"in",
"pending",
"ibr",
"to",
"zero"
]
| [
"public",
"void",
"reset",
"blocks",
"in",
"pending",
"i",
"b",
"r",
"(",
")",
"{",
"blocks",
"in",
"pending",
"i",
"b",
"r",
"set",
"(",
"0",
")",
";",
"blocks",
"receiving",
"in",
"pending",
"i",
"b",
"r",
"set",
"(",
"0",
")",
";",
"blocks",
"received",
"in",
"pending",
"i",
"b",
"r",
"set",
"(",
"0",
")",
";",
"blocks",
"deleted",
"in",
"pending",
"i",
"b",
"r",
"set",
"(",
"0",
")",
";",
"}"
]
|
[
"specify",
"the",
"uri",
"for",
"the",
"request",
"using",
"a",
"uri",
"template",
"and",
"uri",
"variables",
"if",
"a",
"{",
"@",
"link",
"uri",
"builder",
"factory",
"}",
"was",
"configured",
"for",
"the",
"client",
"(",
"e",
"g",
"with",
"a",
"base",
"uri",
")",
"it",
"will",
"be",
"used",
"to",
"expand",
"the",
"uri",
"template"
]
| [
"s",
"uri",
"(",
"string",
"uri",
",",
"map",
"<",
"string",
",",
"?",
">",
"uri",
"variables",
")",
";"
]
|
[
"merges",
"already",
"-",
"sorted",
"sections",
",",
"reading",
"one",
"value",
"from",
"each",
"dex",
"into",
"memory",
"at",
"a",
"time"
]
| [
"public",
"final",
"void",
"merge",
"sorted",
"(",
")",
"{",
"table",
"of",
"contents",
"section",
"[",
"]",
"sections",
"=",
"new",
"table",
"of",
"contents",
"section",
"[",
"dexes",
"length",
"]",
";",
"dex",
"section",
"[",
"]",
"dex",
"sections",
"=",
"new",
"dex",
"section",
"[",
"dexes",
"length",
"]",
";",
"int",
"[",
"]",
"offsets",
"=",
"new",
"int",
"[",
"dexes",
"length",
"]",
";",
"int",
"[",
"]",
"indexes",
"=",
"new",
"int",
"[",
"dexes",
"length",
"]",
";",
"/",
"/",
"values",
"contains",
"one",
"value",
"from",
"each",
"dex",
",",
"sorted",
"for",
"fast",
"retrieval",
"of",
"/",
"/",
"the",
"smallest",
"value",
"the",
"list",
"associated",
"with",
"a",
"value",
"has",
"the",
"indexes",
"/",
"/",
"of",
"the",
"dexes",
"that",
"had",
"that",
"value",
"tree",
"map",
"<",
"t",
",",
"list",
"<",
"integer",
">",
">",
"values",
"=",
"new",
"tree",
"map",
"<",
"t",
",",
"list",
"<",
"integer",
">",
">",
"(",
")",
";",
"boolean",
"has",
"value",
"=",
"false",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"dexes",
"length",
";",
"i",
"+",
"+",
")",
"{",
"sections",
"[",
"i",
"]",
"=",
"get",
"section",
"(",
"dexes",
"[",
"i",
"]",
"get",
"table",
"of",
"contents",
"(",
")",
")",
";",
"dex",
"sections",
"[",
"i",
"]",
"=",
"sections",
"[",
"i",
"]",
"exists",
"(",
")",
"?",
"dexes",
"[",
"i",
"]",
"open",
"(",
"sections",
"[",
"i",
"]",
"off",
")",
":",
"null",
";",
"/",
"/",
"fill",
"in",
"values",
"with",
"the",
"first",
"value",
"of",
"each",
"dex",
"offsets",
"[",
"i",
"]",
"=",
"read",
"into",
"map",
"(",
"dex",
"sections",
"[",
"i",
"]",
",",
"sections",
"[",
"i",
"]",
",",
"index",
"maps",
"[",
"i",
"]",
",",
"indexes",
"[",
"i",
"]",
",",
"values",
",",
"i",
")",
";",
"if",
"(",
"offsets",
"[",
"i",
"]",
">",
"0",
")",
"{",
"has",
"value",
"=",
"true",
";",
"}",
"}",
"if",
"(",
"has",
"value",
")",
"{",
"get",
"section",
"(",
"contents",
"out",
")",
"off",
"=",
"out",
"get",
"position",
"(",
")",
";",
"}",
"else",
"{",
"get",
"section",
"(",
"contents",
"out",
")",
"off",
"=",
"0",
";",
"}",
"int",
"out",
"count",
"=",
"0",
";",
"while",
"(",
"!",
"values",
"is",
"empty",
"(",
")",
")",
"{",
"map",
"entry",
"<",
"t",
",",
"list",
"<",
"integer",
">",
">",
"first",
"=",
"values",
"poll",
"first",
"entry",
"(",
")",
";",
"for",
"(",
"integer",
"dex",
":",
"first",
"get",
"value",
"(",
")",
")",
"{",
"update",
"index",
"(",
"offsets",
"[",
"dex",
"]",
",",
"index",
"maps",
"[",
"dex",
"]",
",",
"indexes",
"[",
"dex",
"]",
"+",
"+",
",",
"out",
"count",
")",
";",
"/",
"/",
"fetch",
"the",
"next",
"value",
"of",
"the",
"dexes",
"we",
"just",
"polled",
"out",
"offsets",
"[",
"dex",
"]",
"=",
"read",
"into",
"map",
"(",
"dex",
"sections",
"[",
"dex",
"]",
",",
"sections",
"[",
"dex",
"]",
",",
"index",
"maps",
"[",
"dex",
"]",
",",
"indexes",
"[",
"dex",
"]",
",",
"values",
",",
"dex",
")",
";",
"}",
"write",
"(",
"first",
"get",
"key",
"(",
")",
")",
";",
"out",
"count",
"+",
"+",
";",
"}",
"get",
"section",
"(",
"contents",
"out",
")",
"size",
"=",
"out",
"count",
";",
"}"
]
|
[
"converts",
"a",
"short",
"to",
"an",
"integer"
]
| [
"public",
"static",
"int",
"short",
"to",
"int",
"(",
"short",
"s",
")",
"{",
"return",
"(",
"s",
"&",
"short",
"mask",
")",
";",
"}"
]
|
[
"set",
"a",
"buffer",
"for",
"particle",
"data"
]
| [
"public",
"void",
"set",
"particle",
"flags",
"buffer",
"(",
"int",
"[",
"]",
"buffer",
",",
"int",
"capacity",
")",
"{",
"m",
"particle",
"system",
"set",
"particle",
"flags",
"buffer",
"(",
"buffer",
",",
"capacity",
")",
";",
"}"
]
|
[
"to",
"base",
"6",
"4",
"string"
]
| [
"public",
"static",
"string",
"bytes",
"2base",
"6",
"4",
"(",
"byte",
"[",
"]",
"b",
",",
"string",
"code",
")",
"{",
"return",
"bytes",
"2base",
"6",
"4",
"(",
"b",
",",
"0",
",",
"b",
"length",
",",
"code",
")",
";",
"}"
]
|
[
"define",
"a",
"new",
"configuration",
"with",
"no",
"custom",
"recommender"
]
| [
"public",
"config",
"def",
"define",
"(",
"string",
"name",
",",
"type",
"type",
",",
"object",
"default",
"value",
",",
"validator",
"validator",
",",
"importance",
"importance",
",",
"string",
"documentation",
",",
"string",
"group",
",",
"int",
"order",
"in",
"group",
",",
"width",
"width",
",",
"string",
"display",
"name",
",",
"list",
"<",
"string",
">",
"dependents",
")",
"{",
"return",
"define",
"(",
"name",
",",
"type",
",",
"default",
"value",
",",
"validator",
",",
"importance",
",",
"documentation",
",",
"group",
",",
"order",
"in",
"group",
",",
"width",
",",
"display",
"name",
",",
"dependents",
",",
"null",
")",
";",
"}"
]
|
[
"the",
"loopback",
"ip",
"endpoint",
"or",
"unix",
"domain",
"socket",
"to",
"which",
"traffic",
"should",
"be",
"forwarded",
"to",
"by",
"default",
"format",
"should",
"be",
"`",
"127",
"0",
"0",
"1",
":",
"port",
"`",
"or",
"`",
"unix",
":",
"pathtosocket",
"`",
"or",
"`",
"unix",
":",
"&",
"#",
"64",
";",
"foobar",
"`",
"(",
"linux",
"abstract",
"namespace",
")",
"<",
"code",
">",
"string",
"default",
"endpoint",
"=",
"5",
";",
"<",
"code",
">"
]
| [
"com",
"google",
"protobuf",
"byte",
"string",
"get",
"default",
"endpoint",
"bytes",
"(",
")",
";"
]
|
[
"implement",
"comparable",
"contract",
"(",
"compare",
"key",
"at",
"head",
"of",
"proxied",
"rr",
"with",
"that",
"of",
"another",
")"
]
| [
"public",
"int",
"compare",
"to",
"(",
"composable",
"record",
"reader",
"<",
"k",
",",
"?",
">",
"other",
")",
"{",
"return",
"cmp",
"compare",
"(",
"key",
"(",
")",
",",
"other",
"key",
"(",
")",
")",
";",
"}"
]
|
[
"sets",
"a",
"mark",
"position",
"in",
"this",
"reader",
"the",
"parameter",
"{",
"@",
"code",
"read",
"limit",
"}",
"indicates",
"how",
"many",
"characters",
"can",
"be",
"read",
"before",
"the",
"mark",
"is",
"invalidated",
"calling",
"{",
"@",
"code",
"reset",
"(",
")",
"}",
"will",
"reposition",
"the",
"reader",
"back",
"to",
"the",
"marked",
"position",
"if",
"{",
"@",
"code",
"read",
"limit",
"}",
"has",
"not",
"been",
"surpassed",
"this",
"default",
"implementation",
"simply",
"throws",
"an",
"{",
"@",
"code",
"i",
"o",
"exception",
"}",
";",
"subclasses",
"must",
"provide",
"their",
"own",
"implementation"
]
| [
"public",
"void",
"mark",
"(",
"int",
"read",
"limit",
")",
"throws",
"i",
"o",
"exception",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
")",
";",
"}"
]
|
[
"helper",
"method",
"to",
"grow",
"the",
"character",
"buffer",
"as",
"needed",
",",
"this",
"only",
"happens",
"once",
"in",
"a",
"while",
"so",
"it",
"'",
"s",
"ok",
"if",
"it",
"'",
"s",
"in",
"a",
"method",
"call",
"if",
"the",
"index",
"passed",
"in",
"is",
"0",
"then",
"no",
"copying",
"will",
"be",
"done"
]
| [
"private",
"static",
"char",
"[",
"]",
"grow",
"buffer",
"(",
"char",
"[",
"]",
"dest",
",",
"int",
"index",
",",
"int",
"size",
")",
"{",
"char",
"[",
"]",
"copy",
"=",
"new",
"char",
"[",
"size",
"]",
";",
"if",
"(",
"index",
">",
"0",
")",
"{",
"system",
"arraycopy",
"(",
"dest",
",",
"0",
",",
"copy",
",",
"0",
",",
"index",
")",
";",
"}",
"return",
"copy",
";",
"}"
]
|
[
"this",
"isn",
"'",
"t",
"a",
"test",
"of",
"what",
"we",
"\"",
"should",
"\"",
"accept",
"as",
"a",
"span",
",",
"rather",
"that",
"characters",
"that",
"trip",
"-",
"up",
"json",
"don",
"'",
"t",
"fail",
"in",
"codec"
]
| [
"public",
"void",
"special",
"chars",
"in",
"json",
"json",
"v1",
"(",
")",
"{",
"assert",
"that",
"(",
"span",
"bytes",
"decoder",
"json",
"v1",
"decode",
"one",
"(",
"span",
"bytes",
"encoder",
"json",
"v1",
"encode",
"(",
"utf8",
"span",
")",
")",
")",
"is",
"equal",
"to",
"(",
"utf8",
"span",
")",
";",
"}"
]
|
[
"sets",
"the",
"character",
"to",
"use",
"for",
"the",
"delimiter",
"if",
"the",
"character",
"is",
"not",
"found",
"in",
"the",
"set",
"of",
"acceptable",
"delimiters",
",",
"the",
"delimiter",
"is",
"not",
"changed"
]
| [
"public",
"void",
"set",
"delimiter",
"(",
"char",
"delimiter",
")",
"{",
"int",
"count",
"=",
"delimiter",
"character",
"c",
"b",
"get",
"item",
"count",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"count",
";",
"i",
"+",
"+",
")",
"{",
"if",
"(",
"delimiter",
"character",
"c",
"b",
"get",
"item",
"at",
"(",
"i",
")",
"equals",
"(",
"string",
"value",
"of",
"(",
"delimiter",
")",
")",
")",
"{",
"delimiter",
"character",
"c",
"b",
"set",
"selected",
"index",
"(",
"i",
")",
";",
"}",
"}",
"}"
]
|
[
"increment",
"the",
"count",
"of",
"ui",
"thread",
"exectued",
"layout",
"calculations",
"in",
"litho",
"components",
"(",
"by",
"one",
")"
]
| [
"public",
"static",
"long",
"increment",
"component",
"calculate",
"layout",
"on",
"u",
"i",
"count",
"(",
")",
"{",
"return",
"s",
"component",
"calculate",
"layout",
"on",
"u",
"i",
"count",
"add",
"and",
"get",
"(",
"1",
")",
";",
"}"
]
|
[
"establishes",
"the",
"indicated",
"function",
"match",
"as",
"the",
"one",
"being",
"used",
"in",
"the",
"test"
]
| [
"protected",
"void",
"use",
"function",
"match",
"(",
"string",
"source",
"address",
"string",
",",
"string",
"destination",
"address",
"string",
")",
"{",
"source",
"address",
"=",
"addr",
"(",
"source",
"address",
"string",
",",
"source",
"program",
")",
";",
"destination",
"address",
"=",
"addr",
"(",
"destination",
"address",
"string",
",",
"destination",
"program",
")",
";",
"test",
"match",
"=",
"get",
"match",
"(",
"source",
"address",
",",
"destination",
"address",
")",
";",
"assert",
"not",
"null",
"(",
"test",
"match",
")",
";",
"assert",
"equals",
"(",
"v",
"t",
"association",
"type",
"function",
",",
"test",
"match",
"get",
"association",
"(",
")",
"get",
"type",
"(",
")",
")",
";",
"source",
"function",
"=",
"source",
"program",
"get",
"function",
"manager",
"(",
")",
"get",
"function",
"at",
"(",
"source",
"address",
")",
";",
"assert",
"not",
"null",
"(",
"source",
"function",
")",
";",
"destination",
"function",
"=",
"destination",
"program",
"get",
"function",
"manager",
"(",
")",
"get",
"function",
"at",
"(",
"destination",
"address",
")",
";",
"assert",
"not",
"null",
"(",
"destination",
"function",
")",
";",
"}"
]
|
[
"{",
"@",
"inherit",
"doc",
"}"
]
| [
"public",
"lexer",
"action",
"type",
"get",
"action",
"type",
"(",
")",
"{",
"return",
"lexer",
"action",
"type",
"more",
";",
"}"
]
|
[
"gets",
"the",
"cell",
"values",
"that",
"will",
"be",
"used",
"as",
"the",
"defaults",
"for",
"all",
"cells",
"in",
"the",
"specified",
"column",
"columns",
"are",
"indexed",
"starting",
"at",
"0"
]
| [
"public",
"cell",
"column",
"defaults",
"(",
"int",
"column",
")",
"{",
"cell",
"cell",
"=",
"column",
"defaults",
"size",
">",
"column",
"?",
"column",
"defaults",
"get",
"(",
"column",
")",
":",
"null",
";",
"if",
"(",
"cell",
"=",
"=",
"null",
")",
"{",
"cell",
"=",
"obtain",
"cell",
"(",
")",
";",
"cell",
"clear",
"(",
")",
";",
"if",
"(",
"column",
">",
"=",
"column",
"defaults",
"size",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"column",
"defaults",
"size",
";",
"i",
"<",
"column",
";",
"i",
"+",
"+",
")",
"column",
"defaults",
"add",
"(",
"null",
")",
";",
"column",
"defaults",
"add",
"(",
"cell",
")",
";",
"}",
"else",
"column",
"defaults",
"set",
"(",
"column",
",",
"cell",
")",
";",
"}",
"return",
"cell",
";",
"}"
]
|
[
"sets",
"a",
"default",
"loading",
"listener",
"for",
"all",
"display",
"and",
"loading",
"tasks"
]
| [
"public",
"void",
"set",
"default",
"loading",
"listener",
"(",
"image",
"loading",
"listener",
"listener",
")",
"{",
"default",
"listener",
"=",
"listener",
"=",
"=",
"null",
"?",
"new",
"simple",
"image",
"loading",
"listener",
"(",
")",
":",
"listener",
";",
"}"
]
|
[
"get",
"parity",
"blocks"
]
| [
"public",
"e",
"c",
"block",
"[",
"]",
"get",
"parity",
"blocks",
"(",
")",
"{",
"return",
"parity",
"blocks",
";",
"}"
]
|
[
"set",
"the",
"ttl",
"value",
"for",
"the",
"records",
"created",
"by",
"the",
"factory"
]
| [
"public",
"static",
"void",
"set",
"ttl",
"(",
"long",
"ttl",
")",
"{",
"record",
"creator",
"factory",
"ttl",
"=",
"ttl",
";",
"}"
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.