docstring_tokens
list | code_tokens
list |
|---|---|
[
"build",
"a",
"config",
"dump",
"event"
] | [
"public",
"config",
"dump",
"event",
"build",
"(",
")",
"{",
"config",
"dump",
"event",
"config",
"dump",
"event",
"=",
"new",
"config",
"dump",
"event",
"(",
")",
";",
"config",
"dump",
"event",
"set",
"remove",
"(",
"remove",
")",
";",
"config",
"dump",
"event",
"set",
"namespace",
"id",
"(",
"namespace",
"id",
")",
";",
"config",
"dump",
"event",
"set",
"data",
"id",
"(",
"data",
"id",
")",
";",
"config",
"dump",
"event",
"set",
"group",
"(",
"group",
")",
";",
"config",
"dump",
"event",
"set",
"tag",
"(",
"tag",
")",
";",
"config",
"dump",
"event",
"set",
"content",
"(",
"content",
")",
";",
"config",
"dump",
"event",
"set",
"beta",
"ips",
"(",
"beta",
"ips",
")",
";",
"config",
"dump",
"event",
"set",
"handle",
"ip",
"(",
"handle",
"ip",
")",
";",
"config",
"dump",
"event",
"set",
"type",
"(",
"type",
")",
";",
"config",
"dump",
"event",
"set",
"last",
"modified",
"ts",
"(",
"last",
"modified",
"ts",
")",
";",
"config",
"dump",
"event",
"is",
"beta",
"=",
"this",
"is",
"beta",
";",
"return",
"config",
"dump",
"event",
";",
"}"
] |
[
"set",
"the",
"content",
"type",
"for",
"this",
"view",
"default",
"is",
"\"",
"texthtml",
";",
"charset",
"=",
"iso",
"-",
"8859",
"-",
"1",
"\"",
"may",
"be",
"ignored",
"by",
"subclasses",
"if",
"the",
"view",
"itself",
"is",
"assumed",
"to",
"set",
"the",
"content",
"type",
",",
"e",
"g",
"in",
"case",
"of",
"j",
"s",
"ps"
] | [
"public",
"void",
"set",
"content",
"type",
"(",
"@",
"nullable",
"string",
"content",
"type",
")",
"{",
"this",
"content",
"type",
"=",
"content",
"type",
";",
"}"
] |
[
"set",
"the",
"{",
"@",
"link",
"message",
"size",
"estimator",
"}",
"which",
"is",
"used",
"for",
"the",
"channel",
"to",
"detect",
"the",
"size",
"of",
"a",
"message"
] | [
"channel",
"config",
"set",
"message",
"size",
"estimator",
"(",
"message",
"size",
"estimator",
"estimator",
")",
";"
] |
[
"releases",
"the",
"guarantee",
"that",
"the",
"array",
"returned",
"by",
"{",
"@",
"link",
"#",
"begin",
"(",
")",
"}",
"won",
"'",
"t",
"be",
"modified"
] | [
"public",
"void",
"end",
"(",
")",
"{",
"snapshots",
"=",
"math",
"max",
"(",
"0",
",",
"snapshots",
"-",
"1",
")",
";",
"if",
"(",
"snapshot",
"=",
"=",
"null",
")",
"return",
";",
"if",
"(",
"snapshot",
"!",
"=",
"items",
"&",
"&",
"snapshots",
"=",
"=",
"0",
")",
"{",
"/",
"/",
"the",
"backing",
"array",
"was",
"copied",
",",
"keep",
"around",
"the",
"old",
"array",
"recycled",
"=",
"snapshot",
";",
"for",
"(",
"int",
"i",
"=",
"0",
",",
"n",
"=",
"recycled",
"length",
";",
"i",
"<",
"n",
";",
"i",
"+",
"+",
")",
"recycled",
"[",
"i",
"]",
"=",
"null",
";",
"}",
"snapshot",
"=",
"null",
";",
"}"
] |
[
"verify",
"some",
"rpc",
"with",
"previous",
"block",
"not",
"null"
] | [
"public",
"void",
"test",
"previous",
"block",
"not",
"null",
"(",
")",
"throws",
"i",
"o",
"exception",
",",
"u",
"r",
"i",
"syntax",
"exception",
"{",
"final",
"federation",
"r",
"p",
"c",
"metrics",
"metrics",
"=",
"get",
"router",
"context",
"(",
")",
"get",
"router",
"(",
")",
"get",
"rpc",
"server",
"(",
")",
"get",
"r",
"p",
"c",
"metrics",
"(",
")",
";",
"final",
"client",
"protocol",
"client",
"protocol",
"=",
"get",
"router",
"protocol",
"(",
")",
";",
"final",
"enum",
"set",
"<",
"create",
"flag",
">",
"create",
"flag",
"=",
"enum",
"set",
"of",
"(",
"create",
"flag",
"create",
",",
"create",
"flag",
"overwrite",
")",
";",
"final",
"string",
"client",
"name",
"=",
"get",
"router",
"context",
"(",
")",
"get",
"client",
"(",
")",
"get",
"client",
"name",
"(",
")",
";",
"final",
"string",
"test",
"path",
"=",
"\"",
"/",
"get",
"additional",
"data",
"/",
"test",
"txt",
"\"",
";",
"final",
"string",
"ns",
"1",
"=",
"get",
"cluster",
"(",
")",
"get",
"nameservices",
"(",
")",
"get",
"(",
"1",
")",
";",
"final",
"file",
"system",
"file",
"system",
"1",
"=",
"get",
"cluster",
"(",
")",
"get",
"namenode",
"(",
"ns",
"1",
",",
"null",
")",
"get",
"file",
"system",
"(",
")",
";",
"try",
"{",
"/",
"/",
"create",
"the",
"test",
"file",
"in",
"ns1",
"create",
"file",
"(",
"file",
"system",
"1",
",",
"test",
"path",
",",
"32",
")",
";",
"/",
"/",
"crate",
"the",
"test",
"file",
"via",
"router",
"to",
"get",
"file",
"status",
"hdfs",
"file",
"status",
"status",
"=",
"client",
"protocol",
"create",
"(",
"test",
"path",
",",
"new",
"fs",
"permission",
"(",
"\"",
"777",
"\"",
")",
",",
"client",
"name",
",",
"new",
"enum",
"set",
"writable",
"<",
">",
"(",
"create",
"flag",
")",
",",
"true",
",",
"(",
"short",
")",
"1",
",",
"(",
"long",
")",
"1024",
",",
"crypto",
"protocol",
"version",
"supported",
"(",
")",
",",
"null",
",",
"null",
")",
";",
"long",
"proxy",
"num",
"create",
"=",
"metrics",
"get",
"processing",
"ops",
"(",
")",
";",
"/",
"/",
"add",
"a",
"block",
"via",
"router",
"and",
"previous",
"block",
"is",
"null",
"located",
"block",
"block",
"one",
"=",
"client",
"protocol",
"add",
"block",
"(",
"test",
"path",
",",
"client",
"name",
",",
"null",
",",
"null",
",",
"status",
"get",
"file",
"id",
"(",
")",
",",
"null",
",",
"null",
")",
";",
"assert",
"not",
"null",
"(",
"block",
"one",
")",
";",
"long",
"proxy",
"num",
"add",
"block",
"=",
"metrics",
"get",
"processing",
"ops",
"(",
")",
";",
"assert",
"equals",
"(",
"2",
",",
"proxy",
"num",
"add",
"block",
"-",
"proxy",
"num",
"create",
")",
";",
"/",
"/",
"add",
"a",
"block",
"via",
"router",
"and",
"previous",
"block",
"is",
"not",
"null",
"located",
"block",
"block",
"two",
"=",
"client",
"protocol",
"add",
"block",
"(",
"test",
"path",
",",
"client",
"name",
",",
"block",
"one",
"get",
"block",
"(",
")",
",",
"null",
",",
"status",
"get",
"file",
"id",
"(",
")",
",",
"null",
",",
"null",
")",
";",
"assert",
"not",
"null",
"(",
"block",
"two",
")",
";",
"long",
"proxy",
"num",
"add",
"block",
"2",
"=",
"metrics",
"get",
"processing",
"ops",
"(",
")",
";",
"assert",
"equals",
"(",
"1",
",",
"proxy",
"num",
"add",
"block",
"2",
"-",
"proxy",
"num",
"add",
"block",
")",
";",
"/",
"/",
"get",
"additional",
"datanode",
"via",
"router",
"and",
"block",
"is",
"not",
"null",
"datanode",
"info",
"[",
"]",
"exclusions",
"=",
"new",
"datanode",
"info",
"[",
"0",
"]",
";",
"located",
"block",
"new",
"block",
"=",
"client",
"protocol",
"get",
"additional",
"datanode",
"(",
"test",
"path",
",",
"status",
"get",
"file",
"id",
"(",
")",
",",
"block",
"two",
"get",
"block",
"(",
")",
",",
"block",
"two",
"get",
"locations",
"(",
")",
",",
"block",
"two",
"get",
"storage",
"i",
"ds",
"(",
")",
",",
"exclusions",
",",
"1",
",",
"client",
"name",
")",
";",
"assert",
"not",
"null",
"(",
"new",
"block",
")",
";",
"long",
"proxy",
"num",
"additional",
"datanode",
"=",
"metrics",
"get",
"processing",
"ops",
"(",
")",
";",
"assert",
"equals",
"(",
"1",
",",
"proxy",
"num",
"additional",
"datanode",
"-",
"proxy",
"num",
"add",
"block",
"2",
")",
";",
"/",
"/",
"complete",
"the",
"file",
"via",
"router",
"and",
"last",
"block",
"is",
"not",
"null",
"client",
"protocol",
"complete",
"(",
"test",
"path",
",",
"client",
"name",
",",
"new",
"block",
"get",
"block",
"(",
")",
",",
"status",
"get",
"file",
"id",
"(",
")",
")",
";",
"long",
"proxy",
"num",
"complete",
"=",
"metrics",
"get",
"processing",
"ops",
"(",
")",
";",
"assert",
"equals",
"(",
"1",
",",
"proxy",
"num",
"complete",
"-",
"proxy",
"num",
"additional",
"datanode",
")",
";",
"}",
"finally",
"{",
"client",
"protocol",
"delete",
"(",
"test",
"path",
",",
"true",
")",
";",
"}",
"}"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"sets",
"the",
"angle",
"of",
"the",
"vector",
"in",
"degrees",
"relative",
"to",
"the",
"x",
"-",
"axis",
",",
"towards",
"the",
"positive",
"y",
"-",
"axis",
"(",
"typically",
"counter",
"-",
"clockwise",
")"
] | [
"public",
"vector",
"2",
"set",
"angle",
"(",
"float",
"degrees",
")",
"{",
"return",
"set",
"angle",
"rad",
"(",
"degrees",
"*",
"math",
"utils",
"degrees",
"to",
"radians",
")",
";",
"}"
] |
[
"we",
"print",
"to",
"upper",
"case",
"to",
"make",
"the",
"test",
"timeout",
"warnings",
"more",
"readable"
] | [
"public",
"string",
"pretty",
"print",
"(",
")",
"{",
"return",
"super",
"to",
"string",
"(",
")",
"to",
"upper",
"case",
"(",
")",
";",
"}"
] |
[
"this",
"method",
"gets",
"called",
"everytime",
"before",
"any",
"readwrite",
"to",
"make",
"sure",
"that",
"any",
"change",
"to",
"local",
"dirs",
"is",
"reflected",
"immediately"
] | [
"private",
"context",
"conf",
"changed",
"(",
"configuration",
"conf",
")",
"throws",
"i",
"o",
"exception",
"{",
"context",
"ctx",
"=",
"current",
"context",
"get",
"(",
")",
";",
"string",
"new",
"local",
"dirs",
"=",
"conf",
"get",
"(",
"context",
"cfg",
"item",
"name",
")",
";",
"if",
"(",
"null",
"=",
"=",
"new",
"local",
"dirs",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"context",
"cfg",
"item",
"name",
"+",
"\"",
"not",
"configured",
"\"",
")",
";",
"}",
"if",
"(",
"!",
"new",
"local",
"dirs",
"equals",
"(",
"ctx",
"saved",
"local",
"dirs",
")",
")",
"{",
"ctx",
"=",
"new",
"context",
"(",
")",
";",
"string",
"[",
"]",
"dir",
"strings",
"=",
"string",
"utils",
"get",
"trimmed",
"strings",
"(",
"new",
"local",
"dirs",
")",
";",
"ctx",
"local",
"f",
"s",
"=",
"file",
"system",
"get",
"local",
"(",
"conf",
")",
";",
"int",
"num",
"dirs",
"=",
"dir",
"strings",
"length",
";",
"array",
"list",
"<",
"path",
">",
"dirs",
"=",
"new",
"array",
"list",
"<",
"path",
">",
"(",
"num",
"dirs",
")",
";",
"array",
"list",
"<",
"df",
">",
"df",
"list",
"=",
"new",
"array",
"list",
"<",
"df",
">",
"(",
"num",
"dirs",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"num",
"dirs",
";",
"i",
"+",
"+",
")",
"{",
"try",
"{",
"/",
"/",
"filter",
"problematic",
"directories",
"path",
"tmp",
"dir",
"=",
"new",
"path",
"(",
"dir",
"strings",
"[",
"i",
"]",
")",
";",
"if",
"(",
"ctx",
"local",
"f",
"s",
"mkdirs",
"(",
"tmp",
"dir",
")",
"|",
"|",
"ctx",
"local",
"f",
"s",
"exists",
"(",
"tmp",
"dir",
")",
")",
"{",
"try",
"{",
"file",
"tmp",
"file",
"=",
"tmp",
"dir",
"is",
"absolute",
"(",
")",
"?",
"new",
"file",
"(",
"ctx",
"local",
"f",
"s",
"make",
"qualified",
"(",
"tmp",
"dir",
")",
"to",
"uri",
"(",
")",
")",
":",
"new",
"file",
"(",
"dir",
"strings",
"[",
"i",
"]",
")",
";",
"disk",
"validator",
"check",
"status",
"(",
"tmp",
"file",
")",
";",
"dirs",
"add",
"(",
"new",
"path",
"(",
"tmp",
"file",
"get",
"path",
"(",
")",
")",
")",
";",
"df",
"list",
"add",
"(",
"new",
"df",
"(",
"tmp",
"file",
",",
"30000",
")",
")",
";",
"}",
"catch",
"(",
"disk",
"error",
"exception",
"de",
")",
"{",
"log",
"warn",
"(",
"dir",
"strings",
"[",
"i",
"]",
"+",
"\"",
"is",
"not",
"writable",
"\\",
"n",
"\"",
",",
"de",
")",
";",
"}",
"}",
"else",
"{",
"log",
"warn",
"(",
"\"",
"failed",
"to",
"create",
"\"",
"+",
"dir",
"strings",
"[",
"i",
"]",
")",
";",
"}",
"}",
"catch",
"(",
"i",
"o",
"exception",
"ie",
")",
"{",
"log",
"warn",
"(",
"\"",
"failed",
"to",
"create",
"\"",
"+",
"dir",
"strings",
"[",
"i",
"]",
"+",
"\"",
":",
"\"",
"+",
"ie",
"get",
"message",
"(",
")",
"+",
"\"",
"\\",
"n",
"\"",
",",
"ie",
")",
";",
"}",
"/",
"/",
"ignore",
"}",
"ctx",
"local",
"dirs",
"=",
"dirs",
"to",
"array",
"(",
"new",
"path",
"[",
"dirs",
"size",
"(",
")",
"]",
")",
";",
"ctx",
"dir",
"d",
"f",
"=",
"df",
"list",
"to",
"array",
"(",
"new",
"df",
"[",
"dirs",
"size",
"(",
")",
"]",
")",
";",
"ctx",
"saved",
"local",
"dirs",
"=",
"new",
"local",
"dirs",
";",
"if",
"(",
"dirs",
"size",
"(",
")",
">",
"0",
")",
"{",
"/",
"/",
"randomize",
"the",
"first",
"disk",
"picked",
"in",
"the",
"round",
"-",
"robin",
"selection",
"ctx",
"dir",
"num",
"last",
"accessed",
"set",
"(",
"dir",
"index",
"randomizer",
"next",
"int",
"(",
"dirs",
"size",
"(",
")",
")",
")",
";",
"}",
"current",
"context",
"set",
"(",
"ctx",
")",
";",
"}",
"return",
"ctx",
";",
"}"
] |
[
"trims",
"the",
"given",
"string",
"the",
"<",
"code",
">",
"max",
"<",
"code",
">",
"number",
"of",
"characters",
"ellipses",
"will",
"be",
"added",
"to",
"signal",
"that",
"content",
"was",
"removed",
"thus",
",",
"the",
"actual",
"number",
"of",
"removed",
"characters",
"will",
"be",
"<",
"code",
">",
"(",
"s",
"length",
"(",
")",
"-",
"max",
")",
"+",
"{",
"@",
"value",
"string",
"utilities",
"#",
"ellipses",
"}",
"<",
"code",
">",
"length",
"if",
"the",
"string",
"fits",
"within",
"the",
"max",
",",
"then",
"the",
"string",
"will",
"be",
"returned",
"the",
"given",
"<",
"code",
">",
"max",
"<",
"code",
">",
"value",
"must",
"be",
"at",
"least",
"5",
"this",
"is",
"to",
"ensure",
"that",
",",
"at",
"a",
"minimum",
",",
"we",
"can",
"display",
"the",
"{",
"@",
"value",
"#",
"ellipses",
"}",
"plus",
"one",
"character",
"from",
"the",
"front",
"and",
"back",
"of",
"the",
"string"
] | [
"public",
"static",
"string",
"trim",
"middle",
"(",
"string",
"s",
",",
"int",
"max",
")",
"{",
"int",
"len",
"=",
"s",
"length",
"(",
")",
";",
"if",
"(",
"len",
"<",
"=",
"max",
")",
"{",
"return",
"s",
";",
"}",
"int",
"minimum",
"=",
"ellipses",
"length",
"(",
")",
"+",
"2",
";",
"/",
"/",
"+",
"2",
"for",
"one",
"char",
"on",
"each",
"side",
"if",
"(",
"max",
"<",
"minimum",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"max",
"cannot",
"be",
"less",
"than",
"\"",
"+",
"minimum",
")",
";",
"}",
"int",
"to",
"remove",
"=",
"(",
"len",
"-",
"max",
")",
"+",
"ellipses",
"length",
"(",
")",
";",
"int",
"to",
"keep",
"=",
"len",
"-",
"to",
"remove",
";",
"int",
"lhs",
"size",
"=",
"to",
"keep",
"/",
"2",
";",
"int",
"rhs",
"size",
"=",
"lhs",
"size",
";",
"if",
"(",
"to",
"keep",
"%",
"2",
"!",
"=",
"0",
")",
"{",
"rhs",
"size",
"+",
"+",
";",
"/",
"/",
"compensate",
"for",
"roundoff",
"on",
"odd",
"size",
"}",
"string",
"builder",
"buffy",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"buffy",
"append",
"(",
"s",
"substring",
"(",
"0",
",",
"lhs",
"size",
")",
")",
";",
"buffy",
"append",
"(",
"ellipses",
")",
";",
"buffy",
"append",
"(",
"s",
"substring",
"(",
"len",
"-",
"rhs",
"size",
",",
"len",
")",
")",
";",
"return",
"buffy",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"the",
"passed",
"{",
"@",
"link",
"circuit",
"breaker",
"}",
"object",
"is",
"the",
"same",
"one",
"that",
"was",
"constructed",
"by",
"the",
"{",
"@",
"link",
"breaker",
"settings",
"}",
"provided",
"by",
"{",
"@",
"link",
"circuit",
"breaker",
"plugin",
"#",
"get",
"circuit",
"breaker",
"(",
"settings",
")",
"}",
"this",
"reference",
"should",
"never",
"change",
"throughout",
"the",
"lifetime",
"of",
"the",
"node"
] | [
"void",
"set",
"circuit",
"breaker",
"(",
"circuit",
"breaker",
"circuit",
"breaker",
")",
";"
] |
[
"assert",
"that",
"an",
"array",
"has",
"a",
"given",
"size",
";",
"in",
"failure",
"the",
"full",
"string",
"values",
"of",
"the",
"array",
"will",
"be",
"included",
",",
"one",
"per",
"line"
] | [
"private",
"<",
"t",
">",
"void",
"assert",
"array",
"size",
"(",
"final",
"string",
"message",
",",
"final",
"int",
"expected",
",",
"final",
"t",
"[",
"]",
"array",
")",
"{",
"if",
"(",
"expected",
"!",
"=",
"array",
"length",
")",
"{",
"/",
"/",
"condition",
"is",
"not",
"met",
",",
"build",
"an",
"error",
"which",
"includes",
"all",
"the",
"entries",
"string",
"listing",
"=",
"arrays",
"stream",
"(",
"array",
")",
"map",
"(",
"object",
":",
":",
"to",
"string",
")",
"collect",
"(",
"collectors",
"joining",
"(",
"\"",
"\\",
"n",
"\"",
")",
")",
";",
"fail",
"(",
"message",
"+",
"\"",
":",
"expected",
"\"",
"+",
"expected",
"+",
"\"",
"elements",
"but",
"found",
"\"",
"+",
"array",
"length",
"+",
"\"",
"\\",
"n",
"\"",
"+",
"listing",
")",
";",
"}",
"}"
] |
[
"parse",
"the",
"first",
"header",
"value",
"for",
"the",
"given",
"header",
"name",
"as",
"a",
"date",
",",
"return",
"{",
"@",
"code",
"null",
"}",
"if",
"there",
"is",
"no",
"value",
"or",
"also",
"in",
"case",
"of",
"an",
"invalid",
"value",
"(",
"if",
"{",
"@",
"code",
"reject",
"invalid",
"=",
"false",
"}",
")",
",",
"or",
"raise",
"{",
"@",
"link",
"illegal",
"argument",
"exception",
"}",
"if",
"the",
"value",
"cannot",
"be",
"parsed",
"as",
"a",
"date"
] | [
"private",
"zoned",
"date",
"time",
"get",
"first",
"zoned",
"date",
"time",
"(",
"string",
"header",
"name",
",",
"boolean",
"reject",
"invalid",
")",
"{",
"string",
"header",
"value",
"=",
"get",
"first",
"(",
"header",
"name",
")",
";",
"if",
"(",
"header",
"value",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"no",
"header",
"value",
"sent",
"at",
"all",
"return",
"null",
";",
"}",
"if",
"(",
"header",
"value",
"length",
"(",
")",
">",
"=",
"3",
")",
"{",
"/",
"/",
"short",
"\"",
"0",
"\"",
"or",
"\"",
"-",
"1",
"\"",
"like",
"values",
"are",
"never",
"valid",
"http",
"date",
"headers",
"/",
"/",
"let",
"'",
"s",
"only",
"bother",
"with",
"date",
"time",
"formatter",
"parsing",
"for",
"long",
"enough",
"values",
"/",
"/",
"see",
"https",
":",
"/",
"/",
"stackoverflow",
"com",
"/",
"questions",
"/",
"12626699",
"/",
"if",
"-",
"modified",
"-",
"since",
"-",
"http",
"-",
"header",
"-",
"passed",
"-",
"by",
"-",
"ie",
"9",
"-",
"includes",
"-",
"length",
"int",
"parameters",
"index",
"=",
"header",
"value",
"index",
"of",
"(",
"'",
";",
"'",
")",
";",
"if",
"(",
"parameters",
"index",
"!",
"=",
"-",
"1",
")",
"{",
"header",
"value",
"=",
"header",
"value",
"substring",
"(",
"0",
",",
"parameters",
"index",
")",
";",
"}",
"for",
"(",
"date",
"time",
"formatter",
"date",
"formatter",
":",
"date",
"parsers",
")",
"{",
"try",
"{",
"return",
"zoned",
"date",
"time",
"parse",
"(",
"header",
"value",
",",
"date",
"formatter",
")",
";",
"}",
"catch",
"(",
"date",
"time",
"parse",
"exception",
"ex",
")",
"{",
"/",
"/",
"ignore",
"}",
"}",
"}",
"if",
"(",
"reject",
"invalid",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"cannot",
"parse",
"date",
"value",
"\\",
"\"",
"\"",
"+",
"header",
"value",
"+",
"\"",
"\\",
"\"",
"for",
"\\",
"\"",
"\"",
"+",
"header",
"name",
"+",
"\"",
"\\",
"\"",
"header",
"\"",
")",
";",
"}",
"return",
"null",
";",
"}"
] |
[
"enables",
"or",
"disables",
"a",
"view",
"and",
"all",
"child",
"views",
"recursively"
] | [
"public",
"static",
"void",
"set",
"enabled",
"recursive",
"(",
"@",
"non",
"null",
"view",
"view",
",",
"boolean",
"enabled",
")",
"{",
"view",
"set",
"enabled",
"(",
"enabled",
")",
";",
"if",
"(",
"view",
"instanceof",
"view",
"group",
")",
"{",
"view",
"group",
"view",
"group",
"=",
"(",
"view",
"group",
")",
"view",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"view",
"group",
"get",
"child",
"count",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"set",
"enabled",
"recursive",
"(",
"view",
"group",
"get",
"child",
"at",
"(",
"i",
")",
",",
"enabled",
")",
";",
"}",
"}",
"}"
] |
[
"returns",
"the",
"distribution",
"pattern",
"used",
"for",
"this",
"edge"
] | [
"public",
"distribution",
"pattern",
"get",
"distribution",
"pattern",
"(",
")",
"{",
"return",
"this",
"distribution",
"pattern",
";",
"}"
] |
[
"set",
"the",
"view",
"class",
"that",
"should",
"be",
"used",
"to",
"create",
"views"
] | [
"public",
"void",
"set",
"view",
"class",
"(",
"@",
"nullable",
"class",
"<",
"?",
">",
"view",
"class",
")",
"{",
"if",
"(",
"view",
"class",
"!",
"=",
"null",
"&",
"&",
"!",
"required",
"view",
"class",
"(",
")",
"is",
"assignable",
"from",
"(",
"view",
"class",
")",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"given",
"view",
"class",
"[",
"\"",
"+",
"view",
"class",
"get",
"name",
"(",
")",
"+",
"\"",
"]",
"is",
"not",
"of",
"type",
"[",
"\"",
"+",
"required",
"view",
"class",
"(",
")",
"get",
"name",
"(",
")",
"+",
"\"",
"]",
"\"",
")",
";",
"}",
"this",
"view",
"class",
"=",
"view",
"class",
";",
"}"
] |
[
"maps",
"a",
"filter",
"to",
"be",
"executed",
"after",
"any",
"matching",
"routes"
] | [
"public",
"void",
"after",
"(",
"filter",
"filter",
")",
"{",
"add",
"filter",
"(",
"http",
"method",
"after",
",",
"filter",
"impl",
"create",
"(",
"spark",
"utils",
"all",
"paths",
",",
"filter",
")",
")",
";",
"}"
] |
[
"clears",
"all",
"arrays",
"from",
"the",
"pool"
] | [
"void",
"clear",
"memory",
"(",
")",
";"
] |
[
"there",
"was",
"a",
"crash",
"when",
"mounting",
"a",
"drawing",
"in",
"place",
"of",
"a",
"view",
"this",
"test",
"is",
"here",
"to",
"make",
"sure",
"this",
"does",
"not",
"regress",
"to",
"reproduce",
"this",
"crash",
"the",
"pools",
"needed",
"to",
"be",
"in",
"a",
"specific",
"state",
"as",
"view",
"layout",
"outputs",
"and",
"mount",
"items",
"were",
"being",
"re",
"-",
"used",
"for",
"drawables"
] | [
"public",
"void",
"test",
"remount",
"different",
"mount",
"type",
"(",
")",
"throws",
"illegal",
"access",
"exception",
",",
"no",
"such",
"field",
"exception",
"{",
"final",
"litho",
"view",
"litho",
"view",
"=",
"component",
"test",
"helper",
"mount",
"component",
"(",
"m",
"context",
",",
"test",
"view",
"component",
"create",
"(",
"m",
"context",
")",
"build",
"(",
")",
")",
";",
"component",
"test",
"helper",
"mount",
"component",
"(",
"m",
"context",
",",
"litho",
"view",
",",
"test",
"drawable",
"component",
"create",
"(",
"m",
"context",
")",
"build",
"(",
")",
")",
";",
"}"
] |
[
"resizes",
"the",
"hashtable",
"to",
"allow",
"more",
"entries"
] | [
"private",
"void",
"grow",
"(",
")",
"{",
"capacity",
"=",
"indexer",
"get",
"capacity",
"(",
")",
";",
"object",
"[",
"]",
"old",
"values",
"=",
"values",
";",
"values",
"=",
"(",
"t",
"[",
"]",
")",
"new",
"object",
"[",
"capacity",
"]",
";",
"system",
"arraycopy",
"(",
"old",
"values",
",",
"0",
",",
"values",
",",
"0",
",",
"old",
"values",
"length",
")",
";",
"}"
] |
[
"override",
"close",
"(",
")",
"so",
"that",
"we",
"don",
"'",
"t",
"finalize",
"edit",
"logs"
] | [
"public",
"synchronized",
"void",
"close",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"edit",
"log",
"abort",
"current",
"log",
"segment",
"(",
")",
";",
"storage",
"close",
"(",
")",
";",
"}"
] |
[
"set",
"all",
"{",
"@",
"link",
"sequence",
"}",
"s",
"in",
"the",
"group",
"to",
"a",
"given",
"value"
] | [
"public",
"void",
"set",
"(",
"final",
"long",
"value",
")",
"{",
"final",
"sequence",
"[",
"]",
"sequences",
"=",
"this",
"sequences",
";",
"for",
"(",
"sequence",
"sequence",
":",
"sequences",
")",
"{",
"sequence",
"set",
"(",
"value",
")",
";",
"}",
"}"
] |
[
"adds",
"groups",
"to",
"cache",
",",
"no",
"need",
"to",
"do",
"that",
"for",
"this",
"provider"
] | [
"public",
"void",
"cache",
"groups",
"add",
"(",
"list",
"<",
"string",
">",
"groups",
")",
"throws",
"i",
"o",
"exception",
"{",
"/",
"/",
"does",
"nothing",
"in",
"this",
"provider",
"of",
"user",
"to",
"groups",
"mapping",
"}"
] |
[
"rx",
"version",
"of",
"{",
"@",
"link",
"abstract",
"dao",
"#",
"delete",
"in",
"tx",
"(",
"iterable",
")",
"}",
"returning",
"an",
"observable"
] | [
"public",
"observable",
"<",
"void",
">",
"delete",
"in",
"tx",
"(",
"final",
"iterable",
"<",
"t",
">",
"entities",
")",
"{",
"return",
"wrap",
"(",
"new",
"callable",
"<",
"void",
">",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"call",
"(",
")",
"throws",
"exception",
"{",
"dao",
"delete",
"in",
"tx",
"(",
"entities",
")",
";",
"return",
"null",
";",
"}",
"}",
")",
";",
"}"
] |
[
"returns",
"true",
"if",
"there",
"is",
"an",
"attribute",
"with",
"the",
"specified",
"name",
"managed",
"by",
"this",
"attribute",
"manager"
] | [
"public",
"boolean",
"has",
"attribute",
"named",
"(",
"string",
"attribute",
"name",
")",
"{",
"return",
"defined",
"attributes",
"contains",
"key",
"(",
"attribute",
"name",
")",
";",
"}"
] |
[
"get",
"the",
"key",
"of",
"the",
"firing",
"timer"
] | [
"public",
"abstract",
"ks",
"get",
"current",
"key",
"(",
")",
";"
] |
[
"returns",
"the",
"target",
"configuration",
"for",
"the",
"most",
"recent",
"build",
",",
"as",
"created",
"in",
"blaze",
"'",
"s",
"master",
"configuration",
"creation",
"phase",
"tries",
"to",
"find",
"the",
"configuration",
"used",
"by",
"all",
"of",
"the",
"top",
"-",
"level",
"targets",
"in",
"the",
"last",
"invocation",
"if",
"they",
"used",
"multiple",
"different",
"configurations",
",",
"or",
"if",
"none",
"of",
"them",
"had",
"a",
"configuration",
",",
"then",
"falls",
"back",
"to",
"the",
"base",
"top",
"-",
"level",
"configuration"
] | [
"protected",
"build",
"configuration",
"get",
"target",
"configuration",
"(",
")",
"{",
"build",
"configuration",
"base",
"configuration",
"=",
"iterables",
"get",
"only",
"element",
"(",
"get",
"configuration",
"collection",
"(",
")",
"get",
"target",
"configurations",
"(",
")",
")",
";",
"build",
"result",
"result",
"=",
"get",
"result",
"(",
")",
";",
"if",
"(",
"result",
"=",
"=",
"null",
")",
"{",
"return",
"base",
"configuration",
";",
"}",
"set",
"<",
"build",
"configuration",
">",
"top",
"level",
"target",
"configurations",
"=",
"result",
"get",
"actual",
"targets",
"(",
")",
"stream",
"(",
")",
"map",
"(",
"(",
"ct",
")",
"-",
">",
"get",
"configuration",
"(",
"ct",
")",
")",
"filter",
"(",
"(",
"config",
")",
"-",
">",
"config",
"!",
"=",
"null",
")",
"collect",
"(",
"to",
"immutable",
"set",
"(",
")",
")",
";",
"if",
"(",
"top",
"level",
"target",
"configurations",
"size",
"(",
")",
"!",
"=",
"1",
")",
"{",
"return",
"base",
"configuration",
";",
"}",
"return",
"iterables",
"get",
"only",
"element",
"(",
"top",
"level",
"target",
"configurations",
")",
";",
"}"
] |
[
"creates",
"a",
"new",
"instance",
"of",
"a",
"{",
"@",
"link",
"describable",
"}",
"from",
"the",
"structured",
"form",
"submission",
"data",
"posted",
"by",
"a",
"radio",
"button",
"group"
] | [
"public",
"t",
"new",
"instance",
"from",
"radio",
"list",
"(",
"j",
"s",
"o",
"n",
"object",
"parent",
",",
"string",
"name",
")",
"throws",
"form",
"exception",
"{",
"try",
"{",
"return",
"new",
"instance",
"from",
"radio",
"list",
"(",
"parent",
"get",
"j",
"s",
"o",
"n",
"object",
"(",
"name",
")",
")",
";",
"}",
"catch",
"(",
"j",
"s",
"o",
"n",
"exception",
"ex",
")",
"{",
"throw",
"new",
"form",
"exception",
"(",
"ex",
",",
"name",
")",
";",
"}",
"}"
] |
[
"test",
"the",
"property",
"'",
"namespace",
"boolean",
"'"
] | [
"public",
"void",
"namespace",
"boolean",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"namespace",
"boolean",
"}"
] |
[
"submits",
"a",
"request",
"for",
"prefetching",
"to",
"the",
"disk",
"cache",
"with",
"a",
"default",
"priority",
"beware",
"that",
"if",
"your",
"network",
"fetcher",
"doesn",
"'",
"t",
"support",
"priorities",
"prefetch",
"requests",
"may",
"slow",
"down",
"images",
"which",
"are",
"immediately",
"required",
"on",
"screen"
] | [
"public",
"data",
"source",
"<",
"void",
">",
"prefetch",
"to",
"disk",
"cache",
"(",
"image",
"request",
"image",
"request",
",",
"object",
"caller",
"context",
")",
"{",
"return",
"prefetch",
"to",
"disk",
"cache",
"(",
"image",
"request",
",",
"caller",
"context",
",",
"priority",
"medium",
")",
";",
"}"
] |
[
"overrides",
"default",
"clock",
"instance"
] | [
"public",
"static",
"synchronized",
"void",
"set",
"clock",
"(",
"clock",
"clock",
")",
"{",
"instance",
"=",
"clock",
";",
"}"
] |
[
"concrete",
"builder",
"classes",
"should",
"override",
"this",
"method",
"to",
"return",
"a",
"new",
"controller"
] | [
"protected",
"abstract",
"abstract",
"drawee",
"controller",
"obtain",
"controller",
"(",
")",
";"
] |
[
"creates",
"a",
"data",
"entry",
"writer",
"that",
"can",
"write",
"to",
"the",
"given",
"class",
"path",
"entries"
] | [
"public",
"static",
"data",
"entry",
"writer",
"create",
"data",
"entry",
"writer",
"(",
"class",
"path",
"class",
"path",
",",
"int",
"from",
"index",
",",
"int",
"to",
"index",
")",
"{",
"data",
"entry",
"writer",
"writer",
"=",
"null",
";",
"/",
"/",
"create",
"a",
"chain",
"of",
"writers",
",",
"one",
"for",
"each",
"class",
"path",
"entry",
"for",
"(",
"int",
"index",
"=",
"to",
"index",
"-",
"1",
";",
"index",
">",
"=",
"from",
"index",
";",
"index",
"-",
"-",
")",
"{",
"class",
"path",
"entry",
"entry",
"=",
"class",
"path",
"get",
"(",
"index",
")",
";",
"writer",
"=",
"create",
"class",
"path",
"entry",
"writer",
"(",
"entry",
",",
"writer",
")",
";",
"}",
"return",
"writer",
";",
"}"
] |
[
"removes",
"the",
"address",
"set",
"which",
"was",
"restricting",
"the",
"results",
"of",
"the",
"get",
"differences",
"method"
] | [
"synchronized",
"void",
"remove",
"restricted",
"address",
"set",
"(",
")",
"{",
"this",
"restrict",
"address",
"set",
"=",
"null",
";",
"compute",
"diffs",
"to",
"return",
"(",
")",
";",
"}"
] |
[
"determine",
"whether",
"the",
"given",
"dependency",
"declares",
"a",
"value",
"annotation"
] | [
"public",
"object",
"get",
"suggested",
"value",
"(",
"dependency",
"descriptor",
"descriptor",
")",
"{",
"object",
"value",
"=",
"find",
"value",
"(",
"descriptor",
"get",
"annotations",
"(",
")",
")",
";",
"if",
"(",
"value",
"=",
"=",
"null",
")",
"{",
"method",
"parameter",
"method",
"param",
"=",
"descriptor",
"get",
"method",
"parameter",
"(",
")",
";",
"if",
"(",
"method",
"param",
"!",
"=",
"null",
")",
"{",
"value",
"=",
"find",
"value",
"(",
"method",
"param",
"get",
"method",
"annotations",
"(",
")",
")",
";",
"}",
"}",
"return",
"value",
";",
"}"
] |
[
"get",
"typedef",
"record",
"whoose",
"source",
"i",
"d",
"and",
"datatype",
"i",
"d",
"match",
"the",
"specified",
"universal",
"i",
"ds"
] | [
"abstract",
"d",
"b",
"record",
"get",
"record",
"with",
"i",
"ds",
"(",
"universal",
"i",
"d",
"source",
"i",
"d",
",",
"universal",
"i",
"d",
"datatype",
"i",
"d",
")",
"throws",
"i",
"o",
"exception",
";"
] |
[
"corrects",
"the",
"name",
"of",
"the",
"{",
"@",
"link",
"all",
"view",
"}",
"if",
"and",
"only",
"if",
"the",
"{",
"@",
"link",
"all",
"view",
"}",
"is",
"the",
"primary",
"view",
"and",
"its",
"name",
"is",
"one",
"of",
"the",
"localized",
"forms",
"of",
"{",
"@",
"link",
"messages",
"#",
"hudson",
"view",
"name",
"(",
")",
"}",
"and",
"the",
"user",
"has",
"not",
"opted",
"out",
"of",
"fixing",
"the",
"view",
"name",
"by",
"setting",
"the",
"system",
"property",
"{",
"@",
"code",
"hudson",
"mode",
"all",
"view",
"jenkins",
"-",
"38606",
"}",
"to",
"{",
"@",
"code",
"false",
"}",
"use",
"this",
"method",
"to",
"round",
"-",
"trip",
"the",
"primary",
"view",
"name",
",",
"e",
"g",
"{",
"@",
"code",
"primary",
"view",
"=",
"migrate",
"legacy",
"primary",
"all",
"view",
"localized",
"name",
"(",
"views",
",",
"primary",
"view",
")",
"}",
"note",
":",
"we",
"can",
"only",
"fix",
"the",
"localized",
"name",
"of",
"an",
"{",
"@",
"link",
"all",
"view",
"}",
"if",
"it",
"is",
"the",
"primary",
"view",
"as",
"otherwise",
"urls",
"would",
"change",
",",
"whereas",
"the",
"primary",
"view",
"is",
"special",
"and",
"does",
"not",
"normally",
"get",
"accessed",
"by",
"the",
"{",
"@",
"code",
"view",
"name",
"}",
"url",
"(",
"also",
"note",
"that",
"there",
"are",
"some",
"cases",
"where",
"the",
"primary",
"view",
"will",
"get",
"accessed",
"by",
"its",
"{",
"@",
"code",
"view",
"name",
"}",
"url",
"which",
"will",
"then",
"fall",
"back",
"to",
"the",
"primary",
"view",
")"
] | [
"public",
"static",
"string",
"migrate",
"legacy",
"primary",
"all",
"view",
"localized",
"name",
"(",
"@",
"non",
"null",
"list",
"<",
"view",
">",
"views",
",",
"@",
"non",
"null",
"string",
"primary",
"view",
")",
"{",
"if",
"(",
"default",
"view",
"name",
"equals",
"(",
"primary",
"view",
")",
")",
"{",
"/",
"/",
"modern",
"name",
",",
"we",
"are",
"safe",
"return",
"primary",
"view",
";",
"}",
"if",
"(",
"system",
"properties",
"get",
"boolean",
"(",
"all",
"view",
"class",
"get",
"name",
"(",
")",
"+",
"\"",
"jenkins",
"-",
"38606",
"\"",
",",
"true",
")",
")",
"{",
"all",
"view",
"all",
"view",
"=",
"null",
";",
"for",
"(",
"view",
"v",
":",
"views",
")",
"{",
"if",
"(",
"default",
"view",
"name",
"equals",
"(",
"v",
"get",
"view",
"name",
"(",
")",
")",
")",
"{",
"/",
"/",
"name",
"conflict",
",",
"we",
"cannot",
"rename",
"the",
"all",
"view",
"anyway",
"return",
"primary",
"view",
";",
"}",
"if",
"(",
"string",
"utils",
"equals",
"(",
"v",
"get",
"view",
"name",
"(",
")",
",",
"primary",
"view",
")",
")",
"{",
"if",
"(",
"v",
"instanceof",
"all",
"view",
")",
"{",
"all",
"view",
"=",
"(",
"all",
"view",
")",
"v",
";",
"}",
"else",
"{",
"/",
"/",
"none",
"of",
"our",
"business",
"fixing",
"as",
"we",
"can",
"only",
"safely",
"fix",
"the",
"primary",
"view",
"return",
"primary",
"view",
";",
"}",
"}",
"}",
"if",
"(",
"all",
"view",
"!",
"=",
"null",
")",
"{",
"/",
"/",
"the",
"primary",
"view",
"is",
"an",
"all",
"view",
"but",
"using",
"a",
"non",
"-",
"default",
"name",
"for",
"(",
"locale",
"l",
":",
"locale",
"get",
"available",
"locales",
"(",
")",
")",
"{",
"if",
"(",
"primary",
"view",
"equals",
"(",
"messages",
"hudson",
"view",
"name",
"(",
")",
"to",
"string",
"(",
"l",
")",
")",
")",
"{",
"/",
"/",
"bingo",
"jenkins",
"-",
"38606",
"detected",
"logger",
"log",
"(",
"level",
"info",
",",
"\"",
"jenkins",
"-",
"38606",
"detected",
"for",
"all",
"view",
"in",
"{",
"0",
"}",
";",
"renaming",
"view",
"from",
"{",
"1",
"}",
"to",
"{",
"2",
"}",
"\"",
",",
"new",
"object",
"[",
"]",
"{",
"all",
"view",
"owner",
",",
"primary",
"view",
",",
"default",
"view",
"name",
"}",
")",
";",
"all",
"view",
"name",
"=",
"default",
"view",
"name",
";",
"return",
"default",
"view",
"name",
";",
"}",
"}",
"}",
"}",
"return",
"primary",
"view",
";",
"}"
] |
[
"manually",
"sets",
"the",
"current",
"value"
] | [
"public",
"void",
"set",
"value",
"(",
"float",
"value",
")",
"{",
"m",
"value",
"=",
"value",
";",
"}"
] |
[
"get",
"enum",
"integer"
] | [
"public",
"enum",
"integer",
"enum",
"get",
"enum",
"integer",
"(",
")",
"{",
"return",
"enum",
"integer",
";",
"}"
] |
[
"dismisses",
"all",
"open",
"editors",
"without",
"prompting",
"to",
"save",
"any",
"changes",
"performs",
"any",
"other",
"cleanup",
"necessary",
"for",
"this",
"manager"
] | [
"public",
"void",
"dispose",
"(",
")",
"{",
"/",
"/",
"close",
"all",
"editors",
"without",
"checking",
"for",
"changes",
"dismiss",
"editors",
"(",
"null",
")",
";",
"editor",
"option",
"mgr",
"dispose",
"(",
")",
";",
"}"
] |
[
"return",
"whether",
"the",
"given",
"property",
"key",
"is",
"available",
"for",
"resolution",
",",
"i",
"e",
"if",
"the",
"value",
"for",
"the",
"given",
"key",
"is",
"not",
"{",
"@",
"code",
"null",
"}"
] | [
"boolean",
"contains",
"property",
"(",
"string",
"key",
")",
";"
] |
[
"take",
"a",
"{",
"@",
"code",
"string",
"}",
"that",
"is",
"a",
"delimited",
"list",
"and",
"convert",
"it",
"into",
"a",
"{",
"@",
"code",
"string",
"}",
"array",
"a",
"single",
"{",
"@",
"code",
"delimiter",
"}",
"may",
"consist",
"of",
"more",
"than",
"one",
"character",
",",
"but",
"it",
"will",
"still",
"be",
"considered",
"as",
"a",
"single",
"delimiter",
"string",
",",
"rather",
"than",
"as",
"bunch",
"of",
"potential",
"delimiter",
"characters",
",",
"in",
"contrast",
"to",
"{",
"@",
"link",
"#",
"tokenize",
"to",
"string",
"array",
"}"
] | [
"public",
"static",
"string",
"[",
"]",
"delimited",
"list",
"to",
"string",
"array",
"(",
"@",
"nullable",
"string",
"str",
",",
"@",
"nullable",
"string",
"delimiter",
")",
"{",
"return",
"delimited",
"list",
"to",
"string",
"array",
"(",
"str",
",",
"delimiter",
",",
"null",
")",
";",
"}"
] |
[
"read",
"one",
"line",
"up",
"to",
"-",
"-",
"delimiter",
"or",
"-",
"-",
"delimiter",
"-",
"-",
"and",
"if",
"existing",
"the",
"crlf",
"or",
"lf",
"read",
"one",
"line",
"up",
"to",
"-",
"-",
"delimiter",
"or",
"-",
"-",
"delimiter",
"-",
"-",
"and",
"if",
"existing",
"the",
"crlf",
"or",
"lf",
"note",
"that",
"crlf",
"or",
"lf",
"are",
"mandatory",
"for",
"opening",
"delimiter",
"(",
"-",
"-",
"delimiter",
")",
"but",
"not",
"for",
"closing",
"delimiter",
"(",
"-",
"-",
"delimiter",
"-",
"-",
")",
"since",
"some",
"clients",
"does",
"not",
"include",
"crlf",
"in",
"this",
"case"
] | [
"private",
"string",
"read",
"delimiter",
"(",
"byte",
"buf",
"undecoded",
"chunk",
",",
"string",
"delimiter",
")",
"{",
"final",
"int",
"reader",
"index",
"=",
"undecoded",
"chunk",
"reader",
"index",
"(",
")",
";",
"try",
"{",
"final",
"int",
"len",
"=",
"delimiter",
"length",
"(",
")",
";",
"if",
"(",
"len",
"+",
"2",
">",
"undecoded",
"chunk",
"readable",
"bytes",
"(",
")",
")",
"{",
"/",
"/",
"not",
"able",
"to",
"check",
"if",
"\"",
"-",
"-",
"\"",
"is",
"present",
"throw",
"new",
"not",
"enough",
"data",
"decoder",
"exception",
"(",
")",
";",
"}",
"int",
"new",
"position",
"delimiter",
"=",
"find",
"delimiter",
"(",
"undecoded",
"chunk",
",",
"delimiter",
",",
"0",
")",
";",
"if",
"(",
"new",
"position",
"delimiter",
"!",
"=",
"0",
")",
"{",
"/",
"/",
"delimiter",
"not",
"fully",
"found",
"throw",
"new",
"not",
"enough",
"data",
"decoder",
"exception",
"(",
")",
";",
"}",
"byte",
"next",
"byte",
"=",
"undecoded",
"chunk",
"get",
"byte",
"(",
"reader",
"index",
"+",
"len",
")",
";",
"/",
"/",
"first",
"check",
"for",
"opening",
"delimiter",
"if",
"(",
"next",
"byte",
"=",
"=",
"http",
"constants",
"cr",
")",
"{",
"next",
"byte",
"=",
"undecoded",
"chunk",
"get",
"byte",
"(",
"reader",
"index",
"+",
"len",
"+",
"1",
")",
";",
"if",
"(",
"next",
"byte",
"=",
"=",
"http",
"constants",
"lf",
")",
"{",
"char",
"sequence",
"line",
"=",
"undecoded",
"chunk",
"read",
"char",
"sequence",
"(",
"len",
",",
"charset",
")",
";",
"undecoded",
"chunk",
"skip",
"bytes",
"(",
"2",
")",
";",
"return",
"line",
"to",
"string",
"(",
")",
";",
"}",
"else",
"{",
"/",
"/",
"error",
"since",
"cr",
"must",
"be",
"followed",
"by",
"lf",
"/",
"/",
"delimiter",
"not",
"found",
"so",
"break",
"here",
"!",
"undecoded",
"chunk",
"reader",
"index",
"(",
"reader",
"index",
")",
";",
"throw",
"new",
"not",
"enough",
"data",
"decoder",
"exception",
"(",
")",
";",
"}",
"}",
"else",
"if",
"(",
"next",
"byte",
"=",
"=",
"http",
"constants",
"lf",
")",
"{",
"char",
"sequence",
"line",
"=",
"undecoded",
"chunk",
"read",
"char",
"sequence",
"(",
"len",
",",
"charset",
")",
";",
"undecoded",
"chunk",
"skip",
"bytes",
"(",
"1",
")",
";",
"return",
"line",
"to",
"string",
"(",
")",
";",
"}",
"else",
"if",
"(",
"next",
"byte",
"=",
"=",
"'",
"-",
"'",
")",
"{",
"/",
"/",
"second",
"check",
"for",
"closing",
"delimiter",
"next",
"byte",
"=",
"undecoded",
"chunk",
"get",
"byte",
"(",
"reader",
"index",
"+",
"len",
"+",
"1",
")",
";",
"if",
"(",
"next",
"byte",
"=",
"=",
"'",
"-",
"'",
")",
"{",
"char",
"sequence",
"line",
"=",
"undecoded",
"chunk",
"read",
"char",
"sequence",
"(",
"len",
"+",
"2",
",",
"charset",
")",
";",
"/",
"/",
"now",
"try",
"to",
"find",
"if",
"crlf",
"or",
"lf",
"there",
"if",
"(",
"undecoded",
"chunk",
"is",
"readable",
"(",
")",
")",
"{",
"next",
"byte",
"=",
"undecoded",
"chunk",
"read",
"byte",
"(",
")",
";",
"if",
"(",
"next",
"byte",
"=",
"=",
"http",
"constants",
"cr",
")",
"{",
"next",
"byte",
"=",
"undecoded",
"chunk",
"read",
"byte",
"(",
")",
";",
"if",
"(",
"next",
"byte",
"=",
"=",
"http",
"constants",
"lf",
")",
"{",
"return",
"line",
"to",
"string",
"(",
")",
";",
"}",
"else",
"{",
"/",
"/",
"error",
"cr",
"without",
"lf",
"/",
"/",
"delimiter",
"not",
"found",
"so",
"break",
"here",
"!",
"undecoded",
"chunk",
"reader",
"index",
"(",
"reader",
"index",
")",
";",
"throw",
"new",
"not",
"enough",
"data",
"decoder",
"exception",
"(",
")",
";",
"}",
"}",
"else",
"if",
"(",
"next",
"byte",
"=",
"=",
"http",
"constants",
"lf",
")",
"{",
"return",
"line",
"to",
"string",
"(",
")",
";",
"}",
"else",
"{",
"/",
"/",
"no",
"crlf",
"but",
"ok",
"however",
"(",
"adobe",
"flash",
"uploader",
")",
"/",
"/",
"minus",
"1",
"since",
"we",
"read",
"one",
"char",
"ahead",
"but",
"/",
"/",
"should",
"not",
"undecoded",
"chunk",
"reader",
"index",
"(",
"undecoded",
"chunk",
"reader",
"index",
"(",
")",
"-",
"1",
")",
";",
"return",
"line",
"to",
"string",
"(",
")",
";",
"}",
"}",
"/",
"/",
"fixme",
"what",
"do",
"we",
"do",
"here",
"?",
"/",
"/",
"either",
"considering",
"it",
"is",
"fine",
",",
"either",
"waiting",
"for",
"/",
"/",
"more",
"data",
"to",
"come",
"?",
"/",
"/",
"lets",
"try",
"considering",
"it",
"is",
"fine",
"return",
"line",
"to",
"string",
"(",
")",
";",
"}",
"/",
"/",
"only",
"one",
"'",
"-",
"'",
"=",
">",
"not",
"enough",
"/",
"/",
"whatever",
"now",
"=",
">",
"error",
"since",
"incomplete",
"}",
"}",
"catch",
"(",
"index",
"out",
"of",
"bounds",
"exception",
"e",
")",
"{",
"undecoded",
"chunk",
"reader",
"index",
"(",
"reader",
"index",
")",
";",
"throw",
"new",
"not",
"enough",
"data",
"decoder",
"exception",
"(",
"e",
")",
";",
"}",
"undecoded",
"chunk",
"reader",
"index",
"(",
"reader",
"index",
")",
";",
"throw",
"new",
"not",
"enough",
"data",
"decoder",
"exception",
"(",
")",
";",
"}"
] |
[
"add",
"the",
"given",
"{",
"@",
"link",
"handler",
"method",
"return",
"value",
"handler",
"handler",
"method",
"return",
"value",
"handlers",
"}"
] | [
"public",
"handler",
"method",
"return",
"value",
"handler",
"composite",
"add",
"handlers",
"(",
"@",
"nullable",
"list",
"<",
"?",
"extends",
"handler",
"method",
"return",
"value",
"handler",
">",
"handlers",
")",
"{",
"if",
"(",
"handlers",
"!",
"=",
"null",
")",
"{",
"this",
"return",
"value",
"handlers",
"add",
"all",
"(",
"handlers",
")",
";",
"}",
"return",
"this",
";",
"}"
] |
[
"finds",
"the",
"next",
"entry",
"in",
"the",
"current",
"chain",
"returns",
"true",
"if",
"an",
"entry",
"was",
"found"
] | [
"boolean",
"next",
"in",
"chain",
"(",
")",
"{",
"if",
"(",
"next",
"entry",
"!",
"=",
"null",
")",
"{",
"for",
"(",
"next",
"entry",
"=",
"next",
"entry",
"get",
"next",
"(",
")",
";",
"next",
"entry",
"!",
"=",
"null",
";",
"next",
"entry",
"=",
"next",
"entry",
"get",
"next",
"(",
")",
")",
"{",
"if",
"(",
"advance",
"to",
"(",
"next",
"entry",
")",
")",
"{",
"return",
"true",
";",
"}",
"}",
"}",
"return",
"false",
";",
"}"
] |
[
"read",
"file",
"content",
"by",
"{",
"@",
"link",
"input",
"stream",
"}"
] | [
"public",
"static",
"string",
"read",
"file",
"(",
"input",
"stream",
"is",
")",
"{",
"try",
"(",
"buffered",
"reader",
"reader",
"=",
"new",
"buffered",
"reader",
"(",
"new",
"input",
"stream",
"reader",
"(",
"is",
")",
")",
")",
"{",
"string",
"builder",
"text",
"builder",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"string",
"line",
"txt",
"=",
"null",
";",
"while",
"(",
"(",
"line",
"txt",
"=",
"reader",
"read",
"line",
"(",
")",
")",
"!",
"=",
"null",
")",
"{",
"text",
"builder",
"append",
"(",
"line",
"txt",
")",
";",
"}",
"return",
"text",
"builder",
"to",
"string",
"(",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"return",
"null",
";",
"}",
"}"
] |
[
"reads",
"a",
"runtime",
"[",
"in",
"]",
"visible",
"parameter",
"annotations",
"attribute",
"and",
"makes",
"the",
"given",
"visitor",
"visit",
"it"
] | [
"private",
"void",
"read",
"parameter",
"annotations",
"(",
"final",
"method",
"visitor",
"method",
"visitor",
",",
"final",
"context",
"context",
",",
"final",
"int",
"runtime",
"parameter",
"annotations",
"offset",
",",
"final",
"boolean",
"visible",
")",
"{",
"int",
"current",
"offset",
"=",
"runtime",
"parameter",
"annotations",
"offset",
";",
"int",
"num",
"parameters",
"=",
"class",
"file",
"buffer",
"[",
"current",
"offset",
"+",
"+",
"]",
"&",
"0x",
"f",
"f",
";",
"method",
"visitor",
"visit",
"annotable",
"parameter",
"count",
"(",
"num",
"parameters",
",",
"visible",
")",
";",
"char",
"[",
"]",
"char",
"buffer",
"=",
"context",
"char",
"buffer",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"num",
"parameters",
";",
"+",
"+",
"i",
")",
"{",
"int",
"num",
"annotations",
"=",
"read",
"unsigned",
"short",
"(",
"current",
"offset",
")",
";",
"current",
"offset",
"+",
"=",
"2",
";",
"while",
"(",
"num",
"annotations",
"-",
"-",
">",
"0",
")",
"{",
"/",
"/",
"parse",
"the",
"type",
"index",
"field",
"string",
"annotation",
"descriptor",
"=",
"read",
"u",
"t",
"f",
"8",
"(",
"current",
"offset",
",",
"char",
"buffer",
")",
";",
"current",
"offset",
"+",
"=",
"2",
";",
"/",
"/",
"parse",
"num",
"element",
"value",
"pairs",
"and",
"element",
"value",
"pairs",
"and",
"visit",
"these",
"values",
"current",
"offset",
"=",
"read",
"element",
"values",
"(",
"method",
"visitor",
"visit",
"parameter",
"annotation",
"(",
"i",
",",
"annotation",
"descriptor",
",",
"visible",
")",
",",
"current",
"offset",
",",
"/",
"*",
"named",
"=",
"*",
"/",
"true",
",",
"char",
"buffer",
")",
";",
"}",
"}",
"}"
] |
[
"find",
"the",
"fields",
"constant",
"that",
"matches",
"field",
"id",
",",
"or",
"null",
"if",
"its",
"not",
"found"
] | [
"public",
"static",
"fields",
"find",
"by",
"thrift",
"id",
"(",
"int",
"field",
"id",
")",
"{",
"switch",
"(",
"field",
"id",
")",
"{",
"default",
":",
"return",
"null",
";",
"}",
"}"
] |
[
"define",
"a",
"token",
"channel",
"with",
"a",
"specified",
"name",
"if",
"a",
"channel",
"with",
"the",
"specified",
"name",
"already",
"exists",
",",
"the",
"previously",
"assigned",
"channel",
"value",
"is",
"returned"
] | [
"public",
"int",
"define",
"channel",
"name",
"(",
"string",
"name",
")",
"{",
"integer",
"prev",
"=",
"channel",
"name",
"to",
"value",
"map",
"get",
"(",
"name",
")",
";",
"if",
"(",
"prev",
"=",
"=",
"null",
")",
"{",
"return",
"define",
"channel",
"name",
"(",
"name",
",",
"get",
"new",
"channel",
"number",
"(",
")",
")",
";",
"}",
"return",
"prev",
";",
"}"
] |
[
"returns",
"the",
"indices",
"to",
"close"
] | [
"public",
"string",
"[",
"]",
"indices",
"(",
")",
"{",
"return",
"indices",
";",
"}"
] |
[
"the",
"internal",
"method",
"finds",
"the",
"nest",
"host",
"for",
"a",
"given",
"class",
"from",
"a",
"class",
"attribute",
"record",
"the",
"method",
"returns",
"{",
"@",
"link",
"optional",
"#",
"empty",
"(",
")",
"}",
"if",
"the",
"class",
"is",
"not",
"part",
"of",
"a",
"nest",
"a",
"generated",
"nest",
"companion",
"class",
"and",
"its",
"nest",
"host",
"are",
"considered",
"to",
"be",
"a",
"nest",
"hostmember",
"relationship",
"in",
"addition",
"to",
"exam",
"the",
"nest",
"host",
"attribute",
"from",
"the",
"class",
"file",
",",
"this",
"method",
"returns",
"the",
"class",
"under",
"investigation",
"itself",
"for",
"a",
"class",
"with",
"nest",
"members",
"attribute",
"but",
"without",
"nest",
"host",
"attribute"
] | [
"private",
"static",
"optional",
"<",
"class",
"name",
">",
"nest",
"host",
"(",
"class",
"name",
"class",
"name",
",",
"class",
"attribute",
"record",
"class",
"attribute",
"record",
",",
"map",
"<",
"class",
"name",
",",
"class",
"name",
">",
"companion",
"to",
"host",
"map",
")",
"{",
"if",
"(",
"companion",
"to",
"host",
"map",
"contains",
"key",
"(",
"class",
"name",
")",
")",
"{",
"return",
"optional",
"of",
"(",
"companion",
"to",
"host",
"map",
"get",
"(",
"class",
"name",
")",
")",
";",
"}",
"optional",
"<",
"class",
"name",
">",
"nest",
"host",
"=",
"class",
"attribute",
"record",
"get",
"nest",
"host",
"(",
"class",
"name",
")",
";",
"if",
"(",
"nest",
"host",
"is",
"present",
"(",
")",
")",
"{",
"return",
"nest",
"host",
";",
"}",
"set",
"<",
"class",
"name",
">",
"nest",
"members",
"=",
"class",
"attribute",
"record",
"get",
"nest",
"members",
"(",
"class",
"name",
")",
";",
"if",
"(",
"!",
"nest",
"members",
"is",
"empty",
"(",
")",
")",
"{",
"return",
"optional",
"of",
"(",
"class",
"name",
")",
";",
"}",
"return",
"optional",
"empty",
"(",
")",
";",
"}"
] |
[
"gets",
"the",
"accumulated",
"stats",
"for",
"r",
"p",
"cs",
"sent",
"by",
"a",
"test",
"client"
] | [
"public",
"void",
"get",
"client",
"accumulated",
"stats",
"(",
"io",
"grpc",
"testing",
"integration",
"messages",
"load",
"balancer",
"accumulated",
"stats",
"request",
"request",
",",
"io",
"grpc",
"stub",
"stream",
"observer",
"<",
"io",
"grpc",
"testing",
"integration",
"messages",
"load",
"balancer",
"accumulated",
"stats",
"response",
">",
"response",
"observer",
")",
"{",
"io",
"grpc",
"stub",
"server",
"calls",
"async",
"unimplemented",
"unary",
"call",
"(",
"get",
"get",
"client",
"accumulated",
"stats",
"method",
"(",
")",
",",
"response",
"observer",
")",
";",
"}"
] |
[
"interns",
"an",
"instance",
",",
"adding",
"to",
"the",
"descriptor",
"as",
"necessary",
"based",
"on",
"the",
"given",
"definer",
",",
"name",
",",
"and",
"flags",
"for",
"example",
",",
"an",
"init",
"method",
"has",
"an",
"uninitialized",
"object",
"of",
"type",
"{",
"@",
"code",
"definer",
"}",
"as",
"its",
"first",
"argument"
] | [
"public",
"static",
"prototype",
"intern",
"(",
"string",
"descriptor",
",",
"type",
"definer",
",",
"boolean",
"is",
"static",
",",
"boolean",
"is",
"init",
")",
"{",
"prototype",
"base",
"=",
"intern",
"(",
"descriptor",
")",
";",
"if",
"(",
"is",
"static",
")",
"{",
"return",
"base",
";",
"}",
"if",
"(",
"is",
"init",
")",
"{",
"definer",
"=",
"definer",
"as",
"uninitialized",
"(",
"integer",
"max",
"value",
")",
";",
"}",
"return",
"base",
"with",
"first",
"parameter",
"(",
"definer",
")",
";",
"}"
] |
[
"gets",
"the",
"value",
"of",
"the",
"code",
"property",
"this",
"accessor",
"method",
"returns",
"a",
"reference",
"to",
"the",
"live",
"list",
",",
"not",
"a",
"snapshot",
"therefore",
"any",
"modification",
"you",
"make",
"to",
"the",
"returned",
"list",
"will",
"be",
"present",
"inside",
"the",
"jaxb",
"object",
"this",
"is",
"why",
"there",
"is",
"not",
"a",
"<",
"code",
">",
"set",
"<",
"code",
">",
"method",
"for",
"the",
"code",
"property",
"for",
"example",
",",
"to",
"add",
"a",
"new",
"item",
",",
"do",
"as",
"follows",
":",
"get",
"code",
"(",
")",
"add",
"(",
"new",
"item",
")",
";",
"objects",
"of",
"the",
"following",
"type",
"(",
"s",
")",
"are",
"allowed",
"in",
"the",
"list",
"{",
"@",
"link",
"string",
"}"
] | [
"public",
"list",
"<",
"string",
">",
"get",
"code",
"(",
")",
"{",
"if",
"(",
"code",
"=",
"=",
"null",
")",
"{",
"code",
"=",
"new",
"array",
"list",
"<",
"string",
">",
"(",
")",
";",
"}",
"return",
"this",
"code",
";",
"}"
] |
[
"sets",
"the",
"executable",
"to",
"be",
"a",
"jar",
"executed",
"from",
"the",
"given",
"deploy",
"jar",
"the",
"deploy",
"jar",
"is",
"automatically",
"added",
"to",
"the",
"action",
"inputs",
"this",
"method",
"is",
"similar",
"to",
"{",
"@",
"link",
"#",
"set",
"java",
"executable",
"}",
"but",
"it",
"assumes",
"that",
"the",
"jar",
"artifact",
"declares",
"a",
"main",
"class",
"calling",
"this",
"method",
"overrides",
"any",
"previous",
"values",
"set",
"via",
"calls",
"to",
"{",
"@",
"link",
"#",
"set",
"executable",
"}",
",",
"{",
"@",
"link",
"#",
"set",
"java",
"executable",
"}",
",",
"or",
"{",
"@",
"link",
"#",
"set",
"shell",
"command",
"}"
] | [
"public",
"builder",
"set",
"jar",
"executable",
"(",
"path",
"fragment",
"java",
"executable",
",",
"artifact",
"deploy",
"jar",
",",
"list",
"<",
"string",
">",
"jvm",
"args",
")",
"{",
"return",
"set",
"java",
"executable",
"(",
"java",
"executable",
",",
"deploy",
"jar",
",",
"jvm",
"args",
",",
"\"",
"-",
"jar",
"\"",
",",
"deploy",
"jar",
"get",
"exec",
"path",
"string",
"(",
")",
")",
";",
"}"
] |
[
"check",
"whether",
"a",
"node",
"has",
"some",
"input",
"which",
"have",
"correlation",
"condition",
"e",
"g",
"select",
"from",
"l",
"where",
"exists",
"(",
"select",
"from",
"r",
"left",
"join",
"(",
"select",
"from",
"t",
"where",
"t",
"j",
"=",
"l",
"b",
")",
"t",
"1",
"on",
"r",
"f",
"=",
"t",
"1",
"k",
")",
"the",
"above",
"sql",
"can",
"not",
"be",
"converted",
"to",
"semi",
"-",
"join",
"plan",
",",
"because",
"the",
"right",
"input",
"of",
"left",
"-",
"join",
"has",
"the",
"correlation",
"condition",
"(",
"t",
"j",
"=",
"l",
"b",
")"
] | [
"private",
"void",
"check",
"cor",
"condition",
"of",
"input",
"(",
"final",
"rel",
"node",
"input",
")",
"{",
"final",
"rel",
"shuttle",
"impl",
"shuttle",
"=",
"new",
"rel",
"shuttle",
"impl",
"(",
")",
"{",
"final",
"rex",
"visitor",
"<",
"void",
">",
"visitor",
"=",
"new",
"rex",
"visitor",
"impl",
"<",
"void",
">",
"(",
"true",
")",
"{",
"@",
"override",
"public",
"void",
"visit",
"correl",
"variable",
"(",
"rex",
"correl",
"variable",
"correl",
"variable",
")",
"{",
"has",
"unsupported",
"cor",
"condition",
"=",
"true",
";",
"return",
"super",
"visit",
"correl",
"variable",
"(",
"correl",
"variable",
")",
";",
"}",
"}",
";",
"@",
"override",
"public",
"rel",
"node",
"visit",
"(",
"logical",
"filter",
"filter",
")",
"{",
"filter",
"get",
"condition",
"(",
")",
"accept",
"(",
"visitor",
")",
";",
"return",
"super",
"visit",
"(",
"filter",
")",
";",
"}",
"@",
"override",
"public",
"rel",
"node",
"visit",
"(",
"logical",
"project",
"project",
")",
"{",
"for",
"(",
"rex",
"node",
"rex",
":",
"project",
"get",
"projects",
"(",
")",
")",
"{",
"rex",
"accept",
"(",
"visitor",
")",
";",
"}",
"return",
"super",
"visit",
"(",
"project",
")",
";",
"}",
"@",
"override",
"public",
"rel",
"node",
"visit",
"(",
"logical",
"join",
"join",
")",
"{",
"join",
"get",
"condition",
"(",
")",
"accept",
"(",
"visitor",
")",
";",
"return",
"super",
"visit",
"(",
"join",
")",
";",
"}",
"}",
";",
"input",
"accept",
"(",
"shuttle",
")",
";",
"}"
] |
[
"retains",
"all",
"current",
"headers",
"but",
"calls",
"{",
"@",
"link",
"#",
"set",
"(",
"k",
",",
"v",
")",
"}",
"for",
"each",
"entry",
"in",
"{",
"@",
"code",
"headers",
"}"
] | [
"t",
"set",
"all",
"(",
"headers",
"<",
"?",
"extends",
"k",
",",
"?",
"extends",
"v",
",",
"?",
">",
"headers",
")",
";"
] |
[
"sets",
"the",
"{",
"@",
"code",
"strict",
"spec",
"behavior",
"}",
"and",
"returns",
"a",
"reference",
"to",
"this",
"builder",
"so",
"that",
"the",
"methods",
"can",
"be",
"chained",
"together"
] | [
"public",
"builder",
"with",
"strict",
"spec",
"behavior",
"(",
"boolean",
"strict",
"spec",
"behavior",
")",
"{",
"this",
"strict",
"spec",
"behavior",
"=",
"strict",
"spec",
"behavior",
"!",
"=",
"null",
"?",
"strict",
"spec",
"behavior",
":",
"boolean",
"value",
"of",
"(",
"default",
"strict",
"spec",
"behavior",
")",
";",
"return",
"this",
";",
"}"
] |
[
"return",
"true",
"if",
"successful"
] | [
"public",
"boolean",
"translate",
"left",
"recursive",
"rule",
"(",
"grammar",
"root",
"a",
"s",
"t",
"ast",
",",
"left",
"recursive",
"rule",
"r",
",",
"string",
"language",
")",
"{",
"/",
"/",
"tool",
"log",
"(",
"\"",
"grammar",
"\"",
",",
"rule",
"a",
"s",
"t",
"to",
"string",
"tree",
"(",
")",
")",
";",
"grammar",
"a",
"s",
"t",
"prev",
"rule",
"a",
"s",
"t",
"=",
"r",
"ast",
";",
"string",
"rule",
"name",
"=",
"prev",
"rule",
"a",
"s",
"t",
"get",
"child",
"(",
"0",
")",
"get",
"text",
"(",
")",
";",
"left",
"recursive",
"rule",
"analyzer",
"left",
"recursive",
"rule",
"walker",
"=",
"new",
"left",
"recursive",
"rule",
"analyzer",
"(",
"prev",
"rule",
"a",
"s",
"t",
",",
"tool",
",",
"rule",
"name",
",",
"language",
")",
";",
"boolean",
"is",
"left",
"rec",
";",
"try",
"{",
"/",
"/",
"system",
"out",
"println",
"(",
"\"",
"testing",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"\\",
"n",
"\"",
"+",
"/",
"/",
"left",
"recursive",
"rule",
"walker",
"text",
"(",
"rule",
"a",
"s",
"t",
")",
")",
";",
"is",
"left",
"rec",
"=",
"left",
"recursive",
"rule",
"walker",
"rec",
"rule",
"(",
")",
";",
"}",
"catch",
"(",
"recognition",
"exception",
"re",
")",
"{",
"is",
"left",
"rec",
"=",
"false",
";",
"/",
"/",
"didn",
"'",
"t",
"match",
";",
"oh",
"well",
"}",
"if",
"(",
"!",
"is",
"left",
"rec",
")",
"return",
"false",
";",
"/",
"/",
"replace",
"old",
"rule",
"'",
"s",
"ast",
";",
"first",
"create",
"text",
"of",
"altered",
"rule",
"grammar",
"a",
"s",
"t",
"rules",
"=",
"(",
"grammar",
"a",
"s",
"t",
")",
"ast",
"get",
"first",
"child",
"with",
"type",
"(",
"a",
"n",
"t",
"l",
"r",
"parser",
"rules",
")",
";",
"string",
"new",
"rule",
"text",
"=",
"left",
"recursive",
"rule",
"walker",
"get",
"artificial",
"op",
"prec",
"rule",
"(",
")",
";",
"/",
"/",
"system",
"out",
"println",
"(",
"\"",
"created",
":",
"\"",
"+",
"new",
"rule",
"text",
")",
";",
"/",
"/",
"now",
"parse",
"within",
"the",
"context",
"of",
"the",
"grammar",
"that",
"originally",
"created",
"/",
"/",
"the",
"ast",
"we",
"are",
"transforming",
"this",
"could",
"be",
"an",
"imported",
"grammar",
"so",
"/",
"/",
"we",
"cannot",
"just",
"reference",
"this",
"g",
"because",
"the",
"role",
"might",
"come",
"from",
"/",
"/",
"the",
"imported",
"grammar",
"and",
"not",
"the",
"root",
"grammar",
"(",
"this",
"g",
")",
"rule",
"a",
"s",
"t",
"t",
"=",
"parse",
"artificial",
"rule",
"(",
"prev",
"rule",
"a",
"s",
"t",
"g",
",",
"new",
"rule",
"text",
")",
";",
"/",
"/",
"reuse",
"the",
"name",
"token",
"from",
"the",
"original",
"ast",
"since",
"it",
"refers",
"to",
"the",
"proper",
"source",
"location",
"in",
"the",
"original",
"grammar",
"(",
"(",
"grammar",
"a",
"s",
"t",
")",
"t",
"get",
"child",
"(",
"0",
")",
")",
"token",
"=",
"(",
"(",
"grammar",
"a",
"s",
"t",
")",
"prev",
"rule",
"a",
"s",
"t",
"get",
"child",
"(",
"0",
")",
")",
"get",
"token",
"(",
")",
";",
"/",
"/",
"update",
"grammar",
"ast",
"and",
"set",
"rule",
"'",
"s",
"ast",
"rules",
"set",
"child",
"(",
"prev",
"rule",
"a",
"s",
"t",
"get",
"child",
"index",
"(",
")",
",",
"t",
")",
";",
"r",
"ast",
"=",
"t",
";",
"/",
"/",
"reduce",
"sets",
"in",
"newly",
"created",
"rule",
"tree",
"grammar",
"transform",
"pipeline",
"transform",
"=",
"new",
"grammar",
"transform",
"pipeline",
"(",
"g",
",",
"g",
"tool",
")",
";",
"transform",
"reduce",
"blocks",
"to",
"sets",
"(",
"r",
"ast",
")",
";",
"transform",
"expand",
"parameterized",
"loops",
"(",
"r",
"ast",
")",
";",
"/",
"/",
"rerun",
"semantic",
"checks",
"on",
"the",
"new",
"rule",
"rule",
"collector",
"rule",
"collector",
"=",
"new",
"rule",
"collector",
"(",
"g",
")",
";",
"rule",
"collector",
"visit",
"(",
"t",
",",
"\"",
"rule",
"\"",
")",
";",
"basic",
"semantic",
"checks",
"basics",
"=",
"new",
"basic",
"semantic",
"checks",
"(",
"g",
",",
"rule",
"collector",
")",
";",
"/",
"/",
"disable",
"the",
"assoc",
"element",
"option",
"checks",
"because",
"they",
"are",
"already",
"/",
"/",
"handled",
"for",
"the",
"pre",
"-",
"transformed",
"rule",
"basics",
"check",
"assoc",
"element",
"option",
"=",
"false",
";",
"basics",
"visit",
"(",
"t",
",",
"\"",
"rule",
"\"",
")",
";",
"/",
"/",
"track",
"recursive",
"alt",
"info",
"for",
"codegen",
"r",
"rec",
"primary",
"alts",
"=",
"new",
"array",
"list",
"<",
"left",
"recursive",
"rule",
"alt",
"info",
">",
"(",
")",
";",
"r",
"rec",
"primary",
"alts",
"add",
"all",
"(",
"left",
"recursive",
"rule",
"walker",
"prefix",
"and",
"other",
"alts",
")",
";",
"if",
"(",
"r",
"rec",
"primary",
"alts",
"is",
"empty",
"(",
")",
")",
"{",
"tool",
"err",
"mgr",
"grammar",
"error",
"(",
"error",
"type",
"no",
"non",
"lr",
"alts",
",",
"g",
"file",
"name",
",",
"(",
"(",
"grammar",
"a",
"s",
"t",
")",
"r",
"ast",
"get",
"child",
"(",
"0",
")",
")",
"get",
"token",
"(",
")",
",",
"r",
"name",
")",
";",
"}",
"r",
"rec",
"op",
"alts",
"=",
"new",
"ordered",
"hash",
"map",
"<",
"integer",
",",
"left",
"recursive",
"rule",
"alt",
"info",
">",
"(",
")",
";",
"r",
"rec",
"op",
"alts",
"put",
"all",
"(",
"left",
"recursive",
"rule",
"walker",
"binary",
"alts",
")",
";",
"r",
"rec",
"op",
"alts",
"put",
"all",
"(",
"left",
"recursive",
"rule",
"walker",
"ternary",
"alts",
")",
";",
"r",
"rec",
"op",
"alts",
"put",
"all",
"(",
"left",
"recursive",
"rule",
"walker",
"suffix",
"alts",
")",
";",
"/",
"/",
"walk",
"alt",
"info",
"records",
"and",
"set",
"their",
"alt",
"a",
"s",
"t",
"to",
"point",
"to",
"appropriate",
"alt",
"subtree",
"/",
"/",
"from",
"freshly",
"created",
"ast",
"set",
"alt",
"a",
"s",
"t",
"pointers",
"(",
"r",
",",
"t",
")",
";",
"/",
"/",
"update",
"rule",
"to",
"just",
"one",
"alt",
"and",
"add",
"prec",
"alt",
"action",
"a",
"s",
"t",
"arg",
"=",
"(",
"action",
"a",
"s",
"t",
")",
"r",
"ast",
"get",
"first",
"child",
"with",
"type",
"(",
"a",
"n",
"t",
"l",
"r",
"parser",
"arg",
"action",
")",
";",
"if",
"(",
"arg",
"!",
"=",
"null",
")",
"{",
"r",
"args",
"=",
"scope",
"parser",
"parse",
"typed",
"arg",
"list",
"(",
"arg",
",",
"arg",
"get",
"text",
"(",
")",
",",
"g",
")",
";",
"r",
"args",
"type",
"=",
"attribute",
"dict",
"dict",
"type",
"arg",
";",
"r",
"args",
"ast",
"=",
"arg",
";",
"arg",
"resolver",
"=",
"r",
"alt",
"[",
"1",
"]",
";",
"/",
"/",
"todo",
":",
"isn",
"'",
"t",
"this",
"rule",
"or",
"something",
"?",
"}",
"/",
"/",
"define",
"labels",
"on",
"recursive",
"rule",
"refs",
"we",
"delete",
";",
"they",
"don",
"'",
"t",
"point",
"to",
"nodes",
"of",
"course",
"/",
"/",
"these",
"are",
"so",
"$",
"label",
"in",
"action",
"translation",
"works",
"for",
"(",
"pair",
"<",
"grammar",
"a",
"s",
"t",
",",
"string",
">",
"pair",
":",
"left",
"recursive",
"rule",
"walker",
"left",
"recursive",
"rule",
"ref",
"labels",
")",
"{",
"grammar",
"a",
"s",
"t",
"label",
"node",
"=",
"pair",
"a",
";",
"grammar",
"a",
"s",
"t",
"label",
"op",
"node",
"=",
"(",
"grammar",
"a",
"s",
"t",
")",
"label",
"node",
"get",
"parent",
"(",
")",
";",
"grammar",
"a",
"s",
"t",
"element",
"node",
"=",
"(",
"grammar",
"a",
"s",
"t",
")",
"label",
"op",
"node",
"get",
"child",
"(",
"1",
")",
";",
"label",
"element",
"pair",
"lp",
"=",
"new",
"label",
"element",
"pair",
"(",
"g",
",",
"label",
"node",
",",
"element",
"node",
",",
"label",
"op",
"node",
"get",
"type",
"(",
")",
")",
";",
"r",
"alt",
"[",
"1",
"]",
"label",
"defs",
"map",
"(",
"label",
"node",
"get",
"text",
"(",
")",
",",
"lp",
")",
";",
"}",
"/",
"/",
"copy",
"to",
"rule",
"from",
"walker",
"r",
"left",
"recursive",
"rule",
"ref",
"labels",
"=",
"left",
"recursive",
"rule",
"walker",
"left",
"recursive",
"rule",
"ref",
"labels",
";",
"tool",
"log",
"(",
"\"",
"grammar",
"\"",
",",
"\"",
"added",
":",
"\"",
"+",
"t",
"to",
"string",
"tree",
"(",
")",
")",
";",
"return",
"true",
";",
"}"
] |
[
"creates",
"a",
"{",
"@",
"link",
"bean",
"definition",
"}",
"for",
"the",
"{",
"@",
"link",
"aspect",
"j",
"expression",
"pointcut",
"}",
"class",
"using",
"the",
"supplied",
"pointcut",
"expression"
] | [
"protected",
"abstract",
"bean",
"definition",
"create",
"pointcut",
"definition",
"(",
"string",
"expression",
")",
"{",
"root",
"bean",
"definition",
"bean",
"definition",
"=",
"new",
"root",
"bean",
"definition",
"(",
"aspect",
"j",
"expression",
"pointcut",
"class",
")",
";",
"bean",
"definition",
"set",
"scope",
"(",
"bean",
"definition",
"scope",
"prototype",
")",
";",
"bean",
"definition",
"set",
"synthetic",
"(",
"true",
")",
";",
"bean",
"definition",
"get",
"property",
"values",
"(",
")",
"add",
"(",
"expression",
",",
"expression",
")",
";",
"return",
"bean",
"definition",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"array",
"of",
"string",
"'"
] | [
"public",
"void",
"array",
"of",
"string",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"array",
"of",
"string",
"}"
] |
[
"return",
"whether",
"the",
"rom",
"is",
"made",
"by",
"htc"
] | [
"public",
"static",
"boolean",
"is",
"htc",
"(",
")",
"{",
"return",
"rom",
"htc",
"[",
"0",
"]",
"equals",
"(",
"get",
"rom",
"info",
"(",
")",
"name",
")",
";",
"}"
] |
[
"resolve",
"the",
"given",
"path",
",",
"replacing",
"placeholders",
"with",
"corresponding",
"environment",
"property",
"values",
"if",
"necessary",
"applied",
"to",
"config",
"locations"
] | [
"protected",
"string",
"resolve",
"path",
"(",
"string",
"path",
")",
"{",
"return",
"get",
"environment",
"(",
")",
"resolve",
"required",
"placeholders",
"(",
"path",
")",
";",
"}"
] |
[
"returns",
"a",
"new",
"{",
"@",
"link",
"drawable",
"}",
"that",
"safely",
"wraps",
"and",
"tints",
"the",
"provided",
"drawable"
] | [
"public",
"static",
"@",
"non",
"null",
"drawable",
"tint",
"(",
"@",
"non",
"null",
"drawable",
"drawable",
",",
"@",
"color",
"int",
"int",
"tint",
")",
"{",
"drawable",
"tinted",
"=",
"drawable",
"compat",
"wrap",
"(",
"drawable",
")",
"mutate",
"(",
")",
";",
"drawable",
"compat",
"set",
"tint",
"(",
"tinted",
",",
"tint",
")",
";",
"return",
"tinted",
";",
"}"
] |
[
"start",
"the",
"specified",
"{",
"@",
"link",
"m",
"bean",
"exporter",
"}"
] | [
"protected",
"void",
"start",
"(",
"m",
"bean",
"exporter",
"exporter",
")",
"{",
"exporter",
"after",
"properties",
"set",
"(",
")",
";",
"exporter",
"after",
"singletons",
"instantiated",
"(",
")",
";",
"}"
] |
[
"try",
"to",
"extend",
"a",
"match",
"on",
"a",
"pair",
"of",
"n",
"-",
"grams",
"to",
"the",
"instructions",
"right",
"before",
"and",
"right",
"after",
"the",
"n",
"-",
"gram",
"the",
"match",
"is",
"extended",
"if",
"the",
"instruction",
"adjacent",
"to",
"the",
"n",
"-",
"gram",
",",
"and",
"its",
"corresponding",
"pair",
"on",
"the",
"other",
"side",
",",
"hash",
"to",
"the",
"same",
"value",
"using",
"the",
"hash",
"function",
"the",
"ngram",
"match",
"objects",
"are",
"updated",
"to",
"reflect",
"the",
"original",
"n",
"-",
"gram",
"match",
"plus",
"any",
"additional",
"extension"
] | [
"public",
"static",
"void",
"extend",
"match",
"(",
"int",
"n",
"gram",
"size",
",",
"instruct",
"hash",
"src",
"instruct",
",",
"ngram",
"match",
"src",
"match",
",",
"instruct",
"hash",
"dest",
"instruct",
",",
"ngram",
"match",
"dest",
"match",
",",
"hash",
"calculator",
"hash",
"calc",
")",
"throws",
"memory",
"access",
"exception",
"{",
"src",
"match",
"block",
"=",
"src",
"instruct",
"block",
";",
"src",
"match",
"startindex",
"=",
"src",
"instruct",
"index",
";",
"src",
"match",
"endindex",
"=",
"src",
"match",
"startindex",
"+",
"n",
"gram",
"size",
"-",
"1",
";",
"dest",
"match",
"block",
"=",
"dest",
"instruct",
"block",
";",
"dest",
"match",
"startindex",
"=",
"dest",
"instruct",
"index",
";",
"dest",
"match",
"endindex",
"=",
"dest",
"match",
"startindex",
"+",
"n",
"gram",
"size",
"-",
"1",
";",
"/",
"/",
"try",
"to",
"extend",
"to",
"earlier",
"instructions",
"while",
"(",
"src",
"match",
"startindex",
">",
"0",
"&",
"&",
"dest",
"match",
"startindex",
">",
"0",
")",
"{",
"/",
"/",
"can",
"'",
"t",
"go",
"past",
"beginning",
"of",
"block",
"instruct",
"hash",
"cur",
"src",
"instruct",
"=",
"src",
"match",
"block",
"inst",
"list",
"[",
"src",
"match",
"startindex",
"-",
"1",
"]",
";",
"instruct",
"hash",
"cur",
"dest",
"instruct",
"=",
"dest",
"match",
"block",
"inst",
"list",
"[",
"dest",
"match",
"startindex",
"-",
"1",
"]",
";",
"if",
"(",
"cur",
"src",
"instruct",
"is",
"matched",
")",
"break",
";",
"/",
"/",
"if",
"instruction",
"already",
"matched",
",",
"can",
"'",
"t",
"extend",
"if",
"(",
"cur",
"dest",
"instruct",
"is",
"matched",
")",
"break",
";",
"int",
"src",
"val",
"=",
"hash",
"alternate",
"seed",
";",
"/",
"/",
"seed",
"the",
"hash",
"function",
"int",
"dest",
"val",
"=",
"hash",
"alternate",
"seed",
";",
"src",
"val",
"=",
"hash",
"calc",
"calc",
"hash",
"(",
"src",
"val",
",",
"cur",
"src",
"instruct",
"instruction",
")",
";",
"dest",
"val",
"=",
"hash",
"calc",
"calc",
"hash",
"(",
"dest",
"val",
",",
"cur",
"dest",
"instruct",
"instruction",
")",
";",
"if",
"(",
"src",
"val",
"!",
"=",
"dest",
"val",
")",
"break",
";",
"/",
"/",
"compare",
"hashes",
",",
"if",
"they",
"differ",
",",
"we",
"can",
"'",
"t",
"extend",
"src",
"match",
"startindex",
"-",
"=",
"1",
";",
"dest",
"match",
"startindex",
"-",
"=",
"1",
";",
"}",
"/",
"/",
"try",
"to",
"extend",
"to",
"later",
"instructions",
"int",
"src",
"max",
"=",
"src",
"match",
"block",
"inst",
"list",
"length",
"-",
"1",
";",
"int",
"dest",
"max",
"=",
"dest",
"match",
"block",
"inst",
"list",
"length",
"-",
"1",
";",
"while",
"(",
"src",
"match",
"endindex",
"<",
"src",
"max",
"&",
"&",
"dest",
"match",
"endindex",
"<",
"dest",
"max",
")",
"{",
"/",
"/",
"can",
"'",
"t",
"go",
"past",
"end",
"of",
"block",
"instruct",
"hash",
"cur",
"src",
"instruct",
"=",
"src",
"match",
"block",
"inst",
"list",
"[",
"src",
"match",
"endindex",
"+",
"1",
"]",
";",
"instruct",
"hash",
"cur",
"dest",
"instruct",
"=",
"dest",
"match",
"block",
"inst",
"list",
"[",
"dest",
"match",
"endindex",
"+",
"1",
"]",
";",
"if",
"(",
"cur",
"src",
"instruct",
"is",
"matched",
")",
"break",
";",
"/",
"/",
"if",
"instruction",
"already",
"matched",
",",
"can",
"'",
"t",
"extend",
"if",
"(",
"cur",
"dest",
"instruct",
"is",
"matched",
")",
"break",
";",
"int",
"src",
"val",
"=",
"hash",
"alternate",
"seed",
";",
"/",
"/",
"seed",
"the",
"hash",
"function",
"int",
"dest",
"val",
"=",
"hash",
"alternate",
"seed",
";",
"src",
"val",
"=",
"hash",
"calc",
"calc",
"hash",
"(",
"src",
"val",
",",
"cur",
"src",
"instruct",
"instruction",
")",
";",
"dest",
"val",
"=",
"hash",
"calc",
"calc",
"hash",
"(",
"dest",
"val",
",",
"cur",
"dest",
"instruct",
"instruction",
")",
";",
"if",
"(",
"src",
"val",
"!",
"=",
"dest",
"val",
")",
"break",
";",
"/",
"/",
"compare",
"hashes",
",",
"if",
"they",
"differ",
",",
"we",
"can",
"'",
"t",
"extend",
"src",
"match",
"endindex",
"+",
"=",
"1",
";",
"dest",
"match",
"endindex",
"+",
"=",
"1",
";",
"}",
"}"
] |
[
"sets",
"the",
"streams",
"uncaught",
"exception",
"handler"
] | [
"public",
"void",
"set",
"streams",
"uncaught",
"exception",
"handler",
"(",
"final",
"java",
"util",
"function",
"consumer",
"<",
"throwable",
">",
"streams",
"uncaught",
"exception",
"handler",
")",
"{",
"this",
"streams",
"uncaught",
"exception",
"handler",
"=",
"streams",
"uncaught",
"exception",
"handler",
";",
"}"
] |
[
"true",
",",
"if",
"the",
"return",
"value",
"of",
"the",
"repository",
"rule",
"contained",
"new",
"information",
"with",
"respect",
"to",
"the",
"way",
"it",
"was",
"called"
] | [
"public",
"boolean",
"is",
"new",
"information",
"returned",
"(",
")",
"{",
"return",
"information",
"returned",
";",
"}"
] |
[
"returns",
"the",
"child",
"level",
"of",
"this",
"level",
"the",
"child",
"of",
"a",
"level",
"has",
"the",
"same",
"direction",
"as",
"this",
"level",
",",
"with",
"a",
"distance",
"of",
"one",
"more",
"than",
"this",
"level"
] | [
"public",
"fcg",
"level",
"child",
"(",
")",
"{",
"if",
"(",
"direction",
"=",
"=",
"in",
"and",
"out",
")",
"{",
"/",
"/",
"undefined",
"-",
"-",
"this",
"node",
"goes",
"in",
"both",
"directions",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"to",
"get",
"the",
"child",
"of",
"the",
"source",
"level",
"you",
"\"",
"+",
"\"",
"must",
"use",
"the",
"constructor",
"directly",
"\"",
")",
";",
"}",
"return",
"child",
"(",
"direction",
")",
";",
"}"
] |
[
"returns",
"the",
"address",
"of",
"the",
"optional",
"copy",
"of",
"original",
"iat"
] | [
"public",
"long",
"get",
"address",
"of",
"original",
"i",
"a",
"t",
"(",
")",
"{",
"return",
"p",
"unload",
"i",
"a",
"t",
";",
"}"
] |
[
"rx",
"version",
"of",
"{",
"@",
"link",
"abstract",
"dao",
"#",
"insert",
"(",
"object",
")",
"}",
"returning",
"an",
"observable",
"note",
"that",
"the",
"observable",
"will",
"emit",
"the",
"given",
"entity",
"back",
"to",
"its",
"subscribers"
] | [
"public",
"observable",
"<",
"t",
">",
"insert",
"(",
"final",
"t",
"entity",
")",
"{",
"return",
"wrap",
"(",
"new",
"callable",
"<",
"t",
">",
"(",
")",
"{",
"@",
"override",
"public",
"t",
"call",
"(",
")",
"throws",
"exception",
"{",
"dao",
"insert",
"(",
"entity",
")",
";",
"return",
"entity",
";",
"}",
"}",
")",
";",
"}"
] |
[
"get",
"the",
"read",
"permission",
"for",
"the",
"specified",
"segment"
] | [
"public",
"boolean",
"is",
"segment",
"readable",
"(",
"elf",
"program",
"header",
"segment",
")",
"{",
"return",
"(",
"segment",
"get",
"flags",
"(",
")",
"&",
"elf",
"program",
"header",
"constants",
"pf",
"r",
")",
"!",
"=",
"0",
";",
"}"
] |
[
"get",
"boss",
"thread",
"prefix",
"string"
] | [
"public",
"string",
"get",
"boss",
"thread",
"prefix",
"(",
")",
"{",
"return",
"config",
"get",
"config",
"(",
"configuration",
"keys",
"boss",
"thread",
"prefix",
",",
"default",
"boss",
"thread",
"prefix",
")",
";",
"}"
] |
[
"generates",
"a",
"string",
"representation",
"of",
"the",
"stats"
] | [
"public",
"string",
"to",
"string",
"(",
"duration",
"total",
",",
"boolean",
"summary",
")",
"{",
"string",
"builder",
"sb",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"sb",
"append",
"(",
"\"",
"(",
"\"",
")",
";",
"sb",
"append",
"(",
"pretty",
"percentage",
"(",
"total",
"time",
",",
"total",
")",
")",
";",
"sb",
"append",
"(",
"\"",
"of",
"the",
"time",
")",
":",
"[",
"\"",
")",
";",
"list",
"<",
"string",
">",
"stats",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"8",
")",
";",
"add",
"stat",
"to",
"string",
"(",
"stats",
",",
"\"",
"parse",
"\"",
",",
"!",
"summary",
",",
"parse",
"time",
",",
"total",
")",
";",
"add",
"stat",
"to",
"string",
"(",
"stats",
",",
"\"",
"queue",
"\"",
",",
"true",
",",
"queue",
"time",
",",
"total",
")",
";",
"add",
"stat",
"to",
"string",
"(",
"stats",
",",
"\"",
"network",
"\"",
",",
"!",
"summary",
",",
"network",
"time",
",",
"total",
")",
";",
"add",
"stat",
"to",
"string",
"(",
"stats",
",",
"\"",
"upload",
"\"",
",",
"!",
"summary",
",",
"upload",
"time",
",",
"total",
")",
";",
"add",
"stat",
"to",
"string",
"(",
"stats",
",",
"\"",
"setup",
"\"",
",",
"true",
",",
"setup",
"time",
",",
"total",
")",
";",
"add",
"stat",
"to",
"string",
"(",
"stats",
",",
"\"",
"process",
"\"",
",",
"true",
",",
"execution",
"wall",
"time",
",",
"total",
")",
";",
"add",
"stat",
"to",
"string",
"(",
"stats",
",",
"\"",
"fetch",
"\"",
",",
"!",
"summary",
",",
"fetch",
"time",
",",
"total",
")",
";",
"add",
"stat",
"to",
"string",
"(",
"stats",
",",
"\"",
"retry",
"\"",
",",
"!",
"summary",
",",
"retry",
"time",
"(",
")",
",",
"total",
")",
";",
"add",
"stat",
"to",
"string",
"(",
"stats",
",",
"\"",
"process",
"outputs",
"\"",
",",
"!",
"summary",
",",
"process",
"outputs",
"time",
",",
"total",
")",
";",
"add",
"stat",
"to",
"string",
"(",
"stats",
",",
"\"",
"other",
"\"",
",",
"!",
"summary",
",",
"other",
"time",
"(",
")",
",",
"total",
")",
";",
"if",
"(",
"!",
"summary",
")",
"{",
"stats",
"add",
"(",
"\"",
"input",
"files",
":",
"\"",
"+",
"input",
"files",
")",
";",
"stats",
"add",
"(",
"\"",
"input",
"bytes",
":",
"\"",
"+",
"input",
"bytes",
")",
";",
"stats",
"add",
"(",
"\"",
"memory",
"bytes",
":",
"\"",
"+",
"memory",
"estimate",
"bytes",
")",
";",
"}",
"joiner",
"on",
"(",
"\"",
",",
"\"",
")",
"append",
"to",
"(",
"sb",
",",
"stats",
")",
";",
"sb",
"append",
"(",
"\"",
"]",
"\"",
")",
";",
"return",
"sb",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"keep",
"in",
"sync",
"with",
"code",
"changes",
"in",
"s",
"3",
"a",
"file",
"system",
"finished",
"write",
"(",
")",
"so",
"that",
"the",
"production",
"code",
"can",
"be",
"tested",
"here"
] | [
"public",
"void",
"test",
"put",
"file",
"deep",
"under",
"tombstone",
"(",
")",
"throws",
"throwable",
"{",
"describe",
"(",
"\"",
"put",
"a",
"file",
"two",
"levels",
"under",
"a",
"tombstone",
"\"",
")",
";",
"string",
"base",
"=",
"\"",
"/",
"\"",
"+",
"get",
"method",
"name",
"(",
")",
";",
"string",
"dir",
"=",
"base",
"+",
"\"",
"/",
"dir",
"\"",
";",
"long",
"now",
"=",
"get",
"time",
"(",
")",
";",
"/",
"/",
"creating",
"a",
"file",
"must",
"create",
"its",
"parents",
"string",
"child",
"=",
"dir",
"+",
"\"",
"/",
"file",
"\"",
";",
"path",
"child",
"path",
"=",
"str",
"to",
"path",
"(",
"child",
")",
";",
"put",
"file",
"(",
"child",
",",
"now",
",",
"null",
")",
";",
"get",
"file",
"(",
"child",
")",
";",
"get",
"directory",
"(",
"dir",
")",
";",
"get",
"directory",
"(",
"base",
")",
";",
"/",
"/",
"now",
"put",
"the",
"tombstone",
"put",
"tombstone",
"(",
"base",
",",
"now",
",",
"null",
")",
";",
"assert",
"is",
"tombstone",
"(",
"base",
")",
";",
"/",
"*",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"*",
"/",
"/",
"*",
"begin",
"s",
"3",
"file",
"system",
"finished",
"write",
"(",
")",
"sequence",
"*",
"/",
"/",
"*",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"*",
"/",
"ancestor",
"state",
"ancestor",
"state",
"=",
"get",
"dynamo",
"metadata",
"store",
"(",
")",
"initiate",
"bulk",
"write",
"(",
"bulk",
"operation",
"state",
"operation",
"type",
"put",
",",
"child",
"path",
")",
";",
"s",
"3",
"guard",
"add",
"ancestors",
"(",
"get",
"dynamo",
"metadata",
"store",
"(",
")",
",",
"child",
"path",
",",
"get",
"ttl",
"time",
"provider",
"(",
")",
",",
"ancestor",
"state",
")",
";",
"/",
"/",
"now",
"write",
"the",
"file",
"again",
"put",
"file",
"(",
"child",
",",
"now",
",",
"ancestor",
"state",
")",
";",
"/",
"*",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"*",
"/",
"/",
"*",
"end",
"s",
"3",
"file",
"system",
"finished",
"write",
"(",
")",
"sequence",
"*",
"/",
"/",
"*",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"*",
"/",
"get",
"file",
"(",
"child",
")",
";",
"/",
"/",
"the",
"ancestor",
"will",
"now",
"exist",
"get",
"directory",
"(",
"dir",
")",
";",
"get",
"directory",
"(",
"base",
")",
";",
"}"
] |
[
"access",
"a",
"url",
",",
"ignoring",
"some",
"i",
"o",
"exception",
"such",
"as",
"the",
"page",
"does",
"not",
"exist"
] | [
"static",
"void",
"access",
"(",
"string",
"urlstring",
")",
"throws",
"i",
"o",
"exception",
"{",
"log",
"warn",
"(",
"\"",
"access",
"\"",
"+",
"urlstring",
")",
";",
"url",
"url",
"=",
"new",
"url",
"(",
"urlstring",
")",
";",
"u",
"r",
"l",
"connection",
"connection",
"=",
"url",
"open",
"connection",
"(",
")",
";",
"connection",
"connect",
"(",
")",
";",
"try",
"{",
"buffered",
"reader",
"in",
"=",
"new",
"buffered",
"reader",
"(",
"new",
"input",
"stream",
"reader",
"(",
"connection",
"get",
"input",
"stream",
"(",
")",
")",
")",
";",
"try",
"{",
"for",
"(",
";",
"in",
"read",
"line",
"(",
")",
"!",
"=",
"null",
";",
")",
";",
"}",
"finally",
"{",
"in",
"close",
"(",
")",
";",
"}",
"}",
"catch",
"(",
"i",
"o",
"exception",
"ioe",
")",
"{",
"log",
"warn",
"(",
"\"",
"urlstring",
"=",
"\"",
"+",
"urlstring",
",",
"ioe",
")",
";",
"}",
"}"
] |
[
"returns",
"a",
"splitter",
"that",
"uses",
"the",
"given",
"fixed",
"string",
"as",
"a",
"separator",
"for",
"example",
",",
"{",
"@",
"code",
"splitter",
"on",
"(",
"\"",
",",
"\"",
")",
"split",
"(",
"\"",
"foo",
",",
"bar",
",",
"baz",
"\"",
")",
"}",
"returns",
"an",
"iterable",
"containing",
"{",
"@",
"code",
"[",
"\"",
"foo",
"\"",
",",
"\"",
"bar",
",",
"baz",
"\"",
"]",
"}"
] | [
"public",
"static",
"splitter",
"on",
"(",
"final",
"string",
"separator",
")",
"{",
"check",
"argument",
"(",
"separator",
"length",
"(",
")",
"!",
"=",
"0",
",",
"\"",
"the",
"separator",
"may",
"not",
"be",
"the",
"empty",
"string",
"\"",
")",
";",
"if",
"(",
"separator",
"length",
"(",
")",
"=",
"=",
"1",
")",
"{",
"return",
"splitter",
"on",
"(",
"separator",
"char",
"at",
"(",
"0",
")",
")",
";",
"}",
"return",
"new",
"splitter",
"(",
"new",
"strategy",
"(",
")",
"{",
"@",
"override",
"public",
"splitting",
"iterator",
"iterator",
"(",
"splitter",
"splitter",
",",
"char",
"sequence",
"to",
"split",
")",
"{",
"return",
"new",
"splitting",
"iterator",
"(",
"splitter",
",",
"to",
"split",
")",
"{",
"@",
"override",
"public",
"int",
"separator",
"start",
"(",
"int",
"start",
")",
"{",
"int",
"separator",
"length",
"=",
"separator",
"length",
"(",
")",
";",
"positions",
":",
"for",
"(",
"int",
"p",
"=",
"start",
",",
"last",
"=",
"to",
"split",
"length",
"(",
")",
"-",
"separator",
"length",
";",
"p",
"<",
"=",
"last",
";",
"p",
"+",
"+",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"separator",
"length",
";",
"i",
"+",
"+",
")",
"{",
"if",
"(",
"to",
"split",
"char",
"at",
"(",
"i",
"+",
"p",
")",
"!",
"=",
"separator",
"char",
"at",
"(",
"i",
")",
")",
"{",
"continue",
"positions",
";",
"}",
"}",
"return",
"p",
";",
"}",
"return",
"-",
"1",
";",
"}",
"@",
"override",
"public",
"int",
"separator",
"end",
"(",
"int",
"separator",
"position",
")",
"{",
"return",
"separator",
"position",
"+",
"separator",
"length",
"(",
")",
";",
"}",
"}",
";",
"}",
"}",
")",
";",
"}"
] |
[
"rpc",
"stream",
"close",
"and",
"retry",
"while",
"there",
"is",
"listener",
"watcher",
"registered"
] | [
"public",
"void",
"stream",
"closed",
"and",
"retry",
"(",
")",
"{",
"in",
"order",
"in",
"order",
"=",
"mockito",
"in",
"order",
"(",
"mocked",
"discovery",
"service",
",",
"backoff",
"policy",
"provider",
",",
"backoff",
"policy",
"1",
",",
"backoff",
"policy",
"2",
")",
";",
"xds",
"client",
"watch",
"listener",
"data",
"(",
"port",
",",
"listener",
"watcher",
")",
";",
"argument",
"captor",
"<",
"stream",
"observer",
"<",
"discovery",
"response",
">",
">",
"response",
"observer",
"captor",
"=",
"argument",
"captor",
"for",
"class",
"(",
"null",
")",
";",
"in",
"order",
"verify",
"(",
"mocked",
"discovery",
"service",
")",
"stream",
"aggregated",
"resources",
"(",
"response",
"observer",
"captor",
"capture",
"(",
")",
")",
";",
"stream",
"observer",
"<",
"discovery",
"response",
">",
"response",
"observer",
"=",
"response",
"observer",
"captor",
"get",
"value",
"(",
")",
";",
"/",
"/",
"same",
"as",
"response",
"observers",
"poll",
"(",
")",
"request",
"observers",
"poll",
"(",
")",
";",
"final",
"filter",
"chain",
"filter",
"chain",
"outbound",
"=",
"build",
"filter",
"chain",
"(",
"build",
"filter",
"chain",
"match",
"(",
"8000",
")",
",",
"null",
")",
";",
"final",
"filter",
"chain",
"filter",
"chain",
"inbound",
"=",
"build",
"filter",
"chain",
"(",
"build",
"filter",
"chain",
"match",
"(",
"port",
",",
"cidr",
"range",
"new",
"builder",
"(",
")",
"set",
"address",
"prefix",
"(",
"local",
"ip",
")",
"set",
"prefix",
"len",
"(",
"u",
"int",
"3",
"2",
"value",
"of",
"(",
"32",
")",
")",
"build",
"(",
")",
")",
",",
"common",
"tls",
"context",
"tests",
"util",
"build",
"test",
"downstream",
"tls",
"context",
"(",
"\"",
"google",
"-",
"sds",
"-",
"config",
"-",
"default",
"\"",
",",
"\"",
"rootca",
"\"",
")",
",",
"build",
"test",
"filter",
"(",
"\"",
"envoy",
"http",
"connection",
"manager",
"\"",
")",
")",
";",
"list",
"<",
"any",
">",
"listeners",
"=",
"immutable",
"list",
"of",
"(",
"any",
"pack",
"(",
"build",
"listener",
"with",
"filter",
"chain",
"(",
"listener",
"name",
",",
"15001",
",",
"\"",
"0",
"0",
"0",
"0",
"\"",
",",
"filter",
"chain",
"outbound",
",",
"filter",
"chain",
"inbound",
")",
")",
")",
";",
"discovery",
"response",
"response",
"=",
"build",
"discovery",
"response",
"(",
"\"",
"0",
"\"",
",",
"listeners",
",",
"resource",
"type",
"lds",
"type",
"url",
"(",
")",
",",
"\"",
"0000",
"\"",
")",
";",
"response",
"observer",
"on",
"next",
"(",
"response",
")",
";",
"/",
"/",
"client",
"sent",
"an",
"ack",
"cds",
"request",
"(",
"omitted",
")",
"argument",
"captor",
"<",
"status",
">",
"status",
"captor",
"=",
"argument",
"captor",
"for",
"class",
"(",
"null",
")",
";",
"/",
"/",
"management",
"server",
"closes",
"the",
"rpc",
"stream",
"with",
"an",
"error",
"response",
"observer",
"on",
"error",
"(",
"status",
"unknown",
"as",
"exception",
"(",
")",
")",
";",
"verify",
"(",
"listener",
"watcher",
")",
"on",
"error",
"(",
"status",
"captor",
"capture",
"(",
")",
")",
";",
"assert",
"that",
"(",
"status",
"captor",
"get",
"value",
"(",
")",
"get",
"code",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"code",
"unknown",
")",
";",
"/",
"/",
"resets",
"backoff",
"and",
"retry",
"immediately",
"in",
"order",
"verify",
"(",
"backoff",
"policy",
"provider",
")",
"get",
"(",
")",
";",
"fake",
"clock",
"run",
"due",
"tasks",
"(",
")",
";",
"in",
"order",
"verify",
"(",
"mocked",
"discovery",
"service",
")",
"stream",
"aggregated",
"resources",
"(",
"response",
"observer",
"captor",
"capture",
"(",
")",
")",
";",
"response",
"observer",
"=",
"response",
"observer",
"captor",
"get",
"value",
"(",
")",
";",
"stream",
"observer",
"<",
"discovery",
"request",
">",
"request",
"observer",
"=",
"request",
"observers",
"poll",
"(",
")",
";",
"/",
"/",
"retry",
"resumes",
"requests",
"for",
"all",
"wanted",
"resources",
"verify",
"(",
"request",
"observer",
")",
"on",
"next",
"(",
"eq",
"(",
"build",
"discovery",
"request",
"(",
"node",
",",
"\"",
"0",
"\"",
",",
"immutable",
"list",
"of",
"(",
"\"",
"test",
"/",
"value",
"?",
"udpa",
"resource",
"listening",
"address",
"=",
"192",
"168",
"3",
"7",
":",
"7000",
"\"",
")",
",",
"resource",
"type",
"lds",
"type",
"url",
"(",
")",
",",
"\"",
"\"",
")",
")",
")",
";",
"verify",
"no",
"more",
"interactions",
"(",
"request",
"observer",
")",
";",
"/",
"/",
"management",
"server",
"becomes",
"unreachable",
"response",
"observer",
"on",
"error",
"(",
"status",
"unavailable",
"as",
"exception",
"(",
")",
")",
";",
"verify",
"(",
"listener",
"watcher",
",",
"times",
"(",
"2",
")",
")",
"on",
"error",
"(",
"status",
"captor",
"capture",
"(",
")",
")",
";",
"assert",
"that",
"(",
"status",
"captor",
"get",
"value",
"(",
")",
"get",
"code",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"code",
"unavailable",
")",
";",
"in",
"order",
"verify",
"(",
"backoff",
"policy",
"1",
")",
"next",
"backoff",
"nanos",
"(",
")",
";",
"assert",
"that",
"(",
"fake",
"clock",
"get",
"pending",
"tasks",
"(",
"rpc",
"retry",
"task",
"filter",
")",
")",
"has",
"size",
"(",
"1",
")",
";",
"/",
"/",
"retry",
"after",
"backoff",
"fake",
"clock",
"forward",
"nanos",
"(",
"9l",
")",
";",
"assert",
"that",
"(",
"request",
"observers",
")",
"is",
"empty",
"(",
")",
";",
"fake",
"clock",
"forward",
"nanos",
"(",
"1l",
")",
";",
"in",
"order",
"verify",
"(",
"mocked",
"discovery",
"service",
")",
"stream",
"aggregated",
"resources",
"(",
"response",
"observer",
"captor",
"capture",
"(",
")",
")",
";",
"response",
"observer",
"=",
"response",
"observer",
"captor",
"get",
"value",
"(",
")",
";",
"request",
"observer",
"=",
"request",
"observers",
"poll",
"(",
")",
";",
"verify",
"(",
"request",
"observer",
")",
"on",
"next",
"(",
"eq",
"(",
"build",
"discovery",
"request",
"(",
"node",
",",
"\"",
"0",
"\"",
",",
"immutable",
"list",
"of",
"(",
"\"",
"test",
"/",
"value",
"?",
"udpa",
"resource",
"listening",
"address",
"=",
"192",
"168",
"3",
"7",
":",
"7000",
"\"",
")",
",",
"resource",
"type",
"lds",
"type",
"url",
"(",
")",
",",
"\"",
"\"",
")",
")",
")",
";",
"verify",
"no",
"more",
"interactions",
"(",
"request",
"observer",
")",
";",
"/",
"/",
"management",
"server",
"is",
"still",
"not",
"reachable",
"response",
"observer",
"on",
"error",
"(",
"status",
"unavailable",
"as",
"exception",
"(",
")",
")",
";",
"verify",
"(",
"listener",
"watcher",
",",
"times",
"(",
"3",
")",
")",
"on",
"error",
"(",
"status",
"captor",
"capture",
"(",
")",
")",
";",
"assert",
"that",
"(",
"status",
"captor",
"get",
"value",
"(",
")",
"get",
"code",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"code",
"unavailable",
")",
";",
"in",
"order",
"verify",
"(",
"backoff",
"policy",
"1",
")",
"next",
"backoff",
"nanos",
"(",
")",
";",
"assert",
"that",
"(",
"fake",
"clock",
"get",
"pending",
"tasks",
"(",
"rpc",
"retry",
"task",
"filter",
")",
")",
"has",
"size",
"(",
"1",
")",
";",
"/",
"/",
"retry",
"after",
"backoff",
"fake",
"clock",
"forward",
"nanos",
"(",
"99l",
")",
";",
"assert",
"that",
"(",
"request",
"observers",
")",
"is",
"empty",
"(",
")",
";",
"fake",
"clock",
"forward",
"nanos",
"(",
"1l",
")",
";",
"in",
"order",
"verify",
"(",
"mocked",
"discovery",
"service",
")",
"stream",
"aggregated",
"resources",
"(",
"response",
"observer",
"captor",
"capture",
"(",
")",
")",
";",
"response",
"observer",
"=",
"response",
"observer",
"captor",
"get",
"value",
"(",
")",
";",
"request",
"observer",
"=",
"request",
"observers",
"poll",
"(",
")",
";",
"verify",
"(",
"request",
"observer",
")",
"on",
"next",
"(",
"eq",
"(",
"build",
"discovery",
"request",
"(",
"node",
",",
"\"",
"0",
"\"",
",",
"immutable",
"list",
"of",
"(",
"\"",
"test",
"/",
"value",
"?",
"udpa",
"resource",
"listening",
"address",
"=",
"192",
"168",
"3",
"7",
":",
"7000",
"\"",
")",
",",
"resource",
"type",
"lds",
"type",
"url",
"(",
")",
",",
"\"",
"\"",
")",
")",
")",
";",
"verify",
"no",
"more",
"interactions",
"(",
"request",
"observer",
")",
";",
"/",
"/",
"management",
"server",
"sends",
"back",
"a",
"lds",
"response",
"response",
"=",
"build",
"discovery",
"response",
"(",
"\"",
"1",
"\"",
",",
"listeners",
",",
"resource",
"type",
"lds",
"type",
"url",
"(",
")",
",",
"\"",
"0001",
"\"",
")",
";",
"response",
"observer",
"on",
"next",
"(",
"response",
")",
";",
"/",
"/",
"client",
"sent",
"an",
"lds",
"ack",
"request",
"(",
"omitted",
")",
"/",
"/",
"management",
"server",
"closes",
"the",
"rpc",
"stream",
"response",
"observer",
"on",
"completed",
"(",
")",
";",
"verify",
"(",
"listener",
"watcher",
",",
"times",
"(",
"4",
")",
")",
"on",
"error",
"(",
"any",
"(",
"status",
"class",
")",
")",
";",
"/",
"/",
"resets",
"backoff",
"and",
"retry",
"immediately",
"in",
"order",
"verify",
"(",
"backoff",
"policy",
"provider",
")",
"get",
"(",
")",
";",
"fake",
"clock",
"run",
"due",
"tasks",
"(",
")",
";",
"in",
"order",
"verify",
"(",
"mocked",
"discovery",
"service",
")",
"stream",
"aggregated",
"resources",
"(",
"response",
"observer",
"captor",
"capture",
"(",
")",
")",
";",
"response",
"observer",
"=",
"response",
"observer",
"captor",
"get",
"value",
"(",
")",
";",
"request",
"observer",
"=",
"request",
"observers",
"poll",
"(",
")",
";",
"verify",
"(",
"request",
"observer",
")",
"on",
"next",
"(",
"eq",
"(",
"build",
"discovery",
"request",
"(",
"node",
",",
"\"",
"1",
"\"",
",",
"immutable",
"list",
"of",
"(",
"\"",
"test",
"/",
"value",
"?",
"udpa",
"resource",
"listening",
"address",
"=",
"192",
"168",
"3",
"7",
":",
"7000",
"\"",
")",
",",
"resource",
"type",
"lds",
"type",
"url",
"(",
")",
",",
"\"",
"\"",
")",
")",
")",
";",
"verify",
"no",
"more",
"interactions",
"(",
"request",
"observer",
")",
";",
"/",
"/",
"management",
"server",
"becomes",
"unreachable",
"again",
"response",
"observer",
"on",
"error",
"(",
"status",
"unavailable",
"as",
"exception",
"(",
")",
")",
";",
"verify",
"(",
"listener",
"watcher",
",",
"times",
"(",
"5",
")",
")",
"on",
"error",
"(",
"status",
"captor",
"capture",
"(",
")",
")",
";",
"assert",
"that",
"(",
"status",
"captor",
"get",
"value",
"(",
")",
"get",
"code",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"code",
"unavailable",
")",
";",
"in",
"order",
"verify",
"(",
"backoff",
"policy",
"2",
")",
"next",
"backoff",
"nanos",
"(",
")",
";",
"assert",
"that",
"(",
"fake",
"clock",
"get",
"pending",
"tasks",
"(",
"rpc",
"retry",
"task",
"filter",
")",
")",
"has",
"size",
"(",
"1",
")",
";",
"/",
"/",
"retry",
"after",
"backoff",
"fake",
"clock",
"forward",
"nanos",
"(",
"19l",
")",
";",
"assert",
"that",
"(",
"request",
"observers",
")",
"is",
"empty",
"(",
")",
";",
"fake",
"clock",
"forward",
"nanos",
"(",
"1l",
")",
";",
"in",
"order",
"verify",
"(",
"mocked",
"discovery",
"service",
")",
"stream",
"aggregated",
"resources",
"(",
"response",
"observer",
"captor",
"capture",
"(",
")",
")",
";",
"request",
"observer",
"=",
"request",
"observers",
"poll",
"(",
")",
";",
"verify",
"(",
"request",
"observer",
")",
"on",
"next",
"(",
"eq",
"(",
"build",
"discovery",
"request",
"(",
"node",
",",
"\"",
"1",
"\"",
",",
"immutable",
"list",
"of",
"(",
"\"",
"test",
"/",
"value",
"?",
"udpa",
"resource",
"listening",
"address",
"=",
"192",
"168",
"3",
"7",
":",
"7000",
"\"",
")",
",",
"resource",
"type",
"lds",
"type",
"url",
"(",
")",
",",
"\"",
"\"",
")",
")",
")",
";",
"verify",
"no",
"more",
"interactions",
"(",
"mocked",
"discovery",
"service",
",",
"backoff",
"policy",
"provider",
",",
"backoff",
"policy",
"1",
",",
"backoff",
"policy",
"2",
",",
"request",
"observer",
")",
";",
"}"
] |
[
"identify",
"the",
"node",
"at",
"the",
"given",
"address",
"and",
",",
"if",
"it",
"is",
"a",
"master",
"node",
"and",
"not",
"the",
"local",
"node",
"then",
"establish",
"a",
"full",
"connection",
"to",
"it"
] | [
"void",
"connect",
"to",
"remote",
"master",
"node",
"(",
"transport",
"address",
"transport",
"address",
",",
"action",
"listener",
"<",
"discovery",
"node",
">",
"listener",
")",
";"
] |
[
"sets",
"the",
"last",
"row",
"in",
"the",
"viewport",
"to",
"be",
"the",
"end",
"of",
"the",
"current",
"selection",
"range",
"the",
"start",
"of",
"the",
"selection",
"range",
"remains",
"untouched"
] | [
"private",
"void",
"update",
"selection",
"to",
"viewport",
"bottom",
"(",
")",
"{",
"int",
"bottom",
"row",
"=",
"get",
"viewport",
"position",
"as",
"row",
"(",
")",
"+",
"get",
"num",
"rows",
"in",
"viewport",
"(",
")",
";",
"pair",
"file",
"pos",
"=",
"model",
"get",
"file",
"position",
"for",
"row",
"(",
"bottom",
"row",
")",
";",
"if",
"(",
"file",
"pos",
"=",
"=",
"null",
")",
"{",
"return",
";",
"}",
"long",
"file",
"pos",
"for",
"bottom",
"row",
"=",
"file",
"pos",
"get",
"end",
"(",
")",
";",
"model",
"selected",
"byte",
"end",
"=",
"file",
"pos",
"for",
"bottom",
"row",
";",
"table",
"restore",
"selection",
"(",
")",
";",
"}"
] |
[
"returns",
"the",
"first",
"directory",
"in",
"the",
"sequence",
"of",
"parents",
"of",
"the",
"exec",
"path",
"of",
"the",
"given",
"artifact",
"that",
"matches",
"{",
"@",
"code",
"type",
"}",
"for",
"instance",
",",
"if",
"{",
"@",
"code",
"type",
"}",
"is",
"file",
"type",
"of",
"(",
"\"",
"foo",
"\"",
")",
"and",
"the",
"exec",
"path",
"of",
"{",
"@",
"code",
"artifact",
"}",
"is",
"{",
"@",
"code",
"abcbar",
"foode",
"}",
",",
"then",
"the",
"return",
"value",
"is",
"{",
"@",
"code",
"abcbar",
"foo",
"}"
] | [
"static",
"optional",
"<",
"path",
"fragment",
">",
"nearest",
"container",
"matching",
"(",
"file",
"type",
"type",
",",
"artifact",
"artifact",
")",
"{",
"path",
"fragment",
"container",
"=",
"artifact",
"get",
"exec",
"path",
"(",
")",
";",
"do",
"{",
"if",
"(",
"type",
"matches",
"(",
"container",
")",
")",
"{",
"return",
"optional",
"of",
"(",
"container",
")",
";",
"}",
"container",
"=",
"container",
"get",
"parent",
"directory",
"(",
")",
";",
"}",
"while",
"(",
"container",
"!",
"=",
"null",
")",
";",
"return",
"optional",
"absent",
"(",
")",
";",
"}"
] |
[
"required",
"the",
"hosts",
"associated",
"with",
"the",
"service",
"entry",
"could",
"be",
"a",
"dns",
"name",
"with",
"wildcard",
"prefix",
"1",
"the",
"hosts",
"field",
"is",
"used",
"to",
"select",
"matching",
"hosts",
"in",
"virtual",
"services",
"and",
"destination",
"rules",
"2",
"for",
"http",
"traffic",
"the",
"http",
"host",
"authority",
"header",
"will",
"be",
"matched",
"against",
"the",
"hosts",
"field",
"3",
"for",
"h",
"t",
"t",
"ps",
"or",
"tls",
"traffic",
"containing",
"server",
"name",
"indication",
"(",
"sni",
")",
",",
"the",
"sni",
"value",
"will",
"be",
"matched",
"against",
"the",
"hosts",
"field",
"note",
"that",
"when",
"resolution",
"is",
"set",
"to",
"type",
"dns",
"and",
"no",
"endpoints",
"are",
"specified",
",",
"the",
"host",
"field",
"will",
"be",
"used",
"as",
"the",
"dns",
"name",
"of",
"the",
"endpoint",
"to",
"route",
"traffic",
"to",
"<",
"code",
">",
"repeated",
"string",
"hosts",
"=",
"1",
";",
"<",
"code",
">"
] | [
"public",
"com",
"google",
"protobuf",
"protocol",
"string",
"list",
"get",
"hosts",
"list",
"(",
")",
"{",
"return",
"hosts",
"get",
"unmodifiable",
"view",
"(",
")",
";",
"}"
] |
[
"creates",
"a",
"virtual",
"file",
"wrapper",
"for",
"a",
"local",
"file"
] | [
"public",
"static",
"virtual",
"file",
"for",
"file",
"(",
"final",
"file",
"f",
")",
"{",
"return",
"new",
"file",
"v",
"f",
"(",
"f",
",",
"f",
")",
";",
"}"
] |
[
"gets",
"the",
"literal",
"value",
",",
"masked",
"to",
"be",
"a",
"byte",
"in",
"size",
"this",
"will",
"throw",
"if",
"the",
"value",
"is",
"out",
"of",
"the",
"range",
"of",
"a",
"signed",
"byte"
] | [
"public",
"final",
"int",
"get",
"literal",
"byte",
"(",
")",
"{",
"if",
"(",
"literal",
"!",
"=",
"(",
"byte",
")",
"literal",
")",
"{",
"throw",
"new",
"dex",
"exception",
"2",
"(",
"\"",
"literal",
"out",
"of",
"range",
":",
"\"",
"+",
"hex",
"u",
"8",
"(",
"literal",
")",
")",
";",
"}",
"return",
"(",
"int",
")",
"literal",
"&",
"0xff",
";",
"}"
] |
[
"checks",
"requested",
"access",
"against",
"an",
"access",
"control",
"list",
"this",
"method",
"relies",
"on",
"finding",
"the",
"acl",
"data",
"in",
"the",
"relevant",
"portions",
"of",
"{",
"@",
"link",
"fs",
"permission",
"}",
"and",
"{",
"@",
"link",
"acl",
"feature",
"}",
"as",
"implemented",
"in",
"the",
"logic",
"of",
"{",
"@",
"link",
"acl",
"storage",
"}",
"this",
"method",
"also",
"relies",
"on",
"receiving",
"the",
"acl",
"entries",
"in",
"sorted",
"order",
"this",
"is",
"assumed",
"to",
"be",
"true",
",",
"because",
"the",
"acl",
"modification",
"methods",
"in",
"{",
"@",
"link",
"acl",
"transformation",
"}",
"sort",
"the",
"resulting",
"entries",
"more",
"specifically",
",",
"this",
"method",
"depends",
"on",
"these",
"invariants",
"in",
"an",
"acl",
":",
"-",
"the",
"list",
"must",
"be",
"sorted",
"-",
"each",
"entry",
"in",
"the",
"list",
"must",
"be",
"unique",
"by",
"scope",
"+",
"type",
"+",
"name",
"-",
"there",
"is",
"exactly",
"one",
"each",
"of",
"the",
"unnamed",
"usergroupother",
"entries",
"-",
"the",
"mask",
"entry",
"must",
"not",
"have",
"a",
"name",
"-",
"the",
"other",
"entry",
"must",
"not",
"have",
"a",
"name",
"-",
"default",
"entries",
"may",
"be",
"present",
",",
"but",
"they",
"are",
"ignored",
"during",
"enforcement"
] | [
"private",
"boolean",
"has",
"acl",
"permission",
"(",
"i",
"node",
"attributes",
"inode",
",",
"fs",
"action",
"access",
",",
"fs",
"permission",
"mode",
",",
"acl",
"feature",
"acl",
"feature",
")",
"{",
"boolean",
"found",
"match",
"=",
"false",
";",
"/",
"/",
"use",
"owner",
"entry",
"from",
"permission",
"bits",
"if",
"user",
"is",
"owner",
"if",
"(",
"get",
"user",
"(",
")",
"equals",
"(",
"inode",
"get",
"user",
"name",
"(",
")",
")",
")",
"{",
"if",
"(",
"mode",
"get",
"user",
"action",
"(",
")",
"implies",
"(",
"access",
")",
")",
"{",
"return",
"true",
";",
"}",
"found",
"match",
"=",
"true",
";",
"}",
"/",
"/",
"check",
"named",
"user",
"and",
"group",
"entries",
"if",
"user",
"was",
"not",
"denied",
"by",
"owner",
"entry",
"if",
"(",
"!",
"found",
"match",
")",
"{",
"for",
"(",
"int",
"pos",
"=",
"0",
",",
"entry",
";",
"pos",
"<",
"acl",
"feature",
"get",
"entries",
"size",
"(",
")",
";",
"pos",
"+",
"+",
")",
"{",
"entry",
"=",
"acl",
"feature",
"get",
"entry",
"at",
"(",
"pos",
")",
";",
"if",
"(",
"acl",
"entry",
"status",
"format",
"get",
"scope",
"(",
"entry",
")",
"=",
"=",
"acl",
"entry",
"scope",
"default",
")",
"{",
"break",
";",
"}",
"acl",
"entry",
"type",
"type",
"=",
"acl",
"entry",
"status",
"format",
"get",
"type",
"(",
"entry",
")",
";",
"string",
"name",
"=",
"acl",
"entry",
"status",
"format",
"get",
"name",
"(",
"entry",
")",
";",
"if",
"(",
"type",
"=",
"=",
"acl",
"entry",
"type",
"user",
")",
"{",
"/",
"/",
"use",
"named",
"user",
"entry",
"with",
"mask",
"from",
"permission",
"bits",
"applied",
"if",
"user",
"/",
"/",
"matches",
"name",
"if",
"(",
"get",
"user",
"(",
")",
"equals",
"(",
"name",
")",
")",
"{",
"fs",
"action",
"masked",
"=",
"acl",
"entry",
"status",
"format",
"get",
"permission",
"(",
"entry",
")",
"and",
"(",
"mode",
"get",
"group",
"action",
"(",
")",
")",
";",
"if",
"(",
"masked",
"implies",
"(",
"access",
")",
")",
"{",
"return",
"true",
";",
"}",
"found",
"match",
"=",
"true",
";",
"break",
";",
"}",
"}",
"else",
"if",
"(",
"type",
"=",
"=",
"acl",
"entry",
"type",
"group",
")",
"{",
"/",
"/",
"use",
"group",
"entry",
"(",
"unnamed",
"or",
"named",
")",
"with",
"mask",
"from",
"permission",
"bits",
"/",
"/",
"applied",
"if",
"user",
"is",
"a",
"member",
"and",
"entry",
"grants",
"access",
"if",
"user",
"is",
"a",
"/",
"/",
"member",
"of",
"multiple",
"groups",
"that",
"have",
"entries",
"that",
"grant",
"access",
",",
"then",
"/",
"/",
"it",
"doesn",
"'",
"t",
"matter",
"which",
"is",
"chosen",
",",
"so",
"exit",
"early",
"after",
"first",
"match",
"string",
"group",
"=",
"name",
"=",
"=",
"null",
"?",
"inode",
"get",
"group",
"name",
"(",
")",
":",
"name",
";",
"if",
"(",
"is",
"member",
"of",
"group",
"(",
"group",
")",
")",
"{",
"fs",
"action",
"masked",
"=",
"acl",
"entry",
"status",
"format",
"get",
"permission",
"(",
"entry",
")",
"and",
"(",
"mode",
"get",
"group",
"action",
"(",
")",
")",
";",
"if",
"(",
"masked",
"implies",
"(",
"access",
")",
")",
"{",
"return",
"true",
";",
"}",
"found",
"match",
"=",
"true",
";",
"}",
"}",
"}",
"}",
"/",
"/",
"use",
"other",
"entry",
"if",
"user",
"was",
"not",
"denied",
"by",
"an",
"earlier",
"match",
"return",
"!",
"found",
"match",
"&",
"&",
"mode",
"get",
"other",
"action",
"(",
")",
"implies",
"(",
"access",
")",
";",
"}"
] |
[
"test",
"older",
"than",
"(",
"page",
"down",
")",
"when",
"set",
"to",
"id",
"greater",
"than",
"newest",
"(",
"should",
"never",
"happen",
")",
"should",
"be",
"same",
"as",
"not",
"specifying",
"newer",
"thanolder",
"than"
] | [
"public",
"void",
"test",
"older",
"than",
"gt",
"newest",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"history",
"page",
"filter",
"<",
"model",
"object",
">",
"history",
"page",
"filter",
"=",
"new",
"page",
"(",
"5",
",",
"null",
",",
"11l",
")",
";",
"list",
"<",
"model",
"object",
">",
"item",
"list",
"=",
"new",
"runs",
"(",
"1",
",",
"10",
")",
";",
"history",
"page",
"filter",
"add",
"(",
"item",
"list",
")",
";",
"assert",
"assert",
"false",
"(",
"history",
"page",
"filter",
"has",
"up",
"page",
")",
";",
"assert",
"assert",
"true",
"(",
"history",
"page",
"filter",
"has",
"down",
"page",
")",
";",
"assert",
"assert",
"equals",
"(",
"5",
",",
"history",
"page",
"filter",
"runs",
"size",
"(",
")",
")",
";",
"assert",
"assert",
"equals",
"(",
"history",
"page",
"entry",
"get",
"entry",
"id",
"(",
"10",
")",
",",
"history",
"page",
"filter",
"newest",
"on",
"page",
")",
";",
"assert",
"assert",
"equals",
"(",
"history",
"page",
"entry",
"get",
"entry",
"id",
"(",
"6",
")",
",",
"history",
"page",
"filter",
"oldest",
"on",
"page",
")",
";",
"}"
] |
[
"retrieve",
"the",
"first",
"element",
"of",
"the",
"given",
"list",
",",
"accessing",
"the",
"zero",
"index"
] | [
"public",
"static",
"<",
"t",
">",
"t",
"first",
"element",
"(",
"@",
"nullable",
"list",
"<",
"t",
">",
"list",
")",
"{",
"if",
"(",
"is",
"empty",
"(",
"list",
")",
")",
"{",
"return",
"null",
";",
"}",
"return",
"list",
"get",
"(",
"0",
")",
";",
"}"
] |
[
"prepare",
"the",
"model",
"to",
"use",
"for",
"rendering",
"by",
"potentially",
"exposing",
"a",
"{",
"@",
"link",
"request",
"context",
"}",
"for",
"use",
"in",
"spring",
"free",
"marker",
"macros",
"and",
"then",
"delegating",
"to",
"the",
"inherited",
"implementation",
"of",
"this",
"method"
] | [
"protected",
"mono",
"<",
"map",
"<",
"string",
",",
"object",
">",
">",
"get",
"model",
"attributes",
"(",
"@",
"nullable",
"map",
"<",
"string",
",",
"?",
">",
"model",
",",
"server",
"web",
"exchange",
"exchange",
")",
"{",
"if",
"(",
"this",
"expose",
"spring",
"macro",
"helpers",
")",
"{",
"if",
"(",
"model",
"!",
"=",
"null",
"&",
"&",
"model",
"contains",
"key",
"(",
"spring",
"macro",
"request",
"context",
"attribute",
")",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"cannot",
"expose",
"bind",
"macro",
"helper",
"'",
"\"",
"+",
"spring",
"macro",
"request",
"context",
"attribute",
"+",
"\"",
"'",
"because",
"of",
"an",
"existing",
"model",
"object",
"of",
"the",
"same",
"name",
"\"",
")",
";",
"}",
"/",
"/",
"make",
"a",
"defensive",
"copy",
"of",
"the",
"model",
"map",
"<",
"string",
",",
"object",
">",
"attributes",
"=",
"(",
"model",
"!",
"=",
"null",
"?",
"new",
"hash",
"map",
"<",
">",
"(",
"model",
")",
":",
"new",
"hash",
"map",
"<",
">",
"(",
")",
")",
";",
"/",
"/",
"expose",
"request",
"context",
"instance",
"for",
"spring",
"macros",
"attributes",
"put",
"(",
"spring",
"macro",
"request",
"context",
"attribute",
",",
"new",
"request",
"context",
"(",
"exchange",
",",
"attributes",
",",
"obtain",
"application",
"context",
"(",
")",
",",
"get",
"request",
"data",
"value",
"processor",
"(",
")",
")",
")",
";",
"return",
"super",
"get",
"model",
"attributes",
"(",
"attributes",
",",
"exchange",
")",
";",
"}",
"return",
"super",
"get",
"model",
"attributes",
"(",
"model",
",",
"exchange",
")",
";",
"}"
] |
[
"re",
"-",
"initializes",
"the",
"arguments",
"list"
] | [
"public",
"void",
"clear",
"(",
")",
"{",
"args",
"clear",
"(",
")",
";",
"mask",
"clear",
"(",
")",
";",
"}"
] |
[
"check",
"whether",
"the",
"given",
"bean",
"has",
"any",
"kind",
"of",
"destroy",
"method",
"to",
"call"
] | [
"public",
"static",
"boolean",
"has",
"destroy",
"method",
"(",
"object",
"bean",
",",
"root",
"bean",
"definition",
"bean",
"definition",
")",
"{",
"if",
"(",
"bean",
"instanceof",
"disposable",
"bean",
"|",
"|",
"bean",
"instanceof",
"auto",
"closeable",
")",
"{",
"return",
"true",
";",
"}",
"string",
"destroy",
"method",
"name",
"=",
"bean",
"definition",
"get",
"destroy",
"method",
"name",
"(",
")",
";",
"if",
"(",
"abstract",
"bean",
"definition",
"infer",
"method",
"equals",
"(",
"destroy",
"method",
"name",
")",
")",
"{",
"return",
"(",
"class",
"utils",
"has",
"method",
"(",
"bean",
"get",
"class",
"(",
")",
",",
"close",
"method",
"name",
")",
"|",
"|",
"class",
"utils",
"has",
"method",
"(",
"bean",
"get",
"class",
"(",
")",
",",
"shutdown",
"method",
"name",
")",
")",
";",
"}",
"return",
"string",
"utils",
"has",
"length",
"(",
"destroy",
"method",
"name",
")",
";",
"}"
] |
[
"http",
":",
"www",
"vt",
"1",
"0",
"0",
"netdocsvt",
"5",
"1",
"0",
"-",
"rm",
"d",
"e",
"c",
"e",
"r",
"a"
] | [
"public",
"void",
"test",
"erase",
"rectangular",
"area",
"(",
")",
"{",
"with",
"terminal",
"sized",
"(",
"3",
",",
"3",
")",
"enter",
"string",
"(",
"\"",
"abcdefghi",
"\\",
"033",
"[",
"$",
"z",
"\"",
")",
"assert",
"lines",
"are",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
";",
"with",
"terminal",
"sized",
"(",
"3",
",",
"3",
")",
"enter",
"string",
"(",
"\"",
"abcdefghi",
"\\",
"033",
"[",
"1",
";",
"1",
";",
"2",
";",
"10",
"$",
"z",
"\"",
")",
"assert",
"lines",
"are",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"ghi",
"\"",
")",
";",
"with",
"terminal",
"sized",
"(",
"3",
",",
"3",
")",
"enter",
"string",
"(",
"\"",
"abcdefghi",
"\\",
"033",
"[",
"2",
";",
"1",
";",
"3",
";",
"10",
"$",
"z",
"\"",
")",
"assert",
"lines",
"are",
"(",
"\"",
"abc",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
";",
"with",
"terminal",
"sized",
"(",
"3",
",",
"3",
")",
"enter",
"string",
"(",
"\"",
"abcdefghi",
"\\",
"033",
"[",
"1",
";",
"1",
";",
"100",
";",
"1",
"$",
"z",
"\"",
")",
"assert",
"lines",
"are",
"(",
"\"",
"bc",
"\"",
",",
"\"",
"ef",
"\"",
",",
"\"",
"hi",
"\"",
")",
";",
"with",
"terminal",
"sized",
"(",
"3",
",",
"3",
")",
"enter",
"string",
"(",
"\"",
"abcdefghi",
"\\",
"033",
"[",
"1",
";",
"1",
";",
"100",
";",
"2",
"$",
"z",
"\"",
")",
"assert",
"lines",
"are",
"(",
"\"",
"c",
"\"",
",",
"\"",
"f",
"\"",
",",
"\"",
"i",
"\"",
")",
";",
"with",
"terminal",
"sized",
"(",
"3",
",",
"3",
")",
"enter",
"string",
"(",
"\"",
"abcdefghi",
"\\",
"033",
"[",
"100",
";",
"1",
";",
"100",
";",
"2",
"$",
"z",
"\"",
")",
"assert",
"lines",
"are",
"(",
"\"",
"abc",
"\"",
",",
"\"",
"def",
"\"",
",",
"\"",
"ghi",
"\"",
")",
";",
"with",
"terminal",
"sized",
"(",
"3",
",",
"3",
")",
"enter",
"string",
"(",
"\"",
"a",
"\\",
"033",
"[",
"$",
"z",
"b",
"c",
"\"",
")",
"assert",
"lines",
"are",
"(",
"\"",
"bc",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
";",
"}"
] |
[
"set",
"the",
"acceptable",
"language",
"ranges",
",",
"as",
"specified",
"by",
"the",
"{",
"@",
"literal",
"accept",
"-",
"language",
"}",
"header"
] | [
"public",
"void",
"set",
"accept",
"language",
"(",
"list",
"<",
"locale",
"language",
"range",
">",
"languages",
")",
"{",
"assert",
"not",
"null",
"(",
"languages",
",",
"\"",
"language",
"range",
"list",
"must",
"not",
"be",
"null",
"\"",
")",
";",
"decimal",
"format",
"decimal",
"=",
"new",
"decimal",
"format",
"(",
"\"",
"0",
"0",
"\"",
",",
"decimal",
"format",
"symbols",
")",
";",
"list",
"<",
"string",
">",
"values",
"=",
"languages",
"stream",
"(",
")",
"map",
"(",
"range",
"-",
">",
"range",
"get",
"weight",
"(",
")",
"=",
"=",
"locale",
"language",
"range",
"max",
"weight",
"?",
"range",
"get",
"range",
"(",
")",
":",
"range",
"get",
"range",
"(",
")",
"+",
"\"",
";",
"q",
"=",
"\"",
"+",
"decimal",
"format",
"(",
"range",
"get",
"weight",
"(",
")",
")",
")",
"collect",
"(",
"collectors",
"to",
"list",
"(",
")",
")",
";",
"set",
"(",
"accept",
"language",
",",
"to",
"comma",
"delimited",
"string",
"(",
"values",
")",
")",
";",
"}"
] |
[
"return",
"an",
"address",
"iterator",
"over",
"each",
"address",
"with",
"an",
"equate",
"reference",
"that",
"is",
"in",
"the",
"specified",
"address",
"set"
] | [
"public",
"address",
"iterator",
"get",
"equate",
"addresses",
"(",
"address",
"set",
"view",
"asv",
")",
";"
] |
[
"tests",
"that",
"the",
"restore",
"procedure",
"follows",
"the",
"order",
"of",
"the",
"iterator",
"and",
"will",
"retries",
"failed",
"attempts",
"if",
"there",
"are",
"more",
"options"
] | [
"public",
"void",
"test",
"restore",
"procedure",
"order",
"and",
"failure",
"(",
")",
"throws",
"exception",
"{",
"closeable",
"registry",
"closeable",
"registry",
"=",
"new",
"closeable",
"registry",
"(",
")",
";",
"checkpoint",
"stream",
"factory",
"checkpoint",
"stream",
"factory",
"=",
"new",
"mem",
"checkpoint",
"stream",
"factory",
"(",
"1024",
")",
";",
"list",
"state",
"descriptor",
"<",
"integer",
">",
"state",
"descriptor",
"=",
"new",
"list",
"state",
"descriptor",
"<",
">",
"(",
"\"",
"test",
"-",
"state",
"\"",
",",
"integer",
"class",
")",
";",
"operator",
"state",
"backend",
"original",
"backend",
"=",
"backend",
"supplier",
"apply",
"(",
"collections",
"empty",
"list",
"(",
")",
")",
";",
"snapshot",
"result",
"<",
"operator",
"state",
"handle",
">",
"snapshot",
"result",
";",
"try",
"{",
"list",
"state",
"<",
"integer",
">",
"list",
"state",
"=",
"original",
"backend",
"get",
"list",
"state",
"(",
"state",
"descriptor",
")",
";",
"list",
"state",
"add",
"(",
"0",
")",
";",
"list",
"state",
"add",
"(",
"1",
")",
";",
"list",
"state",
"add",
"(",
"2",
")",
";",
"list",
"state",
"add",
"(",
"3",
")",
";",
"runnable",
"future",
"<",
"snapshot",
"result",
"<",
"operator",
"state",
"handle",
">",
">",
"snapshot",
"=",
"original",
"backend",
"snapshot",
"(",
"0l",
",",
"0l",
",",
"checkpoint",
"stream",
"factory",
",",
"checkpoint",
"options",
"for",
"checkpoint",
"with",
"default",
"location",
"(",
")",
")",
";",
"snapshot",
"run",
"(",
")",
";",
"snapshot",
"result",
"=",
"snapshot",
"get",
"(",
")",
";",
"}",
"finally",
"{",
"original",
"backend",
"close",
"(",
")",
";",
"original",
"backend",
"dispose",
"(",
")",
";",
"}",
"operator",
"state",
"handle",
"first",
"fail",
"handle",
"=",
"mock",
"(",
"operator",
"state",
"handle",
"class",
")",
";",
"operator",
"state",
"handle",
"second",
"success",
"handle",
"=",
"spy",
"(",
"snapshot",
"result",
"get",
"job",
"manager",
"owned",
"snapshot",
"(",
")",
")",
";",
"operator",
"state",
"handle",
"third",
"not",
"used",
"handle",
"=",
"mock",
"(",
"operator",
"state",
"handle",
"class",
")",
";",
"list",
"<",
"state",
"object",
"collection",
"<",
"operator",
"state",
"handle",
">",
">",
"sorted",
"restore",
"options",
"=",
"arrays",
"as",
"list",
"(",
"new",
"state",
"object",
"collection",
"<",
">",
"(",
"collections",
"singleton",
"list",
"(",
"first",
"fail",
"handle",
")",
")",
",",
"new",
"state",
"object",
"collection",
"<",
">",
"(",
"collections",
"singleton",
"list",
"(",
"second",
"success",
"handle",
")",
")",
",",
"new",
"state",
"object",
"collection",
"<",
">",
"(",
"collections",
"singleton",
"list",
"(",
"third",
"not",
"used",
"handle",
")",
")",
")",
";",
"backend",
"restorer",
"procedure",
"<",
"operator",
"state",
"backend",
",",
"operator",
"state",
"handle",
">",
"restorer",
"procedure",
"=",
"new",
"backend",
"restorer",
"procedure",
"<",
">",
"(",
"backend",
"supplier",
",",
"closeable",
"registry",
",",
"\"",
"test",
"op",
"state",
"backend",
"\"",
")",
";",
"operator",
"state",
"backend",
"restored",
"backend",
"=",
"restorer",
"procedure",
"create",
"and",
"restore",
"(",
"sorted",
"restore",
"options",
")",
";",
"assert",
"assert",
"not",
"null",
"(",
"restored",
"backend",
")",
";",
"try",
"{",
"verify",
"(",
"first",
"fail",
"handle",
")",
"open",
"input",
"stream",
"(",
")",
";",
"verify",
"(",
"second",
"success",
"handle",
")",
"open",
"input",
"stream",
"(",
")",
";",
"verify",
"zero",
"interactions",
"(",
"third",
"not",
"used",
"handle",
")",
";",
"list",
"state",
"<",
"integer",
">",
"list",
"state",
"=",
"restored",
"backend",
"get",
"list",
"state",
"(",
"state",
"descriptor",
")",
";",
"iterator",
"<",
"integer",
">",
"state",
"iterator",
"=",
"list",
"state",
"get",
"(",
")",
"iterator",
"(",
")",
";",
"assert",
"assert",
"equals",
"(",
"0",
",",
"(",
"int",
")",
"state",
"iterator",
"next",
"(",
")",
")",
";",
"assert",
"assert",
"equals",
"(",
"1",
",",
"(",
"int",
")",
"state",
"iterator",
"next",
"(",
")",
")",
";",
"assert",
"assert",
"equals",
"(",
"2",
",",
"(",
"int",
")",
"state",
"iterator",
"next",
"(",
")",
")",
";",
"assert",
"assert",
"equals",
"(",
"3",
",",
"(",
"int",
")",
"state",
"iterator",
"next",
"(",
")",
")",
";",
"assert",
"assert",
"false",
"(",
"state",
"iterator",
"has",
"next",
"(",
")",
")",
";",
"}",
"finally",
"{",
"restored",
"backend",
"close",
"(",
")",
";",
"restored",
"backend",
"dispose",
"(",
")",
";",
"}",
"}"
] |
[
"delete",
"user",
"this",
"can",
"only",
"be",
"done",
"by",
"the",
"logged",
"in",
"user"
] | [
"public",
"void",
"delete",
"user",
"(",
"string",
"username",
")",
"{",
"/",
"/",
"todo",
":",
"implement",
"}"
] |
[
"did",
"this",
"batch",
"time",
"out",
"?"
] | [
"public",
"boolean",
"is",
"timed",
"out",
"(",
")",
"{",
"return",
"timed",
"out",
";",
"}"
] |
[
"tests",
"that",
"the",
"mutable",
"hash",
"table",
"spills",
"its",
"partitions",
"when",
"creating",
"the",
"initial",
"table",
"without",
"overflow",
"segments",
"in",
"the",
"partitions",
"this",
"means",
"that",
"the",
"records",
"are",
"large"
] | [
"public",
"void",
"test",
"spilling",
"when",
"building",
"table",
"without",
"overflow",
"(",
")",
"throws",
"exception",
"{",
"try",
"(",
"final",
"i",
"o",
"manager",
"io",
"man",
"=",
"new",
"i",
"o",
"manager",
"async",
"(",
")",
")",
"{",
"final",
"type",
"serializer",
"<",
"byte",
"[",
"]",
">",
"serializer",
"=",
"byte",
"primitive",
"array",
"serializer",
"instance",
";",
"final",
"type",
"comparator",
"<",
"byte",
"[",
"]",
">",
"build",
"comparator",
"=",
"new",
"byte",
"primitive",
"array",
"comparator",
"(",
"true",
")",
";",
"final",
"type",
"comparator",
"<",
"byte",
"[",
"]",
">",
"probe",
"comparator",
"=",
"new",
"byte",
"primitive",
"array",
"comparator",
"(",
"true",
")",
";",
"@",
"suppress",
"warnings",
"(",
"\"",
"unchecked",
"\"",
")",
"final",
"type",
"pair",
"comparator",
"<",
"byte",
"[",
"]",
",",
"byte",
"[",
"]",
">",
"pair",
"comparator",
"=",
"new",
"generic",
"pair",
"comparator",
"<",
">",
"(",
"new",
"byte",
"primitive",
"array",
"comparator",
"(",
"true",
")",
",",
"new",
"byte",
"primitive",
"array",
"comparator",
"(",
"true",
")",
")",
";",
"final",
"int",
"page",
"size",
"=",
"128",
";",
"final",
"int",
"num",
"segments",
"=",
"33",
";",
"list",
"<",
"memory",
"segment",
">",
"memory",
"=",
"get",
"memory",
"(",
"num",
"segments",
",",
"page",
"size",
")",
";",
"mutable",
"hash",
"table",
"<",
"byte",
"[",
"]",
",",
"byte",
"[",
"]",
">",
"table",
"=",
"new",
"mutable",
"hash",
"table",
"<",
"byte",
"[",
"]",
",",
"byte",
"[",
"]",
">",
"(",
"serializer",
",",
"serializer",
",",
"build",
"comparator",
",",
"probe",
"comparator",
",",
"pair",
"comparator",
",",
"memory",
",",
"io",
"man",
",",
"1",
",",
"false",
")",
";",
"int",
"num",
"elements",
"=",
"9",
";",
"table",
"open",
"(",
"new",
"combining",
"iterator",
"<",
"byte",
"[",
"]",
">",
"(",
"new",
"byte",
"array",
"iterator",
"(",
"num",
"elements",
",",
"128",
",",
"(",
"byte",
")",
"0",
")",
",",
"new",
"byte",
"array",
"iterator",
"(",
"num",
"elements",
",",
"128",
",",
"(",
"byte",
")",
"1",
")",
")",
",",
"new",
"combining",
"iterator",
"<",
"byte",
"[",
"]",
">",
"(",
"new",
"byte",
"array",
"iterator",
"(",
"1",
",",
"128",
",",
"(",
"byte",
")",
"0",
")",
",",
"new",
"byte",
"array",
"iterator",
"(",
"1",
",",
"128",
",",
"(",
"byte",
")",
"1",
")",
")",
")",
";",
"while",
"(",
"table",
"next",
"record",
"(",
")",
")",
"{",
"mutable",
"object",
"iterator",
"<",
"byte",
"[",
"]",
">",
"iterator",
"=",
"table",
"get",
"build",
"side",
"iterator",
"(",
")",
";",
"int",
"counter",
"=",
"0",
";",
"while",
"(",
"iterator",
"next",
"(",
")",
"!",
"=",
"null",
")",
"{",
"counter",
"+",
"+",
";",
"}",
"/",
"/",
"check",
"that",
"we",
"retrieve",
"all",
"our",
"elements",
"assert",
"assert",
"equals",
"(",
"num",
"elements",
",",
"counter",
")",
";",
"}",
"table",
"close",
"(",
")",
";",
"}",
"}"
] |
[
"setting",
"this",
"flag",
"to",
"`",
"true",
"`",
"removes",
"certain",
"fields",
"from",
"the",
"configuration",
"on",
"retrieval",
"this",
"is",
"useful",
"when",
"getting",
"the",
"configuration",
"and",
"wanting",
"to",
"put",
"it",
"in",
"another",
"cluster",
"default",
"value",
"is",
"false"
] | [
"public",
"void",
"set",
"exclude",
"generated",
"(",
"boolean",
"exclude",
"generated",
")",
"{",
"this",
"exclude",
"generated",
"=",
"exclude",
"generated",
";",
"}"
] |
[
"as",
"{",
"@",
"link",
"#",
"write",
"to",
"stream",
"(",
"bit",
"matrix",
",",
"string",
",",
"output",
"stream",
")",
"}",
",",
"but",
"allows",
"customization",
"of",
"the",
"output"
] | [
"public",
"static",
"void",
"write",
"to",
"stream",
"(",
"bit",
"matrix",
"matrix",
",",
"string",
"format",
",",
"output",
"stream",
"stream",
",",
"matrix",
"to",
"image",
"config",
"config",
")",
"throws",
"i",
"o",
"exception",
"{",
"buffered",
"image",
"image",
"=",
"to",
"buffered",
"image",
"(",
"matrix",
",",
"config",
")",
";",
"if",
"(",
"!",
"image",
"i",
"o",
"write",
"(",
"image",
",",
"format",
",",
"stream",
")",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"could",
"not",
"write",
"an",
"image",
"of",
"format",
"\"",
"+",
"format",
")",
";",
"}",
"}"
] |
[
"removes",
"the",
"allocated",
"slot",
"specified",
"by",
"the",
"provided",
"slot",
"allocation",
"id"
] | [
"allocated",
"slot",
"remove",
"(",
"final",
"allocation",
"i",
"d",
"allocation",
"i",
"d",
")",
"{",
"allocated",
"slot",
"allocated",
"slot",
"=",
"allocated",
"slots",
"by",
"id",
"remove",
"key",
"a",
"(",
"allocation",
"i",
"d",
")",
";",
"if",
"(",
"allocated",
"slot",
"!",
"=",
"null",
")",
"{",
"remove",
"allocated",
"slot",
"(",
"allocated",
"slot",
")",
";",
"}",
"return",
"allocated",
"slot",
";",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.