docstring_tokens
list | code_tokens
list |
|---|---|
[
"gets",
"the",
"current",
"termination",
"setting",
"from",
"the",
"given",
"settings",
"objects",
"or",
"returns",
"the",
"default",
"if",
"not",
"in",
"either",
"settings",
"object"
]
| [
"public",
"boolean",
"is",
"terminated",
"(",
"settings",
"settings",
")",
"{",
"if",
"(",
"settings",
"=",
"=",
"null",
")",
"{",
"return",
"false",
";",
"}",
"long",
"value",
"=",
"settings",
"get",
"long",
"(",
"terminated",
")",
";",
"if",
"(",
"value",
"=",
"=",
"null",
")",
"{",
"return",
"false",
";",
"}",
"return",
"(",
"value",
"long",
"value",
"(",
")",
"=",
"=",
"terminated",
"value",
")",
";",
"}"
]
|
[
"notifies",
"the",
"listener",
"of",
"the",
"text",
"entered",
"by",
"the",
"user",
"when",
"a",
"text",
"edit",
"is",
"completed"
]
| [
"void",
"edit",
"completed",
"(",
"string",
"new",
"text",
")",
";"
]
|
[
"check",
"if",
"the",
"streamers",
"were",
"successfully",
"updated",
",",
"adding",
"failed",
"streamers",
"in",
"the",
"failed",
"return",
"parameter"
]
| [
"private",
"int",
"check",
"streamer",
"updates",
"(",
"set",
"<",
"striped",
"data",
"streamer",
">",
"failed",
",",
"set",
"<",
"striped",
"data",
"streamer",
">",
"streamers",
")",
"{",
"for",
"(",
"striped",
"data",
"streamer",
"streamer",
":",
"streamers",
")",
"{",
"if",
"(",
"!",
"coordinator",
"update",
"streamer",
"map",
"contains",
"key",
"(",
"streamer",
")",
")",
"{",
"if",
"(",
"!",
"streamer",
"is",
"healthy",
"(",
")",
"&",
"&",
"coordinator",
"get",
"new",
"blocks",
"(",
")",
"peek",
"(",
"streamer",
"get",
"index",
"(",
")",
")",
"!",
"=",
"null",
")",
"{",
"/",
"/",
"this",
"streamer",
"had",
"internal",
"error",
"before",
"getting",
"updated",
"block",
"failed",
"add",
"(",
"streamer",
")",
";",
"}",
"}",
"}",
"return",
"coordinator",
"update",
"streamer",
"map",
"size",
"(",
")",
"+",
"failed",
"size",
"(",
")",
";",
"}"
]
|
[
"performs",
"a",
"variable",
"substitution",
"to",
"the",
"given",
"text",
"and",
"return",
"it"
]
| [
"public",
"string",
"substitute",
"(",
"abstract",
"build",
"<",
"?",
",",
"?",
">",
"build",
",",
"string",
"text",
")",
"{",
"return",
"util",
"replace",
"macro",
"(",
"text",
",",
"create",
"variable",
"resolver",
"(",
"build",
")",
")",
";",
"}"
]
|
[
"run",
"all",
"tasks",
"in",
"the",
"queue",
"in",
"the",
"current",
"thread",
",",
"if",
"no",
"other",
"thread",
"is",
"running",
"this",
"method",
"otherwise",
"do",
"nothing",
"upon",
"returning",
",",
"it",
"guarantees",
"that",
"all",
"tasks",
"submitted",
"by",
"{",
"@",
"code",
"#",
"execute",
"later",
"}",
"before",
"it",
"have",
"been",
"or",
"will",
"eventually",
"be",
"run",
",",
"while",
"not",
"requiring",
"any",
"more",
"calls",
"to",
"{",
"@",
"code",
"drain",
"(",
")",
"}"
]
| [
"public",
"final",
"void",
"drain",
"(",
")",
"{",
"do",
"{",
"if",
"(",
"!",
"draining",
"thread",
"compare",
"and",
"set",
"(",
"null",
",",
"thread",
"current",
"thread",
"(",
")",
")",
")",
"{",
"return",
";",
"}",
"try",
"{",
"runnable",
"runnable",
";",
"while",
"(",
"(",
"runnable",
"=",
"queue",
"poll",
"(",
")",
")",
"!",
"=",
"null",
")",
"{",
"try",
"{",
"runnable",
"run",
"(",
")",
";",
"}",
"catch",
"(",
"throwable",
"t",
")",
"{",
"uncaught",
"exception",
"handler",
"uncaught",
"exception",
"(",
"thread",
"current",
"thread",
"(",
")",
",",
"t",
")",
";",
"}",
"}",
"}",
"finally",
"{",
"draining",
"thread",
"set",
"(",
"null",
")",
";",
"}",
"/",
"/",
"must",
"check",
"queue",
"again",
"here",
"to",
"catch",
"any",
"added",
"prior",
"to",
"clearing",
"draining",
"thread",
"}",
"while",
"(",
"!",
"queue",
"is",
"empty",
"(",
")",
")",
";",
"}"
]
|
[
"customize",
"response",
"specification"
]
| [
"public",
"find",
"pets",
"by",
"tags",
"oper",
"resp",
"spec",
"(",
"consumer",
"<",
"response",
"spec",
"builder",
">",
"resp",
"spec",
"customizer",
")",
"{",
"resp",
"spec",
"customizer",
"accept",
"(",
"resp",
"spec",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"registers",
"an",
"{",
"@",
"link",
"table",
"aggregate",
"function",
"}",
"under",
"a",
"unique",
"name",
"in",
"the",
"table",
"environment",
"'",
"s",
"catalog",
"registered",
"functions",
"can",
"only",
"be",
"referenced",
"in",
"table",
"api"
]
| [
"<",
"t",
",",
"acc",
">",
"void",
"register",
"function",
"(",
"string",
"name",
",",
"table",
"aggregate",
"function",
"<",
"t",
",",
"acc",
">",
"table",
"aggregate",
"function",
")",
";"
]
|
[
"returns",
"a",
"new",
"instance",
"that",
"reads",
"utf",
"-",
"8",
"encoded",
"json",
"from",
"{",
"@",
"code",
"source",
"}"
]
| [
"public",
"static",
"json",
"reader",
"of",
"(",
"buffered",
"source",
"source",
")",
"{",
"return",
"new",
"json",
"utf",
"8",
"reader",
"(",
"source",
")",
";",
"}"
]
|
[
"copies",
"the",
"content",
"of",
"{",
"@",
"code",
"source",
"bitmap",
"}",
"to",
"{",
"@",
"code",
"dest",
"bitmap",
"}",
"both",
"bitmaps",
"must",
"have",
"the",
"same",
"width",
"and",
"height",
"if",
"their",
"{",
"@",
"link",
"bitmap",
"config",
"}",
"are",
"identical",
",",
"the",
"memory",
"is",
"directly",
"copied",
"otherwise",
",",
"the",
"{",
"@",
"code",
"source",
"bitmap",
"}",
"is",
"drawn",
"into",
"{",
"@",
"code",
"dest",
"bitmap",
"}"
]
| [
"private",
"static",
"void",
"internal",
"copy",
"bitmap",
"(",
"bitmap",
"dest",
"bitmap",
",",
"bitmap",
"source",
"bitmap",
")",
"{",
"if",
"(",
"native",
"code",
"setup",
"get",
"use",
"native",
"code",
"(",
")",
"&",
"&",
"dest",
"bitmap",
"get",
"config",
"(",
")",
"=",
"=",
"source",
"bitmap",
"get",
"config",
"(",
")",
")",
"{",
"try",
"{",
"if",
"(",
"s",
"copy",
"bitmap",
"=",
"=",
"null",
")",
"{",
"class",
"<",
"?",
">",
"clazz",
"=",
"class",
"for",
"name",
"(",
"\"",
"com",
"facebook",
"imagepipeline",
"nativecode",
"bitmaps",
"\"",
")",
";",
"s",
"copy",
"bitmap",
"=",
"clazz",
"get",
"declared",
"method",
"(",
"\"",
"copy",
"bitmap",
"\"",
",",
"bitmap",
"class",
",",
"bitmap",
"class",
")",
";",
"}",
"s",
"copy",
"bitmap",
"invoke",
"(",
"null",
",",
"dest",
"bitmap",
",",
"source",
"bitmap",
")",
";",
"return",
";",
"}",
"catch",
"(",
"class",
"not",
"found",
"exception",
"e",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"wrong",
"native",
"code",
"setup",
",",
"reflection",
"failed",
"\"",
",",
"e",
")",
";",
"}",
"catch",
"(",
"illegal",
"access",
"exception",
"e",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"wrong",
"native",
"code",
"setup",
",",
"reflection",
"failed",
"\"",
",",
"e",
")",
";",
"}",
"catch",
"(",
"no",
"such",
"method",
"exception",
"e",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"wrong",
"native",
"code",
"setup",
",",
"reflection",
"failed",
"\"",
",",
"e",
")",
";",
"}",
"catch",
"(",
"invocation",
"target",
"exception",
"e",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"wrong",
"native",
"code",
"setup",
",",
"reflection",
"failed",
"\"",
",",
"e",
")",
";",
"}",
"}",
"/",
"/",
"this",
"code",
"will",
"be",
"run",
"only",
"if",
"we",
"fail",
"to",
"use",
"native",
"version",
"with",
"any",
"reason",
"(",
"configuration",
"or",
"/",
"/",
"reflection",
"fail",
")",
"/",
"/",
"the",
"bitmap",
"configurations",
"might",
"be",
"different",
"when",
"the",
"source",
"bitmap",
"'",
"s",
"configuration",
"is",
"/",
"/",
"null",
",",
"because",
"it",
"uses",
"an",
"internal",
"configuration",
"and",
"the",
"destination",
"bitmap",
"'",
"s",
"configuration",
"/",
"/",
"is",
"the",
"fallback",
"bitmap",
"configuration",
"this",
"is",
"the",
"case",
"for",
"static",
"images",
"for",
"animated",
"g",
"i",
"fs",
"canvas",
"canvas",
"=",
"new",
"canvas",
"(",
"dest",
"bitmap",
")",
";",
"canvas",
"draw",
"bitmap",
"(",
"source",
"bitmap",
",",
"0",
",",
"0",
",",
"null",
")",
";",
"}"
]
|
[
"returns",
"the",
"float",
"at",
"the",
"specified",
"index",
"the",
"4",
"bytes",
"starting",
"at",
"the",
"specified",
"index",
"are",
"composed",
"into",
"a",
"float",
"according",
"to",
"the",
"current",
"byte",
"order",
"and",
"returned",
"the",
"position",
"is",
"not",
"changed"
]
| [
"public",
"abstract",
"float",
"get",
"float",
"(",
"int",
"index",
")",
";"
]
|
[
"get",
"a",
"data",
"buffer"
]
| [
"private",
"data",
"buffer",
"get",
"buffer",
"(",
"int",
"index",
")",
"throws",
"i",
"o",
"exception",
"{",
"/",
"/",
"if",
"databuffer",
"id",
"table",
"is",
"null",
",",
"index",
"must",
"be",
"null",
"let",
"it",
"throw",
"null",
"pointer",
"in",
"this",
"case",
"int",
"buffer",
"id",
"=",
"(",
"data",
"buffer",
"id",
"table",
"=",
"=",
"null",
"&",
"&",
"index",
"=",
"=",
"0",
")",
"?",
"first",
"buffer",
"id",
":",
"data",
"buffer",
"id",
"table",
"[",
"index",
"]",
";",
"if",
"(",
"buffer",
"id",
"<",
"0",
")",
"{",
"data",
"buffer",
"buf",
"=",
"buffer",
"mgr",
"create",
"buffer",
"(",
")",
";",
"initialize",
"allocated",
"buffer",
"(",
"index",
",",
"buf",
")",
";",
"add",
"buffer",
"(",
"index",
",",
"buf",
")",
";",
"return",
"buf",
";",
"}",
"return",
"buffer",
"mgr",
"get",
"buffer",
"(",
"buffer",
"id",
")",
";",
"}"
]
|
[
"whether",
"to",
"show",
"column",
"headers",
"in",
"table",
"output",
"this",
"is",
"the",
"default"
]
| [
"public",
"builder",
"show",
"headers",
"(",
")",
"{",
"this",
"show",
"header",
"=",
"true",
";",
"return",
"this",
";",
"}"
]
|
[
"verify",
"that",
"all",
"the",
"events",
"are",
"flushed",
"on",
"stopping",
"the",
"history",
"handler"
]
| [
"public",
"void",
"test",
"events",
"flush",
"on",
"stop",
"(",
")",
"throws",
"exception",
"{",
"configuration",
"conf",
"=",
"new",
"configuration",
"(",
")",
";",
"m",
"r",
"app",
"app",
"=",
"new",
"m",
"r",
"app",
"with",
"special",
"history",
"handler",
"(",
"1",
",",
"0",
",",
"true",
",",
"this",
"get",
"class",
"(",
")",
"get",
"name",
"(",
")",
",",
"true",
")",
";",
"app",
"submit",
"(",
"conf",
")",
";",
"job",
"job",
"=",
"app",
"get",
"context",
"(",
")",
"get",
"all",
"jobs",
"(",
")",
"values",
"(",
")",
"iterator",
"(",
")",
"next",
"(",
")",
";",
"job",
"id",
"job",
"id",
"=",
"job",
"get",
"i",
"d",
"(",
")",
";",
"log",
"info",
"(",
"\"",
"jobid",
"is",
"\"",
"+",
"type",
"converter",
"from",
"yarn",
"(",
"job",
"id",
")",
"to",
"string",
"(",
")",
")",
";",
"app",
"wait",
"for",
"state",
"(",
"job",
",",
"job",
"state",
"succeeded",
")",
";",
"/",
"/",
"make",
"sure",
"all",
"events",
"are",
"flushed",
"app",
"wait",
"for",
"state",
"(",
"service",
"state",
"stopped",
")",
";",
"/",
"*",
"*",
"use",
"history",
"context",
"to",
"read",
"logged",
"events",
"and",
"verify",
"the",
"number",
"of",
"*",
"completed",
"maps",
"*",
"/",
"history",
"context",
"context",
"=",
"new",
"job",
"history",
"(",
")",
";",
"(",
"(",
"job",
"history",
")",
"context",
")",
"init",
"(",
"conf",
")",
";",
"job",
"parsed",
"job",
"=",
"context",
"get",
"job",
"(",
"job",
"id",
")",
";",
"assert",
"assert",
"equals",
"(",
"\"",
"completed",
"maps",
"not",
"correct",
"\"",
",",
"1",
",",
"parsed",
"job",
"get",
"completed",
"maps",
"(",
")",
")",
";",
"map",
"<",
"task",
"id",
",",
"task",
">",
"tasks",
"=",
"parsed",
"job",
"get",
"tasks",
"(",
")",
";",
"assert",
"assert",
"equals",
"(",
"\"",
"no",
"of",
"tasks",
"not",
"correct",
"\"",
",",
"1",
",",
"tasks",
"size",
"(",
")",
")",
";",
"verify",
"task",
"(",
"tasks",
"values",
"(",
")",
"iterator",
"(",
")",
"next",
"(",
")",
")",
";",
"map",
"<",
"task",
"id",
",",
"task",
">",
"maps",
"=",
"parsed",
"job",
"get",
"tasks",
"(",
"task",
"type",
"map",
")",
";",
"assert",
"assert",
"equals",
"(",
"\"",
"no",
"of",
"maps",
"not",
"correct",
"\"",
",",
"1",
",",
"maps",
"size",
"(",
")",
")",
";",
"assert",
"assert",
"equals",
"(",
"\"",
"job",
"state",
"not",
"currect",
"\"",
",",
"job",
"state",
"succeeded",
",",
"parsed",
"job",
"get",
"state",
"(",
")",
")",
";",
"}"
]
|
[
"put",
"selectable",
"multifactor",
"authentication",
"providers"
]
| [
"public",
"static",
"void",
"put",
"selectable",
"multifactor",
"authentication",
"providers",
"(",
"final",
"request",
"context",
"request",
"context",
",",
"final",
"list",
"<",
"string",
">",
"mfa",
"providers",
")",
"{",
"request",
"context",
"get",
"view",
"scope",
"(",
")",
"put",
"(",
"\"",
"mfa",
"selectable",
"providers",
"\"",
",",
"mfa",
"providers",
")",
";",
"}"
]
|
[
"times",
"the",
"given",
"future",
"out",
"after",
"the",
"timeout"
]
| [
"public",
"static",
"<",
"t",
">",
"completable",
"future",
"<",
"t",
">",
"or",
"timeout",
"(",
"completable",
"future",
"<",
"t",
">",
"future",
",",
"long",
"timeout",
",",
"time",
"unit",
"time",
"unit",
",",
"@",
"nullable",
"string",
"timeout",
"msg",
")",
"{",
"return",
"or",
"timeout",
"(",
"future",
",",
"timeout",
",",
"time",
"unit",
",",
"executors",
"direct",
"executor",
"(",
")",
",",
"timeout",
"msg",
")",
";",
"}"
]
|
[
"creates",
"a",
"duplicate",
"for",
"the",
"cow",
"data",
"structure",
"in",
"preparation",
"for",
"mutation"
]
| [
"private",
"index",
"copy",
"(",
")",
"{",
"return",
"new",
"index",
"(",
"index",
")",
";",
"}"
]
|
[
"construct",
"a",
"half",
"-",
"sized",
"version",
"of",
"this",
"md5",
"fits",
"in",
"a",
"long"
]
| [
"public",
"long",
"half",
"digest",
"(",
")",
"{",
"long",
"value",
"=",
"0",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"8",
";",
"i",
"+",
"+",
")",
"value",
"|",
"=",
"(",
"(",
"digest",
"[",
"i",
"]",
"&",
"0xff",
"l",
")",
"<",
"<",
"(",
"8",
"*",
"(",
"7",
"-",
"i",
")",
")",
")",
";",
"return",
"value",
";",
"}"
]
|
[
"adds",
"a",
"route",
"to",
"the",
"given",
"handler",
"function",
"that",
"handles",
"http",
"{",
"@",
"code",
"get",
"}",
"requests"
]
| [
"builder",
"get",
"(",
"handler",
"function",
"<",
"server",
"response",
">",
"handler",
"function",
")",
";"
]
|
[
"return",
"a",
"new",
"{",
"@",
"link",
"int",
"set",
"}",
"object",
"containing",
"all",
"elements",
"that",
"are",
"present",
"in",
"{",
"@",
"code",
"elements",
"}",
"but",
"not",
"present",
"in",
"the",
"current",
"set",
"the",
"following",
"expressions",
"are",
"equivalent",
"for",
"input",
"non",
"-",
"null",
"{",
"@",
"link",
"int",
"set",
"}",
"instances",
"{",
"@",
"code",
"x",
"}",
"and",
"{",
"@",
"code",
"y",
"}",
"{",
"@",
"code",
"x",
"complement",
"(",
"y",
")",
"}",
"{",
"@",
"code",
"y",
"subtract",
"(",
"x",
")",
"}"
]
| [
"int",
"set",
"complement",
"(",
"int",
"set",
"elements",
")",
";"
]
|
[
"writes",
"a",
"{",
"@",
"code",
"long",
"}",
"as",
"specified",
"by",
"{",
"@",
"link",
"data",
"output",
"stream",
"#",
"write",
"long",
"(",
"long",
")",
"}",
",",
"except",
"using",
"little",
"-",
"endian",
"byte",
"order"
]
| [
"public",
"void",
"write",
"long",
"(",
"long",
"v",
")",
"throws",
"i",
"o",
"exception",
"{",
"byte",
"[",
"]",
"bytes",
"=",
"to",
"byte",
"array",
"(",
"long",
"reverse",
"bytes",
"(",
"v",
")",
")",
";",
"write",
"(",
"bytes",
",",
"0",
",",
"bytes",
"length",
")",
";",
"}"
]
|
[
"writes",
"three",
"code",
"units",
"to",
"the",
"given",
"output",
"destination"
]
| [
"protected",
"static",
"void",
"write",
"(",
"annotated",
"output",
"out",
",",
"short",
"c",
"0",
",",
"short",
"c",
"1",
",",
"short",
"c",
"2",
")",
"{",
"out",
"write",
"short",
"(",
"c",
"0",
")",
";",
"out",
"write",
"short",
"(",
"c",
"1",
")",
";",
"out",
"write",
"short",
"(",
"c",
"2",
")",
";",
"}"
]
|
[
"run",
"the",
"tests",
"in",
"the",
"supplied",
"{",
"@",
"code",
"test",
"class",
"}",
",",
"using",
"the",
"specified",
"{",
"@",
"link",
"runner",
"}",
",",
"and",
"assert",
"the",
"expectations",
"of",
"the",
"test",
"execution",
"if",
"the",
"specified",
"{",
"@",
"code",
"runner",
"class",
"}",
"is",
"{",
"@",
"code",
"null",
"}",
",",
"the",
"tests",
"will",
"be",
"run",
"with",
"the",
"runner",
"that",
"the",
"test",
"class",
"is",
"configured",
"with",
"(",
"i",
"e",
",",
"via",
"{",
"@",
"link",
"run",
"with",
"@",
"run",
"with",
"}",
")",
"or",
"the",
"default",
"j",
"unit",
"runner"
]
| [
"public",
"static",
"void",
"run",
"tests",
"and",
"assert",
"counters",
"(",
"class",
"<",
"?",
"extends",
"runner",
">",
"runner",
"class",
",",
"class",
"<",
"?",
">",
"test",
"class",
",",
"int",
"expected",
"started",
"count",
",",
"int",
"expected",
"failed",
"count",
",",
"int",
"expected",
"finished",
"count",
",",
"int",
"expected",
"ignored",
"count",
",",
"int",
"expected",
"assumption",
"failed",
"count",
")",
"throws",
"exception",
"{",
"tracking",
"run",
"listener",
"listener",
"=",
"new",
"tracking",
"run",
"listener",
"(",
")",
";",
"if",
"(",
"runner",
"class",
"!",
"=",
"null",
")",
"{",
"constructor",
"<",
"?",
">",
"constructor",
"=",
"runner",
"class",
"get",
"constructor",
"(",
"class",
"class",
")",
";",
"runner",
"runner",
"=",
"(",
"runner",
")",
"bean",
"utils",
"instantiate",
"class",
"(",
"constructor",
",",
"test",
"class",
")",
";",
"run",
"notifier",
"notifier",
"=",
"new",
"run",
"notifier",
"(",
")",
";",
"notifier",
"add",
"listener",
"(",
"listener",
")",
";",
"runner",
"run",
"(",
"notifier",
")",
";",
"}",
"else",
"{",
"j",
"unit",
"core",
"junit",
"=",
"new",
"j",
"unit",
"core",
"(",
")",
";",
"junit",
"add",
"listener",
"(",
"listener",
")",
";",
"junit",
"run",
"(",
"test",
"class",
")",
";",
"}",
"assert",
"softly",
"(",
"softly",
"-",
">",
"{",
"softly",
"assert",
"that",
"(",
"listener",
"get",
"test",
"started",
"count",
"(",
")",
")",
"as",
"(",
"\"",
"tests",
"started",
"for",
"[",
"%",
"s",
"]",
"\"",
",",
"test",
"class",
")",
"is",
"equal",
"to",
"(",
"expected",
"started",
"count",
")",
";",
"softly",
"assert",
"that",
"(",
"listener",
"get",
"test",
"failure",
"count",
"(",
")",
")",
"as",
"(",
"\"",
"tests",
"failed",
"for",
"[",
"%",
"s",
"]",
"\"",
",",
"test",
"class",
")",
"is",
"equal",
"to",
"(",
"expected",
"failed",
"count",
")",
";",
"softly",
"assert",
"that",
"(",
"listener",
"get",
"test",
"finished",
"count",
"(",
")",
")",
"as",
"(",
"\"",
"tests",
"finished",
"for",
"[",
"%",
"s",
"]",
"\"",
",",
"test",
"class",
")",
"is",
"equal",
"to",
"(",
"expected",
"finished",
"count",
")",
";",
"softly",
"assert",
"that",
"(",
"listener",
"get",
"test",
"ignored",
"count",
"(",
")",
")",
"as",
"(",
"\"",
"tests",
"ignored",
"for",
"[",
"%",
"s",
"]",
"\"",
",",
"test",
"class",
")",
"is",
"equal",
"to",
"(",
"expected",
"ignored",
"count",
")",
";",
"softly",
"assert",
"that",
"(",
"listener",
"get",
"test",
"assumption",
"failure",
"count",
"(",
")",
")",
"as",
"(",
"\"",
"failed",
"assumptions",
"for",
"[",
"%",
"s",
"]",
"\"",
",",
"test",
"class",
")",
"is",
"equal",
"to",
"(",
"expected",
"assumption",
"failed",
"count",
")",
";",
"}",
")",
";",
"}"
]
|
[
"uses",
"kafka",
"as",
"a",
"message",
"bus",
"to",
"persist",
"key",
"by",
"shuffle",
"persisting",
"key",
"by",
"shuffle",
"is",
"achieved",
"by",
"wrapping",
"a",
"{",
"@",
"link",
"flink",
"kafka",
"shuffle",
"producer",
"}",
"and",
"{",
"@",
"link",
"flink",
"kafka",
"shuffle",
"consumer",
"}",
"together",
"on",
"the",
"producer",
"side",
",",
"{",
"@",
"link",
"flink",
"kafka",
"shuffle",
"producer",
"}",
"is",
"similar",
"to",
"{",
"@",
"link",
"data",
"stream",
"#",
"key",
"by",
"(",
"key",
"selector",
")",
"}",
"they",
"use",
"the",
"same",
"key",
"group",
"assignment",
"function",
"{",
"@",
"link",
"key",
"group",
"range",
"assignment",
"#",
"assign",
"key",
"to",
"parallel",
"operator",
"}",
"to",
"decide",
"which",
"partition",
"a",
"key",
"goes",
"hence",
",",
"each",
"producer",
"task",
"can",
"potentially",
"write",
"to",
"each",
"kafka",
"partition",
"based",
"on",
"where",
"the",
"key",
"goes",
"here",
",",
"`",
"number",
"of",
"partitions",
"`",
"equals",
"to",
"the",
"key",
"group",
"size",
"in",
"the",
"case",
"of",
"using",
"{",
"@",
"link",
"time",
"characteristic",
"#",
"event",
"time",
"}",
",",
"each",
"producer",
"task",
"broadcasts",
"its",
"watermark",
"to",
"all",
"of",
"the",
"kafka",
"partitions",
"to",
"make",
"sure",
"watermark",
"information",
"is",
"propagated",
"correctly",
"on",
"the",
"consumer",
"side",
",",
"each",
"consumer",
"task",
"should",
"read",
"partitions",
"equal",
"to",
"the",
"key",
"group",
"indices",
"it",
"is",
"assigned",
"`",
"number",
"of",
"partitions",
"`",
"is",
"the",
"maximum",
"parallelism",
"of",
"the",
"consumer",
"this",
"version",
"only",
"supports",
"number",
"of",
"partitions",
"=",
"consumer",
"parallelism",
"in",
"the",
"case",
"of",
"using",
"{",
"@",
"link",
"time",
"characteristic",
"#",
"event",
"time",
"}",
",",
"a",
"consumer",
"task",
"is",
"responsible",
"to",
"emit",
"watermarks",
"watermarks",
"are",
"read",
"from",
"the",
"corresponding",
"kafka",
"partitions",
"notice",
"that",
"a",
"consumer",
"task",
"only",
"starts",
"to",
"emit",
"a",
"watermark",
"after",
"reading",
"at",
"least",
"one",
"watermark",
"from",
"each",
"producer",
"task",
"to",
"make",
"sure",
"watermarks",
"are",
"monotonically",
"increasing",
"hence",
"a",
"consumer",
"task",
"needs",
"to",
"know",
"`",
"producer",
"parallelism",
"`",
"as",
"well"
]
| [
"public",
"static",
"<",
"t",
",",
"k",
">",
"keyed",
"stream",
"<",
"t",
",",
"k",
">",
"persistent",
"key",
"by",
"(",
"data",
"stream",
"<",
"t",
">",
"data",
"stream",
",",
"string",
"topic",
",",
"int",
"producer",
"parallelism",
",",
"int",
"number",
"of",
"partitions",
",",
"properties",
"properties",
",",
"key",
"selector",
"<",
"t",
",",
"k",
">",
"key",
"selector",
")",
"{",
"/",
"/",
"kafka",
"producer",
"#",
"props",
"to",
"map",
"uses",
"properties",
"purely",
"as",
"a",
"hash",
"map",
"without",
"considering",
"the",
"/",
"/",
"default",
"properties",
"/",
"/",
"so",
"we",
"have",
"to",
"flatten",
"the",
"default",
"property",
"to",
"first",
"level",
"elements",
"properties",
"kafka",
"properties",
"=",
"properties",
"util",
"flatten",
"(",
"properties",
")",
";",
"kafka",
"properties",
"set",
"property",
"(",
"producer",
"parallelism",
",",
"string",
"value",
"of",
"(",
"producer",
"parallelism",
")",
")",
";",
"kafka",
"properties",
"set",
"property",
"(",
"partition",
"number",
",",
"string",
"value",
"of",
"(",
"number",
"of",
"partitions",
")",
")",
";",
"stream",
"execution",
"environment",
"env",
"=",
"data",
"stream",
"get",
"execution",
"environment",
"(",
")",
";",
"write",
"key",
"by",
"(",
"data",
"stream",
",",
"topic",
",",
"kafka",
"properties",
",",
"key",
"selector",
")",
";",
"return",
"read",
"key",
"by",
"(",
"topic",
",",
"env",
",",
"data",
"stream",
"get",
"type",
"(",
")",
",",
"kafka",
"properties",
",",
"key",
"selector",
")",
";",
"}"
]
|
[
"get",
"pet",
"id"
]
| [
"public",
"long",
"get",
"pet",
"id",
"(",
")",
"{",
"return",
"pet",
"id",
";",
"}"
]
|
[
"show",
"the",
"toast",
"for",
"a",
"long",
"period",
"of",
"time"
]
| [
"public",
"static",
"void",
"show",
"long",
"(",
"final",
"char",
"sequence",
"text",
")",
"{",
"show",
"(",
"text",
",",
"toast",
"length",
"long",
",",
"default",
"maker",
")",
";",
"}"
]
|
[
"choose",
"a",
"volume",
"to",
"place",
"a",
"replica",
",",
"given",
"a",
"list",
"of",
"volumes",
"and",
"the",
"replica",
"size",
"sought",
"for",
"storage",
"the",
"caller",
"should",
"synchronize",
"access",
"to",
"the",
"list",
"of",
"volumes"
]
| [
"v",
"choose",
"volume",
"(",
"list",
"<",
"v",
">",
"volumes",
",",
"long",
"replica",
"size",
",",
"string",
"storage",
"id",
")",
"throws",
"i",
"o",
"exception",
";"
]
|
[
"returns",
"pet",
"inventories",
"by",
"status",
"returns",
"a",
"map",
"of",
"status",
"codes",
"to",
"quantities"
]
| [
"public",
"void",
"get",
"inventory",
"test",
"(",
")",
"throws",
"api",
"exception",
"{",
"/",
"/",
"map",
"<",
"string",
",",
"integer",
">",
"response",
"=",
"api",
"get",
"inventory",
"(",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
]
|
[
"called",
"when",
"the",
"service",
"initially",
"becomes",
"healthy",
"this",
"will",
"be",
"called",
"at",
"most",
"once",
"after",
"all",
"the",
"services",
"have",
"entered",
"the",
"{",
"@",
"linkplain",
"state",
"#",
"running",
"running",
"}",
"state",
"if",
"any",
"services",
"fail",
"during",
"start",
"up",
"or",
"{",
"@",
"linkplain",
"state",
"#",
"failed",
"fail",
"}",
"{",
"@",
"linkplain",
"state",
"#",
"terminated",
"terminate",
"}",
"before",
"all",
"other",
"services",
"have",
"started",
"{",
"@",
"linkplain",
"state",
"#",
"running",
"running",
"}",
"then",
"this",
"method",
"will",
"not",
"be",
"called"
]
| [
"public",
"void",
"healthy",
"(",
")",
"{",
"}"
]
|
[
"check",
"whether",
"there",
"are",
"any",
"batches",
"which",
"haven",
"'",
"t",
"been",
"drained"
]
| [
"public",
"boolean",
"has",
"undrained",
"(",
")",
"{",
"for",
"(",
"map",
"entry",
"<",
"topic",
"partition",
",",
"deque",
"<",
"producer",
"batch",
">",
">",
"entry",
":",
"this",
"batches",
"entry",
"set",
"(",
")",
")",
"{",
"deque",
"<",
"producer",
"batch",
">",
"deque",
"=",
"entry",
"get",
"value",
"(",
")",
";",
"synchronized",
"(",
"deque",
")",
"{",
"if",
"(",
"!",
"deque",
"is",
"empty",
"(",
")",
")",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}"
]
|
[
"tests",
"that",
"inconsistent",
"dynamic",
"slot",
"allocation",
"with",
"the",
"same",
"allocation",
"i",
"d",
"to",
"a",
"different",
"slot",
"is",
"rejected"
]
| [
"public",
"void",
"test",
"inconsistent",
"dynamic",
"slot",
"allocation",
"(",
")",
"throws",
"exception",
"{",
"try",
"(",
"final",
"task",
"slot",
"table",
"<",
"task",
"slot",
"payload",
">",
"task",
"slot",
"table",
"=",
"create",
"task",
"slot",
"table",
"and",
"start",
"(",
"1",
")",
")",
"{",
"final",
"job",
"i",
"d",
"job",
"id",
"1",
"=",
"new",
"job",
"i",
"d",
"(",
")",
";",
"final",
"job",
"i",
"d",
"job",
"id",
"2",
"=",
"new",
"job",
"i",
"d",
"(",
")",
";",
"final",
"allocation",
"i",
"d",
"allocation",
"id",
"=",
"new",
"allocation",
"i",
"d",
"(",
")",
";",
"assert",
"that",
"(",
"task",
"slot",
"table",
"allocate",
"slot",
"(",
"-",
"1",
",",
"job",
"id",
"1",
",",
"allocation",
"id",
",",
"slot",
"timeout",
")",
",",
"is",
"(",
"true",
")",
")",
";",
"assert",
"that",
"(",
"task",
"slot",
"table",
"allocate",
"slot",
"(",
"-",
"1",
",",
"job",
"id",
"2",
",",
"allocation",
"id",
",",
"slot",
"timeout",
")",
",",
"is",
"(",
"false",
")",
")",
";",
"assert",
"that",
"(",
"task",
"slot",
"table",
"is",
"allocated",
"(",
"1",
",",
"job",
"id",
"1",
",",
"allocation",
"id",
")",
",",
"is",
"(",
"true",
")",
")",
";",
"iterator",
"<",
"task",
"slot",
"<",
"task",
"slot",
"payload",
">",
">",
"allocated",
"slots",
"=",
"task",
"slot",
"table",
"get",
"allocated",
"slots",
"(",
"job",
"id",
"1",
")",
";",
"assert",
"that",
"(",
"allocated",
"slots",
"next",
"(",
")",
"get",
"allocation",
"id",
"(",
")",
",",
"is",
"(",
"allocation",
"id",
")",
")",
";",
"assert",
"that",
"(",
"allocated",
"slots",
"has",
"next",
"(",
")",
",",
"is",
"(",
"false",
")",
")",
";",
"}",
"}"
]
|
[
"pixel",
"count",
"must",
"be",
"no",
"smaller",
"than",
"{",
"@",
"link",
"#",
"minimum",
"crop",
"pixel",
"count",
"}",
"(",
"unless",
"its",
"original",
"size",
"was",
"less",
"than",
"that",
")",
"and",
"all",
"points",
"must",
"be",
"within",
"the",
"bounds"
]
| [
"private",
"boolean",
"current",
"crop",
"is",
"acceptable",
"(",
")",
"{",
"point",
"output",
"size",
"=",
"get",
"output",
"size",
"(",
")",
";",
"int",
"output",
"pixel",
"count",
"=",
"output",
"size",
"x",
"*",
"output",
"size",
"y",
";",
"int",
"minimum",
"pixel",
"count",
"=",
"math",
"min",
"(",
"size",
"x",
"*",
"size",
"y",
",",
"minimum",
"crop",
"pixel",
"count",
")",
";",
"point",
"thinnest",
"ratio",
"=",
"minimum",
"ratio",
";",
"if",
"(",
"compare",
"ratios",
"(",
"size",
",",
"thinnest",
"ratio",
")",
"<",
"0",
")",
"{",
"/",
"/",
"original",
"is",
"narrower",
"than",
"the",
"thinnest",
"ratio",
"thinnest",
"ratio",
"=",
"size",
";",
"}",
"return",
"compare",
"ratios",
"(",
"output",
"size",
",",
"thinnest",
"ratio",
")",
">",
"=",
"0",
"&",
"&",
"output",
"pixel",
"count",
">",
"=",
"minimum",
"pixel",
"count",
"&",
"&",
"crop",
"is",
"within",
"main",
"image",
"bounds",
"(",
")",
";",
"}"
]
|
[
"returns",
"the",
"current",
"event",
"-",
"time",
"watermark"
]
| [
"long",
"current",
"watermark",
"(",
")",
";"
]
|
[
"set",
"the",
"virtual",
"host"
]
| [
"public",
"builder",
"set",
"virtual",
"host",
"(",
"string",
"virtual",
"host",
")",
"{",
"this",
"virtual",
"host",
"=",
"virtual",
"host",
";",
"return",
"this",
";",
"}"
]
|
[
"a",
"test",
"to",
"run",
"after",
"the",
"main",
"{",
"@",
"link",
"#",
"test",
"200",
"execute",
"(",
")",
"}",
"test",
"is",
"invoked"
]
| [
"void",
"test",
"500",
"(",
")",
"throws",
"throwable",
"{",
"}"
]
|
[
"appends",
"to",
"{",
"@",
"code",
"appendable",
"}",
"the",
"string",
"representation",
"of",
"each",
"of",
"the",
"remaining",
"arguments"
]
| [
"public",
"final",
"<",
"a",
"extends",
"appendable",
">",
"a",
"append",
"to",
"(",
"a",
"appendable",
",",
"@",
"nullable",
"decl",
"object",
"first",
",",
"@",
"nullable",
"decl",
"object",
"second",
",",
"object",
"rest",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"append",
"to",
"(",
"appendable",
",",
"iterable",
"(",
"first",
",",
"second",
",",
"rest",
")",
")",
";",
"}"
]
|
[
"this",
"flag",
"can",
"be",
"used",
"to",
"force",
"existing",
"jobs",
"to",
"be",
"migrated",
"to",
"a",
"new",
"naming",
"strategy",
"-",
"if",
"this",
"method",
"returns",
"true",
",",
"the",
"naming",
"will",
"be",
"enforced",
"at",
"every",
"config",
"change",
"if",
"{",
"@",
"code",
"false",
"}",
"is",
"returned",
",",
"only",
"new",
"jobs",
"have",
"to",
"follow",
"the",
"strategy"
]
| [
"public",
"boolean",
"is",
"force",
"existing",
"jobs",
"(",
")",
"{",
"return",
"false",
";",
"}"
]
|
[
"whether",
"this",
"values",
"source",
"is",
"able",
"to",
"provide",
"a",
"mapping",
"between",
"global",
"and",
"segment",
"ordinals",
",",
"by",
"returning",
"the",
"underlying",
"{",
"@",
"link",
"ordinal",
"map",
"}",
"if",
"this",
"method",
"returns",
"false",
",",
"then",
"calling",
"{",
"@",
"link",
"#",
"global",
"ordinals",
"mapping",
"}",
"will",
"result",
"in",
"an",
"{",
"@",
"link",
"unsupported",
"operation",
"exception",
"}"
]
| [
"public",
"boolean",
"supports",
"global",
"ordinals",
"mapping",
"(",
")",
"{",
"return",
"true",
";",
"}"
]
|
[
"build",
"call",
"for",
"create",
"xml",
"item"
]
| [
"public",
"okhttp",
"3",
"call",
"create",
"xml",
"item",
"call",
"(",
"xml",
"item",
"xml",
"item",
",",
"final",
"api",
"callback",
"callback",
")",
"throws",
"api",
"exception",
"{",
"object",
"local",
"var",
"post",
"body",
"=",
"xml",
"item",
";",
"/",
"/",
"create",
"path",
"and",
"map",
"variables",
"string",
"local",
"var",
"path",
"=",
"\"",
"/",
"fake",
"/",
"create",
"xml",
"item",
"\"",
";",
"list",
"<",
"pair",
">",
"local",
"var",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
"pair",
">",
"(",
")",
";",
"list",
"<",
"pair",
">",
"local",
"var",
"collection",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
"pair",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"header",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"cookie",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"object",
">",
"local",
"var",
"form",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"object",
">",
"(",
")",
";",
"final",
"string",
"[",
"]",
"local",
"var",
"accepts",
"=",
"{",
"}",
";",
"final",
"string",
"local",
"var",
"accept",
"=",
"local",
"var",
"api",
"client",
"select",
"header",
"accept",
"(",
"local",
"var",
"accepts",
")",
";",
"if",
"(",
"local",
"var",
"accept",
"!",
"=",
"null",
")",
"{",
"local",
"var",
"header",
"params",
"put",
"(",
"\"",
"accept",
"\"",
",",
"local",
"var",
"accept",
")",
";",
"}",
"final",
"string",
"[",
"]",
"local",
"var",
"content",
"types",
"=",
"{",
"\"",
"application",
"/",
"xml",
"\"",
",",
"\"",
"application",
"/",
"xml",
";",
"charset",
"=",
"utf",
"-",
"8",
"\"",
",",
"\"",
"application",
"/",
"xml",
";",
"charset",
"=",
"utf",
"-",
"16",
"\"",
",",
"\"",
"text",
"/",
"xml",
"\"",
",",
"\"",
"text",
"/",
"xml",
";",
"charset",
"=",
"utf",
"-",
"8",
"\"",
",",
"\"",
"text",
"/",
"xml",
";",
"charset",
"=",
"utf",
"-",
"16",
"\"",
"}",
";",
"final",
"string",
"local",
"var",
"content",
"type",
"=",
"local",
"var",
"api",
"client",
"select",
"header",
"content",
"type",
"(",
"local",
"var",
"content",
"types",
")",
";",
"local",
"var",
"header",
"params",
"put",
"(",
"\"",
"content",
"-",
"type",
"\"",
",",
"local",
"var",
"content",
"type",
")",
";",
"string",
"[",
"]",
"local",
"var",
"auth",
"names",
"=",
"new",
"string",
"[",
"]",
"{",
"}",
";",
"return",
"local",
"var",
"api",
"client",
"build",
"call",
"(",
"local",
"var",
"path",
",",
"\"",
"post",
"\"",
",",
"local",
"var",
"query",
"params",
",",
"local",
"var",
"collection",
"query",
"params",
",",
"local",
"var",
"post",
"body",
",",
"local",
"var",
"header",
"params",
",",
"local",
"var",
"cookie",
"params",
",",
"local",
"var",
"form",
"params",
",",
"local",
"var",
"auth",
"names",
",",
"callback",
")",
";",
"}"
]
|
[
"called",
"when",
"the",
"specified",
"controller",
"is",
"disconnected"
]
| [
"void",
"on",
"disconnected",
"(",
"media",
"session",
"session",
",",
"media",
"session",
"controller",
"info",
"controller",
"info",
")",
";"
]
|
[
"tests",
"that",
"the",
"{",
"@",
"link",
"slot",
"pool",
"impl",
"}",
"completes",
"slots",
"in",
"request",
"order"
]
| [
"public",
"void",
"test",
"requests",
"are",
"completed",
"in",
"request",
"order",
"(",
")",
"{",
"run",
"slot",
"request",
"completion",
"test",
"(",
"checked",
"supplier",
"unchecked",
"(",
"this",
":",
":",
"create",
"and",
"set",
"up",
"slot",
"pool",
")",
",",
"slot",
"pool",
"-",
">",
"{",
"}",
")",
";",
"}"
]
|
[
"returns",
"true",
"if",
"the",
"delimiters",
"are",
"\"",
"\\",
"n",
"\"",
"and",
"\"",
"\\",
"r",
"\\",
"n",
"\""
]
| [
"private",
"static",
"boolean",
"is",
"line",
"based",
"(",
"final",
"byte",
"buf",
"[",
"]",
"delimiters",
")",
"{",
"if",
"(",
"delimiters",
"length",
"!",
"=",
"2",
")",
"{",
"return",
"false",
";",
"}",
"byte",
"buf",
"a",
"=",
"delimiters",
"[",
"0",
"]",
";",
"byte",
"buf",
"b",
"=",
"delimiters",
"[",
"1",
"]",
";",
"if",
"(",
"a",
"capacity",
"(",
")",
"<",
"b",
"capacity",
"(",
")",
")",
"{",
"a",
"=",
"delimiters",
"[",
"1",
"]",
";",
"b",
"=",
"delimiters",
"[",
"0",
"]",
";",
"}",
"return",
"a",
"capacity",
"(",
")",
"=",
"=",
"2",
"&",
"&",
"b",
"capacity",
"(",
")",
"=",
"=",
"1",
"&",
"&",
"a",
"get",
"byte",
"(",
"0",
")",
"=",
"=",
"'",
"\\",
"r",
"'",
"&",
"&",
"a",
"get",
"byte",
"(",
"1",
")",
"=",
"=",
"'",
"\\",
"n",
"'",
"&",
"&",
"b",
"get",
"byte",
"(",
"0",
")",
"=",
"=",
"'",
"\\",
"n",
"'",
";",
"}"
]
|
[
"returns",
"a",
"new",
"instance",
"with",
"no",
"registered",
"compressors"
]
| [
"public",
"static",
"compressor",
"registry",
"new",
"empty",
"instance",
"(",
")",
"{",
"return",
"new",
"compressor",
"registry",
"(",
")",
";",
"}"
]
|
[
"gets",
"the",
"size",
"of",
"the",
"bytecode",
"array",
",",
"per",
"se"
]
| [
"public",
"int",
"size",
"(",
")",
"{",
"return",
"bytes",
"size",
"(",
")",
";",
"}"
]
|
[
"creates",
"a",
"dialog",
"for",
"given",
"{",
"@",
"link",
"mapped",
"track",
"info",
"}",
"and",
"{",
"@",
"link",
"default",
"track",
"selector",
"parameters",
"}"
]
| [
"public",
"static",
"track",
"selection",
"dialog",
"create",
"for",
"mapped",
"track",
"info",
"and",
"parameters",
"(",
"int",
"title",
"id",
",",
"mapped",
"track",
"info",
"mapped",
"track",
"info",
",",
"default",
"track",
"selector",
"parameters",
"initial",
"parameters",
",",
"boolean",
"allow",
"adaptive",
"selections",
",",
"boolean",
"allow",
"multiple",
"overrides",
",",
"dialog",
"interface",
"on",
"click",
"listener",
"on",
"click",
"listener",
",",
"dialog",
"interface",
"on",
"dismiss",
"listener",
"on",
"dismiss",
"listener",
")",
"{",
"track",
"selection",
"dialog",
"track",
"selection",
"dialog",
"=",
"new",
"track",
"selection",
"dialog",
"(",
")",
";",
"track",
"selection",
"dialog",
"init",
"(",
"title",
"id",
",",
"mapped",
"track",
"info",
",",
"initial",
"parameters",
",",
"allow",
"adaptive",
"selections",
",",
"allow",
"multiple",
"overrides",
",",
"on",
"click",
"listener",
",",
"on",
"dismiss",
"listener",
")",
";",
"return",
"track",
"selection",
"dialog",
";",
"}"
]
|
[
"returns",
"a",
"new",
"iterator",
"over",
"{",
"@",
"code",
"buffer",
"}",
",",
"starting",
"at",
"{",
"@",
"code",
"offset",
"}",
"and",
"continuing",
"for",
"{",
"@",
"code",
"byte",
"count",
"}",
"bytes",
"items",
"larger",
"than",
"a",
"byte",
"are",
"interpreted",
"using",
"the",
"given",
"byte",
"order"
]
| [
"public",
"static",
"buffer",
"iterator",
"iterator",
"(",
"byte",
"[",
"]",
"buffer",
",",
"int",
"offset",
",",
"int",
"byte",
"count",
",",
"byte",
"order",
"order",
")",
"{",
"return",
"new",
"heap",
"buffer",
"iterator",
"(",
"buffer",
",",
"offset",
",",
"byte",
"count",
",",
"order",
")",
";",
"}"
]
|
[
"creates",
"a",
"new",
"entry",
"with",
"the",
"usage",
"count",
"of",
"0"
]
| [
"public",
"static",
"<",
"k",
",",
"v",
">",
"counting",
"memory",
"cache",
"entry",
"<",
"k",
",",
"v",
">",
"of",
"(",
"final",
"k",
"key",
",",
"final",
"closeable",
"reference",
"<",
"v",
">",
"value",
"ref",
",",
"final",
"@",
"nullable",
"entry",
"state",
"observer",
"<",
"k",
">",
"observer",
")",
"{",
"return",
"new",
"entry",
"<",
">",
"(",
"key",
",",
"value",
"ref",
",",
"observer",
")",
";",
"}"
]
|
[
"adds",
"a",
"new",
"outgoing",
"connection",
"to",
"this",
"node"
]
| [
"public",
"void",
"add",
"outgoing",
"connection",
"(",
"dag",
"connection",
"connection",
")",
"{",
"if",
"(",
"this",
"outgoing",
"connections",
"=",
"=",
"null",
")",
"{",
"this",
"outgoing",
"connections",
"=",
"new",
"array",
"list",
"<",
"dag",
"connection",
">",
"(",
")",
";",
"}",
"else",
"{",
"if",
"(",
"this",
"outgoing",
"connections",
"size",
"(",
")",
"=",
"=",
"64",
")",
"{",
"throw",
"new",
"compiler",
"exception",
"(",
"\"",
"cannot",
"currently",
"handle",
"nodes",
"with",
"more",
"than",
"64",
"outputs",
"\"",
")",
";",
"}",
"}",
"this",
"outgoing",
"connections",
"add",
"(",
"connection",
")",
";",
"}"
]
|
[
"called",
"to",
"get",
"the",
"{",
"@",
"link",
"track",
"output",
"}",
"for",
"a",
"specific",
"track",
"the",
"same",
"{",
"@",
"link",
"track",
"output",
"}",
"is",
"returned",
"if",
"multiple",
"calls",
"are",
"made",
"with",
"the",
"same",
"{",
"@",
"code",
"id",
"}"
]
| [
"track",
"output",
"track",
"(",
"int",
"id",
",",
"int",
"type",
")",
";"
]
|
[
"get",
"map",
"string"
]
| [
"public",
"map",
"<",
"string",
",",
"string",
">",
"get",
"map",
"string",
"(",
")",
"{",
"return",
"map",
"string",
";",
"}"
]
|
[
"grabs",
"a",
"screenshot",
"of",
"the",
"{",
"@",
"link",
"instruction",
"table",
"}",
"panel",
"within",
"the",
"main",
"instruction",
"search",
"dialog"
]
| [
"public",
"void",
"test",
"search",
"instruction",
"patterns",
"instruction",
"table",
"(",
")",
"{",
"go",
"to",
"listing",
"(",
"0x",
"0",
"0",
"4",
"0",
"1",
"2",
"2",
"1",
",",
"\"",
"address",
"\"",
",",
"false",
")",
";",
"make",
"selection",
"(",
"0x",
"0",
"0",
"4",
"0",
"1",
"2",
"2",
"1",
",",
"0x",
"0",
"0",
"4",
"0",
"1",
"2",
"3",
"6",
")",
";",
"wait",
"for",
"swing",
"(",
")",
";",
"docking",
"action",
"if",
"open",
"search",
"dialog",
"action",
"=",
"get",
"action",
"(",
"instruction",
"search",
"plugin",
",",
"\"",
"search",
"instruction",
"patterns",
"\"",
")",
";",
"perform",
"action",
"(",
"open",
"search",
"dialog",
"action",
",",
"true",
")",
";",
"wait",
"for",
"swing",
"(",
")",
";",
"component",
"instr",
"table",
"=",
"find",
"component",
"by",
"name",
"(",
"this",
"get",
"dialog",
"(",
")",
"get",
"component",
"(",
")",
",",
"\"",
"instruction",
"table",
"panel",
"\"",
")",
";",
"capture",
"component",
"(",
"instr",
"table",
")",
";",
"}"
]
|
[
"get",
"a",
"filesystem",
"handle",
"we",
"need",
"this",
"to",
"prepare",
"jobs",
"for",
"submission",
"to",
"the",
"map",
"reduce",
"system"
]
| [
"public",
"synchronized",
"file",
"system",
"get",
"fs",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"try",
"{",
"return",
"cluster",
"get",
"file",
"system",
"(",
")",
";",
"}",
"catch",
"(",
"interrupted",
"exception",
"ie",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"ie",
")",
";",
"}",
"}"
]
|
[
"get",
"anytype",
"3"
]
| [
"public",
"object",
"get",
"anytype",
"3",
"(",
")",
"{",
"return",
"anytype",
"3",
";",
"}"
]
|
[
"checks",
"whether",
"the",
"new",
"{",
"@",
"link",
"pojo",
"serializer",
"}",
"has",
"a",
"different",
"subclass",
"registration",
"order",
"compared",
"to",
"the",
"previous",
"one"
]
| [
"private",
"static",
"boolean",
"new",
"pojo",
"has",
"different",
"subclass",
"registration",
"order",
"(",
"linked",
"optional",
"map",
"<",
"class",
"<",
"?",
">",
",",
"type",
"serializer",
"snapshot",
"<",
"?",
">",
">",
"registered",
"subclass",
"serializer",
"snapshots",
",",
"pojo",
"serializer",
"<",
"?",
">",
"new",
"pojo",
"serializer",
")",
"{",
"set",
"<",
"class",
"<",
"?",
">",
">",
"previous",
"registration",
"order",
"=",
"registered",
"subclass",
"serializer",
"snapshots",
"unwrap",
"optionals",
"(",
")",
"key",
"set",
"(",
")",
";",
"set",
"<",
"class",
"<",
"?",
">",
">",
"new",
"registration",
"order",
"=",
"new",
"pojo",
"serializer",
"get",
"registered",
"classes",
"(",
")",
"key",
"set",
"(",
")",
";",
"return",
"!",
"is",
"previous",
"registration",
"prefix",
"of",
"new",
"registration",
"(",
"previous",
"registration",
"order",
",",
"new",
"registration",
"order",
")",
";",
"}"
]
|
[
"invokes",
"the",
"given",
"initialization",
"method"
]
| [
"protected",
"void",
"invoke",
"(",
"method",
"e",
")",
"{",
"try",
"{",
"class",
"<",
"?",
">",
"[",
"]",
"pt",
"=",
"e",
"get",
"parameter",
"types",
"(",
")",
";",
"object",
"[",
"]",
"args",
"=",
"new",
"object",
"[",
"pt",
"length",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"args",
"length",
";",
"i",
"+",
"+",
")",
"args",
"[",
"i",
"]",
"=",
"look",
"up",
"(",
"pt",
"[",
"i",
"]",
")",
";",
"e",
"invoke",
"(",
"modifier",
"is",
"static",
"(",
"e",
"get",
"modifiers",
"(",
")",
")",
"?",
"null",
":",
"look",
"up",
"(",
"e",
"get",
"declaring",
"class",
"(",
")",
")",
",",
"args",
")",
";",
"}",
"catch",
"(",
"illegal",
"access",
"exception",
"x",
")",
"{",
"throw",
"(",
"error",
")",
"new",
"illegal",
"access",
"error",
"(",
")",
"init",
"cause",
"(",
"x",
")",
";",
"}",
"catch",
"(",
"invocation",
"target",
"exception",
"x",
")",
"{",
"throw",
"new",
"error",
"(",
"x",
")",
";",
"}",
"}"
]
|
[
"returns",
"an",
"attribute",
"value",
"retriever",
"for",
"the",
"given",
"rule",
"for",
"the",
"target",
"configuration"
]
| [
"protected",
"attribute",
"map",
"attributes",
"(",
"rule",
"configured",
"target",
"ct",
")",
"{",
"configured",
"target",
"and",
"data",
"ctad",
";",
"try",
"{",
"ctad",
"=",
"get",
"configured",
"target",
"and",
"data",
"(",
"ct",
"get",
"label",
"(",
")",
"to",
"string",
"(",
")",
")",
";",
"}",
"catch",
"(",
"label",
"syntax",
"exception",
"|",
"starlark",
"transition",
"transition",
"exception",
"|",
"invalid",
"configuration",
"exception",
"|",
"interrupted",
"exception",
"e",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"e",
")",
";",
"}",
"return",
"get",
"mapper",
"from",
"configured",
"target",
"and",
"target",
"(",
"ctad",
")",
";",
"}"
]
|
[
"specify",
"the",
"{",
"@",
"link",
"org",
"springframework",
"http",
"cache",
"control",
"}",
"which",
"should",
"be",
"used",
"by",
"the",
"resource",
"handler",
"setting",
"a",
"custom",
"value",
"here",
"will",
"override",
"the",
"configuration",
"set",
"with",
"{",
"@",
"link",
"#",
"set",
"cache",
"period",
"}"
]
| [
"public",
"resource",
"handler",
"registration",
"set",
"cache",
"control",
"(",
"cache",
"control",
"cache",
"control",
")",
"{",
"this",
"cache",
"control",
"=",
"cache",
"control",
";",
"return",
"this",
";",
"}"
]
|
[
"adds",
"a",
"change",
"listener",
"that",
"will",
"be",
"notified",
"anytime",
"this",
"address",
"value",
"in",
"this",
"panel",
"changes"
]
| [
"public",
"void",
"add",
"change",
"listener",
"(",
"change",
"listener",
"listener",
")",
"{",
"change",
"listener",
"=",
"listener",
";",
"}"
]
|
[
"chance",
"to",
"change",
"the",
"{",
"@",
"link",
"menu",
"item",
"}",
"after",
"inflation"
]
| [
"boolean",
"on",
"prepare",
"options",
"menu",
"item",
"(",
"@",
"non",
"null",
"menu",
"item",
"menu",
"item",
")",
";"
]
|
[
"join",
"an",
"array",
"of",
"strings",
"with",
"the",
"given",
"separator",
"note",
":",
"this",
"might",
"be",
"replaced",
"by",
"utility",
"method",
"from",
"commons",
"-",
"lang",
"or",
"guava",
"someday",
"if",
"one",
"of",
"those",
"libraries",
"is",
"added",
"as",
"dependency"
]
| [
"public",
"static",
"string",
"join",
"(",
"string",
"[",
"]",
"array",
",",
"string",
"separator",
")",
"{",
"int",
"len",
"=",
"array",
"length",
";",
"if",
"(",
"len",
"=",
"=",
"0",
")",
"{",
"return",
"\"",
"\"",
";",
"}",
"string",
"builder",
"out",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"out",
"append",
"(",
"array",
"[",
"0",
"]",
")",
";",
"for",
"(",
"int",
"i",
"=",
"1",
";",
"i",
"<",
"len",
";",
"i",
"+",
"+",
")",
"{",
"out",
"append",
"(",
"separator",
")",
"append",
"(",
"array",
"[",
"i",
"]",
")",
";",
"}",
"return",
"out",
"to",
"string",
"(",
")",
";",
"}"
]
|
[
"{",
"@",
"inherit",
"doc",
"}"
]
| [
"public",
"void",
"write",
"to",
"(",
"annotated",
"output",
"out",
",",
"dalv",
"insn",
"insn",
")",
"{",
"register",
"spec",
"list",
"regs",
"=",
"insn",
"get",
"registers",
"(",
")",
";",
"int",
"offset",
"=",
"(",
"(",
"target",
"insn",
")",
"insn",
")",
"get",
"target",
"offset",
"(",
")",
";",
"write",
"(",
"out",
",",
"opcode",
"unit",
"(",
"insn",
",",
"make",
"byte",
"(",
"regs",
"get",
"(",
"0",
")",
"get",
"reg",
"(",
")",
",",
"regs",
"get",
"(",
"1",
")",
"get",
"reg",
"(",
")",
")",
")",
",",
"(",
"short",
")",
"offset",
")",
";",
"}"
]
|
[
"load",
"file",
"diff",
"list",
"for",
"a",
"file",
"with",
"snapshot",
"feature"
]
| [
"private",
"void",
"load",
"file",
"diff",
"list",
"(",
"input",
"stream",
"in",
",",
"i",
"node",
"file",
"file",
",",
"int",
"size",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"file",
"diff",
"list",
"diffs",
"=",
"new",
"file",
"diff",
"list",
"(",
")",
";",
"final",
"loader",
"context",
"state",
"=",
"parent",
"get",
"loader",
"context",
"(",
")",
";",
"final",
"block",
"manager",
"bm",
"=",
"fsn",
"get",
"block",
"manager",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"size",
";",
"i",
"+",
"+",
")",
"{",
"snapshot",
"diff",
"section",
"file",
"diff",
"pbf",
"=",
"snapshot",
"diff",
"section",
"file",
"diff",
"parse",
"delimited",
"from",
"(",
"in",
")",
";",
"i",
"node",
"file",
"attributes",
"copy",
"=",
"null",
";",
"if",
"(",
"pbf",
"has",
"snapshot",
"copy",
"(",
")",
")",
"{",
"i",
"node",
"section",
"i",
"node",
"file",
"file",
"in",
"pb",
"=",
"pbf",
"get",
"snapshot",
"copy",
"(",
")",
";",
"permission",
"status",
"permission",
"=",
"load",
"permission",
"(",
"file",
"in",
"pb",
"get",
"permission",
"(",
")",
",",
"state",
"get",
"string",
"table",
"(",
")",
")",
";",
"acl",
"feature",
"acl",
"=",
"null",
";",
"if",
"(",
"file",
"in",
"pb",
"has",
"acl",
"(",
")",
")",
"{",
"int",
"[",
"]",
"entries",
"=",
"acl",
"entry",
"status",
"format",
"to",
"int",
"(",
"f",
"s",
"image",
"format",
"p",
"b",
"i",
"node",
"loader",
"load",
"acl",
"entries",
"(",
"file",
"in",
"pb",
"get",
"acl",
"(",
")",
",",
"state",
"get",
"string",
"table",
"(",
")",
")",
")",
";",
"acl",
"=",
"new",
"acl",
"feature",
"(",
"entries",
")",
";",
"}",
"x",
"attr",
"feature",
"x",
"attrs",
"=",
"null",
";",
"if",
"(",
"file",
"in",
"pb",
"has",
"x",
"attrs",
"(",
")",
")",
"{",
"x",
"attrs",
"=",
"new",
"x",
"attr",
"feature",
"(",
"f",
"s",
"image",
"format",
"p",
"b",
"i",
"node",
"loader",
"load",
"x",
"attrs",
"(",
"file",
"in",
"pb",
"get",
"x",
"attrs",
"(",
")",
",",
"state",
"get",
"string",
"table",
"(",
")",
")",
")",
";",
"}",
"boolean",
"is",
"striped",
"=",
"(",
"file",
"in",
"pb",
"get",
"block",
"type",
"(",
")",
"=",
"=",
"block",
"type",
"proto",
"striped",
")",
";",
"short",
"replication",
"=",
"(",
"!",
"is",
"striped",
"?",
"(",
"short",
")",
"file",
"in",
"pb",
"get",
"replication",
"(",
")",
":",
"null",
")",
";",
"byte",
"ec",
"policy",
"i",
"d",
"=",
"(",
"is",
"striped",
"?",
"(",
"byte",
")",
"file",
"in",
"pb",
"get",
"erasure",
"coding",
"policy",
"i",
"d",
"(",
")",
":",
"null",
")",
";",
"copy",
"=",
"new",
"i",
"node",
"file",
"attributes",
"snapshot",
"copy",
"(",
"pbf",
"get",
"name",
"(",
")",
"to",
"byte",
"array",
"(",
")",
",",
"permission",
",",
"acl",
",",
"file",
"in",
"pb",
"get",
"modification",
"time",
"(",
")",
",",
"file",
"in",
"pb",
"get",
"access",
"time",
"(",
")",
",",
"replication",
",",
"ec",
"policy",
"i",
"d",
",",
"file",
"in",
"pb",
"get",
"preferred",
"block",
"size",
"(",
")",
",",
"(",
"byte",
")",
"file",
"in",
"pb",
"get",
"storage",
"policy",
"i",
"d",
"(",
")",
",",
"x",
"attrs",
",",
"p",
"b",
"helper",
"client",
"convert",
"(",
"file",
"in",
"pb",
"get",
"block",
"type",
"(",
")",
")",
")",
";",
"}",
"file",
"diff",
"diff",
"=",
"new",
"file",
"diff",
"(",
"pbf",
"get",
"snapshot",
"id",
"(",
")",
",",
"copy",
",",
"null",
",",
"pbf",
"get",
"file",
"size",
"(",
")",
")",
";",
"list",
"<",
"block",
"proto",
">",
"bpl",
"=",
"pbf",
"get",
"blocks",
"list",
"(",
")",
";",
"/",
"/",
"in",
"file",
"diff",
"there",
"can",
"only",
"be",
"contiguous",
"blocks",
"block",
"info",
"[",
"]",
"blocks",
"=",
"new",
"block",
"info",
"[",
"bpl",
"size",
"(",
")",
"]",
";",
"for",
"(",
"int",
"j",
"=",
"0",
",",
"e",
"=",
"bpl",
"size",
"(",
")",
";",
"j",
"<",
"e",
";",
"+",
"+",
"j",
")",
"{",
"block",
"blk",
"=",
"p",
"b",
"helper",
"client",
"convert",
"(",
"bpl",
"get",
"(",
"j",
")",
")",
";",
"block",
"info",
"stored",
"block",
"=",
"bm",
"get",
"stored",
"block",
"(",
"blk",
")",
";",
"if",
"(",
"stored",
"block",
"=",
"=",
"null",
")",
"{",
"stored",
"block",
"=",
"(",
"block",
"info",
"contiguous",
")",
"fsn",
"get",
"block",
"manager",
"(",
")",
"add",
"block",
"collection",
"with",
"check",
"(",
"new",
"block",
"info",
"contiguous",
"(",
"blk",
",",
"copy",
"get",
"file",
"replication",
"(",
")",
")",
",",
"file",
")",
";",
"}",
"blocks",
"[",
"j",
"]",
"=",
"stored",
"block",
";",
"}",
"if",
"(",
"blocks",
"length",
">",
"0",
")",
"{",
"diff",
"set",
"blocks",
"(",
"blocks",
")",
";",
"}",
"diffs",
"add",
"first",
"(",
"diff",
")",
";",
"}",
"file",
"add",
"snapshot",
"feature",
"(",
"diffs",
")",
";",
"short",
"repl",
"=",
"file",
"get",
"preferred",
"block",
"replication",
"(",
")",
";",
"for",
"(",
"block",
"info",
"b",
":",
"file",
"get",
"blocks",
"(",
")",
")",
"{",
"if",
"(",
"b",
"get",
"replication",
"(",
")",
"<",
"repl",
")",
"{",
"bm",
"set",
"replication",
"(",
"b",
"get",
"replication",
"(",
")",
",",
"repl",
",",
"b",
")",
";",
"}",
"}",
"}"
]
|
[
"low",
"-",
"level",
"routine",
"for",
"clearing",
"any",
"variables",
"in",
"the",
"database",
"which",
"conflict",
"with",
"this",
"variable",
"and",
"return",
"one",
"of",
"them",
"for",
"re",
"-",
"use",
"the",
"returned",
"variable",
"still",
"exists",
"within",
"the",
"function",
"at",
"the",
"same",
"first",
"-",
"use",
"-",
"offset"
]
| [
"private",
"static",
"variable",
"clear",
"conflicting",
"local",
"variables",
"(",
"function",
"function",
",",
"variable",
"storage",
"storage",
",",
"address",
"pc",
"addr",
")",
"{",
"int",
"first",
"use",
"offset",
"=",
"0",
";",
"if",
"(",
"pc",
"addr",
"!",
"=",
"null",
")",
"{",
"first",
"use",
"offset",
"=",
"(",
"int",
")",
"pc",
"addr",
"subtract",
"(",
"function",
"get",
"entry",
"point",
"(",
")",
")",
";",
"}",
"if",
"(",
"storage",
"is",
"hash",
"storage",
"(",
")",
")",
"{",
"long",
"hash",
"val",
"=",
"storage",
"get",
"first",
"varnode",
"(",
")",
"get",
"offset",
"(",
")",
";",
"for",
"(",
"variable",
"ul",
":",
"function",
"get",
"local",
"variables",
"(",
"variable",
"filter",
"unique",
"variable",
"filter",
")",
")",
"{",
"/",
"/",
"note",
":",
"assumes",
"there",
"is",
"only",
"one",
"hash",
"method",
"used",
"for",
"unique",
"locals",
"if",
"(",
"ul",
"get",
"first",
"storage",
"varnode",
"(",
")",
"get",
"offset",
"(",
")",
"=",
"=",
"hash",
"val",
")",
"{",
"return",
"ul",
";",
"}",
"}",
"return",
"null",
";",
"}",
"variable",
"matching",
"variable",
"=",
"null",
";",
"for",
"(",
"variable",
"other",
"var",
":",
"function",
"get",
"local",
"variables",
"(",
")",
")",
"{",
"if",
"(",
"other",
"var",
"get",
"first",
"use",
"offset",
"(",
")",
"!",
"=",
"first",
"use",
"offset",
")",
"{",
"/",
"/",
"other",
"than",
"parameters",
"we",
"will",
"have",
"a",
"hard",
"time",
"identifying",
"/",
"/",
"local",
"variable",
"conflicts",
"due",
"to",
"differences",
"in",
"scope",
"(",
"i",
"e",
",",
"first",
"-",
"use",
")",
"continue",
";",
"}",
"variable",
"storage",
"other",
"storage",
"=",
"other",
"var",
"get",
"variable",
"storage",
"(",
")",
";",
"if",
"(",
"other",
"storage",
"intersects",
"(",
"storage",
")",
")",
"{",
"if",
"(",
"matching",
"variable",
"=",
"=",
"null",
"&",
"&",
"other",
"storage",
"equals",
"(",
"storage",
")",
")",
"{",
"matching",
"variable",
"=",
"other",
"var",
";",
"continue",
";",
"}",
"function",
"remove",
"variable",
"(",
"other",
"var",
")",
";",
"}",
"}",
"return",
"matching",
"variable",
";",
"}"
]
|
[
"sets",
"the",
"stored",
"fields",
"to",
"load",
"and",
"return",
"as",
"part",
"of",
"the",
"search",
"request",
"to",
"disable",
"the",
"stored",
"fields",
"entirely",
"(",
"source",
"and",
"metadata",
"fields",
")",
"use",
"{",
"@",
"code",
"stored",
"field",
"(",
"\"",
"none",
"\"",
")",
"}"
]
| [
"public",
"top",
"hits",
"aggregation",
"builder",
"stored",
"fields",
"(",
"list",
"<",
"string",
">",
"fields",
")",
"{",
"if",
"(",
"fields",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"[",
"fields",
"]",
"must",
"not",
"be",
"null",
":",
"[",
"\"",
"+",
"name",
"+",
"\"",
"]",
"\"",
")",
";",
"}",
"if",
"(",
"stored",
"fields",
"context",
"=",
"=",
"null",
")",
"{",
"stored",
"fields",
"context",
"=",
"stored",
"fields",
"context",
"from",
"list",
"(",
"fields",
")",
";",
"}",
"else",
"{",
"stored",
"fields",
"context",
"add",
"field",
"names",
"(",
"fields",
")",
";",
"}",
"return",
"this",
";",
"}"
]
|
[
"one",
"or",
"more",
"labels",
"associated",
"with",
"the",
"endpoint",
"<",
"code",
">",
"map",
"&",
"lt",
";",
"string",
",",
"string",
"&",
"gt",
";",
"labels",
"=",
"3",
";",
"<",
"code",
">"
]
| [
"public",
"java",
"lang",
"string",
"get",
"labels",
"or",
"default",
"(",
"java",
"lang",
"string",
"key",
",",
"java",
"lang",
"string",
"default",
"value",
")",
"{",
"if",
"(",
"key",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"java",
"lang",
"null",
"pointer",
"exception",
"(",
")",
";",
"}",
"java",
"util",
"map",
"<",
"java",
"lang",
"string",
",",
"java",
"lang",
"string",
">",
"map",
"=",
"internal",
"get",
"labels",
"(",
")",
"get",
"map",
"(",
")",
";",
"return",
"map",
"contains",
"key",
"(",
"key",
")",
"?",
"map",
"get",
"(",
"key",
")",
":",
"default",
"value",
";",
"}"
]
|
[
"returns",
"the",
"injectors",
"for",
"the",
"specified",
"injection",
"points"
]
| [
"list",
"<",
"single",
"member",
"injector",
">",
"get",
"injectors",
"(",
"set",
"<",
"injection",
"point",
">",
"injection",
"points",
",",
"errors",
"errors",
")",
"{",
"list",
"<",
"single",
"member",
"injector",
">",
"injectors",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"for",
"(",
"injection",
"point",
"injection",
"point",
":",
"injection",
"points",
")",
"{",
"try",
"{",
"errors",
"errors",
"for",
"member",
"=",
"injection",
"point",
"is",
"optional",
"(",
")",
"?",
"new",
"errors",
"(",
"injection",
"point",
")",
":",
"errors",
"with",
"source",
"(",
"injection",
"point",
")",
";",
"single",
"member",
"injector",
"injector",
"=",
"injection",
"point",
"get",
"member",
"(",
")",
"instanceof",
"field",
"?",
"new",
"single",
"field",
"injector",
"(",
"this",
"injector",
",",
"injection",
"point",
",",
"errors",
"for",
"member",
")",
":",
"new",
"single",
"method",
"injector",
"(",
"this",
"injector",
",",
"injection",
"point",
",",
"errors",
"for",
"member",
")",
";",
"injectors",
"add",
"(",
"injector",
")",
";",
"}",
"catch",
"(",
"errors",
"exception",
"ignored",
"for",
"now",
")",
"{",
"/",
"/",
"ignored",
"for",
"now",
"}",
"}",
"return",
"collections",
"unmodifiable",
"list",
"(",
"injectors",
")",
";",
"}"
]
|
[
"get",
"the",
"{",
"@",
"link",
"counter",
"}",
"of",
"the",
"given",
"group",
"with",
"the",
"given",
"name"
]
| [
"public",
"abstract",
"counter",
"get",
"counter",
"(",
"string",
"group",
",",
"string",
"name",
")",
";"
]
|
[
"test",
"the",
"property",
"'",
"id",
"'"
]
| [
"public",
"void",
"id",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"id",
"}"
]
|
[
"choose",
"latest",
"image",
"from",
"one",
"of",
"the",
"directories",
",",
"load",
"it",
"and",
"merge",
"with",
"the",
"edits",
"saving",
"and",
"loading",
"fsimage",
"should",
"never",
"trigger",
"symlink",
"resolution",
"the",
"paths",
"that",
"are",
"persisted",
"do",
"not",
"have",
"intermediate",
"symlinks",
"because",
"intermediate",
"symlinks",
"are",
"resolved",
"at",
"the",
"time",
"files",
",",
"directories",
",",
"and",
"symlinks",
"are",
"created",
"all",
"paths",
"accessed",
"while",
"loading",
"or",
"saving",
"fsimage",
"should",
"therefore",
"only",
"see",
"symlinks",
"as",
"the",
"final",
"path",
"component",
",",
"and",
"the",
"functions",
"called",
"below",
"do",
"not",
"resolve",
"symlinks",
"that",
"are",
"the",
"final",
"path",
"component"
]
| [
"private",
"boolean",
"load",
"f",
"s",
"image",
"(",
"f",
"s",
"namesystem",
"target",
",",
"startup",
"option",
"start",
"opt",
",",
"meta",
"recovery",
"context",
"recovery",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"boolean",
"rolling",
"rollback",
"=",
"rolling",
"upgrade",
"startup",
"option",
"rollback",
"matches",
"(",
"start",
"opt",
")",
";",
"final",
"enum",
"set",
"<",
"name",
"node",
"file",
">",
"nnfs",
";",
"if",
"(",
"rolling",
"rollback",
")",
"{",
"/",
"/",
"if",
"it",
"is",
"rollback",
"of",
"rolling",
"upgrade",
",",
"only",
"load",
"from",
"the",
"rollback",
"image",
"nnfs",
"=",
"enum",
"set",
"of",
"(",
"name",
"node",
"file",
"image",
"rollback",
")",
";",
"}",
"else",
"{",
"/",
"/",
"otherwise",
"we",
"can",
"load",
"from",
"both",
"image",
"and",
"image",
"rollback",
"nnfs",
"=",
"enum",
"set",
"of",
"(",
"name",
"node",
"file",
"image",
",",
"name",
"node",
"file",
"image",
"rollback",
")",
";",
"}",
"final",
"f",
"s",
"image",
"storage",
"inspector",
"inspector",
"=",
"storage",
"read",
"and",
"inspect",
"dirs",
"(",
"nnfs",
",",
"start",
"opt",
")",
";",
"is",
"upgrade",
"finalized",
"=",
"inspector",
"is",
"upgrade",
"finalized",
"(",
")",
";",
"list",
"<",
"f",
"s",
"image",
"file",
">",
"image",
"files",
"=",
"inspector",
"get",
"latest",
"images",
"(",
")",
";",
"startup",
"progress",
"prog",
"=",
"name",
"node",
"get",
"startup",
"progress",
"(",
")",
";",
"prog",
"begin",
"phase",
"(",
"phase",
"loading",
"fsimage",
")",
";",
"file",
"phase",
"file",
"=",
"image",
"files",
"get",
"(",
"0",
")",
"get",
"file",
"(",
")",
";",
"prog",
"set",
"file",
"(",
"phase",
"loading",
"fsimage",
",",
"phase",
"file",
"get",
"absolute",
"path",
"(",
")",
")",
";",
"prog",
"set",
"size",
"(",
"phase",
"loading",
"fsimage",
",",
"phase",
"file",
"length",
"(",
")",
")",
";",
"boolean",
"need",
"to",
"save",
"=",
"inspector",
"need",
"to",
"save",
"(",
")",
";",
"iterable",
"<",
"edit",
"log",
"input",
"stream",
">",
"edit",
"streams",
"=",
"null",
";",
"init",
"edit",
"log",
"(",
"start",
"opt",
")",
";",
"if",
"(",
"name",
"node",
"layout",
"version",
"supports",
"(",
"layout",
"version",
"feature",
"txid",
"based",
"layout",
",",
"get",
"layout",
"version",
"(",
")",
")",
")",
"{",
"/",
"/",
"if",
"we",
"'",
"re",
"open",
"for",
"write",
",",
"we",
"'",
"re",
"either",
"non",
"-",
"ha",
"or",
"we",
"'",
"re",
"the",
"active",
"nn",
",",
"so",
"/",
"/",
"we",
"better",
"be",
"able",
"to",
"load",
"all",
"the",
"edits",
"if",
"we",
"'",
"re",
"the",
"standby",
"nn",
",",
"it",
"'",
"s",
"/",
"/",
"ok",
"to",
"not",
"be",
"able",
"to",
"read",
"all",
"of",
"edits",
"right",
"now",
"/",
"/",
"in",
"the",
"meanwhile",
",",
"for",
"ha",
"upgrade",
",",
"we",
"will",
"still",
"write",
"editlog",
"thus",
"need",
"/",
"/",
"this",
"to",
"at",
"least",
"tx",
"id",
"to",
"be",
"set",
"to",
"the",
"max",
"-",
"seen",
"txid",
"/",
"/",
"for",
"rollback",
"in",
"rolling",
"upgrade",
",",
"we",
"need",
"to",
"set",
"the",
"to",
"at",
"least",
"tx",
"id",
"to",
"/",
"/",
"the",
"txid",
"right",
"before",
"the",
"upgrade",
"marker",
"long",
"to",
"at",
"least",
"tx",
"id",
"=",
"edit",
"log",
"is",
"open",
"for",
"write",
"(",
")",
"?",
"inspector",
"get",
"max",
"seen",
"tx",
"id",
"(",
")",
":",
"0",
";",
"if",
"(",
"rolling",
"rollback",
")",
"{",
"/",
"/",
"note",
"that",
"the",
"first",
"image",
"in",
"image",
"files",
"is",
"the",
"special",
"checkpoint",
"/",
"/",
"for",
"the",
"rolling",
"upgrade",
"to",
"at",
"least",
"tx",
"id",
"=",
"image",
"files",
"get",
"(",
"0",
")",
"get",
"checkpoint",
"tx",
"id",
"(",
")",
"+",
"2",
";",
"}",
"edit",
"streams",
"=",
"edit",
"log",
"select",
"input",
"streams",
"(",
"image",
"files",
"get",
"(",
"0",
")",
"get",
"checkpoint",
"tx",
"id",
"(",
")",
"+",
"1",
",",
"to",
"at",
"least",
"tx",
"id",
",",
"recovery",
",",
"false",
")",
";",
"}",
"else",
"{",
"edit",
"streams",
"=",
"f",
"s",
"image",
"pre",
"transactional",
"storage",
"inspector",
"get",
"edit",
"log",
"streams",
"(",
"storage",
")",
";",
"}",
"int",
"max",
"op",
"size",
"=",
"conf",
"get",
"int",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"namenode",
"max",
"op",
"size",
"key",
",",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"namenode",
"max",
"op",
"size",
"default",
")",
";",
"for",
"(",
"edit",
"log",
"input",
"stream",
"elis",
":",
"edit",
"streams",
")",
"{",
"elis",
"set",
"max",
"op",
"size",
"(",
"max",
"op",
"size",
")",
";",
"}",
"for",
"(",
"edit",
"log",
"input",
"stream",
"l",
":",
"edit",
"streams",
")",
"{",
"log",
"debug",
"(",
"\"",
"planning",
"to",
"load",
"edit",
"log",
"stream",
":",
"\"",
"+",
"l",
")",
";",
"}",
"if",
"(",
"!",
"edit",
"streams",
"iterator",
"(",
")",
"has",
"next",
"(",
")",
")",
"{",
"log",
"info",
"(",
"\"",
"no",
"edit",
"log",
"streams",
"selected",
"\"",
")",
";",
"}",
"f",
"s",
"image",
"file",
"image",
"file",
"=",
"null",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"image",
"files",
"size",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"try",
"{",
"image",
"file",
"=",
"image",
"files",
"get",
"(",
"i",
")",
";",
"load",
"f",
"s",
"image",
"file",
"(",
"target",
",",
"recovery",
",",
"image",
"file",
",",
"start",
"opt",
")",
";",
"break",
";",
"}",
"catch",
"(",
"illegal",
"reserved",
"path",
"exception",
"ie",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"failed",
"to",
"load",
"image",
"from",
"\"",
"+",
"image",
"file",
",",
"ie",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"log",
"error",
"(",
"\"",
"failed",
"to",
"load",
"image",
"from",
"\"",
"+",
"image",
"file",
",",
"e",
")",
";",
"target",
"clear",
"(",
")",
";",
"image",
"file",
"=",
"null",
";",
"}",
"}",
"/",
"/",
"failed",
"to",
"load",
"any",
"images",
",",
"error",
"out",
"if",
"(",
"image",
"file",
"=",
"=",
"null",
")",
"{",
"f",
"s",
"edit",
"log",
"close",
"all",
"streams",
"(",
"edit",
"streams",
")",
";",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"failed",
"to",
"load",
"f",
"s",
"image",
"file",
",",
"see",
"error",
"(",
"s",
")",
"\"",
"+",
"\"",
"above",
"for",
"more",
"info",
"\"",
")",
";",
"}",
"prog",
"end",
"phase",
"(",
"phase",
"loading",
"fsimage",
")",
";",
"if",
"(",
"!",
"rolling",
"rollback",
")",
"{",
"prog",
"begin",
"phase",
"(",
"phase",
"loading",
"edits",
")",
";",
"long",
"txns",
"advanced",
"=",
"load",
"edits",
"(",
"edit",
"streams",
",",
"target",
",",
"long",
"max",
"value",
",",
"start",
"opt",
",",
"recovery",
")",
";",
"prog",
"end",
"phase",
"(",
"phase",
"loading",
"edits",
")",
";",
"need",
"to",
"save",
"|",
"=",
"needs",
"resave",
"based",
"on",
"stale",
"checkpoint",
"(",
"image",
"file",
"get",
"file",
"(",
")",
",",
"txns",
"advanced",
")",
";",
"}",
"else",
"{",
"/",
"/",
"trigger",
"the",
"rollback",
"for",
"rolling",
"upgrade",
"here",
"last",
"applied",
"tx",
"id",
"equals",
"/",
"/",
"to",
"the",
"last",
"txid",
"in",
"rollback",
"fsimage",
"rolling",
"rollback",
"(",
"last",
"applied",
"tx",
"id",
"+",
"1",
",",
"image",
"files",
"get",
"(",
"0",
")",
"get",
"checkpoint",
"tx",
"id",
"(",
")",
")",
";",
"need",
"to",
"save",
"=",
"false",
";",
"}",
"edit",
"log",
"set",
"next",
"tx",
"id",
"(",
"last",
"applied",
"tx",
"id",
"+",
"1",
")",
";",
"return",
"need",
"to",
"save",
";",
"}"
]
|
[
"test",
"checking",
"a",
"closed",
"volume",
"i",
"e",
"one",
"which",
"cannot",
"be",
"referenced"
]
| [
"public",
"void",
"test",
"checking",
"closed",
"volume",
"(",
")",
"throws",
"exception",
"{",
"/",
"/",
"add",
"a",
"volume",
"that",
"cannot",
"be",
"referenced",
"final",
"list",
"<",
"fs",
"volume",
"spi",
">",
"volumes",
"=",
"collections",
"singleton",
"list",
"(",
"make",
"closed",
"volume",
"(",
")",
")",
";",
"final",
"fs",
"dataset",
"spi",
"<",
"fs",
"volume",
"spi",
">",
"dataset",
"=",
"test",
"dataset",
"volume",
"checker",
"make",
"dataset",
"(",
"volumes",
")",
";",
"dataset",
"volume",
"checker",
"checker",
"=",
"new",
"dataset",
"volume",
"checker",
"(",
"conf",
",",
"timer",
")",
";",
"set",
"<",
"fs",
"volume",
"spi",
">",
"failed",
"volumes",
"=",
"checker",
"check",
"all",
"volumes",
"(",
"dataset",
")",
";",
"assert",
"that",
"(",
"failed",
"volumes",
"size",
"(",
")",
",",
"is",
"(",
"0",
")",
")",
";",
"assert",
"that",
"(",
"checker",
"get",
"num",
"sync",
"dataset",
"checks",
"(",
")",
",",
"is",
"(",
"0l",
")",
")",
";",
"/",
"/",
"the",
"closed",
"volume",
"should",
"not",
"have",
"been",
"checked",
"as",
"it",
"cannot",
"/",
"/",
"be",
"referenced",
"verify",
"(",
"volumes",
"get",
"(",
"0",
")",
",",
"times",
"(",
"0",
")",
")",
"check",
"(",
"any",
"(",
")",
")",
";",
"}"
]
|
[
"returns",
"the",
"fdo",
"build",
"subtype"
]
| [
"public",
"static",
"string",
"get",
"fdo",
"build",
"stamp",
"(",
"cpp",
"configuration",
"cpp",
"configuration",
",",
"fdo",
"context",
"fdo",
"context",
",",
"feature",
"configuration",
"feature",
"configuration",
")",
"{",
"fdo",
"context",
"branch",
"fdo",
"profile",
"branch",
"fdo",
"profile",
"=",
"fdo",
"context",
"get",
"branch",
"fdo",
"profile",
"(",
")",
";",
"if",
"(",
"branch",
"fdo",
"profile",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"branch",
"fdo",
"profile",
"is",
"auto",
"fdo",
"(",
")",
")",
"{",
"return",
"feature",
"configuration",
"is",
"enabled",
"(",
"cpp",
"rule",
"classes",
"autofdo",
")",
"?",
"\"",
"afdo",
"\"",
":",
"null",
";",
"}",
"if",
"(",
"branch",
"fdo",
"profile",
"is",
"auto",
"x",
"binary",
"fdo",
"(",
")",
")",
"{",
"return",
"feature",
"configuration",
"is",
"enabled",
"(",
"cpp",
"rule",
"classes",
"xbinaryfdo",
")",
"?",
"\"",
"xfdo",
"\"",
":",
"null",
";",
"}",
"}",
"if",
"(",
"cpp",
"configuration",
"is",
"c",
"s",
"fdo",
"(",
")",
")",
"{",
"return",
"\"",
"csfdo",
"\"",
";",
"}",
"if",
"(",
"cpp",
"configuration",
"is",
"fdo",
"(",
")",
")",
"{",
"return",
"\"",
"fdo",
"\"",
";",
"}",
"return",
"null",
";",
"}"
]
|
[
"appends",
"{",
"@",
"code",
"values",
"}",
",",
"in",
"order",
",",
"to",
"the",
"end",
"of",
"the",
"values",
"the",
"built",
"{",
"@",
"link",
"immutable",
"double",
"array",
"}",
"will",
"contain"
]
| [
"public",
"builder",
"add",
"all",
"(",
"immutable",
"double",
"array",
"values",
")",
"{",
"ensure",
"room",
"for",
"(",
"values",
"length",
"(",
")",
")",
";",
"system",
"arraycopy",
"(",
"values",
"array",
",",
"values",
"start",
",",
"array",
",",
"count",
",",
"values",
"length",
"(",
")",
")",
";",
"count",
"+",
"=",
"values",
"length",
"(",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"compute",
"{",
"@",
"link",
"content",
"summary",
"}",
"blocking",
"call"
]
| [
"public",
"final",
"content",
"summary",
"compute",
"content",
"summary",
"(",
"block",
"storage",
"policy",
"suite",
"bsps",
")",
"throws",
"access",
"control",
"exception",
"{",
"return",
"compute",
"and",
"convert",
"content",
"summary",
"(",
"snapshot",
"current",
"state",
"id",
",",
"new",
"content",
"summary",
"computation",
"context",
"(",
"bsps",
")",
")",
";",
"}"
]
|
[
"returns",
"the",
"policy",
"list"
]
| [
"public",
"immutable",
"list",
"<",
"string",
">",
"get",
"policy",
"names",
"(",
")",
"{",
"return",
"this",
"policy",
"names",
";",
"}"
]
|
[
"configure",
"the",
"{",
"@",
"code",
"info",
"receiver",
"}",
"to",
"use",
"to",
"perform",
"the",
"sock",
"j",
"s",
"\"",
"info",
"\"",
"request",
"before",
"the",
"sock",
"j",
"s",
"session",
"starts",
"if",
"the",
"list",
"of",
"transports",
"provided",
"to",
"the",
"constructor",
"contained",
"an",
"{",
"@",
"link",
"xhr",
"transport",
"}",
"or",
"an",
"implementation",
"of",
"{",
"@",
"link",
"info",
"receiver",
"}",
"that",
"instance",
"would",
"have",
"been",
"used",
"to",
"initialize",
"this",
"property",
",",
"or",
"otherwise",
"it",
"defaults",
"to",
"{",
"@",
"link",
"rest",
"template",
"xhr",
"transport",
"}"
]
| [
"public",
"void",
"set",
"info",
"receiver",
"(",
"info",
"receiver",
"info",
"receiver",
")",
"{",
"assert",
"not",
"null",
"(",
"info",
"receiver",
",",
"\"",
"info",
"receiver",
"is",
"required",
"\"",
")",
";",
"this",
"info",
"receiver",
"=",
"info",
"receiver",
";",
"}"
]
|
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
]
| [
"private",
"string",
"to",
"indented",
"string",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
]
|
[
"get",
"map",
"of",
"enum",
"string"
]
| [
"public",
"map",
"<",
"string",
",",
"inner",
"enum",
">",
"get",
"map",
"of",
"enum",
"string",
"(",
")",
"{",
"return",
"map",
"of",
"enum",
"string",
";",
"}"
]
|
[
"verifies",
"that",
"the",
"behaviour",
"tested",
"in",
"{",
"@",
"link",
"#",
"test",
"user",
"with",
"no",
"roles",
"can",
"perform",
"remote",
"search",
"}",
"does",
"not",
"work",
"for",
"requests",
"that",
"are",
"not",
"remote",
"-",
"index",
"-",
"capable"
]
| [
"public",
"void",
"test",
"remote",
"indices",
"only",
"work",
"with",
"applicable",
"request",
"types",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"delete",
"index",
"request",
"request",
"=",
"new",
"delete",
"index",
"request",
"(",
")",
";",
"request",
"indices",
"(",
"\"",
"other",
"cluster",
":",
"index",
"1",
"\"",
",",
"\"",
"other",
"cluster",
":",
"index",
"2",
"\"",
")",
";",
"final",
"authentication",
"authentication",
"=",
"create",
"authentication",
"(",
"new",
"user",
"(",
"\"",
"test",
"user",
"\"",
")",
")",
";",
"mock",
"empty",
"metadata",
"(",
")",
";",
"final",
"string",
"request",
"id",
"=",
"audit",
"util",
"get",
"or",
"generate",
"request",
"id",
"(",
"thread",
"context",
")",
";",
"assert",
"throws",
"authorization",
"exception",
"(",
"(",
")",
"-",
">",
"authorize",
"(",
"authentication",
",",
"delete",
"index",
"action",
"name",
",",
"request",
")",
",",
"delete",
"index",
"action",
"name",
",",
"\"",
"test",
"user",
"\"",
")",
";",
"verify",
"(",
"audit",
"trail",
")",
"access",
"denied",
"(",
"eq",
"(",
"request",
"id",
")",
",",
"eq",
"(",
"authentication",
")",
",",
"eq",
"(",
"delete",
"index",
"action",
"name",
")",
",",
"eq",
"(",
"request",
")",
",",
"authz",
"info",
"roles",
"(",
"role",
"empty",
"names",
"(",
")",
")",
")",
";",
"verify",
"no",
"more",
"interactions",
"(",
"audit",
"trail",
")",
";",
"}"
]
|
[
"return",
"in",
"general",
"how",
"things",
"flow",
"out",
"of",
"this",
"node",
"if",
"there",
"are",
"any",
"abnormal",
"ways",
"to",
"flow",
"out",
"of",
"this",
"node",
",",
"(",
"ie",
":",
"jump",
",",
"call",
",",
"etc",
")",
"then",
"the",
"flow",
"type",
"of",
"the",
"node",
"takes",
"on",
"that",
"type",
"if",
"there",
"are",
"multiple",
"unique",
"ways",
"out",
"of",
"the",
"node",
",",
"then",
"we",
"should",
"return",
"flow",
"type",
"unknown",
"(",
"or",
"flow",
"type",
"multiflow",
"?",
")",
"fallthrough",
"is",
"returned",
"if",
"that",
"is",
"the",
"only",
"way",
"out",
"if",
"this",
"block",
"really",
"has",
"no",
"valid",
"instructions",
",",
"it",
"can",
"'",
"t",
"flow",
",",
"so",
"flow",
"type",
"invalid",
"is",
"returned"
]
| [
"public",
"flow",
"type",
"get",
"flow",
"type",
"(",
"code",
"block",
"block",
")",
"{",
"if",
"(",
"!",
"(",
"block",
"get",
"model",
"(",
")",
"instanceof",
"simple",
"block",
"model",
")",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
")",
";",
"}",
"/",
"/",
"don",
"'",
"t",
"know",
"the",
"flow",
"type",
"yet",
",",
"try",
"to",
"get",
"the",
"instruction",
"type",
"/",
"/",
"of",
"the",
"last",
"address",
"in",
"the",
"block",
"instruction",
"instr",
"=",
"listing",
"get",
"instruction",
"containing",
"(",
"block",
"get",
"max",
"address",
"(",
")",
")",
";",
"if",
"(",
"instr",
"!",
"=",
"null",
")",
"{",
"/",
"/",
"search",
"backwards",
"until",
"a",
"non",
"-",
"delay",
"slot",
"instruction",
"is",
"found",
"while",
"(",
"instr",
"is",
"in",
"delay",
"slot",
"(",
")",
")",
"{",
"address",
"fall",
"from",
"=",
"instr",
"get",
"fall",
"from",
"(",
")",
";",
"if",
"(",
"fall",
"from",
"=",
"=",
"null",
")",
"{",
"msg",
"warn",
"(",
"this",
",",
"\"",
"warning",
":",
"invalid",
"delay",
"slot",
"instruction",
"found",
"at",
"\"",
"+",
"instr",
"get",
"min",
"address",
"(",
")",
")",
";",
"break",
";",
"}",
"instr",
"=",
"listing",
"get",
"instruction",
"containing",
"(",
"fall",
"from",
")",
";",
"}",
"flow",
"type",
"flow",
"type",
"=",
"instr",
"get",
"flow",
"type",
"(",
")",
";",
"if",
"(",
"block",
"get",
"start",
"addresses",
"(",
")",
"length",
">",
"1",
")",
"{",
"/",
"/",
"modify",
"flow",
"type",
"to",
"a",
"conditional",
"if",
"(",
"flow",
"type",
"=",
"=",
"ref",
"type",
"unconditional",
"call",
")",
"{",
"flow",
"type",
"=",
"ref",
"type",
"conditional",
"call",
";",
"}",
"else",
"if",
"(",
"flow",
"type",
"=",
"=",
"ref",
"type",
"unconditional",
"jump",
")",
"{",
"flow",
"type",
"=",
"ref",
"type",
"conditional",
"jump",
";",
"}",
"else",
"if",
"(",
"flow",
"type",
"is",
"terminal",
"(",
")",
")",
"{",
"flow",
"type",
"=",
"ref",
"type",
"conditional",
"terminator",
";",
"}",
"}",
"else",
"if",
"(",
"flow",
"type",
"is",
"fallthrough",
"(",
")",
")",
"{",
"/",
"/",
"use",
"flow",
"type",
"associated",
"with",
"first",
"flow",
"-",
"type",
"reference",
"reference",
"[",
"]",
"refs",
"=",
"reference",
"mgr",
"get",
"flow",
"references",
"from",
"(",
"instr",
"get",
"min",
"address",
"(",
")",
")",
";",
"for",
"(",
"reference",
"ref",
":",
"refs",
")",
"{",
"ref",
"type",
"ref",
"type",
"=",
"ref",
"get",
"reference",
"type",
"(",
")",
";",
"if",
"(",
"ref",
"type",
"instanceof",
"flow",
"type",
")",
"{",
"flow",
"type",
"=",
"(",
"flow",
"type",
")",
"ref",
"type",
";",
"break",
";",
"}",
"}",
"}",
"return",
"flow",
"type",
";",
"}",
"data",
"data",
"=",
"listing",
"get",
"defined",
"data",
"containing",
"(",
"block",
"get",
"min",
"address",
"(",
")",
")",
";",
"if",
"(",
"data",
"!",
"=",
"null",
")",
"{",
"return",
"ref",
"type",
"indirection",
";",
"/",
"/",
"/",
"/",
"/",
"/",
"if",
"no",
"label",
"here",
"/",
"/",
"symbol",
"sym",
"=",
"program",
"get",
"symbol",
"table",
"(",
")",
"get",
"symbol",
"(",
"data",
"get",
"min",
"address",
"(",
")",
")",
";",
"/",
"/",
"if",
"(",
"sym",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"return",
"flow",
"type",
"invalid",
";",
"/",
"/",
"}",
"/",
"/",
"/",
"/",
"/",
"/",
"look",
"at",
"all",
"refs",
"to",
"symbol",
",",
"if",
"not",
"referred",
"to",
"by",
"fallthrough",
"/",
"/",
"/",
"/",
"instruction",
",",
"must",
"be",
"flow",
",",
"so",
"return",
"true",
"/",
"/",
"referent",
"refs",
"[",
"]",
"=",
"sym",
"get",
"references",
"(",
")",
";",
"/",
"/",
"if",
"(",
"refs",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"return",
"flow",
"type",
"invalid",
";",
"/",
"/",
"}",
"/",
"/",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"refs",
"length",
";",
"i",
"+",
"+",
")",
"{",
"/",
"/",
"instruction",
"ref",
"instr",
"=",
"listing",
"get",
"instruction",
"at",
"(",
"refs",
"[",
"i",
"]",
"get",
"address",
"(",
")",
")",
";",
"/",
"/",
"if",
"(",
"ref",
"instr",
"=",
"=",
"null",
"|",
"|",
"ref",
"instr",
"get",
"flow",
"type",
"(",
")",
"is",
"fallthrough",
"(",
")",
")",
"{",
"/",
"/",
"continue",
";",
"/",
"/",
"}",
"/",
"/",
"return",
"ref",
"instr",
"get",
"flow",
"type",
"(",
")",
";",
"/",
"/",
"}",
"}",
"return",
"ref",
"type",
"invalid",
";",
"}"
]
|
[
"define",
"a",
"spring",
"xml",
"namespace",
"definition",
"to",
"use"
]
| [
"public",
"void",
"xmlns",
"(",
"map",
"<",
"string",
",",
"string",
">",
"definition",
")",
"{",
"if",
"(",
"!",
"definition",
"is",
"empty",
"(",
")",
")",
"{",
"for",
"(",
"map",
"entry",
"<",
"string",
",",
"string",
">",
"entry",
":",
"definition",
"entry",
"set",
"(",
")",
")",
"{",
"string",
"namespace",
"=",
"entry",
"get",
"key",
"(",
")",
";",
"string",
"uri",
"=",
"entry",
"get",
"value",
"(",
")",
";",
"if",
"(",
"uri",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"namespace",
"definition",
"must",
"supply",
"a",
"non",
"-",
"null",
"uri",
"\"",
")",
";",
"}",
"namespace",
"handler",
"namespace",
"handler",
"=",
"this",
"groovy",
"dsl",
"xml",
"bean",
"definition",
"reader",
"get",
"namespace",
"handler",
"resolver",
"(",
")",
"resolve",
"(",
"uri",
")",
";",
"if",
"(",
"namespace",
"handler",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"bean",
"definition",
"parsing",
"exception",
"(",
"new",
"problem",
"(",
"\"",
"no",
"namespace",
"handler",
"found",
"for",
"uri",
":",
"\"",
"+",
"uri",
",",
"new",
"location",
"(",
"new",
"descriptive",
"resource",
"(",
"(",
"\"",
"groovy",
"\"",
")",
")",
")",
")",
")",
";",
"}",
"this",
"namespaces",
"put",
"(",
"namespace",
",",
"uri",
")",
";",
"}",
"}",
"}"
]
|
[
"returns",
"pet",
"inventories",
"by",
"status",
"returns",
"a",
"map",
"of",
"status",
"codes",
"to",
"quantities"
]
| [
"public",
"void",
"get",
"inventory",
"test",
"(",
")",
"throws",
"api",
"exception",
"{",
"map",
"<",
"string",
",",
"integer",
">",
"response",
"=",
"api",
"get",
"inventory",
"(",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
]
|
[
"tells",
"if",
"the",
"{",
"@",
"link",
"table",
"environment",
"}",
"should",
"work",
"in",
"a",
"batch",
"or",
"streaming",
"mode"
]
| [
"public",
"boolean",
"is",
"streaming",
"mode",
"(",
")",
"{",
"return",
"is",
"streaming",
"mode",
";",
"}"
]
|
[
"initialize",
"program",
"compiler",
"specification",
"during",
"a",
"language",
"upgrade",
"this",
"will",
"provide",
"a",
"temporary",
"spec",
"until",
"set",
"language",
"is",
"complete"
]
| [
"private",
"void",
"init",
"compiler",
"spec",
"(",
")",
"throws",
"compiler",
"spec",
"not",
"found",
"exception",
"{",
"try",
"{",
"if",
"(",
"language",
"upgrade",
"translator",
"!",
"=",
"null",
")",
"{",
"compiler",
"spec",
"=",
"language",
"upgrade",
"translator",
"get",
"old",
"compiler",
"spec",
"(",
"compiler",
"spec",
"i",
"d",
")",
";",
"}",
"else",
"{",
"compiler",
"spec",
"=",
"language",
"get",
"compiler",
"spec",
"by",
"i",
"d",
"(",
"compiler",
"spec",
"i",
"d",
")",
";",
"}",
"}",
"catch",
"(",
"compiler",
"spec",
"not",
"found",
"exception",
"e",
")",
"{",
"msg",
"error",
"(",
"this",
",",
"\"",
"compiler",
"spec",
"\"",
"+",
"compiler",
"spec",
"i",
"d",
"+",
"\"",
"for",
"language",
"\"",
"+",
"language",
"get",
"language",
"description",
"(",
")",
"get",
"description",
"(",
")",
"+",
"\"",
"not",
"found",
",",
"using",
"default",
":",
"\"",
"+",
"e",
")",
";",
"compiler",
"spec",
"=",
"language",
"get",
"default",
"compiler",
"spec",
"(",
")",
";",
"if",
"(",
"compiler",
"spec",
"=",
"=",
"null",
")",
"{",
"throw",
"e",
";",
"}",
"compiler",
"spec",
"i",
"d",
"=",
"compiler",
"spec",
"get",
"compiler",
"spec",
"i",
"d",
"(",
")",
";",
"}",
"}"
]
|
[
"set",
"auth",
"plugin",
"name"
]
| [
"public",
"void",
"set",
"auth",
"plugin",
"name",
"(",
"final",
"my",
"s",
"q",
"l",
"authentication",
"method",
"mysql",
"authentication",
"method",
")",
"{",
"auth",
"plugin",
"name",
"=",
"mysql",
"authentication",
"method",
"get",
"method",
"name",
"(",
")",
";",
"capability",
"flags",
"upper",
"|",
"=",
"my",
"s",
"q",
"l",
"capability",
"flag",
"client",
"plugin",
"auth",
"get",
"value",
"(",
")",
">",
">",
"16",
";",
"}"
]
|
[
"when",
"a",
"file",
"is",
"copied",
",",
"any",
"ancestors",
"are",
"calculated",
"and",
"then",
"the",
"store",
"is",
"updated",
"with",
"the",
"destination",
"entries",
"the",
"source",
"entries",
"are",
"added",
"to",
"the",
"{",
"@",
"link",
"#",
"paths",
"to",
"delete",
"}",
"list"
]
| [
"public",
"void",
"file",
"copied",
"(",
"final",
"path",
"source",
"path",
",",
"final",
"s",
"3",
"object",
"attributes",
"source",
"attributes",
",",
"final",
"s",
"3",
"object",
"attributes",
"dest",
"attributes",
",",
"final",
"path",
"dest",
"path",
",",
"final",
"long",
"block",
"size",
",",
"final",
"boolean",
"add",
"ancestors",
")",
"throws",
"i",
"o",
"exception",
"{",
"/",
"/",
"build",
"the",
"list",
"of",
"entries",
"to",
"add",
"in",
"a",
"synchronized",
"block",
"final",
"list",
"<",
"path",
"metadata",
">",
"entries",
"to",
"add",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"1",
")",
";",
"log",
"debug",
"(",
"\"",
"updating",
"store",
"with",
"copied",
"file",
"{",
"}",
"\"",
",",
"source",
"path",
")",
";",
"metadata",
"store",
"store",
"=",
"get",
"metadata",
"store",
"(",
")",
";",
"synchronized",
"(",
"this",
")",
"{",
"check",
"argument",
"(",
"!",
"paths",
"to",
"delete",
"contains",
"(",
"source",
"path",
")",
",",
"\"",
"file",
"being",
"renamed",
"is",
"already",
"processed",
"%",
"s",
"\"",
",",
"dest",
"path",
")",
";",
"/",
"/",
"create",
"the",
"file",
"metadata",
"and",
"update",
"the",
"lists",
"/",
"/",
"the",
"paths",
"to",
"delete",
"field",
"is",
"incremented",
"with",
"the",
"new",
"source",
"path",
",",
"/",
"/",
"for",
"deletion",
"after",
"the",
"delete",
"operation",
"succeeds",
";",
"/",
"/",
"the",
"entries",
"to",
"add",
"variable",
"is",
"filled",
"in",
"with",
"all",
"entries",
"/",
"/",
"to",
"add",
"within",
"this",
"method",
"s",
"3",
"guard",
"add",
"move",
"file",
"(",
"store",
",",
"paths",
"to",
"delete",
",",
"entries",
"to",
"add",
",",
"source",
"path",
",",
"dest",
"path",
",",
"source",
"attributes",
"get",
"len",
"(",
")",
",",
"block",
"size",
",",
"get",
"owner",
"(",
")",
",",
"dest",
"attributes",
"get",
"e",
"tag",
"(",
")",
",",
"dest",
"attributes",
"get",
"version",
"id",
"(",
")",
")",
";",
"log",
"debug",
"(",
"\"",
"new",
"metastore",
"entry",
":",
"{",
"}",
"\"",
",",
"entries",
"to",
"add",
"get",
"(",
"0",
")",
")",
";",
"if",
"(",
"add",
"ancestors",
")",
"{",
"/",
"/",
"add",
"all",
"new",
"ancestors",
"to",
"the",
"lists",
"add",
"move",
"ancestors",
"(",
"store",
",",
"paths",
"to",
"delete",
",",
"entries",
"to",
"add",
",",
"get",
"source",
"root",
"(",
")",
",",
"source",
"path",
",",
"dest",
"path",
",",
"get",
"owner",
"(",
")",
")",
";",
"}",
"}",
"/",
"/",
"outside",
"the",
"lock",
",",
"the",
"entries",
"to",
"add",
"variable",
"has",
"all",
"the",
"new",
"entries",
"to",
"/",
"/",
"create",
"so",
"update",
"the",
"store",
"/",
"/",
"no",
"entries",
"are",
"deleted",
"at",
"this",
"point",
"try",
"(",
"duration",
"info",
"ignored",
"=",
"new",
"duration",
"info",
"(",
"log",
",",
"false",
",",
"\"",
"adding",
"new",
"metastore",
"entries",
"\"",
")",
")",
"{",
"store",
"move",
"(",
"null",
",",
"entries",
"to",
"add",
",",
"get",
"operation",
"state",
"(",
")",
")",
";",
"}",
"}"
]
|
[
"read",
"the",
"header",
"of",
"fsedit",
"log"
]
| [
"static",
"int",
"read",
"log",
"version",
"(",
"data",
"input",
"stream",
"in",
",",
"boolean",
"verify",
"layout",
"version",
")",
"throws",
"i",
"o",
"exception",
",",
"log",
"header",
"corrupt",
"exception",
"{",
"int",
"log",
"version",
";",
"try",
"{",
"log",
"version",
"=",
"in",
"read",
"int",
"(",
")",
";",
"}",
"catch",
"(",
"e",
"o",
"f",
"exception",
"eofe",
")",
"{",
"throw",
"new",
"log",
"header",
"corrupt",
"exception",
"(",
"\"",
"reached",
"eof",
"when",
"reading",
"log",
"header",
"\"",
")",
";",
"}",
"if",
"(",
"verify",
"layout",
"version",
"&",
"&",
"(",
"log",
"version",
"<",
"hdfs",
"server",
"constants",
"namenode",
"layout",
"version",
"|",
"|",
"/",
"/",
"future",
"version",
"log",
"version",
">",
"storage",
"last",
"upgradable",
"layout",
"version",
")",
")",
"{",
"/",
"/",
"unsupported",
"throw",
"new",
"log",
"header",
"corrupt",
"exception",
"(",
"\"",
"unexpected",
"version",
"of",
"the",
"file",
"system",
"log",
"file",
":",
"\"",
"+",
"log",
"version",
"+",
"\"",
"current",
"version",
"=",
"\"",
"+",
"hdfs",
"server",
"constants",
"namenode",
"layout",
"version",
"+",
"\"",
"\"",
")",
";",
"}",
"return",
"log",
"version",
";",
"}"
]
|
[
"checks",
"the",
"correct",
"result",
"if",
"a",
"get",
"operation",
"fails",
"during",
"the",
"file",
"download"
]
| [
"private",
"void",
"test",
"get",
"fails",
"during",
"streaming",
"(",
"@",
"nullable",
"final",
"job",
"i",
"d",
"job",
"id",
",",
"blob",
"key",
"blob",
"type",
"blob",
"type",
")",
"throws",
"i",
"o",
"exception",
"{",
"assume",
"false",
"(",
"\"",
"this",
"test",
"can",
"deadlock",
"when",
"using",
"ssl",
"see",
"flink",
"-",
"19369",
"\"",
",",
"is",
"s",
"s",
"l",
"enabled",
"(",
")",
")",
";",
"try",
"(",
"blob",
"client",
"client",
"=",
"new",
"blob",
"client",
"(",
"new",
"inet",
"socket",
"address",
"(",
"\"",
"localhost",
"\"",
",",
"get",
"blob",
"server",
"(",
")",
"get",
"port",
"(",
")",
")",
",",
"get",
"blob",
"client",
"config",
"(",
")",
")",
")",
"{",
"byte",
"[",
"]",
"data",
"=",
"new",
"byte",
"[",
"5000000",
"]",
";",
"random",
"rnd",
"=",
"new",
"random",
"(",
")",
";",
"rnd",
"next",
"bytes",
"(",
"data",
")",
";",
"/",
"/",
"put",
"content",
"addressable",
"(",
"like",
"libraries",
")",
"blob",
"key",
"key",
"=",
"client",
"put",
"buffer",
"(",
"job",
"id",
",",
"data",
",",
"0",
",",
"data",
"length",
",",
"blob",
"type",
")",
";",
"assert",
"not",
"null",
"(",
"key",
")",
";",
"/",
"/",
"issue",
"a",
"get",
"request",
"that",
"succeeds",
"input",
"stream",
"is",
"=",
"client",
"get",
"internal",
"(",
"job",
"id",
",",
"key",
")",
";",
"byte",
"[",
"]",
"receive",
"buffer",
"=",
"new",
"byte",
"[",
"data",
"length",
"]",
";",
"int",
"first",
"chunk",
"len",
"=",
"50000",
";",
"blob",
"utils",
"read",
"fully",
"(",
"is",
",",
"receive",
"buffer",
",",
"0",
",",
"first",
"chunk",
"len",
",",
"null",
")",
";",
"blob",
"utils",
"read",
"fully",
"(",
"is",
",",
"receive",
"buffer",
",",
"first",
"chunk",
"len",
",",
"first",
"chunk",
"len",
",",
"null",
")",
";",
"/",
"/",
"shut",
"down",
"the",
"server",
"for",
"(",
"blob",
"server",
"connection",
"conn",
":",
"get",
"blob",
"server",
"(",
")",
"get",
"current",
"active",
"connections",
"(",
")",
")",
"{",
"conn",
"close",
"(",
")",
";",
"}",
"try",
"{",
"blob",
"utils",
"read",
"fully",
"(",
"is",
",",
"receive",
"buffer",
",",
"2",
"*",
"first",
"chunk",
"len",
",",
"data",
"length",
"-",
"2",
"*",
"first",
"chunk",
"len",
",",
"null",
")",
";",
"/",
"/",
"we",
"tolerate",
"that",
"this",
"succeeds",
",",
"as",
"the",
"receiver",
"socket",
"may",
"have",
"buffered",
"/",
"/",
"everything",
"already",
",",
"but",
"in",
"this",
"case",
",",
"also",
"verify",
"the",
"contents",
"assert",
"array",
"equals",
"(",
"data",
",",
"receive",
"buffer",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"/",
"/",
"expected",
"}",
"}",
"}"
]
|
[
"use",
"the",
"builder",
"api",
"this",
"always",
"looks",
"for",
"a",
"parent",
"unless",
"the",
"caller",
"says",
"otherwise"
]
| [
"public",
"void",
"test",
"create",
"builder",
"(",
")",
"throws",
"throwable",
"{",
"describe",
"(",
"\"",
"test",
"builder",
"file",
"creation",
"cost",
"-",
"raw",
"only",
"\"",
")",
";",
"assume",
"unguarded",
"(",
")",
";",
"path",
"test",
"file",
"=",
"method",
"path",
"(",
")",
";",
"dir",
"(",
"test",
"file",
"get",
"parent",
"(",
")",
")",
";",
"/",
"/",
"builder",
"defaults",
"to",
"looking",
"for",
"parent",
"existence",
"(",
"non",
"-",
"recursive",
")",
"build",
"file",
"(",
"test",
"file",
",",
"false",
",",
"false",
",",
"get",
"file",
"status",
"fnfe",
"/",
"/",
"destination",
"file",
"plus",
"(",
"file",
"status",
"dir",
"probe",
")",
")",
";",
"/",
"/",
"parent",
"dir",
"/",
"/",
"recursive",
"=",
"false",
"and",
"overwrite",
"=",
"true",
":",
"/",
"/",
"only",
"make",
"sure",
"the",
"dest",
"path",
"isn",
"'",
"t",
"a",
"directory",
"build",
"file",
"(",
"test",
"file",
",",
"true",
",",
"true",
",",
"file",
"status",
"dir",
"probe",
")",
";",
"/",
"/",
"now",
"there",
"is",
"a",
"file",
"there",
",",
"an",
"attempt",
"with",
"overwrite",
"=",
"=",
"false",
"will",
"/",
"/",
"fail",
"on",
"the",
"first",
"head",
"intercept",
"raw",
"(",
"file",
"already",
"exists",
"exception",
"class",
",",
"\"",
"\"",
",",
"get",
"file",
"status",
"on",
"file",
",",
"(",
")",
"-",
">",
"build",
"file",
"(",
"test",
"file",
",",
"false",
",",
"true",
",",
"get",
"file",
"status",
"on",
"file",
")",
")",
";",
"}"
]
|
[
"returns",
"a",
"typed",
"{",
"@",
"link",
"generic",
"transition",
"options",
"}",
"object",
"that",
"uses",
"the",
"given",
"transition",
"factory"
]
| [
"public",
"static",
"<",
"transcode",
"type",
">",
"generic",
"transition",
"options",
"<",
"transcode",
"type",
">",
"with",
"(",
"@",
"non",
"null",
"transition",
"factory",
"<",
"?",
"super",
"transcode",
"type",
">",
"transition",
"factory",
")",
"{",
"return",
"new",
"generic",
"transition",
"options",
"<",
"transcode",
"type",
">",
"(",
")",
"transition",
"(",
"transition",
"factory",
")",
";",
"}"
]
|
[
"for",
"the",
"interface",
"that",
"this",
"provider",
"describes",
",",
"return",
"an",
"implementation"
]
| [
"x",
"get",
"implementation",
"(",
"capabilities",
"capabilities",
",",
"execute",
"method",
"execute",
"method",
")",
";"
]
|
[
"gets",
"the",
"base",
"addresses",
"of",
"all",
"the",
"rtti",
"4",
"structures",
"that",
"appear",
"to",
"be",
"associated",
"with",
"the",
"rtti",
"0",
"at",
"the",
"indicated",
"base",
"address"
]
| [
"private",
"static",
"list",
"<",
"address",
">",
"get",
"rtti",
"4",
"addresses",
"(",
"program",
"program",
",",
"list",
"<",
"memory",
"block",
">",
"rtti",
"4",
"blocks",
",",
"list",
"<",
"address",
">",
"rtti",
"0",
"locations",
",",
"data",
"validation",
"options",
"validation",
"options",
",",
"task",
"monitor",
"monitor",
")",
"throws",
"cancelled",
"exception",
"{",
"monitor",
"check",
"canceled",
"(",
")",
";",
"list",
"<",
"address",
">",
"addresses",
"=",
"get",
"refs",
"to",
"rtti",
"0",
"(",
"program",
",",
"rtti",
"4",
"blocks",
",",
"rtti",
"0",
"locations",
",",
"validation",
"options",
",",
"monitor",
")",
";",
"return",
"addresses",
";",
"}"
]
|
[
"sets",
"the",
"starlark",
"call",
"stack",
"associated",
"with",
"this",
"rule",
"class",
"'",
"s",
"creation"
]
| [
"public",
"builder",
"set",
"call",
"stack",
"(",
"immutable",
"list",
"<",
"starlark",
"thread",
"call",
"stack",
"entry",
">",
"callstack",
")",
"{",
"this",
"callstack",
"=",
"callstack",
";",
"return",
"this",
";",
"}"
]
|
[
"gets",
"response",
"type"
]
| [
"public",
"o",
"auth",
"2",
"0",
"response",
"types",
"get",
"response",
"type",
"(",
")",
"{",
"return",
"o",
"auth",
"2",
"0",
"response",
"types",
"code",
";",
"}"
]
|
[
"prepare",
"message",
"digest",
"message",
"digest"
]
| [
"protected",
"static",
"message",
"digest",
"prepare",
"message",
"digest",
"(",
"final",
"string",
"principal",
",",
"final",
"string",
"service",
")",
"{",
"val",
"md",
"=",
"message",
"digest",
"get",
"instance",
"(",
"\"",
"sha",
"\"",
")",
";",
"if",
"(",
"string",
"utils",
"is",
"not",
"blank",
"(",
"service",
")",
")",
"{",
"md",
"update",
"(",
"service",
"get",
"bytes",
"(",
"standard",
"charsets",
"utf",
"8",
")",
")",
";",
"md",
"update",
"(",
"const",
"separator",
")",
";",
"}",
"md",
"update",
"(",
"principal",
"get",
"bytes",
"(",
"standard",
"charsets",
"utf",
"8",
")",
")",
";",
"md",
"update",
"(",
"const",
"separator",
")",
";",
"return",
"md",
";",
"}"
]
|
[
"see",
"{",
"@",
"link",
"stream",
"tracer",
"#",
"inbound",
"uncompressed",
"size",
"}",
"called",
"from",
"{",
"@",
"link",
"io",
"grpc",
"internal",
"message",
"deframer",
"}"
]
| [
"public",
"void",
"inbound",
"uncompressed",
"size",
"(",
"long",
"bytes",
")",
"{",
"for",
"(",
"stream",
"tracer",
"tracer",
":",
"tracers",
")",
"{",
"tracer",
"inbound",
"uncompressed",
"size",
"(",
"bytes",
")",
";",
"}",
"}"
]
|
[
"returns",
"a",
"list",
"of",
"type",
"item",
"i",
"ds",
"that",
"we",
"have",
"not",
"seen",
"in",
"real",
"data",
"while",
"testing"
]
| [
"private",
"string",
"get",
"new",
"data",
"types",
"log",
"(",
")",
"{",
"string",
"builder",
"builder",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"delimiter",
"state",
"ds",
"=",
"new",
"delimiter",
"state",
"(",
"\"",
"new",
"type",
"/",
"item",
"i",
"ds",
"seen",
":",
"\"",
",",
"\"",
",",
"\"",
")",
";",
"/",
"*",
"*",
"sort",
"these",
"before",
"printing",
"to",
"avoid",
"sorting",
"performance",
"hit",
"when",
"logging",
"is",
"not",
"used",
"*",
"/",
"set",
"<",
"integer",
">",
"sorted",
"set",
"=",
"new",
"tree",
"set",
"<",
">",
"(",
"new",
"data",
"types",
")",
";",
"for",
"(",
"integer",
"val",
":",
"sorted",
"set",
")",
"{",
"builder",
"append",
"(",
"ds",
"out",
"(",
"true",
",",
"string",
"format",
"(",
"\"",
"0x",
"%",
"04x",
"\"",
",",
"val",
")",
")",
")",
";",
"}",
"return",
"builder",
"to",
"string",
"(",
")",
";",
"}"
]
|
[
"model",
"tests",
"for",
"cat",
"all",
"of"
]
| [
"public",
"void",
"test",
"cat",
"all",
"of",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"cat",
"all",
"of",
"}"
]
|
[
"constructs",
"a",
"{",
"@",
"link",
"zip",
"entry",
"}",
"view",
"of",
"the",
"entry",
"at",
"the",
"location",
"of",
"the",
"given",
"header"
]
| [
"public",
"zip",
"entry",
"entry",
"with",
"(",
"local",
"file",
"header",
"header",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"header",
"=",
"=",
"null",
")",
"{",
"return",
"new",
"zip",
"entry",
"(",
")",
"with",
"code",
"(",
"zip",
"entry",
"status",
"entry",
"not",
"found",
")",
";",
"}",
"/",
"/",
"header",
"!",
"=",
"null",
"long",
"offset",
"=",
"header",
"file",
"offset",
"(",
")",
";",
"directory",
"entry",
"dir",
"entry",
"=",
"null",
";",
"if",
"(",
"use",
"directory",
")",
"{",
"dir",
"entry",
"=",
"cdir",
"map",
"by",
"offset",
"(",
")",
"get",
"(",
"(",
"int",
")",
"offset",
")",
";",
"if",
"(",
"dir",
"entry",
"=",
"=",
"null",
"&",
"&",
"ignore",
"deleted",
")",
"{",
"return",
"new",
"zip",
"entry",
"(",
")",
"with",
"code",
"(",
"zip",
"entry",
"status",
"entry",
"deleted",
")",
";",
"}",
"}",
"return",
"entry",
"with",
"(",
"header",
",",
"dir",
"entry",
")",
";",
"}"
]
|
[
"set",
"the",
"last",
"modified",
"value"
]
| [
"public",
"list",
"result",
"entry",
"schema",
"with",
"last",
"modified",
"(",
"string",
"last",
"modified",
")",
"{",
"this",
"last",
"modified",
"=",
"last",
"modified",
";",
"return",
"this",
";",
"}"
]
|
[
"creates",
"the",
"actions"
]
| [
"protected",
"void",
"create",
"actions",
"(",
")",
"{",
"toggle",
"ignore",
"byte",
"diffs",
"action",
"=",
"new",
"toggle",
"ignore",
"byte",
"diffs",
"action",
"(",
")",
";",
"toggle",
"ignore",
"constants",
"action",
"=",
"new",
"toggle",
"ignore",
"constants",
"action",
"(",
")",
";",
"toggle",
"ignore",
"register",
"names",
"action",
"=",
"new",
"toggle",
"ignore",
"register",
"names",
"action",
"(",
")",
";",
"}"
]
|
[
"the",
"children",
"of",
"this",
"element",
"<",
"code",
">",
"repeated",
"aapt",
"pb",
"xml",
"node",
"child",
"=",
"5",
";",
"<",
"code",
">"
]
| [
"private",
"void",
"clear",
"child",
"(",
")",
"{",
"child",
"=",
"empty",
"protobuf",
"list",
"(",
")",
";",
"}"
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.