docstring_tokens
sequence | code_tokens
sequence |
|---|---|
[
"check",
"if",
"the",
"i",
"-",
"th",
"block",
"is",
"complete",
";",
"when",
"the",
"i",
"-",
"th",
"block",
"is",
"the",
"last",
"block",
",",
"it",
"may",
"be",
"allowed",
"to",
"be",
"committed"
] | [
"static",
"string",
"check",
"block",
"complete",
"(",
"block",
"info",
"[",
"]",
"blocks",
",",
"int",
"i",
",",
"int",
"num",
"committed",
"allowed",
",",
"short",
"min",
"replication",
")",
"{",
"final",
"block",
"info",
"b",
"=",
"blocks",
"[",
"i",
"]",
";",
"final",
"block",
"u",
"c",
"state",
"state",
"=",
"b",
"get",
"block",
"u",
"c",
"state",
"(",
")",
";",
"if",
"(",
"state",
"=",
"=",
"block",
"u",
"c",
"state",
"complete",
")",
"{",
"return",
"null",
";",
"}",
"if",
"(",
"i",
"<",
"blocks",
"length",
"-",
"num",
"committed",
"allowed",
")",
"{",
"return",
"b",
"+",
"\"",
"is",
"\"",
"+",
"state",
"+",
"\"",
"but",
"not",
"complete",
"\"",
";",
"}",
"if",
"(",
"state",
"!",
"=",
"block",
"u",
"c",
"state",
"committed",
")",
"{",
"return",
"b",
"+",
"\"",
"is",
"\"",
"+",
"state",
"+",
"\"",
"but",
"neither",
"complete",
"nor",
"committed",
"\"",
";",
"}",
"if",
"(",
"b",
"is",
"striped",
"(",
")",
")",
"{",
"block",
"info",
"striped",
"blk",
"striped",
"=",
"(",
"block",
"info",
"striped",
")",
"b",
";",
"if",
"(",
"b",
"get",
"under",
"construction",
"feature",
"(",
")",
"get",
"num",
"expected",
"locations",
"(",
")",
"!",
"=",
"blk",
"striped",
"get",
"real",
"total",
"block",
"num",
"(",
")",
")",
"{",
"return",
"b",
"+",
"\"",
"is",
"a",
"striped",
"block",
"in",
"\"",
"+",
"state",
"+",
"\"",
"with",
"less",
"then",
"\"",
"+",
"\"",
"required",
"number",
"of",
"blocks",
"\"",
";",
"}",
"}",
"else",
"{",
"final",
"int",
"num",
"expected",
"locations",
"=",
"b",
"get",
"under",
"construction",
"feature",
"(",
")",
"get",
"num",
"expected",
"locations",
"(",
")",
";",
"if",
"(",
"num",
"expected",
"locations",
"<",
"=",
"min",
"replication",
")",
"{",
"return",
"b",
"+",
"\"",
"is",
"\"",
"+",
"state",
"+",
"\"",
"but",
"num",
"expected",
"locations",
"=",
"\"",
"+",
"num",
"expected",
"locations",
"+",
"\"",
"<",
"=",
"min",
"replication",
"=",
"\"",
"+",
"min",
"replication",
";",
"}",
"}",
"return",
"null",
";",
"}"
] |
[
"create",
"logout",
"view",
"state"
] | [
"protected",
"void",
"create",
"logout",
"view",
"state",
"(",
"final",
"flow",
"flow",
")",
"{",
"create",
"end",
"state",
"(",
"flow",
",",
"cas",
"webflow",
"constants",
"state",
"id",
"redirect",
"view",
",",
"create",
"external",
"redirect",
"view",
"factory",
"(",
"\"",
"flow",
"scope",
"logout",
"redirect",
"url",
"\"",
")",
")",
";",
"val",
"logout",
"view",
"=",
"create",
"end",
"state",
"(",
"flow",
",",
"cas",
"webflow",
"constants",
"state",
"id",
"logout",
"view",
",",
"\"",
"cas",
"logout",
"view",
"\"",
")",
";",
"logout",
"view",
"get",
"entry",
"action",
"list",
"(",
")",
"add",
"(",
"create",
"evaluate",
"action",
"(",
"cas",
"webflow",
"constants",
"action",
"id",
"logout",
"view",
"setup",
")",
")",
";",
"}"
] |
[
"returns",
"the",
"{",
"@",
"link",
"future",
"}",
"that",
"will",
"provide",
"the",
"result",
"of",
"the",
"mapping",
"the",
"given",
"{",
"@",
"link",
"promise",
"}",
"will",
"be",
"fulfilled",
"when",
"the",
"result",
"is",
"available"
] | [
"future",
"<",
"out",
">",
"map",
"(",
"in",
"input",
",",
"promise",
"<",
"out",
">",
"promise",
")",
";"
] |
[
"configures",
"the",
"message",
"formatter"
] | [
"default",
"public",
"void",
"configure",
"(",
"map",
"<",
"string",
",",
"?",
">",
"configs",
")",
"{",
"properties",
"properties",
"=",
"new",
"properties",
"(",
")",
";",
"properties",
"put",
"all",
"(",
"configs",
")",
";",
"init",
"(",
"properties",
")",
";",
"}"
] |
[
"returns",
"a",
"copy",
"of",
"the",
"input",
"character",
"sequence",
"in",
"which",
"all",
"{",
"@",
"linkplain",
"#",
"is",
"lower",
"case",
"(",
"char",
")",
"lowercase",
"ascii",
"characters",
"}",
"have",
"been",
"converted",
"to",
"uppercase",
"all",
"other",
"characters",
"are",
"copied",
"without",
"modification"
] | [
"public",
"static",
"string",
"to",
"upper",
"case",
"(",
"char",
"sequence",
"chars",
")",
"{",
"if",
"(",
"chars",
"instanceof",
"string",
")",
"{",
"return",
"to",
"upper",
"case",
"(",
"(",
"string",
")",
"chars",
")",
";",
"}",
"char",
"[",
"]",
"new",
"chars",
"=",
"new",
"char",
"[",
"chars",
"length",
"(",
")",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"new",
"chars",
"length",
";",
"i",
"+",
"+",
")",
"{",
"new",
"chars",
"[",
"i",
"]",
"=",
"to",
"upper",
"case",
"(",
"chars",
"char",
"at",
"(",
"i",
")",
")",
";",
"}",
"return",
"string",
"value",
"of",
"(",
"new",
"chars",
")",
";",
"}"
] |
[
"determine",
"the",
"media",
"type",
"for",
"the",
"given",
"request",
"and",
"the",
"resource",
"matched",
"to",
"it",
"this",
"implementation",
"tries",
"to",
"determine",
"the",
"media",
"type",
"using",
"one",
"of",
"the",
"following",
"lookups",
"based",
"on",
"the",
"resource",
"filename",
"and",
"its",
"path",
"extension",
":",
"{",
"@",
"link",
"javax",
"servlet",
"servlet",
"context",
"#",
"get",
"mime",
"type",
"(",
"string",
")",
"}",
"{",
"@",
"link",
"#",
"get",
"media",
"types",
"(",
")",
"}",
"{",
"@",
"link",
"media",
"type",
"factory",
"#",
"get",
"media",
"type",
"(",
"string",
")",
"}"
] | [
"protected",
"media",
"type",
"get",
"media",
"type",
"(",
"http",
"servlet",
"request",
"request",
",",
"resource",
"resource",
")",
"{",
"media",
"type",
"result",
"=",
"null",
";",
"string",
"mime",
"type",
"=",
"request",
"get",
"servlet",
"context",
"(",
")",
"get",
"mime",
"type",
"(",
"resource",
"get",
"filename",
"(",
")",
")",
";",
"if",
"(",
"string",
"utils",
"has",
"text",
"(",
"mime",
"type",
")",
")",
"{",
"result",
"=",
"media",
"type",
"parse",
"media",
"type",
"(",
"mime",
"type",
")",
";",
"}",
"if",
"(",
"result",
"=",
"=",
"null",
"|",
"|",
"media",
"type",
"application",
"octet",
"stream",
"equals",
"(",
"result",
")",
")",
"{",
"media",
"type",
"media",
"type",
"=",
"null",
";",
"string",
"filename",
"=",
"resource",
"get",
"filename",
"(",
")",
";",
"string",
"ext",
"=",
"string",
"utils",
"get",
"filename",
"extension",
"(",
"filename",
")",
";",
"if",
"(",
"ext",
"!",
"=",
"null",
")",
"{",
"media",
"type",
"=",
"this",
"media",
"types",
"get",
"(",
"ext",
"to",
"lower",
"case",
"(",
"locale",
"english",
")",
")",
";",
"}",
"if",
"(",
"media",
"type",
"=",
"=",
"null",
")",
"{",
"list",
"<",
"media",
"type",
">",
"media",
"types",
"=",
"media",
"type",
"factory",
"get",
"media",
"types",
"(",
"filename",
")",
";",
"if",
"(",
"!",
"collection",
"utils",
"is",
"empty",
"(",
"media",
"types",
")",
")",
"{",
"media",
"type",
"=",
"media",
"types",
"get",
"(",
"0",
")",
";",
"}",
"}",
"if",
"(",
"media",
"type",
"!",
"=",
"null",
")",
"{",
"result",
"=",
"media",
"type",
";",
"}",
"}",
"return",
"result",
";",
"}"
] |
[
"returns",
"login",
"object"
] | [
"public",
"login",
"context",
"get",
"login",
"(",
")",
"{",
"return",
"login",
";",
"}"
] |
[
"returns",
"the",
"proper",
"move",
"instruction",
"for",
"the",
"given",
"source",
"spec",
"and",
"destination",
"index"
] | [
"private",
"static",
"simple",
"insn",
"move",
"insn",
"for",
"(",
"register",
"spec",
"src",
",",
"int",
"dest",
"index",
")",
"{",
"return",
"dalv",
"insn",
"make",
"move",
"(",
"source",
"position",
"no",
"info",
",",
"register",
"spec",
"make",
"(",
"dest",
"index",
",",
"src",
"get",
"type",
"(",
")",
")",
",",
"src",
")",
";",
"}"
] |
[
"removes",
"the",
"element",
"at",
"position",
"{",
"@",
"code",
"index",
"}",
"normally",
"this",
"method",
"leaves",
"the",
"elements",
"at",
"up",
"to",
"{",
"@",
"code",
"index",
"-",
"1",
"}",
",",
"inclusive",
",",
"untouched",
"under",
"these",
"circumstances",
",",
"it",
"returns",
"{",
"@",
"code",
"null",
"}",
"occasionally",
",",
"in",
"order",
"to",
"maintain",
"the",
"heap",
"invariant",
",",
"it",
"must",
"swap",
"a",
"later",
"element",
"of",
"the",
"list",
"with",
"one",
"before",
"{",
"@",
"code",
"index",
"}",
"under",
"these",
"circumstances",
"it",
"returns",
"a",
"pair",
"of",
"elements",
"as",
"a",
"{",
"@",
"link",
"move",
"desc",
"}",
"the",
"first",
"one",
"is",
"the",
"element",
"that",
"was",
"previously",
"at",
"the",
"end",
"of",
"the",
"heap",
"and",
"is",
"now",
"at",
"some",
"position",
"before",
"{",
"@",
"code",
"index",
"}",
"the",
"second",
"element",
"is",
"the",
"one",
"that",
"was",
"swapped",
"down",
"to",
"replace",
"the",
"element",
"at",
"{",
"@",
"code",
"index",
"}",
"this",
"fact",
"is",
"used",
"by",
"iterator",
"remove",
"so",
"as",
"to",
"visit",
"elements",
"during",
"a",
"traversal",
"once",
"and",
"only",
"once"
] | [
"move",
"desc",
"<",
"e",
">",
"remove",
"at",
"(",
"int",
"index",
")",
"{",
"check",
"position",
"index",
"(",
"index",
",",
"size",
")",
";",
"mod",
"count",
"+",
"+",
";",
"size",
"-",
"-",
";",
"if",
"(",
"size",
"=",
"=",
"index",
")",
"{",
"queue",
"[",
"size",
"]",
"=",
"null",
";",
"return",
"null",
";",
"}",
"e",
"actual",
"last",
"element",
"=",
"element",
"data",
"(",
"size",
")",
";",
"int",
"last",
"element",
"at",
"=",
"heap",
"for",
"index",
"(",
"size",
")",
"swap",
"with",
"conceptually",
"last",
"element",
"(",
"actual",
"last",
"element",
")",
";",
"if",
"(",
"last",
"element",
"at",
"=",
"=",
"index",
")",
"{",
"/",
"/",
"'",
"actual",
"last",
"element",
"'",
"is",
"now",
"at",
"'",
"last",
"element",
"at",
"'",
",",
"and",
"the",
"element",
"that",
"was",
"at",
"'",
"last",
"element",
"at",
"'",
"/",
"/",
"is",
"now",
"at",
"the",
"end",
"of",
"queue",
"if",
"that",
"'",
"s",
"the",
"element",
"we",
"wanted",
"to",
"remove",
"in",
"the",
"first",
"place",
",",
"/",
"/",
"don",
"'",
"t",
"try",
"to",
"(",
"incorrectly",
")",
"trickle",
"it",
"instead",
",",
"just",
"delete",
"it",
"and",
"we",
"'",
"re",
"done",
"queue",
"[",
"size",
"]",
"=",
"null",
";",
"return",
"null",
";",
"}",
"e",
"to",
"trickle",
"=",
"element",
"data",
"(",
"size",
")",
";",
"queue",
"[",
"size",
"]",
"=",
"null",
";",
"move",
"desc",
"<",
"e",
">",
"changes",
"=",
"fill",
"hole",
"(",
"index",
",",
"to",
"trickle",
")",
";",
"if",
"(",
"last",
"element",
"at",
"<",
"index",
")",
"{",
"/",
"/",
"last",
"element",
"is",
"moved",
"to",
"before",
"index",
",",
"swapped",
"with",
"trickled",
"element",
"if",
"(",
"changes",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"the",
"trickled",
"element",
"is",
"still",
"after",
"index",
"return",
"new",
"move",
"desc",
"<",
"e",
">",
"(",
"actual",
"last",
"element",
",",
"to",
"trickle",
")",
";",
"}",
"else",
"{",
"/",
"/",
"the",
"trickled",
"element",
"is",
"back",
"before",
"index",
",",
"but",
"the",
"replaced",
"element",
"/",
"/",
"has",
"now",
"been",
"moved",
"after",
"index",
"return",
"new",
"move",
"desc",
"<",
"e",
">",
"(",
"actual",
"last",
"element",
",",
"changes",
"replaced",
")",
";",
"}",
"}",
"/",
"/",
"trickled",
"element",
"was",
"after",
"index",
"to",
"begin",
"with",
",",
"no",
"adjustment",
"needed",
"return",
"changes",
";",
"}"
] |
[
"write",
"a",
"file",
",",
"read",
"it",
"back",
",",
"validate",
"the",
"dataset",
"overwrites",
"the",
"file",
"if",
"it",
"is",
"present"
] | [
"protected",
"path",
"write",
"then",
"read",
"file",
"(",
"string",
"name",
",",
"int",
"len",
")",
"throws",
"i",
"o",
"exception",
"{",
"path",
"path",
"=",
"path",
"(",
"name",
")",
";",
"write",
"then",
"read",
"file",
"(",
"path",
",",
"len",
")",
";",
"return",
"path",
";",
"}"
] |
[
"tells",
"whether",
"the",
"target",
"was",
"converted",
"with",
"cvtcil"
] | [
"public",
"boolean",
"was",
"converted",
"with",
"cvtcil",
"(",
")",
"{",
"return",
"converted",
"with",
"cvtcil",
";",
"}"
] |
[
"replaces",
"the",
"reference",
"in",
"program",
"1",
"with",
"the",
"reference",
"from",
"the",
"origin",
"program"
] | [
"public",
"reference",
"replace",
"reference",
"(",
"reference",
"result",
"ref",
",",
"reference",
"origin",
"ref",
",",
"long",
"to",
"symbol",
"i",
"d",
")",
"{",
"reference",
"manager",
"rm",
"=",
"result",
"program",
"get",
"reference",
"manager",
"(",
")",
";",
"if",
"(",
"result",
"ref",
"!",
"=",
"null",
")",
"{",
"/",
"/",
"removing",
"ref",
"rm",
"delete",
"(",
"result",
"ref",
")",
";",
"}",
"if",
"(",
"origin",
"ref",
"!",
"=",
"null",
")",
"{",
"address",
"to",
"address",
"=",
"origin",
"to",
"result",
"translator",
"get",
"address",
"(",
"origin",
"ref",
"get",
"to",
"address",
"(",
")",
")",
";",
"symbol",
"result",
"to",
"symbol",
"=",
"result",
"program",
"get",
"symbol",
"table",
"(",
")",
"get",
"symbol",
"(",
"to",
"symbol",
"i",
"d",
")",
";",
"if",
"(",
"result",
"to",
"symbol",
"!",
"=",
"null",
"&",
"&",
"!",
"result",
"to",
"symbol",
"get",
"address",
"(",
")",
"equals",
"(",
"to",
"address",
")",
")",
"{",
"result",
"to",
"symbol",
"=",
"null",
";",
"}",
"result",
"ref",
"=",
"diff",
"utility",
"create",
"reference",
"(",
"origin",
"program",
",",
"origin",
"ref",
",",
"result",
"program",
")",
";",
"if",
"(",
"result",
"to",
"symbol",
"!",
"=",
"null",
")",
"{",
"rm",
"set",
"association",
"(",
"result",
"to",
"symbol",
",",
"result",
"ref",
")",
";",
"}",
"}",
"else",
"{",
"result",
"ref",
"=",
"null",
";",
"}",
"return",
"result",
"ref",
";",
"}"
] |
[
"invoked",
"when",
"{",
"@",
"link",
"hystrix",
"invokable",
"}",
"emits",
"a",
"value"
] | [
"public",
"<",
"t",
">",
"t",
"on",
"emit",
"(",
"hystrix",
"invokable",
"<",
"t",
">",
"command",
"instance",
",",
"t",
"value",
")",
"{",
"return",
"value",
";",
"/",
"/",
"by",
"default",
",",
"just",
"pass",
"through",
"}"
] |
[
"returns",
"the",
"project",
"manager"
] | [
"public",
"default",
"project",
"manager",
"get",
"project",
"manager",
"(",
")",
"{",
"return",
"project",
"manager",
";",
"}"
] |
[
"end",
"the",
"prefix",
"mapping",
"for",
"the",
"given",
"prefix"
] | [
"protected",
"void",
"end",
"prefix",
"mapping",
"(",
"string",
"prefix",
")",
"throws",
"s",
"a",
"x",
"exception",
"{",
"if",
"(",
"get",
"content",
"handler",
"(",
")",
"!",
"=",
"null",
"&",
"&",
"this",
"namespaces",
"contains",
"key",
"(",
"prefix",
")",
")",
"{",
"get",
"content",
"handler",
"(",
")",
"end",
"prefix",
"mapping",
"(",
"prefix",
")",
";",
"this",
"namespaces",
"remove",
"(",
"prefix",
")",
";",
"}",
"}"
] |
[
"deep",
"equality",
"for",
"tuples",
"by",
"calling",
"equals",
"(",
")",
"on",
"the",
"tuple",
"members"
] | [
"public",
"boolean",
"equals",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"this",
"=",
"=",
"o",
")",
"{",
"return",
"true",
";",
"}",
"if",
"(",
"!",
"(",
"o",
"instanceof",
"tuple",
"1",
")",
")",
"{",
"return",
"false",
";",
"}",
"@",
"suppress",
"warnings",
"(",
"\"",
"rawtypes",
"\"",
")",
"tuple",
"1",
"tuple",
"=",
"(",
"tuple",
"1",
")",
"o",
";",
"if",
"(",
"f",
"0",
"!",
"=",
"null",
"?",
"!",
"f",
"0",
"equals",
"(",
"tuple",
"f",
"0",
")",
":",
"tuple",
"f",
"0",
"!",
"=",
"null",
")",
"{",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}"
] |
[
"simulates",
"sending",
"diffs",
"over",
"the",
"wire"
] | [
"public",
"static",
"<",
"t",
"extends",
"writeable",
">",
"t",
"copy",
"instance",
"(",
"t",
"diffs",
",",
"named",
"writeable",
"registry",
"named",
"writeable",
"registry",
",",
"reader",
"<",
"t",
">",
"reader",
")",
"throws",
"i",
"o",
"exception",
"{",
"try",
"(",
"bytes",
"stream",
"output",
"output",
"=",
"new",
"bytes",
"stream",
"output",
"(",
")",
")",
"{",
"diffs",
"write",
"to",
"(",
"output",
")",
";",
"try",
"(",
"stream",
"input",
"in",
"=",
"new",
"named",
"writeable",
"aware",
"stream",
"input",
"(",
"output",
"bytes",
"(",
")",
"stream",
"input",
"(",
")",
",",
"named",
"writeable",
"registry",
")",
")",
"{",
"return",
"reader",
"read",
"(",
"in",
")",
";",
"}",
"}",
"}"
] |
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
] | [
"private",
"string",
"to",
"indented",
"string",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
] |
[
"sets",
"whether",
"to",
"focus",
"the",
"skip",
"button",
"(",
"when",
"available",
")",
"on",
"android",
"tv",
"devices",
"the",
"default",
"setting",
"is",
"{",
"@",
"code",
"true",
"}"
] | [
"public",
"builder",
"set",
"focus",
"skip",
"button",
"when",
"available",
"(",
"boolean",
"focus",
"skip",
"button",
"when",
"available",
")",
"{",
"this",
"focus",
"skip",
"button",
"when",
"available",
"=",
"focus",
"skip",
"button",
"when",
"available",
";",
"return",
"this",
";",
"}"
] |
[
"create",
"the",
"client",
"if",
"the",
"aws",
"stats",
"are",
"not",
"null",
"then",
"a",
"{",
"@",
"link",
"aws",
"statistics",
"collector",
"}",
"is",
"created",
"to",
"bind",
"to",
"the",
"two",
"important",
":",
"until",
"this",
"binding",
"works",
"properly",
"across",
"regions",
",",
"this",
"should",
"be",
"null"
] | [
"public",
"amazon",
"s",
"3",
"create",
"s",
"3",
"client",
"(",
"uri",
"name",
",",
"final",
"string",
"bucket",
",",
"final",
"a",
"w",
"s",
"credentials",
"provider",
"credentials",
",",
"final",
"string",
"user",
"agent",
"suffix",
",",
"final",
"statistics",
"from",
"aws",
"sdk",
"statistics",
"from",
"aws",
"sdk",
")",
"throws",
"i",
"o",
"exception",
"{",
"configuration",
"conf",
"=",
"get",
"conf",
"(",
")",
";",
"final",
"client",
"configuration",
"aws",
"conf",
"=",
"s",
"3",
"a",
"utils",
"create",
"aws",
"conf",
"(",
"conf",
",",
"bucket",
",",
"constants",
"aws",
"service",
"identifier",
"s3",
")",
";",
"/",
"/",
"when",
"experimental",
"aws",
"internal",
"throttling",
"is",
"false",
"/",
"/",
"throttling",
"is",
"explicitly",
"disabled",
"on",
"the",
"s3",
"client",
"so",
"that",
"/",
"/",
"all",
"failures",
"are",
"collected",
"in",
"s3a",
"instrumentation",
",",
"and",
"its",
"/",
"/",
"retry",
"policy",
"is",
"the",
"only",
"one",
"used",
"/",
"/",
"this",
"may",
"cause",
"problems",
"in",
"copy",
"/",
"rename",
"aws",
"conf",
"set",
"use",
"throttle",
"retries",
"(",
"conf",
"get",
"boolean",
"(",
"experimental",
"aws",
"internal",
"throttling",
",",
"experimental",
"aws",
"internal",
"throttling",
"default",
")",
")",
";",
"if",
"(",
"!",
"string",
"utils",
"is",
"empty",
"(",
"user",
"agent",
"suffix",
")",
")",
"{",
"aws",
"conf",
"set",
"user",
"agent",
"suffix",
"(",
"user",
"agent",
"suffix",
")",
";",
"}",
"/",
"/",
"optional",
"metrics",
"request",
"metric",
"collector",
"metrics",
"=",
"statistics",
"from",
"aws",
"sdk",
"!",
"=",
"null",
"?",
"new",
"aws",
"statistics",
"collector",
"(",
"statistics",
"from",
"aws",
"sdk",
")",
":",
"null",
";",
"return",
"new",
"amazon",
"s",
"3",
"client",
"(",
"credentials",
",",
"aws",
"conf",
",",
"metrics",
",",
"conf",
"get",
"trimmed",
"(",
"endpoint",
",",
"\"",
"\"",
")",
",",
"conf",
"get",
"boolean",
"(",
"path",
"style",
"access",
",",
"false",
")",
")",
";",
"}"
] |
[
"inject",
"a",
"tag",
"field",
"to",
"mark",
"the",
"exception",
"should",
"be",
"not",
"thought",
"error",
"status"
] | [
"public",
"void",
"on",
"construct",
"(",
"enhanced",
"instance",
"obj",
"inst",
",",
"object",
"[",
"]",
"all",
"arguments",
")",
"{",
"if",
"(",
"context",
"manager",
"is",
"active",
"(",
")",
")",
"{",
"obj",
"inst",
"set",
"sky",
"walking",
"dynamic",
"field",
"(",
"annotation",
"match",
"exception",
"check",
"strategy",
"class",
"get",
"simple",
"name",
"(",
")",
")",
";",
"}",
"}"
] |
[
"add",
"add",
"unfinalize",
"block",
"op",
"metrics"
] | [
"public",
"void",
"add",
"unfinalize",
"block",
"op",
"(",
"long",
"latency",
")",
"{",
"unfinalize",
"block",
"op",
"add",
"(",
"latency",
")",
";",
"}"
] |
[
"deserialize",
"the",
"state",
"from",
"the",
"byte",
"buffer",
"which",
"stores",
"skip",
"list",
"value"
] | [
"s",
"deserialize",
"state",
"(",
"memory",
"segment",
"memory",
"segment",
",",
"int",
"offset",
",",
"int",
"len",
")",
"{",
"final",
"memory",
"segment",
"input",
"stream",
"with",
"pos",
"src",
"=",
"new",
"memory",
"segment",
"input",
"stream",
"with",
"pos",
"(",
"memory",
"segment",
",",
"offset",
",",
"len",
")",
";",
"final",
"data",
"input",
"view",
"stream",
"wrapper",
"in",
"=",
"new",
"data",
"input",
"view",
"stream",
"wrapper",
"(",
"src",
")",
";",
"try",
"{",
"return",
"state",
"serializer",
"deserialize",
"(",
"in",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"deserialize",
"state",
"failed",
"\"",
",",
"e",
")",
";",
"}",
"}"
] |
[
"get",
"the",
"declared",
"repeatable",
"{",
"@",
"linkplain",
"annotation",
"annotations",
"}",
"of",
"{",
"@",
"code",
"annotation",
"type",
"}",
"from",
"the",
"supplied",
"{",
"@",
"link",
"annotated",
"element",
"}",
",",
"where",
"such",
"annotations",
"are",
"either",
"directly",
"present",
",",
"indirectly",
"present",
",",
"or",
"meta",
"-",
"present",
"on",
"the",
"element",
"this",
"method",
"mimics",
"the",
"functionality",
"of",
"java",
"8",
"'",
"s",
"{",
"@",
"link",
"java",
"lang",
"reflect",
"annotated",
"element",
"#",
"get",
"declared",
"annotations",
"by",
"type",
"(",
"class",
")",
"}",
"with",
"additional",
"support",
"for",
"meta",
"-",
"annotations",
"handles",
"both",
"single",
"annotations",
"and",
"annotations",
"nested",
"within",
"a",
"container",
"annotation",
"correctly",
"handles",
"bridge",
"methods",
"generated",
"by",
"the",
"compiler",
"if",
"the",
"supplied",
"element",
"is",
"a",
"{",
"@",
"link",
"method",
"}",
"meta",
"-",
"annotations",
"will",
"be",
"searched",
"if",
"the",
"annotation",
"is",
"not",
"present",
"on",
"the",
"supplied",
"element"
] | [
"public",
"static",
"<",
"a",
"extends",
"annotation",
">",
"set",
"<",
"a",
">",
"get",
"declared",
"repeatable",
"annotations",
"(",
"annotated",
"element",
"annotated",
"element",
",",
"class",
"<",
"a",
">",
"annotation",
"type",
",",
"@",
"nullable",
"class",
"<",
"?",
"extends",
"annotation",
">",
"container",
"annotation",
"type",
")",
"{",
"repeatable",
"containers",
"repeatable",
"containers",
"=",
"container",
"annotation",
"type",
"!",
"=",
"null",
"?",
"repeatable",
"containers",
"of",
"(",
"annotation",
"type",
",",
"container",
"annotation",
"type",
")",
":",
"repeatable",
"containers",
"standard",
"repeatables",
"(",
")",
";",
"return",
"merged",
"annotations",
"from",
"(",
"annotated",
"element",
",",
"search",
"strategy",
"direct",
",",
"repeatable",
"containers",
")",
"stream",
"(",
"annotation",
"type",
")",
"map",
"(",
"merged",
"annotation",
":",
":",
"with",
"non",
"merged",
"attributes",
")",
"collect",
"(",
"merged",
"annotation",
"collectors",
"to",
"annotation",
"set",
"(",
")",
")",
";",
"}"
] |
[
"encode",
"cases",
"where",
"'",
"g",
"'",
"is",
"silent",
"at",
"beginning",
"of",
"word"
] | [
"boolean",
"encode",
"silent",
"g",
"at",
"beginning",
"(",
")",
"{",
"/",
"/",
"skip",
"these",
"when",
"at",
"start",
"of",
"word",
"if",
"(",
"(",
"m",
"current",
"=",
"=",
"0",
")",
"&",
"&",
"string",
"at",
"(",
"m",
"current",
",",
"2",
",",
"\"",
"gn",
"\"",
",",
"\"",
"\"",
")",
")",
"{",
"m",
"current",
"+",
"=",
"1",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}"
] |
[
"clear",
"the",
"storage",
"space",
"quota",
"(",
"size",
"of",
"files",
")",
"for",
"a",
"directory",
"note",
"that",
"directories",
"and",
"sym",
"links",
"do",
"not",
"occupy",
"storage",
"space"
] | [
"public",
"void",
"clear",
"space",
"quota",
"(",
"path",
"src",
")",
"throws",
"i",
"o",
"exception",
"{",
"dfs",
"set",
"quota",
"(",
"src",
",",
"hdfs",
"constants",
"quota",
"dont",
"set",
",",
"hdfs",
"constants",
"quota",
"reset",
")",
";",
"}"
] |
[
"clears",
"the",
"depth",
"buffer",
"by",
"setting",
"the",
"depth",
"to",
"-",
"1"
] | [
"public",
"void",
"clear",
"(",
")",
"{",
"buffer",
"clear",
"(",
")",
";",
"while",
"(",
"buffer",
"position",
"(",
")",
"<",
"buffer",
"capacity",
"(",
")",
")",
"buffer",
"put",
"(",
"-",
"1",
")",
";",
"}"
] |
[
"adds",
"a",
"lane",
"size"
] | [
"void",
"add",
"lane",
"size",
"(",
"int",
"lane",
"size",
"in",
"bytes",
")",
"{",
"if",
"(",
"(",
"8",
"*",
"num",
"bytes",
")",
"!",
"=",
"bit",
"length",
")",
"{",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
"\"",
"register",
"\"",
"+",
"get",
"name",
"(",
")",
"+",
"\"",
"does",
"not",
"support",
"lanes",
"\"",
")",
";",
"}",
"if",
"(",
"lane",
"size",
"in",
"bytes",
"<",
"=",
"0",
"|",
"|",
"lane",
"size",
"in",
"bytes",
">",
"=",
"num",
"bytes",
"|",
"|",
"(",
"num",
"bytes",
"%",
"lane",
"size",
"in",
"bytes",
")",
"!",
"=",
"0",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"invalid",
"lane",
"size",
":",
"\"",
"+",
"lane",
"size",
"in",
"bytes",
"+",
"\"",
"for",
"register",
"\"",
"+",
"get",
"name",
"(",
")",
")",
";",
"}",
"if",
"(",
"lane",
"sizes",
"=",
"=",
"null",
")",
"{",
"lane",
"sizes",
"=",
"new",
"tree",
"set",
"<",
">",
"(",
")",
";",
"}",
"type",
"flags",
"|",
"=",
"type",
"vector",
";",
"lane",
"sizes",
"add",
"(",
"lane",
"size",
"in",
"bytes",
")",
";",
"}"
] |
[
"return",
"the",
"fit",
"time",
"span",
"by",
"now"
] | [
"public",
"static",
"string",
"get",
"fit",
"time",
"span",
"by",
"now",
"(",
"final",
"long",
"millis",
",",
"final",
"int",
"precision",
")",
"{",
"return",
"get",
"fit",
"time",
"span",
"(",
"millis",
",",
"system",
"current",
"time",
"millis",
"(",
")",
",",
"precision",
")",
";",
"}"
] |
[
"list",
"of",
"requests",
"to",
"be",
"passed",
"to",
"bulk",
"indexing"
] | [
"public",
"list",
"<",
"index",
"request",
">",
"get",
"to",
"index",
"(",
")",
"{",
"return",
"to",
"index",
";",
"}"
] |
[
"returns",
"true",
"if",
"this",
"was",
"created",
"for",
"a",
"restored",
"operator",
",",
"false",
"otherwise",
"restored",
"operators",
"are",
"operators",
"that",
"participated",
"in",
"a",
"previous",
"checkpoint",
",",
"even",
"if",
"they",
"did",
"not",
"emit",
"any",
"state",
"snapshots"
] | [
"public",
"boolean",
"is",
"restored",
"(",
")",
"{",
"return",
"restored",
";",
"}"
] |
[
"returns",
"an",
"immutable",
"multimap",
"containing",
"the",
"given",
"entries",
",",
"in",
"the",
"\"",
"key",
"-",
"grouped",
"\"",
"insertion",
"order",
"described",
"in",
"the",
"<",
"a",
"href",
"=",
"\"",
"#",
"iteration",
"\"",
">",
"class",
"documentation"
] | [
"public",
"static",
"<",
"k",
",",
"v",
">",
"immutable",
"multimap",
"<",
"k",
",",
"v",
">",
"of",
"(",
"k",
"k",
"1",
",",
"v",
"v",
"1",
",",
"k",
"k",
"2",
",",
"v",
"v",
"2",
",",
"k",
"k",
"3",
",",
"v",
"v",
"3",
")",
"{",
"return",
"immutable",
"list",
"multimap",
"of",
"(",
"k",
"1",
",",
"v",
"1",
",",
"k",
"2",
",",
"v",
"2",
",",
"k",
"3",
",",
"v",
"3",
")",
";",
"}"
] |
[
"writes",
"the",
"given",
"record",
"for",
"sorting"
] | [
"public",
"void",
"write",
"record",
"(",
"e",
"record",
")",
"throws",
"i",
"o",
"exception",
",",
"interrupted",
"exception",
"{",
"if",
"(",
"current",
"buffer",
"=",
"=",
"null",
")",
"{",
"this",
"current",
"buffer",
"=",
"this",
"dispatcher",
"take",
"(",
"sort",
"stage",
"read",
")",
";",
"if",
"(",
"!",
"current",
"buffer",
"get",
"buffer",
"(",
")",
"is",
"empty",
"(",
")",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"new",
"buffer",
"is",
"not",
"empty",
"\"",
")",
";",
"}",
"}",
"in",
"memory",
"sorter",
"<",
"e",
">",
"sorter",
"=",
"current",
"buffer",
"get",
"buffer",
"(",
")",
";",
"long",
"occupancy",
"pre",
"write",
"=",
"sorter",
"get",
"occupancy",
"(",
")",
";",
"if",
"(",
"!",
"sorter",
"write",
"(",
"record",
")",
")",
"{",
"long",
"record",
"size",
"=",
"sorter",
"get",
"capacity",
"(",
")",
"-",
"occupancy",
"pre",
"write",
";",
"signal",
"spilling",
"if",
"necessary",
"(",
"record",
"size",
")",
";",
"boolean",
"is",
"large",
"=",
"occupancy",
"pre",
"write",
"=",
"=",
"0",
";",
"if",
"(",
"is",
"large",
")",
"{",
"/",
"/",
"did",
"not",
"fit",
"in",
"a",
"fresh",
"buffer",
",",
"must",
"be",
"large",
"write",
"large",
"(",
"record",
",",
"sorter",
")",
";",
"this",
"current",
"buffer",
"get",
"buffer",
"(",
")",
"reset",
"(",
")",
";",
"}",
"else",
"{",
"this",
"dispatcher",
"send",
"(",
"sort",
"stage",
"sort",
",",
"current",
"buffer",
")",
";",
"this",
"current",
"buffer",
"=",
"null",
";",
"write",
"record",
"(",
"record",
")",
";",
"}",
"}",
"else",
"{",
"long",
"record",
"size",
"=",
"sorter",
"get",
"occupancy",
"(",
")",
"-",
"occupancy",
"pre",
"write",
";",
"signal",
"spilling",
"if",
"necessary",
"(",
"record",
"size",
")",
";",
"}",
"}"
] |
[
"returns",
"whether",
"the",
"given",
"supertype",
"is",
"possibly",
"assignable",
"from",
"the",
"given",
"subtype",
"this",
"takes",
"into",
"account",
"primitiveness",
",",
"int",
"-",
"likeness",
",",
"known",
"-",
"nullness",
",",
"and",
"array",
"dimensions",
",",
"but",
"does",
"not",
"assume",
"anything",
"about",
"class",
"hierarchy",
"other",
"than",
"that",
"the",
"type",
"{",
"@",
"code",
"object",
"}",
"is",
"the",
"supertype",
"of",
"all",
"reference",
"types",
"and",
"all",
"arrays",
"are",
"assignable",
"to",
"{",
"@",
"code",
"serializable",
"}",
"and",
"{",
"@",
"code",
"cloneable",
"}"
] | [
"public",
"static",
"boolean",
"is",
"possibly",
"assignable",
"from",
"(",
"type",
"bearer",
"supertype",
"bearer",
",",
"type",
"bearer",
"subtype",
"bearer",
")",
"{",
"type",
"supertype",
"=",
"supertype",
"bearer",
"get",
"type",
"(",
")",
";",
"type",
"subtype",
"=",
"subtype",
"bearer",
"get",
"type",
"(",
")",
";",
"if",
"(",
"supertype",
"equals",
"(",
"subtype",
")",
")",
"{",
"/",
"/",
"easy",
"out",
"return",
"true",
";",
"}",
"int",
"super",
"bt",
"=",
"supertype",
"get",
"basic",
"type",
"(",
")",
";",
"int",
"sub",
"bt",
"=",
"subtype",
"get",
"basic",
"type",
"(",
")",
";",
"/",
"/",
"treat",
"return",
"types",
"as",
"object",
"for",
"the",
"purposes",
"of",
"this",
"method",
"if",
"(",
"super",
"bt",
"=",
"=",
"type",
"bt",
"addr",
")",
"{",
"supertype",
"=",
"type",
"object",
";",
"super",
"bt",
"=",
"type",
"bt",
"object",
";",
"}",
"if",
"(",
"sub",
"bt",
"=",
"=",
"type",
"bt",
"addr",
")",
"{",
"subtype",
"=",
"type",
"object",
";",
"sub",
"bt",
"=",
"type",
"bt",
"object",
";",
"}",
"if",
"(",
"(",
"super",
"bt",
"!",
"=",
"type",
"bt",
"object",
")",
"|",
"|",
"(",
"sub",
"bt",
"!",
"=",
"type",
"bt",
"object",
")",
")",
"{",
"/",
"*",
"*",
"no",
"two",
"distinct",
"primitive",
"types",
"are",
"assignable",
"in",
"this",
"sense",
",",
"*",
"unless",
"they",
"are",
"both",
"int",
"-",
"like",
"*",
"/",
"return",
"supertype",
"is",
"intlike",
"(",
")",
"&",
"&",
"subtype",
"is",
"intlike",
"(",
")",
";",
"}",
"/",
"/",
"at",
"this",
"point",
",",
"we",
"know",
"both",
"types",
"are",
"reference",
"types",
"if",
"(",
"supertype",
"=",
"=",
"type",
"known",
"null",
")",
"{",
"/",
"*",
"*",
"a",
"known",
"-",
"null",
"supertype",
"is",
"only",
"assignable",
"from",
"another",
"*",
"known",
"-",
"null",
"(",
"handled",
"in",
"the",
"easy",
"out",
"at",
"the",
"top",
"of",
"the",
"*",
"method",
")",
"*",
"/",
"return",
"false",
";",
"}",
"else",
"if",
"(",
"subtype",
"=",
"=",
"type",
"known",
"null",
")",
"{",
"/",
"*",
"*",
"a",
"known",
"-",
"null",
"subtype",
"is",
"in",
"fact",
"assignable",
"to",
"any",
"*",
"reference",
"type",
"*",
"/",
"return",
"true",
";",
"}",
"else",
"if",
"(",
"supertype",
"=",
"=",
"type",
"object",
")",
"{",
"/",
"*",
"*",
"object",
"is",
"assignable",
"from",
"any",
"reference",
"type",
"*",
"/",
"return",
"true",
";",
"}",
"else",
"if",
"(",
"supertype",
"is",
"array",
"(",
")",
")",
"{",
"/",
"/",
"the",
"supertype",
"is",
"an",
"array",
"type",
"if",
"(",
"!",
"subtype",
"is",
"array",
"(",
")",
")",
"{",
"/",
"/",
"the",
"subtype",
"isn",
"'",
"t",
"an",
"array",
",",
"and",
"so",
"can",
"'",
"t",
"be",
"assignable",
"return",
"false",
";",
"}",
"/",
"*",
"*",
"strip",
"off",
"as",
"many",
"matched",
"component",
"types",
"from",
"both",
"*",
"types",
"as",
"possible",
",",
"and",
"check",
"the",
"assignability",
"of",
"the",
"*",
"results",
"*",
"/",
"do",
"{",
"supertype",
"=",
"supertype",
"get",
"component",
"type",
"(",
")",
";",
"subtype",
"=",
"subtype",
"get",
"component",
"type",
"(",
")",
";",
"}",
"while",
"(",
"supertype",
"is",
"array",
"(",
")",
"&",
"&",
"subtype",
"is",
"array",
"(",
")",
")",
";",
"return",
"is",
"possibly",
"assignable",
"from",
"(",
"supertype",
",",
"subtype",
")",
";",
"}",
"else",
"if",
"(",
"subtype",
"is",
"array",
"(",
")",
")",
"{",
"/",
"*",
"*",
"other",
"than",
"object",
"(",
"handled",
"above",
")",
",",
"array",
"types",
"are",
"*",
"assignable",
"only",
"to",
"serializable",
"and",
"cloneable",
"*",
"/",
"return",
"(",
"supertype",
"=",
"=",
"type",
"serializable",
")",
"|",
"|",
"(",
"supertype",
"=",
"=",
"type",
"cloneable",
")",
";",
"}",
"else",
"{",
"/",
"*",
"*",
"all",
"other",
"unequal",
"reference",
"types",
"are",
"considered",
"at",
"*",
"least",
"possibly",
"assignable",
"*",
"/",
"return",
"true",
";",
"}",
"}"
] |
[
"get",
"map",
"boolean"
] | [
"public",
"map",
"<",
"string",
",",
"boolean",
">",
"get",
"map",
"boolean",
"(",
")",
"{",
"return",
"map",
"boolean",
";",
"}"
] |
[
"make",
"sure",
"that",
"when",
"the",
"principal",
"becomes",
"populated",
"changes",
"we",
"return",
"a",
"new",
"hash"
] | [
"public",
"void",
"verify",
"principal",
"affects",
"hash",
"(",
")",
"{",
"val",
"credential",
"=",
"new",
"spnego",
"credential",
"(",
"array",
"utils",
"empty",
"byte",
"array",
")",
";",
"val",
"hash",
"1",
"=",
"credential",
"hash",
"code",
"(",
")",
";",
"val",
"principal",
"=",
"principal",
"factory",
"utils",
"new",
"principal",
"factory",
"(",
")",
"create",
"principal",
"(",
"\"",
"test",
"\"",
")",
";",
"credential",
"set",
"principal",
"(",
"principal",
")",
";",
"val",
"hash",
"2",
"=",
"credential",
"hash",
"code",
"(",
")",
";",
"assert",
"not",
"equals",
"(",
"hash",
"1",
",",
"hash",
"2",
")",
";",
"}"
] |
[
"fake",
"endpoint",
"for",
"testing",
"various",
"parameters",
"가짜",
"엔드",
"포인트",
"fake",
"endpoint",
"for",
"testing",
"various",
"parameters",
"가짜",
"엔드",
"포인트",
"<",
"b",
">",
"400",
"<",
"b",
">",
"-",
"invalid",
"username",
"supplied",
"<",
"b",
">",
"404",
"<",
"b",
">",
"-",
"user",
"not",
"found"
] | [
"public",
"void",
"test",
"endpoint",
"parameters",
"(",
"big",
"decimal",
"number",
",",
"double",
"double",
",",
"string",
"pattern",
"without",
"delimiter",
",",
"byte",
"[",
"]",
"byte",
",",
"integer",
"integer",
",",
"integer",
"int",
"3",
"2",
",",
"long",
"int",
"6",
"4",
",",
"float",
"float",
",",
"string",
"string",
",",
"file",
"binary",
",",
"local",
"date",
"date",
",",
"offset",
"date",
"time",
"date",
"time",
",",
"string",
"password",
",",
"string",
"param",
"callback",
")",
"throws",
"rest",
"client",
"exception",
"{",
"test",
"endpoint",
"parameters",
"with",
"http",
"info",
"(",
"number",
",",
"double",
",",
"pattern",
"without",
"delimiter",
",",
"byte",
",",
"integer",
",",
"int",
"3",
"2",
",",
"int",
"6",
"4",
",",
"float",
",",
"string",
",",
"binary",
",",
"date",
",",
"date",
"time",
",",
"password",
",",
"param",
"callback",
")",
";",
"}"
] |
[
"checks",
"whether",
"the",
"provided",
"status",
"includes",
"the",
"`",
"is",
"last",
"`",
"flag",
",",
"marking",
"this",
"as",
"the",
"last",
"result",
"the",
"consumer",
"will",
"receive"
] | [
"public",
"static",
"boolean",
"is",
"last",
"(",
"@",
"consumer",
"status",
"int",
"status",
")",
"{",
"return",
"(",
"status",
"&",
"consumer",
"is",
"last",
")",
"=",
"=",
"consumer",
"is",
"last",
";",
"}"
] |
[
"build",
"a",
"{",
"@",
"link",
"prepared",
"statement",
"creator",
"}",
"based",
"on",
"the",
"given",
"sql",
"and",
"named",
"parameters",
"note",
":",
"directly",
"called",
"from",
"all",
"{",
"@",
"code",
"query",
"}",
"variants",
"delegates",
"to",
"the",
"common",
"{",
"@",
"link",
"#",
"get",
"prepared",
"statement",
"creator",
"(",
"string",
",",
"sql",
"parameter",
"source",
",",
"consumer",
")",
"}",
"method"
] | [
"protected",
"prepared",
"statement",
"creator",
"get",
"prepared",
"statement",
"creator",
"(",
"string",
"sql",
",",
"sql",
"parameter",
"source",
"param",
"source",
")",
"{",
"return",
"get",
"prepared",
"statement",
"creator",
"(",
"sql",
",",
"param",
"source",
",",
"null",
")",
";",
"}"
] |
[
"waits",
"for",
"the",
"guard",
"to",
"be",
"satisfied",
"waits",
"at",
"most",
"the",
"given",
"time",
"may",
"be",
"called",
"only",
"by",
"a",
"thread",
"currently",
"occupying",
"this",
"monitor"
] | [
"public",
"boolean",
"wait",
"for",
"uninterruptibly",
"(",
"guard",
"guard",
",",
"long",
"time",
",",
"time",
"unit",
"unit",
")",
"{",
"final",
"long",
"timeout",
"nanos",
"=",
"to",
"safe",
"nanos",
"(",
"time",
",",
"unit",
")",
";",
"if",
"(",
"!",
"(",
"(",
"guard",
"monitor",
"=",
"=",
"this",
")",
"&",
"lock",
"is",
"held",
"by",
"current",
"thread",
"(",
")",
")",
")",
"{",
"throw",
"new",
"illegal",
"monitor",
"state",
"exception",
"(",
")",
";",
"}",
"if",
"(",
"guard",
"is",
"satisfied",
"(",
")",
")",
"{",
"return",
"true",
";",
"}",
"boolean",
"signal",
"before",
"waiting",
"=",
"true",
";",
"final",
"long",
"start",
"time",
"=",
"init",
"nano",
"time",
"(",
"timeout",
"nanos",
")",
";",
"boolean",
"interrupted",
"=",
"thread",
"interrupted",
"(",
")",
";",
"try",
"{",
"for",
"(",
"long",
"remaining",
"nanos",
"=",
"timeout",
"nanos",
";",
";",
")",
"{",
"try",
"{",
"return",
"await",
"nanos",
"(",
"guard",
",",
"remaining",
"nanos",
",",
"signal",
"before",
"waiting",
")",
";",
"}",
"catch",
"(",
"interrupted",
"exception",
"interrupt",
")",
"{",
"interrupted",
"=",
"true",
";",
"if",
"(",
"guard",
"is",
"satisfied",
"(",
")",
")",
"{",
"return",
"true",
";",
"}",
"signal",
"before",
"waiting",
"=",
"false",
";",
"remaining",
"nanos",
"=",
"remaining",
"nanos",
"(",
"start",
"time",
",",
"timeout",
"nanos",
")",
";",
"}",
"}",
"}",
"finally",
"{",
"if",
"(",
"interrupted",
")",
"{",
"thread",
"current",
"thread",
"(",
")",
"interrupt",
"(",
")",
";",
"}",
"}",
"}"
] |
[
"get",
"the",
"maximum",
"number",
"of",
"checkpoints",
"retained"
] | [
"public",
"int",
"get",
"max",
"undos",
"(",
")",
"{",
"return",
"max",
"checkpoints",
";",
"}"
] |
[
"this",
"takes",
"care",
"to",
"not",
"expose",
"health",
"checks",
"into",
"wire",
"level",
"logging"
] | [
"client",
"options",
"builder",
"configure",
"options",
"except",
"http",
"logging",
"(",
"client",
"options",
"builder",
"options",
")",
"{",
"options",
"factory",
"(",
"client",
"factory",
")",
"response",
"timeout",
"millis",
"(",
"timeout",
")",
"write",
"timeout",
"millis",
"(",
"timeout",
")",
";",
"customizers",
"for",
"each",
"(",
"c",
"-",
">",
"c",
"accept",
"(",
"options",
")",
")",
";",
"return",
"options",
";",
"}"
] |
[
"query",
"using",
"a",
"prepared",
"statement",
",",
"allowing",
"for",
"a",
"prepared",
"statement",
"creator",
"and",
"a",
"prepared",
"statement",
"setter",
"most",
"other",
"query",
"methods",
"use",
"this",
"method",
",",
"but",
"application",
"code",
"will",
"always",
"work",
"with",
"either",
"a",
"creator",
"or",
"a",
"setter"
] | [
"public",
"<",
"t",
">",
"t",
"query",
"(",
"prepared",
"statement",
"creator",
"psc",
",",
"@",
"nullable",
"final",
"prepared",
"statement",
"setter",
"pss",
",",
"final",
"result",
"set",
"extractor",
"<",
"t",
">",
"rse",
")",
"throws",
"data",
"access",
"exception",
"{",
"assert",
"not",
"null",
"(",
"rse",
",",
"\"",
"result",
"set",
"extractor",
"must",
"not",
"be",
"null",
"\"",
")",
";",
"logger",
"debug",
"(",
"\"",
"executing",
"prepared",
"sql",
"query",
"\"",
")",
";",
"return",
"execute",
"(",
"psc",
",",
"new",
"prepared",
"statement",
"callback",
"<",
"t",
">",
"(",
")",
"{",
"@",
"override",
"@",
"nullable",
"public",
"t",
"do",
"in",
"prepared",
"statement",
"(",
"prepared",
"statement",
"ps",
")",
"throws",
"s",
"q",
"l",
"exception",
"{",
"result",
"set",
"rs",
"=",
"null",
";",
"try",
"{",
"if",
"(",
"pss",
"!",
"=",
"null",
")",
"{",
"pss",
"set",
"values",
"(",
"ps",
")",
";",
"}",
"rs",
"=",
"ps",
"execute",
"query",
"(",
")",
";",
"return",
"rse",
"extract",
"data",
"(",
"rs",
")",
";",
"}",
"finally",
"{",
"jdbc",
"utils",
"close",
"result",
"set",
"(",
"rs",
")",
";",
"if",
"(",
"pss",
"instanceof",
"parameter",
"disposer",
")",
"{",
"(",
"(",
"parameter",
"disposer",
")",
"pss",
")",
"cleanup",
"parameters",
"(",
")",
";",
"}",
"}",
"}",
"}",
",",
"true",
")",
";",
"}"
] |
[
"converts",
"internal",
"class",
"access",
"flags",
"into",
"an",
"external",
"access",
"description"
] | [
"public",
"static",
"string",
"external",
"class",
"access",
"flags",
"(",
"int",
"access",
"flags",
",",
"string",
"prefix",
")",
"{",
"if",
"(",
"access",
"flags",
"=",
"=",
"0",
")",
"{",
"return",
"empty",
"string",
";",
"}",
"string",
"buffer",
"string",
"=",
"new",
"string",
"buffer",
"(",
"50",
")",
";",
"if",
"(",
"(",
"access",
"flags",
"&",
"class",
"constants",
"acc",
"public",
")",
"!",
"=",
"0",
")",
"{",
"string",
"append",
"(",
"prefix",
")",
"append",
"(",
"java",
"constants",
"acc",
"public",
")",
"append",
"(",
"'",
"'",
")",
";",
"}",
"if",
"(",
"(",
"access",
"flags",
"&",
"class",
"constants",
"acc",
"private",
")",
"!",
"=",
"0",
")",
"{",
"/",
"/",
"only",
"in",
"inner",
"classes",
"attributes",
"string",
"append",
"(",
"prefix",
")",
"append",
"(",
"java",
"constants",
"acc",
"private",
")",
"append",
"(",
"'",
"'",
")",
";",
"}",
"if",
"(",
"(",
"access",
"flags",
"&",
"class",
"constants",
"acc",
"protected",
")",
"!",
"=",
"0",
")",
"{",
"/",
"/",
"only",
"in",
"inner",
"classes",
"attributes",
"string",
"append",
"(",
"prefix",
")",
"append",
"(",
"java",
"constants",
"acc",
"protected",
")",
"append",
"(",
"'",
"'",
")",
";",
"}",
"if",
"(",
"(",
"access",
"flags",
"&",
"class",
"constants",
"acc",
"static",
")",
"!",
"=",
"0",
")",
"{",
"/",
"/",
"only",
"in",
"inner",
"classes",
"attributes",
"string",
"append",
"(",
"prefix",
")",
"append",
"(",
"java",
"constants",
"acc",
"static",
")",
"append",
"(",
"'",
"'",
")",
";",
"}",
"if",
"(",
"(",
"access",
"flags",
"&",
"class",
"constants",
"acc",
"final",
")",
"!",
"=",
"0",
")",
"{",
"string",
"append",
"(",
"prefix",
")",
"append",
"(",
"java",
"constants",
"acc",
"final",
")",
"append",
"(",
"'",
"'",
")",
";",
"}",
"if",
"(",
"(",
"access",
"flags",
"&",
"class",
"constants",
"acc",
"annotattion",
")",
"!",
"=",
"0",
")",
"{",
"string",
"append",
"(",
"prefix",
")",
"append",
"(",
"java",
"constants",
"acc",
"annotation",
")",
";",
"}",
"if",
"(",
"(",
"access",
"flags",
"&",
"class",
"constants",
"acc",
"interface",
")",
"!",
"=",
"0",
")",
"{",
"string",
"append",
"(",
"prefix",
")",
"append",
"(",
"java",
"constants",
"acc",
"interface",
")",
"append",
"(",
"'",
"'",
")",
";",
"}",
"else",
"if",
"(",
"(",
"access",
"flags",
"&",
"class",
"constants",
"acc",
"enum",
")",
"!",
"=",
"0",
")",
"{",
"string",
"append",
"(",
"prefix",
")",
"append",
"(",
"java",
"constants",
"acc",
"enum",
")",
"append",
"(",
"'",
"'",
")",
";",
"}",
"else",
"if",
"(",
"(",
"access",
"flags",
"&",
"class",
"constants",
"acc",
"abstract",
")",
"!",
"=",
"0",
")",
"{",
"string",
"append",
"(",
"prefix",
")",
"append",
"(",
"java",
"constants",
"acc",
"abstract",
")",
"append",
"(",
"'",
"'",
")",
";",
"}",
"else",
"if",
"(",
"(",
"access",
"flags",
"&",
"class",
"constants",
"acc",
"synthetic",
")",
"!",
"=",
"0",
")",
"{",
"string",
"append",
"(",
"prefix",
")",
"append",
"(",
"java",
"constants",
"acc",
"synthetic",
")",
"append",
"(",
"'",
"'",
")",
";",
"}",
"return",
"string",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"performs",
"validity",
"checking",
"of",
"the",
"specified",
"package",
"name",
"returns",
"null",
"on",
"success",
"or",
"an",
"error",
"message",
"otherwise"
] | [
"public",
"static",
"string",
"validate",
"package",
"name",
"(",
"string",
"package",
"name",
")",
"{",
"int",
"len",
"=",
"package",
"name",
"length",
"(",
")",
";",
"if",
"(",
"len",
"=",
"=",
"0",
")",
"{",
"/",
"/",
"empty",
"package",
"name",
"(",
"/",
"/",
":",
"foo",
")",
"return",
"null",
";",
"}",
"if",
"(",
"package",
"name",
"char",
"at",
"(",
"0",
")",
"=",
"=",
"'",
"/",
"'",
")",
"{",
"return",
"\"",
"package",
"names",
"may",
"not",
"start",
"with",
"'",
"/",
"'",
"\"",
";",
"}",
"if",
"(",
"!",
"allowed",
"characters",
"in",
"package",
"name",
"matches",
"all",
"of",
"(",
"package",
"name",
")",
")",
"{",
"return",
"package",
"name",
"error",
";",
"}",
"if",
"(",
"package",
"name",
"char",
"at",
"(",
"package",
"name",
"length",
"(",
")",
"-",
"1",
")",
"=",
"=",
"'",
"/",
"'",
")",
"{",
"return",
"\"",
"package",
"names",
"may",
"not",
"end",
"with",
"'",
"/",
"'",
"\"",
";",
"}",
"/",
"/",
"check",
"for",
"empty",
"or",
"dot",
"-",
"only",
"package",
"segment",
"boolean",
"non",
"dot",
"=",
"false",
";",
"boolean",
"last",
"slash",
"=",
"true",
";",
"/",
"/",
"going",
"backward",
"and",
"marking",
"the",
"last",
"character",
"as",
"being",
"a",
"/",
"so",
"we",
"detect",
"/",
"/",
"'",
"'",
"only",
"package",
"segment",
"for",
"(",
"int",
"i",
"=",
"len",
"-",
"1",
";",
"i",
">",
"=",
"-",
"1",
";",
"-",
"-",
"i",
")",
"{",
"char",
"c",
"=",
"(",
"i",
">",
"=",
"0",
")",
"?",
"package",
"name",
"char",
"at",
"(",
"i",
")",
":",
"'",
"/",
"'",
";",
"if",
"(",
"c",
"=",
"=",
"'",
"/",
"'",
")",
"{",
"if",
"(",
"last",
"slash",
")",
"{",
"return",
"\"",
"package",
"names",
"may",
"not",
"contain",
"'",
"/",
"/",
"'",
"path",
"separators",
"\"",
";",
"}",
"if",
"(",
"!",
"non",
"dot",
")",
"{",
"return",
"package",
"name",
"dot",
"error",
";",
"}",
"non",
"dot",
"=",
"false",
";",
"last",
"slash",
"=",
"true",
";",
"}",
"else",
"{",
"if",
"(",
"c",
"!",
"=",
"'",
"'",
")",
"{",
"non",
"dot",
"=",
"true",
";",
"}",
"last",
"slash",
"=",
"false",
";",
"}",
"}",
"return",
"null",
";",
"/",
"/",
"ok",
"}"
] |
[
"returns",
"true",
"if",
"n",
"m",
"token",
"is",
"present",
"in",
"cache"
] | [
"public",
"boolean",
"contains",
"token",
"(",
"string",
"node",
"addr",
")",
"{",
"return",
"nm",
"tokens",
"contains",
"key",
"(",
"node",
"addr",
")",
";",
"}"
] |
[
"starts",
"the",
"test",
"runner",
"on",
"its",
"own",
"thread",
"this",
"will",
"trigger",
"the",
"creation",
"of",
"the",
"player",
",",
"the",
"listener",
"registration",
",",
"the",
"start",
"of",
"the",
"action",
"schedule",
"and",
"the",
"initial",
"set",
"of",
"media",
"items"
] | [
"public",
"exo",
"player",
"test",
"runner",
"start",
"(",
"boolean",
"do",
"prepare",
")",
"{",
"handler",
"post",
"(",
"(",
")",
"-",
">",
"{",
"try",
"{",
"player",
"=",
"player",
"builder",
"set",
"looper",
"(",
"looper",
"my",
"looper",
"(",
")",
")",
"build",
"(",
")",
";",
"player",
"add",
"listener",
"(",
"exo",
"player",
"test",
"runner",
"this",
")",
";",
"if",
"(",
"event",
"listener",
"!",
"=",
"null",
")",
"{",
"player",
"add",
"listener",
"(",
"event",
"listener",
")",
";",
"}",
"if",
"(",
"analytics",
"listener",
"!",
"=",
"null",
")",
"{",
"player",
"add",
"analytics",
"listener",
"(",
"analytics",
"listener",
")",
";",
"}",
"if",
"(",
"pause",
"at",
"end",
"of",
"media",
"items",
")",
"{",
"player",
"set",
"pause",
"at",
"end",
"of",
"media",
"items",
"(",
"true",
")",
";",
"}",
"player",
"play",
"(",
")",
";",
"if",
"(",
"action",
"schedule",
"!",
"=",
"null",
")",
"{",
"action",
"schedule",
"start",
"(",
"player",
",",
"player",
"builder",
"get",
"track",
"selector",
"(",
")",
",",
"/",
"*",
"surface",
"=",
"*",
"/",
"null",
",",
"handler",
",",
"/",
"*",
"callback",
"=",
"*",
"/",
"exo",
"player",
"test",
"runner",
"this",
")",
";",
"}",
"if",
"(",
"initial",
"window",
"index",
"!",
"=",
"c",
"index",
"unset",
")",
"{",
"player",
"seek",
"to",
"(",
"initial",
"window",
"index",
",",
"initial",
"position",
"ms",
")",
";",
"}",
"if",
"(",
"!",
"skip",
"setting",
"media",
"sources",
")",
"{",
"player",
"set",
"media",
"sources",
"(",
"media",
"sources",
",",
"/",
"*",
"reset",
"position",
"=",
"*",
"/",
"false",
")",
";",
"}",
"if",
"(",
"do",
"prepare",
")",
"{",
"player",
"prepare",
"(",
")",
";",
"}",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"handle",
"exception",
"(",
"e",
")",
";",
"}",
"}",
")",
";",
"return",
"this",
";",
"}"
] |
[
"start",
"the",
"computation"
] | [
"public",
"computation",
"call",
"(",
")",
"{",
"if",
"(",
"sigma",
"get",
"value",
"(",
")",
"=",
"=",
"null",
")",
"try",
"{",
"compute",
"(",
"get",
"job",
"name",
"(",
")",
",",
"sigma",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"util",
"out",
"println",
"(",
"\"",
"error",
":",
"got",
"an",
"exception",
"from",
"\"",
"+",
"get",
"job",
"name",
"(",
")",
")",
";",
"e",
"print",
"stack",
"trace",
"(",
"util",
"out",
")",
";",
"}",
"return",
"this",
";",
"}"
] |
[
"sets",
"the",
"progress",
"message",
"within",
"this",
"panel"
] | [
"public",
"synchronized",
"void",
"set",
"message",
"(",
"string",
"message",
")",
"{",
"this",
"message",
"=",
"message",
";",
"if",
"(",
"!",
"is",
"timer",
"running",
")",
"{",
"update",
"timer",
"start",
"(",
")",
";",
"is",
"timer",
"running",
"=",
"true",
";",
"}",
"}"
] |
[
"registers",
"an",
"arbitrary",
"{",
"@",
"link",
"selectable",
"channel",
"}",
",",
"not",
"necessarily",
"created",
"by",
"netty",
",",
"to",
"the",
"{",
"@",
"link",
"selector",
"}",
"of",
"this",
"event",
"loop",
"once",
"the",
"specified",
"{",
"@",
"link",
"selectable",
"channel",
"}",
"is",
"registered",
",",
"the",
"specified",
"{",
"@",
"code",
"task",
"}",
"will",
"be",
"executed",
"by",
"this",
"event",
"loop",
"when",
"the",
"{",
"@",
"link",
"selectable",
"channel",
"}",
"is",
"ready"
] | [
"public",
"void",
"register",
"(",
"final",
"selectable",
"channel",
"ch",
",",
"final",
"int",
"interest",
"ops",
",",
"final",
"nio",
"task",
"<",
"?",
">",
"task",
")",
"{",
"object",
"util",
"check",
"not",
"null",
"(",
"ch",
",",
"\"",
"ch",
"\"",
")",
";",
"if",
"(",
"interest",
"ops",
"=",
"=",
"0",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"interest",
"ops",
"must",
"be",
"non",
"-",
"zero",
"\"",
")",
";",
"}",
"if",
"(",
"(",
"interest",
"ops",
"&",
"~",
"ch",
"valid",
"ops",
"(",
")",
")",
"!",
"=",
"0",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"invalid",
"interest",
"ops",
":",
"\"",
"+",
"interest",
"ops",
"+",
"\"",
"(",
"valid",
"ops",
":",
"\"",
"+",
"ch",
"valid",
"ops",
"(",
")",
"+",
"'",
")",
"'",
")",
";",
"}",
"object",
"util",
"check",
"not",
"null",
"(",
"task",
",",
"\"",
"task",
"\"",
")",
";",
"if",
"(",
"is",
"shutdown",
"(",
")",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"event",
"loop",
"shut",
"down",
"\"",
")",
";",
"}",
"if",
"(",
"in",
"event",
"loop",
"(",
")",
")",
"{",
"register",
"0",
"(",
"ch",
",",
"interest",
"ops",
",",
"task",
")",
";",
"}",
"else",
"{",
"try",
"{",
"/",
"/",
"offload",
"to",
"the",
"event",
"loop",
"as",
"otherwise",
"java",
"nio",
"channels",
"spi",
"abstract",
"selectable",
"channel",
"register",
"/",
"/",
"may",
"block",
"for",
"a",
"long",
"time",
"while",
"trying",
"to",
"obtain",
"an",
"internal",
"lock",
"that",
"may",
"be",
"hold",
"while",
"selecting",
"submit",
"(",
"new",
"runnable",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"run",
"(",
")",
"{",
"register",
"0",
"(",
"ch",
",",
"interest",
"ops",
",",
"task",
")",
";",
"}",
"}",
")",
"sync",
"(",
")",
";",
"}",
"catch",
"(",
"interrupted",
"exception",
"ignore",
")",
"{",
"/",
"/",
"even",
"if",
"interrupted",
"we",
"did",
"schedule",
"it",
"so",
"just",
"mark",
"the",
"thread",
"as",
"interrupted",
"thread",
"current",
"thread",
"(",
")",
"interrupt",
"(",
")",
";",
"}",
"}",
"}"
] |
[
"returns",
"the",
"name",
"of",
"the",
"structure"
] | [
"public",
"string",
"get",
"name",
"(",
")",
"{",
"return",
"\"",
"image",
"thunk",
"data",
"\"",
"+",
"(",
"is",
"6",
"4bit",
"?",
"\"",
"64",
"\"",
":",
"\"",
"32",
"\"",
")",
";",
"}"
] |
[
"parses",
"and",
"returns",
"in",
"an",
"unsigned",
"int",
",",
"the",
"specified",
"-",
"size",
"unsigned",
"integer",
"type",
"value",
"(",
"8",
"or",
"16",
")"
] | [
"public",
"int",
"parse",
"small",
"var",
"sized",
"u",
"int",
"(",
"int",
"size",
")",
"throws",
"pdb",
"exception",
"{",
"switch",
"(",
"size",
")",
"{",
"case",
"8",
":",
"return",
"parse",
"unsigned",
"byte",
"val",
"(",
")",
";",
"case",
"16",
":",
"return",
"parse",
"unsigned",
"short",
"val",
"(",
")",
";",
"}",
"throw",
"new",
"pdb",
"exception",
"(",
"\"",
"bad",
"int",
"size",
"\"",
")",
";",
"}"
] |
[
"decodes",
"all",
"bytes",
"from",
"the",
"input",
"byte",
"array",
"using",
"the",
"{",
"@",
"link",
"base",
"6",
"4",
"}",
"encoding",
"scheme",
",",
"writing",
"the",
"results",
"into",
"a",
"newly",
"-",
"allocated",
"output",
"byte",
"array",
"the",
"returned",
"byte",
"array",
"is",
"of",
"the",
"length",
"of",
"the",
"resulting",
"bytes"
] | [
"public",
"byte",
"[",
"]",
"decode",
"(",
"byte",
"[",
"]",
"src",
")",
"{",
"byte",
"[",
"]",
"dst",
"=",
"new",
"byte",
"[",
"out",
"length",
"(",
"src",
",",
"0",
",",
"src",
"length",
")",
"]",
";",
"int",
"ret",
"=",
"decode",
"0",
"(",
"src",
",",
"0",
",",
"src",
"length",
",",
"dst",
")",
";",
"if",
"(",
"ret",
"!",
"=",
"dst",
"length",
")",
"{",
"dst",
"=",
"arrays",
"copy",
"of",
"(",
"dst",
",",
"ret",
")",
";",
"}",
"return",
"dst",
";",
"}"
] |
[
"parses",
"the",
"specified",
"string",
"as",
"a",
"signed",
"long",
"value",
"using",
"the",
"specified",
"radix",
"the",
"ascii",
"character",
"{",
"@",
"code",
"'",
"-",
"'",
"}",
"(",
"<",
"code",
">",
"'",
"&",
"#",
"92",
";",
"u",
"0",
"0",
"2",
"d",
"'",
"<",
"code",
">",
")",
"is",
"recognized",
"as",
"the",
"minus",
"sign",
"unlike",
"{",
"@",
"link",
"long",
"#",
"parse",
"long",
"(",
"string",
",",
"int",
")",
"}",
",",
"this",
"method",
"returns",
"{",
"@",
"code",
"null",
"}",
"instead",
"of",
"throwing",
"an",
"exception",
"if",
"parsing",
"fails",
"additionally",
",",
"this",
"method",
"only",
"accepts",
"ascii",
"digits",
",",
"and",
"returns",
"{",
"@",
"code",
"null",
"}",
"if",
"non",
"-",
"ascii",
"digits",
"are",
"present",
"in",
"the",
"string",
"note",
"that",
"strings",
"prefixed",
"with",
"ascii",
"{",
"@",
"code",
"'",
"+",
"'",
"}",
"are",
"rejected",
",",
"even",
"under",
"jdk",
"7",
",",
"despite",
"the",
"change",
"to",
"{",
"@",
"link",
"long",
"#",
"parse",
"long",
"(",
"string",
",",
"int",
")",
"}",
"for",
"that",
"version"
] | [
"public",
"static",
"@",
"nullable",
"long",
"try",
"parse",
"(",
"string",
"string",
",",
"int",
"radix",
")",
"{",
"if",
"(",
"check",
"not",
"null",
"(",
"string",
")",
"is",
"empty",
"(",
")",
")",
"{",
"return",
"null",
";",
"}",
"if",
"(",
"radix",
"<",
"character",
"min",
"radix",
"|",
"|",
"radix",
">",
"character",
"max",
"radix",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"radix",
"must",
"be",
"between",
"min",
"radix",
"and",
"max",
"radix",
"but",
"was",
"\"",
"+",
"radix",
")",
";",
"}",
"boolean",
"negative",
"=",
"string",
"char",
"at",
"(",
"0",
")",
"=",
"=",
"'",
"-",
"'",
";",
"int",
"index",
"=",
"negative",
"?",
"1",
":",
"0",
";",
"if",
"(",
"index",
"=",
"=",
"string",
"length",
"(",
")",
")",
"{",
"return",
"null",
";",
"}",
"int",
"digit",
"=",
"ascii",
"digits",
"digit",
"(",
"string",
"char",
"at",
"(",
"index",
"+",
"+",
")",
")",
";",
"if",
"(",
"digit",
"<",
"0",
"|",
"|",
"digit",
">",
"=",
"radix",
")",
"{",
"return",
"null",
";",
"}",
"long",
"accum",
"=",
"-",
"digit",
";",
"long",
"cap",
"=",
"long",
"min",
"value",
"/",
"radix",
";",
"while",
"(",
"index",
"<",
"string",
"length",
"(",
")",
")",
"{",
"digit",
"=",
"ascii",
"digits",
"digit",
"(",
"string",
"char",
"at",
"(",
"index",
"+",
"+",
")",
")",
";",
"if",
"(",
"digit",
"<",
"0",
"|",
"|",
"digit",
">",
"=",
"radix",
"|",
"|",
"accum",
"<",
"cap",
")",
"{",
"return",
"null",
";",
"}",
"accum",
"*",
"=",
"radix",
";",
"if",
"(",
"accum",
"<",
"long",
"min",
"value",
"+",
"digit",
")",
"{",
"return",
"null",
";",
"}",
"accum",
"-",
"=",
"digit",
";",
"}",
"if",
"(",
"negative",
")",
"{",
"return",
"accum",
";",
"}",
"else",
"if",
"(",
"accum",
"=",
"=",
"long",
"min",
"value",
")",
"{",
"return",
"null",
";",
"}",
"else",
"{",
"return",
"-",
"accum",
";",
"}",
"}"
] |
[
"return",
"this",
"pointcut",
"'",
"s",
"expression"
] | [
"public",
"string",
"get",
"expression",
"(",
")",
"{",
"return",
"this",
"expression",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] | [
"public",
"long",
"get",
"min",
"(",
")",
"{",
"return",
"0l",
";",
"}"
] |
[
"to",
"test",
"special",
"tags",
"to",
"test",
"special",
"tags",
"and",
"operation",
"id",
"starting",
"with",
"number"
] | [
"public",
"api",
"response",
"<",
"client",
">",
"call",
"1",
"2",
"3test",
"special",
"tags",
"with",
"http",
"info",
"(",
"client",
"body",
")",
"throws",
"api",
"exception",
"{",
"object",
"local",
"var",
"post",
"body",
"=",
"body",
";",
"/",
"/",
"verify",
"the",
"required",
"parameter",
"'",
"body",
"'",
"is",
"set",
"if",
"(",
"body",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"api",
"exception",
"(",
"400",
",",
"\"",
"missing",
"the",
"required",
"parameter",
"'",
"body",
"'",
"when",
"calling",
"call",
"1",
"2",
"3test",
"special",
"tags",
"\"",
")",
";",
"}",
"/",
"/",
"create",
"path",
"and",
"map",
"variables",
"string",
"local",
"var",
"path",
"=",
"\"",
"/",
"another",
"-",
"fake",
"/",
"dummy",
"\"",
";",
"/",
"/",
"query",
"params",
"list",
"<",
"pair",
">",
"local",
"var",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
"pair",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"header",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"cookie",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"object",
">",
"local",
"var",
"form",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"object",
">",
"(",
")",
";",
"final",
"string",
"[",
"]",
"local",
"var",
"accepts",
"=",
"{",
"\"",
"application",
"/",
"json",
"\"",
"}",
";",
"final",
"string",
"local",
"var",
"accept",
"=",
"api",
"client",
"select",
"header",
"accept",
"(",
"local",
"var",
"accepts",
")",
";",
"final",
"string",
"[",
"]",
"local",
"var",
"content",
"types",
"=",
"{",
"\"",
"application",
"/",
"json",
"\"",
"}",
";",
"final",
"string",
"local",
"var",
"content",
"type",
"=",
"api",
"client",
"select",
"header",
"content",
"type",
"(",
"local",
"var",
"content",
"types",
")",
";",
"string",
"[",
"]",
"local",
"var",
"auth",
"names",
"=",
"new",
"string",
"[",
"]",
"{",
"}",
";",
"generic",
"type",
"<",
"client",
">",
"local",
"var",
"return",
"type",
"=",
"new",
"generic",
"type",
"<",
"client",
">",
"(",
")",
"{",
"}",
";",
"return",
"api",
"client",
"invoke",
"a",
"p",
"i",
"(",
"\"",
"another",
"fake",
"api",
"call",
"1",
"2",
"3test",
"special",
"tags",
"\"",
",",
"local",
"var",
"path",
",",
"\"",
"patch",
"\"",
",",
"local",
"var",
"query",
"params",
",",
"local",
"var",
"post",
"body",
",",
"local",
"var",
"header",
"params",
",",
"local",
"var",
"cookie",
"params",
",",
"local",
"var",
"form",
"params",
",",
"local",
"var",
"accept",
",",
"local",
"var",
"content",
"type",
",",
"local",
"var",
"auth",
"names",
",",
"local",
"var",
"return",
"type",
",",
"false",
")",
";",
"}"
] |
[
"sets",
"the",
"fallback",
"method",
"to",
"reject",
",",
"if",
"the",
"action",
"cannot",
"be",
"executed",
"the",
"application",
"will",
"get",
"rejected"
] | [
"public",
"mapping",
"rule",
"action",
"set",
"fallback",
"reject",
"(",
")",
"{",
"fallback",
"=",
"mapping",
"rule",
"result",
"create",
"reject",
"result",
"(",
")",
";",
"return",
"this",
";",
"}"
] |
[
"get",
"attribute",
"boolean"
] | [
"public",
"boolean",
"is",
"attribute",
"boolean",
"(",
")",
"{",
"return",
"attribute",
"boolean",
";",
"}"
] |
[
"processes",
"plugin",
"-",
"specific",
"arguments",
"and",
"removes",
"them",
"from",
"the",
"args",
"array"
] | [
"static",
"void",
"process",
"plugin",
"args",
"(",
"immutable",
"list",
"<",
"blaze",
"java",
"compiler",
"plugin",
">",
"plugins",
",",
"immutable",
"list",
"<",
"string",
">",
"standard",
"javacopts",
",",
"immutable",
"list",
"<",
"string",
">",
"blaze",
"javacopts",
")",
"throws",
"invalid",
"command",
"line",
"exception",
"{",
"for",
"(",
"blaze",
"java",
"compiler",
"plugin",
"plugin",
":",
"plugins",
")",
"{",
"plugin",
"process",
"args",
"(",
"standard",
"javacopts",
",",
"blaze",
"javacopts",
")",
";",
"}",
"}"
] |
[
"sets",
"the",
"id",
"of",
"the",
"job",
"that",
"the",
"dataflow",
"plan",
"belongs",
"to",
"if",
"this",
"id",
"is",
"set",
"to",
"{",
"@",
"code",
"null",
"}",
",",
"then",
"the",
"dataflow",
"represents",
"its",
"own",
"independent",
"job"
] | [
"public",
"void",
"set",
"job",
"id",
"(",
"job",
"i",
"d",
"job",
"id",
")",
"{",
"this",
"job",
"id",
"=",
"job",
"id",
";",
"}"
] |
[
"called",
"when",
"a",
"vertex",
"is",
"double",
"-",
"clicked"
] | [
"public",
"boolean",
"vertex",
"double",
"clicked",
"(",
"v",
"v",
",",
"vertex",
"mouse",
"info",
"<",
"v",
",",
"e",
">",
"mouse",
"info",
")",
";"
] |
[
"get",
"the",
"git",
"commit",
"hash",
"of",
"the",
"repository",
"when",
"compiled"
] | [
"public",
"static",
"string",
"get",
"revision",
"(",
")",
"{",
"return",
"common",
"version",
"info",
"get",
"revision",
"(",
")",
";",
"}"
] |
[
"compute",
"the",
"median",
"of",
"a",
"sorted",
"list"
] | [
"public",
"static",
"double",
"compute",
"median",
"(",
"list",
"<",
"double",
">",
"sorted",
"values",
")",
"{",
"if",
"(",
"sorted",
"values",
"size",
"(",
")",
"=",
"=",
"0",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"cannot",
"compute",
"the",
"median",
"of",
"an",
"empty",
"list",
"\"",
")",
";",
"}",
"double",
"median",
"=",
"sorted",
"values",
"get",
"(",
"sorted",
"values",
"size",
"(",
")",
"/",
"2",
")",
";",
"if",
"(",
"sorted",
"values",
"size",
"(",
")",
"%",
"2",
"=",
"=",
"0",
")",
"{",
"median",
"+",
"=",
"sorted",
"values",
"get",
"(",
"(",
"sorted",
"values",
"size",
"(",
")",
"/",
"2",
")",
"-",
"1",
")",
";",
"median",
"/",
"=",
"2",
";",
"}",
"return",
"median",
";",
"}"
] |
[
"get",
"sasl",
"wrapped",
"input",
"stream",
"if",
"sasl",
"qo",
"p",
"requires",
"unwrapping",
",",
"otherwise",
"return",
"original",
"stream",
"can",
"be",
"called",
"only",
"after",
"sasl",
"connect",
"(",
")",
"has",
"been",
"called"
] | [
"public",
"input",
"stream",
"get",
"input",
"stream",
"(",
"input",
"stream",
"in",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"use",
"wrap",
"(",
")",
")",
"{",
"in",
"=",
"new",
"wrapped",
"input",
"stream",
"(",
"in",
")",
";",
"}",
"return",
"in",
";",
"}"
] |
[
"set",
"the",
"drag",
"distance",
",",
"it",
"will",
"force",
"set",
"the",
"bottom",
"view",
"'",
"s",
"width",
"or",
"height",
"via",
"this",
"value"
] | [
"public",
"void",
"set",
"drag",
"distance",
"(",
"int",
"max",
")",
"{",
"if",
"(",
"max",
"<",
"0",
")",
"max",
"=",
"0",
";",
"m",
"drag",
"distance",
"=",
"dp",
"2px",
"(",
"max",
")",
";",
"request",
"layout",
"(",
")",
";",
"}"
] |
[
"configures",
"the",
"maximum",
"size"
] | [
"void",
"maximum",
"weight",
"(",
"string",
"key",
",",
"@",
"nullable",
"string",
"value",
")",
"{",
"require",
"argument",
"(",
"maximum",
"weight",
"=",
"=",
"unset",
"int",
",",
"\"",
"maximum",
"weight",
"was",
"already",
"set",
"to",
"%",
",",
"d",
"\"",
",",
"maximum",
"weight",
")",
";",
"require",
"argument",
"(",
"maximum",
"size",
"=",
"=",
"unset",
"int",
",",
"\"",
"maximum",
"size",
"was",
"already",
"set",
"to",
"%",
",",
"d",
"\"",
",",
"maximum",
"size",
")",
";",
"maximum",
"weight",
"=",
"parse",
"long",
"(",
"key",
",",
"value",
")",
";",
"}"
] |
[
"fully",
"create",
"a",
"new",
"bean",
"instance",
"of",
"the",
"given",
"class",
"performs",
"full",
"initialization",
"of",
"the",
"bean",
",",
"including",
"all",
"applicable",
"{",
"@",
"link",
"bean",
"post",
"processor",
"bean",
"post",
"processors",
"}",
"note",
":",
"this",
"is",
"intended",
"for",
"creating",
"a",
"fresh",
"instance",
",",
"populating",
"annotated",
"fields",
"and",
"methods",
"as",
"well",
"as",
"applying",
"all",
"standard",
"bean",
"initialization",
"callbacks",
"it",
"does",
"not",
"imply",
"traditional",
"by",
"-",
"name",
"or",
"by",
"-",
"type",
"autowiring",
"of",
"properties",
";",
"use",
"{",
"@",
"link",
"#",
"create",
"bean",
"(",
"class",
",",
"int",
",",
"boolean",
")",
"}",
"for",
"those",
"purposes"
] | [
"<",
"t",
">",
"t",
"create",
"bean",
"(",
"class",
"<",
"t",
">",
"bean",
"class",
")",
"throws",
"beans",
"exception",
";"
] |
[
"the",
"encoder",
"should",
"not",
"impose",
"an",
"arbitrary",
"limit",
"on",
"the",
"header",
"size",
"if",
"the",
"server",
"has",
"not",
"specified",
"any",
"limit"
] | [
"public",
"void",
"test",
"will",
"encode",
"1",
"6",
"m",
"b",
"header",
"by",
"default",
"(",
")",
"throws",
"http",
"2",
"exception",
"{",
"byte",
"buf",
"buf",
"=",
"unpooled",
"buffer",
"(",
")",
";",
"string",
"big",
"header",
"name",
"=",
"\"",
"x",
"-",
"big",
"-",
"header",
"\"",
";",
"int",
"big",
"header",
"size",
"=",
"1024",
"*",
"1024",
"*",
"16",
";",
"string",
"big",
"header",
"val",
"=",
"new",
"string",
"(",
"new",
"char",
"[",
"big",
"header",
"size",
"]",
")",
"replace",
"(",
"'",
"\\",
"0",
"'",
",",
"'",
"x",
"'",
")",
";",
"http",
"2",
"headers",
"headers",
"in",
"=",
"new",
"default",
"http",
"2",
"headers",
"(",
")",
"add",
"(",
"\"",
"x",
"-",
"big",
"-",
"header",
"\"",
",",
"big",
"header",
"val",
")",
";",
"http",
"2",
"headers",
"headers",
"out",
"=",
"new",
"default",
"http",
"2",
"headers",
"(",
")",
";",
"try",
"{",
"hpack",
"encoder",
"encode",
"headers",
"(",
"0",
",",
"buf",
",",
"headers",
"in",
",",
"http",
"2",
"headers",
"encoder",
"never",
"sensitive",
")",
";",
"hpack",
"decoder",
"set",
"max",
"header",
"list",
"size",
"(",
"big",
"header",
"size",
"+",
"1024",
")",
";",
"hpack",
"decoder",
"decode",
"(",
"0",
",",
"buf",
",",
"headers",
"out",
",",
"false",
")",
";",
"}",
"finally",
"{",
"buf",
"release",
"(",
")",
";",
"}",
"assert",
"equals",
"(",
"headers",
"out",
"get",
"(",
"big",
"header",
"name",
")",
"to",
"string",
"(",
")",
",",
"big",
"header",
"val",
")",
";",
"}"
] |
[
"sets",
"the",
"<",
"code",
">",
"name",
"boolean",
"<",
"code",
">",
"property"
] | [
"public",
"xml",
"item",
"name",
"boolean",
"(",
"boolean",
"name",
"boolean",
")",
"{",
"this",
"name",
"boolean",
"=",
"name",
"boolean",
";",
"return",
"this",
";",
"}"
] |
[
"hook",
"to",
"allow",
"subclasses",
"to",
"add",
"any",
"parameters",
"they",
"would",
"like",
"to",
"expose",
"to",
"fencing",
"implementationsscripts",
"fencing",
"methods",
"are",
"free",
"to",
"use",
"this",
"map",
"as",
"they",
"see",
"fit",
"-",
"-",
"notably",
",",
"the",
"shell",
"script",
"implementation",
"takes",
"each",
"entry",
",",
"prepends",
"'",
"target",
"'",
",",
"substitutes",
"'",
"'",
"for",
"'",
"'",
",",
"and",
"adds",
"it",
"to",
"the",
"environment",
"of",
"the",
"script",
"subclass",
"implementations",
"should",
"be",
"sure",
"to",
"delegate",
"to",
"the",
"superclass",
"implementation",
"as",
"well",
"as",
"adding",
"their",
"own",
"keys"
] | [
"protected",
"void",
"add",
"fencing",
"parameters",
"(",
"map",
"<",
"string",
",",
"string",
">",
"ret",
")",
"{",
"ret",
"put",
"(",
"address",
"subst",
"key",
",",
"string",
"value",
"of",
"(",
"get",
"address",
"(",
")",
")",
")",
";",
"ret",
"put",
"(",
"host",
"subst",
"key",
",",
"get",
"address",
"(",
")",
"get",
"host",
"name",
"(",
")",
")",
";",
"ret",
"put",
"(",
"port",
"subst",
"key",
",",
"string",
"value",
"of",
"(",
"get",
"address",
"(",
")",
"get",
"port",
"(",
")",
")",
")",
";",
"}"
] |
[
"asserts",
"that",
"the",
"default",
"user",
"avatar",
"can",
"be",
"fetched",
"(",
"ie",
"no",
"404",
")"
] | [
"@",
"test",
"public",
"void",
"default",
"user",
"avatar",
"can",
"be",
"fetched",
"(",
")",
"throws",
"exception",
"{",
"user",
"user",
"=",
"user",
"get",
"(",
"\"",
"avatar",
"-",
"user",
"\"",
",",
"true",
")",
";",
"html",
"page",
"page",
"=",
"j",
"create",
"web",
"client",
"(",
")",
"go",
"to",
"(",
"\"",
"user",
"/",
"\"",
"+",
"user",
"get",
"display",
"name",
"(",
")",
")",
";",
"j",
"assert",
"all",
"image",
"load",
"successfully",
"(",
"page",
")",
";",
"}"
] |
[
"find",
"all",
"candidate",
"advisors",
"to",
"use",
"in",
"auto",
"-",
"proxying"
] | [
"protected",
"list",
"<",
"advisor",
">",
"find",
"candidate",
"advisors",
"(",
")",
"{",
"assert",
"state",
"(",
"this",
"advisor",
"retrieval",
"helper",
"!",
"=",
"null",
",",
"\"",
"no",
"bean",
"factory",
"advisor",
"retrieval",
"helper",
"available",
"\"",
")",
";",
"return",
"this",
"advisor",
"retrieval",
"helper",
"find",
"advisor",
"beans",
"(",
")",
";",
"}"
] |
[
"configure",
"the",
"columns",
"in",
"this",
"model",
"with",
"their",
"preferred",
"size"
] | [
"private",
"void",
"set",
"default",
"preferred",
"column",
"sizes",
"(",
")",
"{",
"/",
"/",
"/",
"/",
"unusual",
"code",
"alert",
"!",
"/",
"/",
"the",
"table",
"model",
"wants",
"to",
"resize",
"the",
"columns",
"such",
"that",
"they",
"all",
"get",
"an",
"equal",
"share",
"/",
"/",
"of",
"any",
"available",
"width",
"upon",
"initialization",
"this",
"defeats",
"the",
"preferred",
"size",
"of",
"/",
"/",
"a",
"column",
"if",
"it",
"is",
"specified",
"(",
"which",
"it",
"is",
"usually",
"not",
")",
"to",
"override",
"this",
"badness",
",",
"/",
"/",
"we",
"will",
"set",
"all",
"preferred",
"sizes",
"and",
"then",
"for",
"all",
"columns",
"without",
"a",
"preferred",
"size",
",",
"/",
"/",
"specify",
"a",
"large",
"value",
",",
"which",
"causes",
"java",
"'",
"s",
"layout",
"algorithm",
"to",
"have",
"less",
"remaining",
"/",
"/",
"width",
"to",
"divided",
"amongst",
"all",
"the",
"table",
"columns",
"essentially",
",",
"we",
"need",
"to",
"make",
"the",
"/",
"/",
"total",
"width",
"of",
"all",
"columns",
"larger",
"than",
"the",
"table",
"size",
"we",
"do",
"this",
"by",
"giving",
"large",
"/",
"/",
"default",
"width",
"values",
"/",
"/",
"/",
"/",
"fyi",
",",
"java",
"'",
"s",
"badness",
"happens",
"inside",
"of",
"j",
"table",
"do",
"layout",
"(",
")",
"/",
"/",
"/",
"/",
"to",
"easily",
"specify",
"a",
"preferred",
"size",
"for",
"a",
"column",
",",
"do",
"so",
"in",
"your",
"dynamic",
"table",
"column",
"'",
"s",
"/",
"/",
"get",
"column",
"preferred",
"width",
"(",
")",
"method",
"if",
"your",
"model",
"is",
"not",
"dynamic",
",",
"then",
"you",
"have",
"/",
"/",
"to",
"specify",
"the",
"preferred",
"size",
"manually",
"after",
"you",
"construct",
"your",
"table",
"by",
"grabbing",
"/",
"/",
"its",
"column",
"model",
"/",
"/",
"table",
"model",
"model",
"=",
"table",
"get",
"unwrapped",
"table",
"model",
"(",
")",
";",
"if",
"(",
"!",
"(",
"model",
"instanceof",
"abstract",
"g",
"table",
"model",
"<",
"?",
">",
")",
")",
"{",
"return",
";",
"}",
"abstract",
"g",
"table",
"model",
"<",
"?",
">",
"g",
"model",
"=",
"(",
"abstract",
"g",
"table",
"model",
"<",
"?",
">",
")",
"model",
";",
"list",
"<",
"table",
"column",
">",
"column",
"list",
"=",
"column",
"model",
"get",
"all",
"columns",
"(",
")",
";",
"for",
"(",
"table",
"column",
"col",
":",
"column",
"list",
")",
"{",
"int",
"default",
"preferred",
"=",
"col",
"get",
"preferred",
"width",
"(",
")",
";",
"if",
"(",
"default",
"preferred",
">",
"0",
"&",
"&",
"default",
"preferred",
"!",
"=",
"75",
")",
"{",
"/",
"/",
"honor",
"any",
"saved",
"preferred",
"size",
"(",
"ignoring",
"the",
"magic",
"default",
"value",
"found",
"/",
"/",
"inside",
"of",
"table",
"column",
")",
"col",
"set",
"width",
"(",
"default",
"preferred",
")",
";",
"continue",
";",
"}",
"int",
"preferred",
"=",
"g",
"model",
"get",
"preferred",
"column",
"width",
"(",
"col",
"get",
"model",
"index",
"(",
")",
")",
";",
"if",
"(",
"preferred",
"<",
"15",
")",
"{",
"preferred",
"=",
"large",
"default",
"col",
"width",
";",
"}",
"int",
"size",
"=",
"preferred",
";",
"col",
"set",
"width",
"(",
"size",
")",
";",
"col",
"set",
"preferred",
"width",
"(",
"size",
")",
";",
"}",
"}"
] |
[
"sorts",
"the",
"elements",
"of",
"{",
"@",
"code",
"array",
"}",
"in",
"descending",
"order"
] | [
"public",
"static",
"void",
"sort",
"descending",
"(",
"byte",
"[",
"]",
"array",
")",
"{",
"check",
"not",
"null",
"(",
"array",
")",
";",
"sort",
"descending",
"(",
"array",
",",
"0",
",",
"array",
"length",
")",
";",
"}"
] |
[
"replay",
"the",
"last",
"tuple",
"emitted"
] | [
"public",
"boolean",
"replay",
"(",
"tuple",
"writable",
"val",
")",
"throws",
"i",
"o",
"exception",
"{",
"/",
"/",
"the",
"last",
"emitted",
"tuple",
"might",
"have",
"drawn",
"on",
"an",
"empty",
"source",
";",
"/",
"/",
"it",
"can",
"'",
"t",
"be",
"cleared",
"prematurely",
",",
"b",
"/",
"c",
"there",
"may",
"be",
"more",
"duplicate",
"/",
"/",
"keys",
"in",
"iterator",
"positions",
"<",
"pos",
"assert",
"!",
"first",
";",
"boolean",
"ret",
"=",
"false",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"iters",
"length",
";",
"+",
"+",
"i",
")",
"{",
"if",
"(",
"iters",
"[",
"i",
"]",
"replay",
"(",
"(",
"x",
")",
"val",
"get",
"(",
"i",
")",
")",
")",
"{",
"val",
"set",
"written",
"(",
"i",
")",
";",
"ret",
"=",
"true",
";",
"}",
"}",
"return",
"ret",
";",
"}"
] |
[
"verify",
"the",
"same",
"invocations",
"have",
"been",
"applied",
"to",
"two",
"mocks",
"this",
"is",
"generally",
"not",
"the",
"preferred",
"way",
"test",
"with",
"mockito",
"and",
"should",
"be",
"avoided",
"if",
"possible"
] | [
"public",
"static",
"<",
"t",
">",
"void",
"verify",
"same",
"invocations",
"(",
"t",
"expected",
",",
"t",
"actual",
",",
"invocation",
"arguments",
"adapter",
"argument",
"adapters",
")",
"{",
"list",
"<",
"invocation",
">",
"expected",
"invocations",
"=",
"(",
"(",
"invocation",
"container",
"impl",
")",
"mock",
"util",
"get",
"mock",
"handler",
"(",
"expected",
")",
"get",
"invocation",
"container",
"(",
")",
")",
"get",
"invocations",
"(",
")",
";",
"list",
"<",
"invocation",
">",
"actual",
"invocations",
"=",
"(",
"(",
"invocation",
"container",
"impl",
")",
"mock",
"util",
"get",
"mock",
"handler",
"(",
"actual",
")",
"get",
"invocation",
"container",
"(",
")",
")",
"get",
"invocations",
"(",
")",
";",
"verify",
"same",
"invocations",
"(",
"expected",
"invocations",
",",
"actual",
"invocations",
",",
"argument",
"adapters",
")",
";",
"}"
] |
[
"verify",
"symlinks",
"can",
"be",
"created",
"in",
"encryption",
"zones",
"and",
"that",
"they",
"function",
"properly",
"when",
"the",
"target",
"is",
"in",
"the",
"same",
"or",
"different",
"ez"
] | [
"public",
"void",
"test",
"encryption",
"zones",
"with",
"symlinks",
"(",
")",
"throws",
"exception",
"{",
"/",
"/",
"verify",
"we",
"can",
"create",
"an",
"encryption",
"zone",
"over",
"both",
"link",
"and",
"target",
"final",
"int",
"len",
"=",
"8192",
";",
"final",
"path",
"parent",
"=",
"new",
"path",
"(",
"\"",
"/",
"parent",
"\"",
")",
";",
"final",
"path",
"link",
"parent",
"=",
"new",
"path",
"(",
"parent",
",",
"\"",
"symdir",
"1",
"\"",
")",
";",
"final",
"path",
"target",
"parent",
"=",
"new",
"path",
"(",
"parent",
",",
"\"",
"symdir",
"2",
"\"",
")",
";",
"final",
"path",
"link",
"=",
"new",
"path",
"(",
"link",
"parent",
",",
"\"",
"link",
"\"",
")",
";",
"final",
"path",
"target",
"=",
"new",
"path",
"(",
"target",
"parent",
",",
"\"",
"target",
"\"",
")",
";",
"fs",
"mkdirs",
"(",
"parent",
")",
";",
"dfs",
"admin",
"create",
"encryption",
"zone",
"(",
"parent",
",",
"test",
"key",
",",
"no",
"trash",
")",
";",
"fs",
"mkdirs",
"(",
"link",
"parent",
")",
";",
"fs",
"mkdirs",
"(",
"target",
"parent",
")",
";",
"d",
"f",
"s",
"test",
"util",
"create",
"file",
"(",
"fs",
",",
"target",
",",
"len",
",",
"(",
"short",
")",
"1",
",",
"0x",
"f",
"e",
"e",
"d",
")",
";",
"string",
"content",
"=",
"d",
"f",
"s",
"test",
"util",
"read",
"file",
"(",
"fs",
",",
"target",
")",
";",
"fs",
"create",
"symlink",
"(",
"target",
",",
"link",
",",
"false",
")",
";",
"assert",
"equals",
"(",
"\"",
"contents",
"read",
"from",
"link",
"are",
"not",
"the",
"same",
"as",
"target",
"\"",
",",
"content",
",",
"d",
"f",
"s",
"test",
"util",
"read",
"file",
"(",
"fs",
",",
"link",
")",
")",
";",
"fs",
"delete",
"(",
"parent",
",",
"true",
")",
";",
"/",
"/",
"now",
"let",
"'",
"s",
"test",
"when",
"the",
"symlink",
"and",
"target",
"are",
"in",
"different",
"/",
"/",
"encryption",
"zones",
"fs",
"mkdirs",
"(",
"link",
"parent",
")",
";",
"fs",
"mkdirs",
"(",
"target",
"parent",
")",
";",
"dfs",
"admin",
"create",
"encryption",
"zone",
"(",
"link",
"parent",
",",
"test",
"key",
",",
"no",
"trash",
")",
";",
"dfs",
"admin",
"create",
"encryption",
"zone",
"(",
"target",
"parent",
",",
"test",
"key",
",",
"no",
"trash",
")",
";",
"d",
"f",
"s",
"test",
"util",
"create",
"file",
"(",
"fs",
",",
"target",
",",
"len",
",",
"(",
"short",
")",
"1",
",",
"0x",
"f",
"e",
"e",
"d",
")",
";",
"content",
"=",
"d",
"f",
"s",
"test",
"util",
"read",
"file",
"(",
"fs",
",",
"target",
")",
";",
"fs",
"create",
"symlink",
"(",
"target",
",",
"link",
",",
"false",
")",
";",
"assert",
"equals",
"(",
"\"",
"contents",
"read",
"from",
"link",
"are",
"not",
"the",
"same",
"as",
"target",
"\"",
",",
"content",
",",
"d",
"f",
"s",
"test",
"util",
"read",
"file",
"(",
"fs",
",",
"link",
")",
")",
";",
"fs",
"delete",
"(",
"link",
",",
"true",
")",
";",
"fs",
"delete",
"(",
"target",
",",
"true",
")",
";",
"}"
] |
[
"specify",
"the",
"http",
"server",
"'",
"s",
"port",
"default",
"is",
"8080",
"only",
"applicable",
"for",
"a",
"locally",
"configured",
"http",
"server",
"ignored",
"when",
"the",
"{",
"@",
"link",
"#",
"set",
"server",
"\"",
"server",
"\"",
"}",
"property",
"has",
"been",
"specified"
] | [
"public",
"void",
"set",
"port",
"(",
"int",
"port",
")",
"{",
"this",
"port",
"=",
"port",
";",
"}"
] |
[
"see",
"{",
"@",
"link",
"gif",
"drawable",
"#",
"get",
"duration",
"(",
")",
"}"
] | [
"public",
"int",
"get",
"duration",
"(",
")",
"{",
"return",
"m",
"gif",
"info",
"handle",
"get",
"duration",
"(",
")",
";",
"}"
] |
[
"release",
"resource",
"sets",
"not",
"needed",
"any",
"more",
",",
"otherwise",
"they",
"will",
"waste",
"heap",
"space",
"for",
"the",
"duration",
"of",
"the",
"build",
"this",
"might",
"be",
"called",
"twice",
"when",
"an",
"incremental",
"build",
"falls",
"back",
"to",
"a",
"full",
"one"
] | [
"private",
"void",
"cleanup",
"(",
")",
"{",
"file",
"validity",
"clear",
"(",
")",
";",
"processed",
"inputs",
"=",
"null",
";",
"}"
] |
[
"get",
"the",
"insert",
"string",
"to",
"be",
"used"
] | [
"public",
"string",
"get",
"insert",
"string",
"(",
")",
"{",
"return",
"this",
"insert",
"string",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"status",
"'"
] | [
"public",
"void",
"status",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"status",
"}"
] |
[
"sets",
"the",
"colors",
"that",
"should",
"be",
"used",
"fore",
"this",
"data",
"set",
"colors",
"are",
"reused",
"as",
"soon",
"as",
"the",
"number",
"of",
"entries",
"the",
"data",
"set",
"represents",
"is",
"higher",
"than",
"the",
"size",
"of",
"the",
"colors",
"array",
"if",
"you",
"are",
"using",
"colors",
"from",
"the",
"resources",
",",
"make",
"sure",
"that",
"the",
"colors",
"are",
"already",
"prepared",
"(",
"by",
"calling",
"get",
"resources",
"(",
")",
"get",
"color",
"(",
")",
")",
"before",
"adding",
"them",
"to",
"the",
"data",
"set"
] | [
"public",
"void",
"set",
"colors",
"(",
"list",
"<",
"integer",
">",
"colors",
")",
"{",
"this",
"m",
"colors",
"=",
"colors",
";",
"}"
] |
[
"adds",
"a",
"rule",
"that",
"will",
"cause",
"matching",
"operations",
"to",
"throw",
"connect",
"transport",
"exceptions"
] | [
"public",
"void",
"add",
"fail",
"to",
"send",
"no",
"connect",
"rule",
"(",
"transport",
"service",
"transport",
"service",
",",
"final",
"string",
"blocked",
"actions",
")",
"{",
"add",
"fail",
"to",
"send",
"no",
"connect",
"rule",
"(",
"transport",
"service",
",",
"new",
"hash",
"set",
"<",
">",
"(",
"arrays",
"as",
"list",
"(",
"blocked",
"actions",
")",
")",
")",
";",
"}"
] |
[
"find",
"relative",
"distance",
"between",
"an",
"old",
"and",
"new",
"set",
"of",
"points"
] | [
"private",
"static",
"double",
"find",
"scale",
"(",
"@",
"non",
"null",
"point",
"f",
"[",
"]",
"from",
",",
"@",
"non",
"null",
"point",
"f",
"[",
"]",
"to",
")",
"{",
"float",
"original",
"d",
"2",
"=",
"get",
"distance",
"squared",
"(",
"from",
"[",
"0",
"]",
",",
"from",
"[",
"1",
"]",
")",
";",
"float",
"new",
"d",
"2",
"=",
"get",
"distance",
"squared",
"(",
"to",
"[",
"0",
"]",
",",
"to",
"[",
"1",
"]",
")",
";",
"return",
"math",
"sqrt",
"(",
"new",
"d",
"2",
"/",
"original",
"d",
"2",
")",
";",
"}"
] |
[
"set",
"the",
"disabled",
"administrative",
"monitors"
] | [
"public",
"void",
"set",
"disabled",
"administrative",
"monitors",
"(",
"set",
"<",
"string",
">",
"disabled",
"administrative",
"monitors",
")",
"{",
"synchronized",
"(",
"this",
"disabled",
"administrative",
"monitors",
")",
"{",
"this",
"disabled",
"administrative",
"monitors",
"clear",
"(",
")",
";",
"this",
"disabled",
"administrative",
"monitors",
"add",
"all",
"(",
"disabled",
"administrative",
"monitors",
")",
";",
"}",
"}",
"/",
"*",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"*",
"implementation",
"provided",
"*",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"=",
"*",
"/"
] |
[
"returns",
"true",
"if",
"this",
"segment",
"is",
"pure"
] | [
"public",
"boolean",
"is",
"pure",
"(",
")",
"{",
"return",
"(",
"flagword",
"&",
"flag",
"pure",
")",
"!",
"=",
"0",
";",
"}"
] |
[
"adds",
",",
"to",
"the",
"existing",
"information",
",",
"field",
"(",
"s",
")",
"that",
"are",
"read",
"in",
"the",
"source",
"record",
"(",
"s",
")",
"from",
"the",
"first",
"input"
] | [
"public",
"void",
"add",
"read",
"fields",
"(",
"int",
"input",
",",
"field",
"set",
"read",
"fields",
")",
"{",
"if",
"(",
"input",
"!",
"=",
"0",
"&",
"&",
"input",
"!",
"=",
"1",
")",
"{",
"throw",
"new",
"index",
"out",
"of",
"bounds",
"exception",
"(",
")",
";",
"}",
"else",
"if",
"(",
"input",
"=",
"=",
"0",
")",
"{",
"this",
"read",
"fields",
"1",
"=",
"(",
"this",
"read",
"fields",
"1",
"=",
"=",
"null",
")",
"?",
"read",
"fields",
"clone",
"(",
")",
":",
"this",
"read",
"fields",
"1",
"add",
"fields",
"(",
"read",
"fields",
")",
";",
"}",
"else",
"{",
"this",
"read",
"fields",
"2",
"=",
"(",
"this",
"read",
"fields",
"2",
"=",
"=",
"null",
")",
"?",
"read",
"fields",
"clone",
"(",
")",
":",
"this",
"read",
"fields",
"2",
"add",
"fields",
"(",
"read",
"fields",
")",
";",
"}",
"}"
] |
[
"returns",
"true",
"if",
"this",
"symbol",
"defines",
"a",
"file"
] | [
"public",
"boolean",
"is",
"file",
"(",
")",
"{",
"return",
"get",
"type",
"(",
")",
"=",
"=",
"stt",
"file",
";",
"}"
] |
[
"renews",
"a",
"delegation",
"token",
"from",
"the",
"server",
"end",
"-",
"point",
"using",
"the",
"configured",
"<",
"code",
">",
"authenticator",
"<",
"code",
">",
"for",
"authentication"
] | [
"public",
"long",
"renew",
"delegation",
"token",
"(",
"url",
"url",
",",
"token",
"token",
")",
"throws",
"i",
"o",
"exception",
",",
"authentication",
"exception",
"{",
"return",
"renew",
"delegation",
"token",
"(",
"url",
",",
"token",
",",
"null",
")",
";",
"}"
] |
[
"a",
"shortcut",
"for",
"{",
"@",
"link",
"#",
"wait",
"for",
"active",
"shards",
"(",
"active",
"shard",
"count",
")",
"}",
"where",
"the",
"numerical",
"shard",
"count",
"is",
"passed",
"in",
",",
"instead",
"of",
"having",
"to",
"first",
"call",
"{",
"@",
"link",
"active",
"shard",
"count",
"#",
"from",
"(",
"int",
")",
"}",
"to",
"get",
"the",
"active",
"shard",
"count"
] | [
"public",
"open",
"index",
"request",
"wait",
"for",
"active",
"shards",
"(",
"final",
"int",
"wait",
"for",
"active",
"shards",
")",
"{",
"return",
"wait",
"for",
"active",
"shards",
"(",
"active",
"shard",
"count",
"from",
"(",
"wait",
"for",
"active",
"shards",
")",
")",
";",
"}"
] |
[
"get",
"a",
"file",
"name",
"based",
"on",
"a",
"file",
"index"
] | [
"public",
"string",
"get",
"file",
"by",
"index",
"(",
"int",
"index",
")",
"{",
"if",
"(",
"index",
"<",
"0",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"negative",
"file",
"index",
"was",
"given",
"\"",
")",
";",
"}",
"if",
"(",
"this",
"line",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"return",
"this",
"line",
"get",
"file",
"(",
"index",
",",
"this",
"comp",
"dir",
")",
";",
"}"
] |
[
"clean",
"up",
"the",
"child",
"procress",
"and",
"socket"
] | [
"void",
"cleanup",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"server",
"socket",
"close",
"(",
")",
";",
"try",
"{",
"downlink",
"close",
"(",
")",
";",
"}",
"catch",
"(",
"interrupted",
"exception",
"ie",
")",
"{",
"thread",
"current",
"thread",
"(",
")",
"interrupt",
"(",
")",
";",
"}",
"}"
] |
[
"tests",
"two",
"adjacent",
"watermarks",
"can",
"be",
"processed",
"successfully"
] | [
"public",
"void",
"test",
"watermark",
"only",
"(",
")",
"{",
"final",
"stream",
"element",
"queue",
"<",
"integer",
">",
"queue",
"=",
"create",
"stream",
"element",
"queue",
"(",
"2",
")",
";",
"put",
"successfully",
"(",
"queue",
",",
"new",
"watermark",
"(",
"2l",
")",
")",
";",
"put",
"successfully",
"(",
"queue",
",",
"new",
"watermark",
"(",
"5l",
")",
")",
";",
"assert",
"assert",
"equals",
"(",
"2",
",",
"queue",
"size",
"(",
")",
")",
";",
"assert",
"assert",
"false",
"(",
"queue",
"is",
"empty",
"(",
")",
")",
";",
"assert",
"assert",
"equals",
"(",
"arrays",
"as",
"list",
"(",
"new",
"watermark",
"(",
"2l",
")",
",",
"new",
"watermark",
"(",
"5l",
")",
")",
",",
"pop",
"completed",
"(",
"queue",
")",
")",
";",
"assert",
"assert",
"equals",
"(",
"0",
",",
"queue",
"size",
"(",
")",
")",
";",
"assert",
"assert",
"true",
"(",
"queue",
"is",
"empty",
"(",
")",
")",
";",
"assert",
"assert",
"equals",
"(",
"collections",
"empty",
"list",
"(",
")",
",",
"pop",
"completed",
"(",
"queue",
")",
")",
";",
"}"
] |
[
"return",
"this",
"node",
"'",
"s",
"parent"
] | [
"public",
"node",
"get",
"parent",
"(",
")",
"{",
"return",
"parent",
";",
"}"
] |
[
"saves",
"the",
"current",
"state",
"of",
"the",
"chart",
"to",
"the",
"gallery",
"as",
"a",
"png",
"image",
"note",
":",
"needs",
"permission",
"write",
"external",
"storage"
] | [
"public",
"boolean",
"save",
"to",
"gallery",
"(",
"string",
"file",
"name",
")",
"{",
"return",
"save",
"to",
"gallery",
"(",
"file",
"name",
",",
"\"",
"\"",
",",
"\"",
"m",
"p",
"android",
"chart",
"-",
"library",
"save",
"\"",
",",
"bitmap",
"compress",
"format",
"png",
",",
"40",
")",
";",
"}"
] |
[
"creates",
"a",
"{",
"@",
"link",
"file",
"output",
"stream",
"}",
"and",
"writes",
"the",
"bytes",
"to",
"the",
"output",
"location"
] | [
"void",
"write",
"to",
"output",
"location",
"(",
"string",
"output",
"path",
"string",
",",
"byte",
"[",
"]",
"content",
")",
"throws",
"i",
"o",
"exception",
";"
] |
[
"returns",
"a",
"local",
"file",
"that",
"the",
"user",
"can",
"write",
"output",
"to",
"the",
"caller",
"provides",
"both",
"the",
"eventual",
"fs",
"target",
"name",
"and",
"the",
"local",
"working",
"file",
"if",
"the",
"fs",
"is",
"local",
",",
"we",
"write",
"directly",
"into",
"the",
"target",
"if",
"the",
"fs",
"is",
"remote",
",",
"we",
"write",
"into",
"the",
"tmp",
"local",
"area"
] | [
"public",
"path",
"start",
"local",
"output",
"(",
"path",
"fs",
"output",
"file",
",",
"path",
"tmp",
"local",
"file",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"fs",
"start",
"local",
"output",
"(",
"fs",
"output",
"file",
",",
"tmp",
"local",
"file",
")",
";",
"}"
] |
[
"check",
"whether",
"the",
"given",
"method",
"is",
"declared",
"on",
"any",
"of",
"the",
"given",
"interfaces"
] | [
"private",
"static",
"boolean",
"implements",
"interface",
"(",
"method",
"method",
",",
"set",
"<",
"class",
"<",
"?",
">",
">",
"ifcs",
")",
"{",
"for",
"(",
"class",
"<",
"?",
">",
"ifc",
":",
"ifcs",
")",
"{",
"if",
"(",
"class",
"utils",
"has",
"method",
"(",
"ifc",
",",
"method",
")",
")",
"{",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.