docstring_tokens
sequence | code_tokens
sequence |
|---|---|
[
"show",
"the",
"mock",
"namenode",
"as",
"active"
] | [
"public",
"void",
"transition",
"to",
"active",
"(",
")",
"{",
"this",
"ha",
"state",
"=",
"h",
"a",
"service",
"state",
"active",
";",
"}"
] |
[
"this",
"is",
"populated",
"when",
"the",
"previous",
"incremental",
"mesh",
"config",
"responses",
"failed",
"to",
"update",
"configuration",
"the",
"message",
"field",
"in",
"error",
"details",
"provides",
"the",
"client",
"internal",
"exception",
"related",
"to",
"the",
"failure",
"<",
"code",
">",
"google",
"rpc",
"status",
"error",
"detail",
"=",
"5",
";",
"<",
"code",
">"
] | [
"com",
"google",
"rpc",
"status",
"or",
"builder",
"get",
"error",
"detail",
"or",
"builder",
"(",
")",
";"
] |
[
"list",
"all",
"the",
"providers",
"'",
"names"
] | [
"public",
"string",
"list",
"provider",
"names",
"(",
")",
"{",
"return",
"providers",
"stream",
"(",
")",
"map",
"(",
"provider",
"-",
">",
"provider",
"get",
"class",
"(",
")",
"get",
"simple",
"name",
"(",
")",
"+",
"'",
"'",
")",
"collect",
"(",
"collectors",
"joining",
"(",
")",
")",
";",
"}"
] |
[
"returns",
"folder",
"name"
] | [
"public",
"string",
"get",
"name",
"(",
")",
"{",
"return",
"name",
";",
"}"
] |
[
"just",
"for",
"unit",
"test"
] | [
"curator",
"framework",
"get",
"client",
"(",
")",
"{",
"return",
"client",
";",
"}"
] |
[
"returns",
"a",
"converter",
"based",
"on",
"separate",
"forward",
"and",
"backward",
"functions",
"this",
"is",
"useful",
"if",
"the",
"function",
"instances",
"already",
"exist",
",",
"or",
"so",
"that",
"you",
"can",
"supply",
"lambda",
"expressions",
"if",
"those",
"circumstances",
"don",
"'",
"t",
"apply",
",",
"you",
"probably",
"don",
"'",
"t",
"need",
"to",
"use",
"this",
";",
"subclass",
"{",
"@",
"code",
"converter",
"}",
"and",
"implement",
"its",
"{",
"@",
"link",
"#",
"do",
"forward",
"}",
"and",
"{",
"@",
"link",
"#",
"do",
"backward",
"}",
"methods",
"directly",
"these",
"functions",
"will",
"never",
"be",
"passed",
"{",
"@",
"code",
"null",
"}",
"and",
"must",
"not",
"under",
"any",
"circumstances",
"return",
"{",
"@",
"code",
"null",
"}",
"if",
"a",
"value",
"cannot",
"be",
"converted",
",",
"the",
"function",
"should",
"throw",
"an",
"unchecked",
"exception",
"(",
"typically",
",",
"but",
"not",
"necessarily",
",",
"{",
"@",
"link",
"illegal",
"argument",
"exception",
"}",
")",
"the",
"returned",
"converter",
"is",
"serializable",
"if",
"both",
"provided",
"functions",
"are"
] | [
"public",
"static",
"<",
"a",
",",
"b",
">",
"converter",
"<",
"a",
",",
"b",
">",
"from",
"(",
"function",
"<",
"?",
"super",
"a",
",",
"?",
"extends",
"b",
">",
"forward",
"function",
",",
"function",
"<",
"?",
"super",
"b",
",",
"?",
"extends",
"a",
">",
"backward",
"function",
")",
"{",
"return",
"new",
"function",
"based",
"converter",
"<",
">",
"(",
"forward",
"function",
",",
"backward",
"function",
")",
";",
"}"
] |
[
"check",
"if",
"the",
"set",
"contains",
"given",
"element"
] | [
"public",
"boolean",
"contains",
"(",
"final",
"object",
"key",
")",
"{",
"return",
"get",
"element",
"(",
"(",
"t",
")",
"key",
")",
"!",
"=",
"null",
";",
"}"
] |
[
"cancels",
"all",
"current",
"and",
"pending",
"updates",
"to",
"the",
"model",
"waits",
"until",
"all",
"updates",
"have",
"been",
"cancelled"
] | [
"public",
"void",
"cancel",
"all",
"updates",
"(",
")",
"{",
"if",
"(",
"worker",
"!",
"=",
"null",
")",
"{",
"worker",
"clear",
"all",
"jobs",
"with",
"interrupt",
"i",
"know",
"the",
"risks",
"(",
")",
";",
"}",
"update",
"manager",
"cancel",
"all",
"jobs",
"(",
")",
";",
"}"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"returns",
"an",
"entry",
"with",
"a",
"key",
"less",
"than",
"the",
"keys",
"of",
"the",
"{",
"@",
"link",
"#",
"samples",
"(",
")",
"}",
"and",
"less",
"than",
"the",
"key",
"of",
"{",
"@",
"link",
"#",
"below",
"samples",
"greater",
"(",
")",
"}"
] | [
"entry",
"<",
"k",
",",
"v",
">",
"below",
"samples",
"lesser",
"(",
")",
";"
] |
[
"returns",
"the",
"original",
"element",
"list",
",",
"unchanged"
] | [
"public",
"list",
"<",
"float",
">",
"order",
"(",
"list",
"<",
"float",
">",
"insertion",
"order",
")",
"{",
"return",
"insertion",
"order",
";",
"}"
] |
[
"check",
"whether",
"given",
"resource",
"entry",
"can",
"pass",
"with",
"provided",
"count"
] | [
"boolean",
"can",
"pass",
"(",
"node",
"node",
",",
"int",
"acquire",
"count",
")",
";"
] |
[
"removes",
"the",
"node",
"entirely",
"this",
"is",
"the",
"same",
"as",
"{",
"@",
"code",
"add",
"(",
"node",
",",
"0",
")",
"}"
] | [
"public",
"synchronized",
"void",
"remove",
"(",
"t",
"node",
")",
"{",
"add",
"(",
"node",
",",
"0",
")",
";",
"}"
] |
[
"returns",
"a",
"hash",
"code",
"value",
"for",
"the",
"object",
"this",
"method",
"is",
"supported",
"for",
"the",
"benefit",
"of",
"hash",
"tables",
"such",
"as",
"those",
"provided",
"by",
"{",
"@",
"link",
"hash",
"map",
"}"
] | [
"public",
"int",
"hash",
"code",
"(",
")",
"{",
"return",
"super",
"hash",
"code",
"(",
")",
";",
"}"
] |
[
"gets",
"all",
"the",
"processors",
"of",
"the",
"given",
"type",
"from",
"within",
"a",
"pipeline"
] | [
"public",
"<",
"p",
"extends",
"processor",
">",
"list",
"<",
"p",
">",
"get",
"processors",
"in",
"pipeline",
"(",
"string",
"pipeline",
"id",
",",
"class",
"<",
"p",
">",
"clazz",
")",
"{",
"pipeline",
"pipeline",
"=",
"get",
"pipeline",
"(",
"pipeline",
"id",
")",
";",
"if",
"(",
"pipeline",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"pipeline",
"with",
"id",
"[",
"\"",
"+",
"pipeline",
"id",
"+",
"\"",
"]",
"does",
"not",
"exist",
"\"",
")",
";",
"}",
"list",
"<",
"p",
">",
"processors",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"for",
"(",
"processor",
"processor",
":",
"pipeline",
"flatten",
"all",
"processors",
"(",
")",
")",
"{",
"if",
"(",
"clazz",
"is",
"assignable",
"from",
"(",
"processor",
"get",
"class",
"(",
")",
")",
")",
"{",
"processors",
"add",
"(",
"clazz",
"cast",
"(",
"processor",
")",
")",
";",
"}",
"while",
"(",
"processor",
"instanceof",
"wrapping",
"processor",
")",
"{",
"wrapping",
"processor",
"wrapping",
"processor",
"=",
"(",
"wrapping",
"processor",
")",
"processor",
";",
"if",
"(",
"clazz",
"is",
"assignable",
"from",
"(",
"wrapping",
"processor",
"get",
"inner",
"processor",
"(",
")",
"get",
"class",
"(",
")",
")",
")",
"{",
"processors",
"add",
"(",
"clazz",
"cast",
"(",
"wrapping",
"processor",
"get",
"inner",
"processor",
"(",
")",
")",
")",
";",
"}",
"processor",
"=",
"wrapping",
"processor",
"get",
"inner",
"processor",
"(",
")",
";",
"/",
"/",
"break",
"in",
"the",
"case",
"of",
"self",
"referencing",
"processors",
"in",
"the",
"event",
"a",
"processor",
"author",
"creates",
"a",
"/",
"/",
"wrapping",
"processor",
"that",
"has",
"its",
"inner",
"processor",
"refer",
"to",
"itself",
"if",
"(",
"wrapping",
"processor",
"=",
"=",
"processor",
")",
"{",
"break",
";",
"}",
"}",
"}",
"return",
"processors",
";",
"}"
] |
[
"get",
"a",
"required",
"counter",
"statistic"
] | [
"private",
"static",
"<",
"e",
">",
"e",
"lookup",
"statistic",
"(",
"final",
"string",
"type",
",",
"final",
"string",
"key",
",",
"final",
"map",
"<",
"string",
",",
"e",
">",
"map",
")",
"{",
"final",
"e",
"statistic",
"=",
"map",
"get",
"(",
"key",
")",
";",
"assert",
"that",
"(",
"statistic",
")",
"described",
"as",
"(",
"\"",
"%",
"s",
"named",
"%",
"s",
"\"",
",",
"type",
",",
"key",
")",
"is",
"not",
"null",
"(",
")",
";",
"return",
"statistic",
";",
"}"
] |
[
"trigger",
"cancellation",
"of",
"this",
"scheduled",
"task"
] | [
"public",
"void",
"cancel",
"(",
")",
"{",
"scheduled",
"future",
"<",
"?",
">",
"future",
"=",
"this",
"future",
";",
"if",
"(",
"future",
"!",
"=",
"null",
")",
"{",
"future",
"cancel",
"(",
"true",
")",
";",
"}",
"}"
] |
[
"the",
"{",
"@",
"link",
"most",
"recent",
"iterator",
"}",
"return",
"is",
"not",
"thread",
"safe",
"in",
"other",
"words",
"don",
"'",
"t",
"call",
"{",
"@",
"link",
"most",
"recent",
"iterator",
"#",
"has",
"next",
"(",
")",
"}",
"in",
"one",
"thread",
"expect",
"{",
"@",
"link",
"most",
"recent",
"iterator",
"#",
"next",
"(",
")",
"}",
"called",
"from",
"a",
"different",
"thread",
"to",
"work"
] | [
"public",
"most",
"recent",
"iterator",
"get",
"iterable",
"(",
")",
"{",
"return",
"new",
"most",
"recent",
"iterator",
"(",
")",
";",
"}"
] |
[
"sets",
"the",
"null",
"literal",
"string",
"that",
"is",
"interpreted",
"as",
"a",
"null",
"value",
"(",
"disabled",
"by",
"default",
")"
] | [
"public",
"csv",
"null",
"literal",
"(",
"string",
"null",
"literal",
")",
"{",
"preconditions",
"check",
"not",
"null",
"(",
"null",
"literal",
")",
";",
"internal",
"properties",
"put",
"string",
"(",
"format",
"null",
"literal",
",",
"null",
"literal",
")",
";",
"return",
"this",
";",
"}"
] |
[
"decorates",
"the",
"remapping",
"function",
"to",
"record",
"statistics",
"if",
"enabled"
] | [
"default",
"<",
"t",
",",
"r",
">",
"function",
"<",
"?",
"super",
"t",
",",
"?",
"extends",
"r",
">",
"stats",
"aware",
"(",
"function",
"<",
"?",
"super",
"t",
",",
"?",
"extends",
"r",
">",
"mapping",
"function",
",",
"boolean",
"record",
"load",
")",
"{",
"if",
"(",
"!",
"is",
"recording",
"stats",
"(",
")",
")",
"{",
"return",
"mapping",
"function",
";",
"}",
"return",
"key",
"-",
">",
"{",
"r",
"value",
";",
"stats",
"counter",
"(",
")",
"record",
"misses",
"(",
"1",
")",
";",
"long",
"start",
"time",
"=",
"stats",
"ticker",
"(",
")",
"read",
"(",
")",
";",
"try",
"{",
"value",
"=",
"mapping",
"function",
"apply",
"(",
"key",
")",
";",
"}",
"catch",
"(",
"runtime",
"exception",
"|",
"error",
"e",
")",
"{",
"stats",
"counter",
"(",
")",
"record",
"load",
"failure",
"(",
"stats",
"ticker",
"(",
")",
"read",
"(",
")",
"-",
"start",
"time",
")",
";",
"throw",
"e",
";",
"}",
"long",
"load",
"time",
"=",
"stats",
"ticker",
"(",
")",
"read",
"(",
")",
"-",
"start",
"time",
";",
"if",
"(",
"record",
"load",
")",
"{",
"if",
"(",
"value",
"=",
"=",
"null",
")",
"{",
"stats",
"counter",
"(",
")",
"record",
"load",
"failure",
"(",
"load",
"time",
")",
";",
"}",
"else",
"{",
"stats",
"counter",
"(",
")",
"record",
"load",
"success",
"(",
"load",
"time",
")",
";",
"}",
"}",
"return",
"value",
";",
"}",
";",
"}"
] |
[
"returns",
"-",
"1",
",",
"0",
",",
"or",
"1",
"if",
"the",
"value",
"is",
"lower",
"than",
",",
"equal",
"to",
",",
"or",
"greater",
"than",
"0"
] | [
"static",
"double",
"signum",
"(",
"object",
"value",
")",
"{",
"if",
"(",
"value",
"instanceof",
"number",
")",
"{",
"double",
"double",
"value",
"=",
"(",
"(",
"number",
")",
"value",
")",
"double",
"value",
"(",
")",
";",
"return",
"math",
"signum",
"(",
"double",
"value",
")",
";",
"}",
"if",
"(",
"value",
"instanceof",
"bytes",
"ref",
")",
"{",
"value",
"=",
"(",
"(",
"bytes",
"ref",
")",
"value",
")",
"utf",
"8",
"to",
"string",
"(",
")",
";",
"}",
"return",
"math",
"signum",
"(",
"double",
"parse",
"double",
"(",
"value",
"to",
"string",
"(",
")",
")",
")",
";",
"}"
] |
[
"request",
"that",
"this",
"node",
"try",
"to",
"become",
"active",
"through",
"a",
"graceful",
"failover",
"if",
"the",
"node",
"is",
"already",
"active",
",",
"this",
"is",
"a",
"no",
"-",
"op",
"and",
"simply",
"returns",
"success",
"without",
"taking",
"any",
"further",
"action",
"if",
"the",
"node",
"is",
"not",
"healthy",
",",
"it",
"will",
"throw",
"an",
"exception",
"indicating",
"that",
"it",
"is",
"not",
"able",
"to",
"become",
"active",
"if",
"the",
"node",
"is",
"healthy",
"and",
"not",
"active",
",",
"it",
"will",
"try",
"to",
"initiate",
"a",
"graceful",
"failover",
"to",
"become",
"active",
",",
"returning",
"only",
"when",
"it",
"has",
"successfully",
"become",
"active",
"see",
"{",
"@",
"link",
"z",
"k",
"failover",
"controller",
"#",
"graceful",
"failover",
"to",
"you",
"(",
")",
"}",
"for",
"the",
"implementation",
"details",
"if",
"the",
"node",
"fails",
"to",
"successfully",
"coordinate",
"the",
"failover",
",",
"throws",
"an",
"exception",
"indicating",
"the",
"reason",
"for",
"failure"
] | [
"public",
"void",
"graceful",
"failover",
"(",
")",
"throws",
"i",
"o",
"exception",
",",
"access",
"control",
"exception",
";"
] |
[
"perform",
"a",
"number",
"on",
"assertions",
"and",
"checks",
"on",
"{",
"@",
"link",
"time",
"unit",
"rounding",
"}",
"intervals"
] | [
"private",
"static",
"void",
"assert",
"interval",
"(",
"long",
"rounded",
",",
"long",
"unrounded",
",",
"long",
"next",
"rounding",
"value",
",",
"rounding",
"rounding",
",",
"date",
"time",
"zone",
"tz",
")",
"{",
"assert",
"that",
"(",
"\"",
"rounding",
"should",
"be",
"idempotent",
"\"",
",",
"rounding",
"round",
"(",
"rounded",
")",
",",
"is",
"date",
"(",
"rounded",
",",
"tz",
")",
")",
";",
"assert",
"that",
"(",
"\"",
"rounded",
"value",
"smaller",
"or",
"equal",
"than",
"unrounded",
"\"",
"+",
"rounding",
",",
"rounded",
",",
"less",
"than",
"or",
"equal",
"to",
"(",
"unrounded",
")",
")",
";",
"assert",
"that",
"(",
"\"",
"values",
"less",
"than",
"rounded",
"should",
"round",
"further",
"down",
"\"",
"+",
"rounding",
",",
"rounding",
"round",
"(",
"rounded",
"-",
"1",
")",
",",
"less",
"than",
"(",
"rounded",
")",
")",
";",
"assert",
"that",
"(",
"\"",
"next",
"rounding",
"value",
"should",
"be",
"a",
"rounded",
"date",
"\"",
",",
"rounding",
"round",
"(",
"next",
"rounding",
"value",
")",
",",
"is",
"date",
"(",
"next",
"rounding",
"value",
",",
"tz",
")",
")",
";",
"assert",
"that",
"(",
"\"",
"values",
"above",
"next",
"rounding",
"should",
"round",
"down",
"there",
"\"",
",",
"rounding",
"round",
"(",
"next",
"rounding",
"value",
"+",
"1",
")",
",",
"is",
"date",
"(",
"next",
"rounding",
"value",
",",
"tz",
")",
")",
";",
"if",
"(",
"is",
"time",
"with",
"well",
"defined",
"rounding",
"(",
"tz",
",",
"unrounded",
")",
")",
"{",
"assert",
"that",
"(",
"\"",
"next",
"rounding",
"value",
"should",
"be",
"greater",
"than",
"date",
"\"",
"+",
"rounding",
",",
"next",
"rounding",
"value",
",",
"greater",
"than",
"(",
"unrounded",
")",
")",
";",
"long",
"date",
"between",
"=",
"date",
"between",
"(",
"rounded",
",",
"next",
"rounding",
"value",
")",
";",
"assert",
"that",
"(",
"\"",
"date",
"between",
"[",
"\"",
"+",
"new",
"date",
"time",
"(",
"date",
"between",
",",
"tz",
")",
"+",
"\"",
"]",
"should",
"round",
"down",
"to",
"rounded",
"date",
"\"",
",",
"rounding",
"round",
"(",
"date",
"between",
")",
",",
"is",
"date",
"(",
"rounded",
",",
"tz",
")",
")",
";",
"assert",
"that",
"(",
"\"",
"date",
"between",
"[",
"\"",
"+",
"new",
"date",
"time",
"(",
"date",
"between",
",",
"tz",
")",
"+",
"\"",
"]",
"should",
"round",
"up",
"to",
"next",
"rounding",
"value",
"\"",
",",
"rounding",
"next",
"rounding",
"value",
"(",
"date",
"between",
")",
",",
"is",
"date",
"(",
"next",
"rounding",
"value",
",",
"tz",
")",
")",
";",
"}",
"}"
] |
[
"remove",
"all",
"of",
"the",
"listeners"
] | [
"public",
"spring",
"remove",
"all",
"listeners",
"(",
")",
"{",
"m",
"listeners",
"clear",
"(",
")",
";",
"return",
"this",
";",
"}"
] |
[
"the",
"validation",
"should",
"verify",
"the",
"parent",
"aggregation",
"is",
"allowed"
] | [
"public",
"void",
"test",
"validate",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"assert",
"that",
"(",
"validate",
"(",
"pipeline",
"aggregation",
"helper",
"tests",
"get",
"random",
"sequentially",
"ordered",
"parent",
"agg",
"(",
")",
",",
"new",
"serial",
"diff",
"pipeline",
"aggregation",
"builder",
"(",
"\"",
"name",
"\"",
",",
"\"",
"valid",
"\"",
")",
")",
",",
"null",
"value",
"(",
")",
")",
";",
"}"
] |
[
"entry",
"point",
"to",
"command",
"-",
"line",
"-",
"driven",
"operation",
"user",
"may",
"specify",
"options",
"and",
"start",
"fsimage",
"viewer",
"from",
"the",
"command",
"line",
"program",
"will",
"process",
"image",
"file",
"and",
"exit",
"cleanly",
"or",
",",
"if",
"an",
"error",
"is",
"encountered",
",",
"inform",
"user",
"and",
"exit"
] | [
"public",
"static",
"void",
"main",
"(",
"string",
"[",
"]",
"args",
")",
"throws",
"i",
"o",
"exception",
"{",
"options",
"options",
"=",
"build",
"options",
"(",
")",
";",
"if",
"(",
"args",
"length",
"=",
"=",
"0",
")",
"{",
"print",
"usage",
"(",
")",
";",
"return",
";",
"}",
"command",
"line",
"parser",
"parser",
"=",
"new",
"posix",
"parser",
"(",
")",
";",
"command",
"line",
"cmd",
";",
"try",
"{",
"cmd",
"=",
"parser",
"parse",
"(",
"options",
",",
"args",
")",
";",
"}",
"catch",
"(",
"parse",
"exception",
"e",
")",
"{",
"system",
"out",
"println",
"(",
"\"",
"error",
"parsing",
"command",
"-",
"line",
"options",
":",
"\"",
")",
";",
"print",
"usage",
"(",
")",
";",
"return",
";",
"}",
"if",
"(",
"cmd",
"has",
"option",
"(",
"\"",
"h",
"\"",
")",
")",
"{",
"/",
"/",
"print",
"help",
"and",
"exit",
"print",
"usage",
"(",
")",
";",
"return",
";",
"}",
"boolean",
"skip",
"blocks",
"=",
"cmd",
"has",
"option",
"(",
"\"",
"skip",
"blocks",
"\"",
")",
";",
"boolean",
"print",
"to",
"screen",
"=",
"cmd",
"has",
"option",
"(",
"\"",
"print",
"to",
"screen",
"\"",
")",
";",
"string",
"input",
"file",
"=",
"cmd",
"get",
"option",
"value",
"(",
"\"",
"i",
"\"",
")",
";",
"string",
"processor",
"=",
"cmd",
"get",
"option",
"value",
"(",
"\"",
"p",
"\"",
",",
"\"",
"ls",
"\"",
")",
";",
"string",
"output",
"file",
"=",
"cmd",
"get",
"option",
"value",
"(",
"\"",
"o",
"\"",
")",
";",
"string",
"delimiter",
"=",
"cmd",
"get",
"option",
"value",
"(",
"\"",
"delimiter",
"\"",
")",
";",
"if",
"(",
"!",
"(",
"delimiter",
"=",
"=",
"null",
"|",
"|",
"processor",
"equals",
"(",
"\"",
"delimited",
"\"",
")",
")",
")",
"{",
"system",
"out",
"println",
"(",
"\"",
"can",
"only",
"specify",
"-",
"delimiter",
"with",
"delimited",
"processor",
"\"",
")",
";",
"print",
"usage",
"(",
")",
";",
"return",
";",
"}",
"image",
"visitor",
"v",
";",
"if",
"(",
"processor",
"equals",
"(",
"\"",
"indented",
"\"",
")",
")",
"{",
"v",
"=",
"new",
"indented",
"image",
"visitor",
"(",
"output",
"file",
",",
"print",
"to",
"screen",
")",
";",
"}",
"else",
"if",
"(",
"processor",
"equals",
"(",
"\"",
"xml",
"\"",
")",
")",
"{",
"v",
"=",
"new",
"xml",
"image",
"visitor",
"(",
"output",
"file",
",",
"print",
"to",
"screen",
")",
";",
"}",
"else",
"if",
"(",
"processor",
"equals",
"(",
"\"",
"delimited",
"\"",
")",
")",
"{",
"v",
"=",
"delimiter",
"=",
"=",
"null",
"?",
"new",
"delimited",
"image",
"visitor",
"(",
"output",
"file",
",",
"print",
"to",
"screen",
")",
":",
"new",
"delimited",
"image",
"visitor",
"(",
"output",
"file",
",",
"print",
"to",
"screen",
",",
"delimiter",
")",
";",
"skip",
"blocks",
"=",
"false",
";",
"}",
"else",
"if",
"(",
"processor",
"equals",
"(",
"\"",
"file",
"distribution",
"\"",
")",
")",
"{",
"long",
"max",
"size",
"=",
"long",
"parse",
"long",
"(",
"cmd",
"get",
"option",
"value",
"(",
"\"",
"max",
"size",
"\"",
",",
"\"",
"0",
"\"",
")",
")",
";",
"int",
"step",
"=",
"integer",
"parse",
"int",
"(",
"cmd",
"get",
"option",
"value",
"(",
"\"",
"step",
"\"",
",",
"\"",
"0",
"\"",
")",
")",
";",
"boolean",
"format",
"output",
"=",
"cmd",
"has",
"option",
"(",
"\"",
"format",
"\"",
")",
";",
"v",
"=",
"new",
"file",
"distribution",
"visitor",
"(",
"output",
"file",
",",
"max",
"size",
",",
"step",
",",
"format",
"output",
")",
";",
"}",
"else",
"if",
"(",
"processor",
"equals",
"(",
"\"",
"name",
"distribution",
"\"",
")",
")",
"{",
"v",
"=",
"new",
"name",
"distribution",
"visitor",
"(",
"output",
"file",
",",
"print",
"to",
"screen",
")",
";",
"}",
"else",
"{",
"v",
"=",
"new",
"ls",
"image",
"visitor",
"(",
"output",
"file",
",",
"print",
"to",
"screen",
")",
";",
"skip",
"blocks",
"=",
"false",
";",
"}",
"try",
"{",
"offline",
"image",
"viewer",
"d",
"=",
"new",
"offline",
"image",
"viewer",
"(",
"input",
"file",
",",
"v",
",",
"skip",
"blocks",
")",
";",
"d",
"go",
"(",
")",
";",
"}",
"catch",
"(",
"e",
"o",
"f",
"exception",
"e",
")",
"{",
"system",
"err",
"println",
"(",
"\"",
"input",
"file",
"ended",
"unexpectedly",
"exiting",
"\"",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"system",
"err",
"println",
"(",
"\"",
"encountered",
"exception",
"exiting",
":",
"\"",
"+",
"e",
"get",
"message",
"(",
")",
")",
";",
"}",
"}"
] |
[
"properties",
"for",
"jpa"
] | [
"private",
"static",
"properties",
"jpa",
"properties",
"(",
")",
"{",
"var",
"properties",
"=",
"new",
"properties",
"(",
")",
";",
"properties",
"set",
"property",
"(",
"\"",
"hibernate",
"dialect",
"\"",
",",
"\"",
"org",
"hibernate",
"dialect",
"h",
"2",
"dialect",
"\"",
")",
";",
"properties",
"set",
"property",
"(",
"\"",
"hibernate",
"hbm",
"2ddl",
"auto",
"\"",
",",
"\"",
"create",
"-",
"drop",
"\"",
")",
";",
"return",
"properties",
";",
"}"
] |
[
"calculates",
"the",
"squared",
"radius",
"of",
"the",
"bounding",
"sphere",
"around",
"the",
"specified",
"center",
"for",
"the",
"specified",
"part"
] | [
"public",
"float",
"calculate",
"radius",
"squared",
"(",
"final",
"float",
"center",
"x",
",",
"final",
"float",
"center",
"y",
",",
"final",
"float",
"center",
"z",
",",
"int",
"offset",
",",
"int",
"count",
",",
"final",
"matrix",
"4",
"transform",
")",
"{",
"int",
"num",
"indices",
"=",
"get",
"num",
"indices",
"(",
")",
";",
"if",
"(",
"offset",
"<",
"0",
"|",
"|",
"count",
"<",
"1",
"|",
"|",
"offset",
"+",
"count",
">",
"num",
"indices",
")",
"throw",
"new",
"gdx",
"runtime",
"exception",
"(",
"\"",
"not",
"enough",
"indices",
"\"",
")",
";",
"final",
"float",
"buffer",
"verts",
"=",
"vertices",
"get",
"buffer",
"(",
")",
";",
"final",
"short",
"buffer",
"index",
"=",
"indices",
"get",
"buffer",
"(",
")",
";",
"final",
"vertex",
"attribute",
"pos",
"attrib",
"=",
"get",
"vertex",
"attribute",
"(",
"usage",
"position",
")",
";",
"final",
"int",
"posoff",
"=",
"pos",
"attrib",
"offset",
"/",
"4",
";",
"final",
"int",
"vertex",
"size",
"=",
"vertices",
"get",
"attributes",
"(",
")",
"vertex",
"size",
"/",
"4",
";",
"final",
"int",
"end",
"=",
"offset",
"+",
"count",
";",
"float",
"result",
"=",
"0",
";",
"switch",
"(",
"pos",
"attrib",
"num",
"components",
")",
"{",
"case",
"1",
":",
"for",
"(",
"int",
"i",
"=",
"offset",
";",
"i",
"<",
"end",
";",
"i",
"+",
"+",
")",
"{",
"final",
"int",
"idx",
"=",
"(",
"index",
"get",
"(",
"i",
")",
"&",
"0x",
"f",
"f",
"f",
"f",
")",
"*",
"vertex",
"size",
"+",
"posoff",
";",
"tmp",
"v",
"set",
"(",
"verts",
"get",
"(",
"idx",
")",
",",
"0",
",",
"0",
")",
";",
"if",
"(",
"transform",
"!",
"=",
"null",
")",
"tmp",
"v",
"mul",
"(",
"transform",
")",
";",
"final",
"float",
"r",
"=",
"tmp",
"v",
"sub",
"(",
"center",
"x",
",",
"center",
"y",
",",
"center",
"z",
")",
"len",
"2",
"(",
")",
";",
"if",
"(",
"r",
">",
"result",
")",
"result",
"=",
"r",
";",
"}",
"break",
";",
"case",
"2",
":",
"for",
"(",
"int",
"i",
"=",
"offset",
";",
"i",
"<",
"end",
";",
"i",
"+",
"+",
")",
"{",
"final",
"int",
"idx",
"=",
"(",
"index",
"get",
"(",
"i",
")",
"&",
"0x",
"f",
"f",
"f",
"f",
")",
"*",
"vertex",
"size",
"+",
"posoff",
";",
"tmp",
"v",
"set",
"(",
"verts",
"get",
"(",
"idx",
")",
",",
"verts",
"get",
"(",
"idx",
"+",
"1",
")",
",",
"0",
")",
";",
"if",
"(",
"transform",
"!",
"=",
"null",
")",
"tmp",
"v",
"mul",
"(",
"transform",
")",
";",
"final",
"float",
"r",
"=",
"tmp",
"v",
"sub",
"(",
"center",
"x",
",",
"center",
"y",
",",
"center",
"z",
")",
"len",
"2",
"(",
")",
";",
"if",
"(",
"r",
">",
"result",
")",
"result",
"=",
"r",
";",
"}",
"break",
";",
"case",
"3",
":",
"for",
"(",
"int",
"i",
"=",
"offset",
";",
"i",
"<",
"end",
";",
"i",
"+",
"+",
")",
"{",
"final",
"int",
"idx",
"=",
"(",
"index",
"get",
"(",
"i",
")",
"&",
"0x",
"f",
"f",
"f",
"f",
")",
"*",
"vertex",
"size",
"+",
"posoff",
";",
"tmp",
"v",
"set",
"(",
"verts",
"get",
"(",
"idx",
")",
",",
"verts",
"get",
"(",
"idx",
"+",
"1",
")",
",",
"verts",
"get",
"(",
"idx",
"+",
"2",
")",
")",
";",
"if",
"(",
"transform",
"!",
"=",
"null",
")",
"tmp",
"v",
"mul",
"(",
"transform",
")",
";",
"final",
"float",
"r",
"=",
"tmp",
"v",
"sub",
"(",
"center",
"x",
",",
"center",
"y",
",",
"center",
"z",
")",
"len",
"2",
"(",
")",
";",
"if",
"(",
"r",
">",
"result",
")",
"result",
"=",
"r",
";",
"}",
"break",
";",
"}",
"return",
"result",
";",
"}"
] |
[
"plus",
"with",
"another",
"matrix"
] | [
"public",
"void",
"plus",
"equals",
"(",
"dense",
"matrix",
"mat",
")",
"{",
"blas",
"axpy",
"(",
"1",
"0",
",",
"mat",
",",
"this",
")",
";",
"}"
] |
[
"set",
"queue",
"name"
] | [
"protected",
"synchronized",
"void",
"set",
"queue",
"(",
"string",
"queue",
")",
"{",
"this",
"queue",
"=",
"queue",
";",
"}"
] |
[
"sets",
"whether",
"to",
"flip",
"the",
"tile",
"vertically"
] | [
"public",
"cell",
"set",
"flip",
"vertically",
"(",
"boolean",
"flip",
"vertically",
")",
"{",
"this",
"flip",
"vertically",
"=",
"flip",
"vertically",
";",
"return",
"this",
";",
"}"
] |
[
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"a",
"{",
"@",
"link",
"required",
"config",
"fragments",
"provider",
"}",
"should",
"be",
"included",
"for",
"this",
"rule"
] | [
"public",
"boolean",
"should",
"include",
"required",
"config",
"fragments",
"provider",
"(",
")",
"{",
"include",
"config",
"fragments",
"enum",
"setting",
"=",
"get",
"configuration",
"(",
")",
"get",
"options",
"(",
")",
"get",
"(",
"core",
"options",
"class",
")",
"include",
"required",
"config",
"fragments",
"provider",
";",
"switch",
"(",
"setting",
")",
"{",
"case",
"off",
":",
"return",
"false",
";",
"case",
"direct",
"host",
"only",
":",
"return",
"get",
"configuration",
"(",
")",
"is",
"host",
"configuration",
"(",
")",
";",
"case",
"direct",
":",
"case",
"transitive",
":",
"return",
"true",
";",
"}",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"unknown",
"setting",
":",
"\"",
"+",
"setting",
")",
";",
"}"
] |
[
"create",
"and",
"compile",
"a",
"default",
"bundle",
"activator"
] | [
"private",
"boolean",
"build",
"default",
"activator",
"(",
"path",
"bindir",
",",
"string",
"activator",
"class",
"name",
",",
"writer",
"writer",
")",
"throws",
"i",
"o",
"exception",
"{",
"path",
"activator",
"source",
"file",
"name",
"=",
"bindir",
"resolve",
"(",
"activator",
"class",
"name",
"+",
"\"",
"java",
"\"",
")",
";",
"try",
"(",
"print",
"writer",
"activator",
"writer",
"=",
"new",
"print",
"writer",
"(",
"files",
"new",
"buffered",
"writer",
"(",
"activator",
"source",
"file",
"name",
",",
"charset",
"for",
"name",
"(",
"\"",
"utf",
"-",
"8",
"\"",
")",
")",
")",
")",
"{",
"activator",
"writer",
"println",
"(",
"\"",
"import",
"\"",
"+",
"ghidra",
"bundle",
"activator",
"class",
"get",
"name",
"(",
")",
"+",
"\"",
";",
"\"",
")",
";",
"activator",
"writer",
"println",
"(",
"\"",
"import",
"org",
"osgi",
"framework",
"bundle",
"activator",
";",
"\"",
")",
";",
"activator",
"writer",
"println",
"(",
"\"",
"import",
"org",
"osgi",
"framework",
"bundle",
"context",
";",
"\"",
")",
";",
"activator",
"writer",
"println",
"(",
"\"",
"public",
"class",
"\"",
"+",
"generated",
"activator",
"classname",
"+",
"\"",
"extends",
"ghidra",
"bundle",
"activator",
"{",
"\"",
")",
";",
"activator",
"writer",
"println",
"(",
"\"",
"protected",
"void",
"start",
"(",
"bundle",
"context",
"bc",
",",
"object",
"api",
")",
"{",
"\"",
")",
";",
"activator",
"writer",
"println",
"(",
"\"",
"/",
"/",
"todo",
":",
"stuff",
"to",
"do",
"on",
"bundle",
"start",
"\"",
")",
";",
"activator",
"writer",
"println",
"(",
"\"",
"}",
"\"",
")",
";",
"activator",
"writer",
"println",
"(",
"\"",
"protected",
"void",
"stop",
"(",
"bundle",
"context",
"bc",
",",
"object",
"api",
")",
"{",
"\"",
")",
";",
"activator",
"writer",
"println",
"(",
"\"",
"/",
"/",
"todo",
":",
"stuff",
"to",
"do",
"on",
"bundle",
"stop",
"\"",
")",
";",
"activator",
"writer",
"println",
"(",
"\"",
"}",
"\"",
")",
";",
"activator",
"writer",
"println",
"(",
")",
";",
"activator",
"writer",
"println",
"(",
"\"",
"}",
"\"",
")",
";",
"}",
"list",
"<",
"string",
">",
"options",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"options",
"add",
"(",
"\"",
"-",
"g",
"\"",
")",
";",
"options",
"add",
"(",
"\"",
"-",
"d",
"\"",
")",
";",
"options",
"add",
"(",
"bindir",
"to",
"string",
"(",
")",
")",
";",
"options",
"add",
"(",
"\"",
"-",
"sourcepath",
"\"",
")",
";",
"options",
"add",
"(",
"bindir",
"to",
"string",
"(",
")",
")",
";",
"options",
"add",
"(",
"\"",
"-",
"classpath",
"\"",
")",
";",
"options",
"add",
"(",
"system",
"get",
"property",
"(",
"\"",
"java",
"class",
"path",
"\"",
")",
")",
";",
"options",
"add",
"(",
"\"",
"-",
"proc",
":",
"none",
"\"",
")",
";",
"try",
"(",
"standard",
"java",
"file",
"manager",
"java",
"file",
"manager",
"=",
"compiler",
"get",
"standard",
"file",
"manager",
"(",
"null",
",",
"null",
",",
"null",
")",
";",
"bundle",
"java",
"manager",
"bundle",
"java",
"manager",
"=",
"new",
"my",
"bundle",
"java",
"manager",
"(",
"bundle",
"host",
"get",
"host",
"framework",
"(",
")",
",",
"java",
"file",
"manager",
",",
"options",
")",
";",
")",
"{",
"iterable",
"<",
"?",
"extends",
"java",
"file",
"object",
">",
"source",
"files",
"=",
"java",
"file",
"manager",
"get",
"java",
"file",
"objects",
"from",
"paths",
"(",
"list",
"of",
"(",
"activator",
"source",
"file",
"name",
")",
")",
";",
"diagnostic",
"collector",
"<",
"java",
"file",
"object",
">",
"diagnostics",
"=",
"new",
"diagnostic",
"collector",
"<",
"java",
"file",
"object",
">",
"(",
")",
";",
"java",
"compiler",
"compilation",
"task",
"task",
"=",
"compiler",
"get",
"task",
"(",
"writer",
",",
"bundle",
"java",
"manager",
",",
"diagnostics",
",",
"options",
",",
"null",
",",
"source",
"files",
")",
";",
"if",
"(",
"!",
"task",
"call",
"(",
")",
")",
"{",
"for",
"(",
"diagnostic",
"<",
"?",
"extends",
"java",
"file",
"object",
">",
"diagnostic",
":",
"diagnostics",
"get",
"diagnostics",
"(",
")",
")",
"{",
"writer",
"write",
"(",
"diagnostic",
"get",
"source",
"(",
")",
"to",
"string",
"(",
")",
"+",
"\"",
":",
"\"",
"+",
"diagnostic",
"get",
"message",
"(",
"null",
")",
"+",
"\"",
"\\",
"n",
"\"",
")",
";",
"}",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"}"
] |
[
"get",
"name",
"number"
] | [
"public",
"big",
"decimal",
"get",
"name",
"number",
"(",
")",
"{",
"return",
"name",
"number",
";",
"}"
] |
[
"creates",
"an",
"access",
"token",
"and",
"optionally",
"a",
"refresh",
"token",
"as",
"well",
"from",
"predefined",
"values",
",",
"based",
"on",
"the",
"provided",
"authentication",
"and",
"metadata",
"the",
"created",
"tokens",
"are",
"stored",
"in",
"the",
"security",
"index",
"for",
"versions",
"up",
"to",
"{",
"@",
"link",
"#",
"version",
"tokens",
"index",
"introduced",
"}",
"and",
"to",
"a",
"specific",
"security",
"tokens",
"index",
"for",
"later",
"versions"
] | [
"public",
"void",
"create",
"o",
"auth",
"2",
"tokens",
"(",
"string",
"access",
"token",
",",
"string",
"refresh",
"token",
",",
"authentication",
"authentication",
",",
"authentication",
"originating",
"client",
"auth",
",",
"map",
"<",
"string",
",",
"object",
">",
"metadata",
",",
"action",
"listener",
"<",
"create",
"token",
"result",
">",
"listener",
")",
"{",
"/",
"/",
"the",
"created",
"token",
"is",
"compatible",
"with",
"the",
"oldest",
"node",
"version",
"in",
"the",
"cluster",
"final",
"version",
"token",
"version",
"=",
"get",
"token",
"version",
"compatibility",
"(",
")",
";",
"/",
"/",
"tokens",
"moved",
"to",
"a",
"separate",
"index",
"in",
"newer",
"versions",
"final",
"security",
"index",
"manager",
"tokens",
"index",
"=",
"get",
"tokens",
"index",
"for",
"version",
"(",
"token",
"version",
")",
";",
"create",
"o",
"auth",
"2",
"tokens",
"(",
"access",
"token",
",",
"refresh",
"token",
",",
"token",
"version",
",",
"tokens",
"index",
",",
"authentication",
",",
"originating",
"client",
"auth",
",",
"metadata",
",",
"listener",
")",
";",
"}"
] |
[
"returns",
"first",
"element",
"of",
"provided",
"iterable",
"or",
"fails",
"fast",
"when",
"iterable",
"is",
"empty"
] | [
"public",
"static",
"<",
"t",
">",
"t",
"first",
"of",
"(",
"iterable",
"<",
"t",
">",
"iterable",
")",
"{",
"iterator",
"<",
"t",
">",
"iterator",
"=",
"iterable",
"iterator",
"(",
")",
";",
"if",
"(",
"!",
"iterator",
"has",
"next",
"(",
")",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"cannot",
"provide",
"1st",
"element",
"from",
"empty",
"iterable",
":",
"\"",
"+",
"iterable",
")",
";",
"}",
"return",
"iterator",
"next",
"(",
")",
";",
"}"
] |
[
"writes",
"a",
"value",
"of",
"specified",
"size",
"into",
"the",
"byte",
"array",
"at",
"the",
"given",
"offset",
"see",
"{",
"@",
"link",
"#",
"get",
"bytes",
"(",
"big",
"integer",
",",
"int",
",",
"byte",
"[",
"]",
",",
"int",
")",
"}"
] | [
"public",
"void",
"put",
"big",
"integer",
"(",
"byte",
"[",
"]",
"b",
",",
"int",
"offset",
",",
"int",
"size",
",",
"big",
"integer",
"value",
")",
";",
"/",
"/",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-"
] |
[
"returns",
"true",
"if",
"and",
"only",
"if",
"this",
"strategy",
"applies",
"to",
"the",
"given",
"job"
] | [
"public",
"abstract",
"boolean",
"is",
"applicable",
"(",
"job",
"<",
"?",
",",
"?",
">",
"job",
")",
";"
] |
[
"returns",
"the",
"command",
"line",
"built",
"by",
"this",
"{",
"@",
"link",
"args",
"}",
"object"
] | [
"public",
"abstract",
"command",
"line",
"build",
"(",
")",
";"
] |
[
"test",
"overflow",
"in",
"the",
"upper",
"bound",
"calculation",
"for",
"the",
"binary",
"search"
] | [
"public",
"void",
"test",
"overflow",
"max",
"share",
"(",
")",
"{",
"long",
"giga",
"=",
"1000l",
"*",
"1000l",
"*",
"1000l",
";",
"scheds",
"add",
"(",
"new",
"fake",
"schedulable",
"(",
"0l",
",",
"giga",
")",
")",
";",
"scheds",
"add",
"(",
"new",
"fake",
"schedulable",
"(",
"0l",
",",
"long",
"max",
"value",
")",
")",
";",
"compute",
"fair",
"shares",
"compute",
"shares",
"(",
"scheds",
",",
"resources",
"create",
"resource",
"(",
"2",
"*",
"giga",
")",
",",
"resource",
"information",
"memory",
"mb",
"get",
"name",
"(",
")",
")",
";",
"verify",
"memory",
"shares",
"(",
"giga",
",",
"giga",
")",
";",
"}"
] |
[
"match",
"the",
"given",
"{",
"@",
"code",
"path",
"}",
"against",
"the",
"corresponding",
"part",
"of",
"the",
"given",
"{",
"@",
"code",
"pattern",
"}",
",",
"according",
"to",
"this",
"path",
"matcher",
"'",
"s",
"matching",
"strategy",
"determines",
"whether",
"the",
"pattern",
"at",
"least",
"matches",
"as",
"far",
"as",
"the",
"given",
"base",
"path",
"goes",
",",
"assuming",
"that",
"a",
"full",
"path",
"may",
"then",
"match",
"as",
"well"
] | [
"boolean",
"match",
"start",
"(",
"string",
"pattern",
",",
"string",
"path",
")",
";"
] |
[
"convenience",
"method",
",",
"so",
"that",
"we",
"don",
"'",
"t",
"open",
"a",
"new",
"connection",
"when",
"using",
"this",
"method",
"from",
"within",
"another",
"method",
"otherwise",
"every",
"api",
"invocation",
"incurs",
"the",
"overhead",
"of",
"openingclosing",
"a",
"tcp",
"connection"
] | [
"private",
"boolean",
"mkdirs",
"(",
"channel",
"sftp",
"client",
",",
"path",
"file",
",",
"fs",
"permission",
"permission",
")",
"throws",
"i",
"o",
"exception",
"{",
"boolean",
"created",
"=",
"true",
";",
"path",
"work",
"dir",
";",
"try",
"{",
"work",
"dir",
"=",
"new",
"path",
"(",
"client",
"pwd",
"(",
")",
")",
";",
"}",
"catch",
"(",
"sftp",
"exception",
"e",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"e",
")",
";",
"}",
"path",
"absolute",
"=",
"make",
"absolute",
"(",
"work",
"dir",
",",
"file",
")",
";",
"string",
"path",
"name",
"=",
"absolute",
"get",
"name",
"(",
")",
";",
"if",
"(",
"!",
"exists",
"(",
"client",
",",
"absolute",
")",
")",
"{",
"path",
"parent",
"=",
"absolute",
"get",
"parent",
"(",
")",
";",
"created",
"=",
"(",
"parent",
"=",
"=",
"null",
"|",
"|",
"mkdirs",
"(",
"client",
",",
"parent",
",",
"fs",
"permission",
"get",
"default",
"(",
")",
")",
")",
";",
"if",
"(",
"created",
")",
"{",
"string",
"parent",
"dir",
"=",
"parent",
"to",
"uri",
"(",
")",
"get",
"path",
"(",
")",
";",
"boolean",
"succeeded",
"=",
"true",
";",
"try",
"{",
"final",
"string",
"previous",
"cwd",
"=",
"client",
"pwd",
"(",
")",
";",
"client",
"cd",
"(",
"parent",
"dir",
")",
";",
"client",
"mkdir",
"(",
"path",
"name",
")",
";",
"client",
"cd",
"(",
"previous",
"cwd",
")",
";",
"}",
"catch",
"(",
"sftp",
"exception",
"e",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"string",
"format",
"(",
"e",
"make",
"dir",
"forpath",
",",
"path",
"name",
",",
"parent",
"dir",
")",
")",
";",
"}",
"created",
"=",
"created",
"&",
"succeeded",
";",
"}",
"}",
"else",
"if",
"(",
"is",
"file",
"(",
"client",
",",
"absolute",
")",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"string",
"format",
"(",
"e",
"dir",
"create",
"fromfile",
",",
"absolute",
")",
")",
";",
"}",
"return",
"created",
";",
"}"
] |
[
"unlike",
"a",
"follower",
",",
"which",
"sees",
"a",
"full",
"request",
"only",
"during",
"the",
"proposal",
"phase",
",",
"observers",
"get",
"all",
"the",
"data",
"required",
"with",
"the",
"inform",
"packet",
"this",
"method",
"commits",
"a",
"request",
"that",
"has",
"been",
"unpacked",
"by",
"from",
"an",
"inform",
"received",
"from",
"the",
"leader"
] | [
"public",
"void",
"commit",
"request",
"(",
"request",
"request",
")",
"{",
"if",
"(",
"sync",
"request",
"processor",
"enabled",
")",
"{",
"/",
"/",
"write",
"to",
"txnlog",
"and",
"take",
"periodic",
"snapshot",
"sync",
"processor",
"process",
"request",
"(",
"request",
")",
";",
"}",
"commit",
"processor",
"commit",
"(",
"request",
")",
";",
"}"
] |
[
"returns",
"an",
"off",
"-",
"heap",
"copy",
"of",
"the",
"specified",
"{",
"@",
"link",
"byte",
"buf",
"}",
",",
"and",
"releases",
"the",
"specified",
"holder",
"the",
"caller",
"must",
"ensure",
"that",
"the",
"holder",
"releases",
"the",
"original",
"{",
"@",
"link",
"byte",
"buf",
"}",
"when",
"the",
"holder",
"is",
"released",
"by",
"this",
"method"
] | [
"protected",
"final",
"byte",
"buf",
"new",
"direct",
"buffer",
"(",
"object",
"holder",
",",
"byte",
"buf",
"buf",
")",
"{",
"final",
"int",
"readable",
"bytes",
"=",
"buf",
"readable",
"bytes",
"(",
")",
";",
"if",
"(",
"readable",
"bytes",
"=",
"=",
"0",
")",
"{",
"reference",
"count",
"util",
"release",
"(",
"holder",
")",
";",
"return",
"unpooled",
"empty",
"buffer",
";",
"}",
"final",
"byte",
"buf",
"allocator",
"alloc",
"=",
"alloc",
"(",
")",
";",
"if",
"(",
"alloc",
"is",
"direct",
"buffer",
"pooled",
"(",
")",
")",
"{",
"return",
"new",
"direct",
"buffer",
"0",
"(",
"holder",
",",
"buf",
",",
"alloc",
",",
"readable",
"bytes",
")",
";",
"}",
"final",
"byte",
"buf",
"direct",
"buf",
"=",
"byte",
"buf",
"util",
"thread",
"local",
"direct",
"buffer",
"(",
")",
";",
"if",
"(",
"direct",
"buf",
"=",
"=",
"null",
")",
"{",
"return",
"new",
"direct",
"buffer",
"0",
"(",
"holder",
",",
"buf",
",",
"alloc",
",",
"readable",
"bytes",
")",
";",
"}",
"direct",
"buf",
"write",
"bytes",
"(",
"buf",
",",
"buf",
"reader",
"index",
"(",
")",
",",
"readable",
"bytes",
")",
";",
"reference",
"count",
"util",
"safe",
"release",
"(",
"holder",
")",
";",
"return",
"direct",
"buf",
";",
"}"
] |
[
"sets",
"gmt",
"modified"
] | [
"public",
"void",
"set",
"gmt",
"modified",
"(",
"date",
"gmt",
"modified",
")",
"{",
"this",
"gmt",
"modified",
"=",
"gmt",
"modified",
";",
"}"
] |
[
"spawns",
"the",
"native",
"controllers",
"for",
"each",
"module"
] | [
"void",
"spawn",
"native",
"controllers",
"(",
"final",
"environment",
"environment",
",",
"final",
"boolean",
"inherit",
"io",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"!",
"spawned",
"compare",
"and",
"set",
"(",
"false",
",",
"true",
")",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"native",
"controllers",
"already",
"spawned",
"\"",
")",
";",
"}",
"if",
"(",
"!",
"files",
"exists",
"(",
"environment",
"modules",
"file",
"(",
")",
")",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"modules",
"directory",
"[",
"\"",
"+",
"environment",
"modules",
"file",
"(",
")",
"+",
"\"",
"]",
"not",
"found",
"\"",
")",
";",
"}",
"/",
"*",
"*",
"for",
"each",
"module",
",",
"attempt",
"to",
"spawn",
"the",
"controller",
"daemon",
"silently",
"ignore",
"any",
"module",
"that",
"doesn",
"'",
"t",
"include",
"a",
"controller",
"for",
"the",
"*",
"correct",
"platform",
"*",
"/",
"list",
"<",
"path",
">",
"paths",
"=",
"plugins",
"service",
"find",
"plugin",
"dirs",
"(",
"environment",
"modules",
"file",
"(",
")",
")",
";",
"for",
"(",
"final",
"path",
"modules",
":",
"paths",
")",
"{",
"final",
"plugin",
"info",
"info",
"=",
"plugin",
"info",
"read",
"from",
"properties",
"(",
"modules",
")",
";",
"final",
"path",
"spawn",
"path",
"=",
"platforms",
"native",
"controller",
"path",
"(",
"modules",
")",
";",
"if",
"(",
"!",
"files",
"is",
"regular",
"file",
"(",
"spawn",
"path",
")",
")",
"{",
"continue",
";",
"}",
"if",
"(",
"!",
"info",
"has",
"native",
"controller",
"(",
")",
")",
"{",
"final",
"string",
"message",
"=",
"string",
"format",
"(",
"locale",
"root",
",",
"\"",
"module",
"[",
"%",
"s",
"]",
"does",
"not",
"have",
"permission",
"to",
"fork",
"native",
"controller",
"\"",
",",
"modules",
"get",
"file",
"name",
"(",
")",
")",
";",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"message",
")",
";",
"}",
"final",
"process",
"process",
"=",
"spawn",
"native",
"controller",
"(",
"spawn",
"path",
",",
"environment",
"tmp",
"file",
"(",
")",
",",
"inherit",
"io",
")",
";",
"processes",
"add",
"(",
"process",
")",
";",
"}",
"}"
] |
[
"wait",
"for",
"the",
"given",
"process",
"to",
"return",
"and",
"check",
"that",
"it",
"exited",
"as",
"required",
"log",
"if",
"the",
"process",
"failed"
] | [
"private",
"static",
"void",
"check",
"process",
"ret",
"(",
"process",
"p",
",",
"boolean",
"expect",
"pass",
")",
"throws",
"i",
"o",
"exception",
"{",
"try",
"{",
"int",
"ret",
"=",
"p",
"wait",
"for",
"(",
")",
";",
"if",
"(",
"ret",
"!",
"=",
"0",
")",
"{",
"dump",
"input",
"stream",
"(",
"p",
"get",
"error",
"stream",
"(",
")",
")",
";",
"}",
"if",
"(",
"expect",
"pass",
")",
"{",
"assert",
"equals",
"(",
"0",
",",
"ret",
")",
";",
"}",
"else",
"{",
"assert",
"true",
"(",
"ret",
"!",
"=",
"0",
")",
";",
"}",
"}",
"catch",
"(",
"interrupted",
"exception",
"ie",
")",
"{",
"fail",
"(",
"\"",
"process",
"interrupted",
":",
"\"",
"+",
"ie",
"get",
"message",
"(",
")",
")",
";",
"}",
"}"
] |
[
"updated",
"user",
"this",
"can",
"only",
"be",
"done",
"by",
"the",
"logged",
"in",
"user"
] | [
"public",
"void",
"update",
"user",
"test",
"(",
")",
"{",
"string",
"username",
"=",
"null",
";",
"user",
"user",
"=",
"null",
";",
"/",
"/",
"api",
"update",
"user",
"(",
"username",
",",
"user",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
] |
[
"verify",
"the",
"directory",
"file",
"status",
"subclass",
"may",
"verify",
"additional",
"fields"
] | [
"protected",
"void",
"verify",
"dir",
"status",
"(",
"s",
"3",
"a",
"file",
"status",
"status",
")",
"{",
"assert",
"true",
"(",
"\"",
"is",
"a",
"dir",
"\"",
",",
"status",
"is",
"directory",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"zero",
"length",
"\"",
",",
"0",
",",
"status",
"get",
"len",
"(",
")",
")",
";",
"}"
] |
[
"read",
"operator",
"{",
"@",
"code",
"list",
"state",
"}",
"from",
"a",
"{",
"@",
"code",
"savepoint",
"}",
"when",
"a",
"custom",
"serializer",
"was",
"used",
";",
"e",
"g",
",",
"a",
"different",
"serializer",
"than",
"the",
"one",
"returned",
"by",
"{",
"@",
"code",
"type",
"information",
"#",
"create",
"serializer",
"}"
] | [
"public",
"<",
"t",
">",
"data",
"set",
"<",
"t",
">",
"read",
"list",
"state",
"(",
"string",
"uid",
",",
"string",
"name",
",",
"type",
"information",
"<",
"t",
">",
"type",
"info",
",",
"type",
"serializer",
"<",
"t",
">",
"serializer",
")",
"throws",
"i",
"o",
"exception",
"{",
"operator",
"state",
"operator",
"state",
"=",
"metadata",
"get",
"operator",
"state",
"(",
"uid",
")",
";",
"list",
"state",
"descriptor",
"<",
"t",
">",
"descriptor",
"=",
"new",
"list",
"state",
"descriptor",
"<",
">",
"(",
"name",
",",
"serializer",
")",
";",
"list",
"state",
"input",
"format",
"<",
"t",
">",
"input",
"format",
"=",
"new",
"list",
"state",
"input",
"format",
"<",
">",
"(",
"operator",
"state",
",",
"descriptor",
")",
";",
"return",
"env",
"create",
"input",
"(",
"input",
"format",
",",
"type",
"info",
")",
";",
"}"
] |
[
"configures",
"the",
"delimiter",
"that",
"separates",
"the",
"fields",
"within",
"a",
"row",
"the",
"comma",
"character",
"(",
"{",
"@",
"code",
"'",
",",
"'",
"}",
")",
"is",
"used",
"by",
"default"
] | [
"public",
"csv",
"reader",
"field",
"delimiter",
"(",
"char",
"delimiter",
")",
"{",
"this",
"field",
"delimiter",
"=",
"string",
"value",
"of",
"(",
"delimiter",
")",
";",
"return",
"this",
";",
"}"
] |
[
"visits",
"a",
"non",
"standard",
"attribute",
"of",
"this",
"method"
] | [
"public",
"void",
"visit",
"attribute",
"(",
"final",
"attribute",
"attribute",
")",
"{",
"if",
"(",
"mv",
"!",
"=",
"null",
")",
"{",
"mv",
"visit",
"attribute",
"(",
"attribute",
")",
";",
"}",
"}"
] |
[
"factory",
"method",
"to",
"create",
"a",
"new",
"{",
"@",
"link",
"annotation",
"metadata",
"}",
"instance",
"for",
"the",
"given",
"class",
"using",
"standard",
"reflection"
] | [
"static",
"annotation",
"metadata",
"introspect",
"(",
"class",
"<",
"?",
">",
"type",
")",
"{",
"return",
"standard",
"annotation",
"metadata",
"from",
"(",
"type",
")",
";",
"}"
] |
[
"configure",
"allowed",
"{",
"@",
"code",
"origin",
"}",
"header",
"values",
"this",
"check",
"is",
"mostly",
"designed",
"for",
"browsers",
"there",
"is",
"nothing",
"preventing",
"other",
"types",
"of",
"client",
"to",
"modify",
"the",
"{",
"@",
"code",
"origin",
"}",
"header",
"value",
"each",
"provided",
"allowed",
"origin",
"must",
"have",
"a",
"scheme",
",",
"and",
"optionally",
"a",
"port",
"(",
"e",
"g",
"\"",
"https",
":",
"example",
"org",
"\"",
",",
"\"",
"https",
":",
"example",
"org",
":",
"9090",
"\"",
")",
"an",
"allowed",
"origin",
"string",
"may",
"also",
"be",
"\"",
"\"",
"in",
"which",
"case",
"all",
"origins",
"are",
"allowed"
] | [
"public",
"void",
"set",
"allowed",
"origins",
"(",
"collection",
"<",
"string",
">",
"allowed",
"origins",
")",
"{",
"assert",
"not",
"null",
"(",
"allowed",
"origins",
",",
"\"",
"allowed",
"origins",
"collection",
"must",
"not",
"be",
"null",
"\"",
")",
";",
"this",
"cors",
"configuration",
"set",
"allowed",
"origins",
"(",
"new",
"array",
"list",
"<",
">",
"(",
"allowed",
"origins",
")",
")",
";",
"}"
] |
[
"makes",
"time",
"pass",
"for",
"the",
"star"
] | [
"public",
"void",
"time",
"passes",
"(",
")",
"{",
"age",
"years",
"*",
"=",
"2",
";",
"mass",
"tons",
"*",
"=",
"8",
";",
"switch",
"(",
"type",
")",
"{",
"case",
"red",
"giant",
":",
"type",
"=",
"star",
"type",
"white",
"dwarf",
";",
"break",
";",
"case",
"sun",
":",
"type",
"=",
"star",
"type",
"red",
"giant",
";",
"break",
";",
"case",
"supernova",
":",
"type",
"=",
"star",
"type",
"dead",
";",
"break",
";",
"case",
"white",
"dwarf",
":",
"type",
"=",
"star",
"type",
"supernova",
";",
"break",
";",
"case",
"dead",
":",
"age",
"years",
"*",
"=",
"2",
";",
"mass",
"tons",
"=",
"0",
";",
"break",
";",
"default",
":",
"break",
";",
"}",
"}"
] |
[
"decode",
"item",
"version",
"data",
"from",
"file"
] | [
"private",
"version",
"decode",
"version",
"(",
"string",
"line",
")",
"throws",
"number",
"format",
"exception",
",",
"no",
"such",
"element",
"exception",
"{",
"string",
"tokenizer",
"st",
"=",
"new",
"string",
"tokenizer",
"(",
"line",
",",
"\"",
";",
"\"",
")",
";",
"int",
"version",
"=",
"integer",
"parse",
"int",
"(",
"st",
"next",
"token",
"(",
")",
")",
";",
"string",
"user",
"=",
"st",
"next",
"token",
"(",
")",
";",
"long",
"time",
"=",
"long",
"parse",
"long",
"(",
"st",
"next",
"token",
"(",
")",
")",
";",
"string",
"comment",
"=",
"\"",
"\"",
";",
"if",
"(",
"st",
"has",
"more",
"tokens",
"(",
")",
")",
"{",
"comment",
"=",
"decode",
"string",
"(",
"st",
"next",
"token",
"(",
")",
")",
";",
"}",
"return",
"new",
"version",
"(",
"version",
",",
"time",
",",
"user",
",",
"comment",
")",
";",
"}"
] |
[
"any",
"<",
"code",
">",
"double",
"<",
"code",
">",
"or",
"non",
"-",
"null",
"<",
"code",
">",
"double",
"<",
"code",
">",
"since",
"mockito",
"2",
"1",
"0",
",",
"only",
"allow",
"valued",
"<",
"code",
">",
"double",
"<",
"code",
">",
",",
"thus",
"<",
"code",
">",
"null",
"<",
"code",
">",
"is",
"not",
"anymore",
"a",
"valid",
"value",
"as",
"primitive",
"wrappers",
"are",
"nullable",
",",
"the",
"suggested",
"api",
"to",
"match",
"<",
"code",
">",
"null",
"<",
"code",
">",
"wrapper",
"would",
"be",
"{",
"@",
"link",
"#",
"is",
"null",
"(",
")",
"}",
"we",
"felt",
"this",
"change",
"would",
"make",
"tests",
"harness",
"much",
"safer",
"that",
"it",
"was",
"with",
"mockito",
"1",
"x",
"see",
"examples",
"in",
"javadoc",
"for",
"{",
"@",
"link",
"argument",
"matchers",
"}",
"class"
] | [
"public",
"static",
"double",
"any",
"double",
"(",
")",
"{",
"report",
"matcher",
"(",
"new",
"instance",
"of",
"(",
"double",
"class",
",",
"\"",
"<",
"any",
"double",
">",
"\"",
")",
")",
";",
"return",
"0",
";",
"}"
] |
[
"gets",
"the",
"number",
"of",
"characters",
"required",
"to",
"display",
"a",
"unit"
] | [
"public",
"int",
"get",
"data",
"unit",
"symbol",
"size",
"(",
")",
"{",
"return",
"symbol",
"size",
";",
"}"
] |
[
"fragment",
"image",
"view"
] | [
"public",
"static",
"void",
"set",
"translucent",
"for",
"image",
"view",
"in",
"fragment",
"(",
"activity",
"activity",
",",
"view",
"need",
"offset",
"view",
")",
"{",
"set",
"translucent",
"for",
"image",
"view",
"in",
"fragment",
"(",
"activity",
",",
"default",
"status",
"bar",
"alpha",
",",
"need",
"offset",
"view",
")",
";",
"}"
] |
[
"removed",
"the",
"mocked",
"std",
"-",
"out",
"{",
"@",
"link",
"print",
"stream",
"}",
"again",
"from",
"the",
"{",
"@",
"link",
"system",
"}",
"class"
] | [
"public",
"void",
"tear",
"down",
"(",
")",
"{",
"system",
"set",
"out",
"(",
"real",
"std",
"out",
")",
";",
"}"
] |
[
"in",
"this",
"scenario",
",",
"we",
"make",
"sure",
"that",
"if",
"a",
"state",
"update",
"happens",
"in",
"the",
"background",
"followed",
"by",
"a",
"second",
"state",
"update",
"in",
"the",
"background",
"before",
"the",
"first",
"can",
"commit",
"on",
"the",
"main",
"thread",
",",
"that",
"the",
"final",
"result",
"includes",
"both",
"state",
"updates"
] | [
"public",
"void",
"test",
"multiple",
"background",
"state",
"updates",
"(",
")",
"{",
"after",
"(",
")",
";",
"component",
"context",
"c",
"=",
"new",
"component",
"context",
"(",
"get",
"application",
"context",
"(",
")",
")",
";",
"litho",
"view",
"litho",
"view",
"=",
"new",
"litho",
"view",
"(",
"c",
")",
";",
"component",
"tree",
"component",
"tree",
"=",
"component",
"tree",
"create",
"(",
"c",
")",
"build",
"(",
")",
";",
"litho",
"view",
"set",
"component",
"tree",
"(",
"component",
"tree",
")",
";",
"litho",
"view",
"measure",
"(",
"view",
"measure",
"spec",
"make",
"measure",
"spec",
"(",
"100",
",",
"view",
"measure",
"spec",
"exactly",
")",
",",
"view",
"measure",
"spec",
"make",
"measure",
"spec",
"(",
"100",
",",
"view",
"measure",
"spec",
"exactly",
")",
")",
";",
"litho",
"view",
"layout",
"(",
"0",
",",
"0",
",",
"100",
",",
"100",
")",
";",
"litho",
"view",
"on",
"attached",
"to",
"window",
"(",
")",
";",
"final",
"simple",
"state",
"update",
"emulator",
"spec",
"caller",
"state",
"updater",
"1",
"=",
"new",
"simple",
"state",
"update",
"emulator",
"spec",
"caller",
"(",
")",
";",
"final",
"simple",
"state",
"update",
"emulator",
"spec",
"caller",
"state",
"updater",
"2",
"=",
"new",
"simple",
"state",
"update",
"emulator",
"spec",
"caller",
"(",
")",
";",
"component",
"tree",
"set",
"root",
"async",
"(",
"row",
"create",
"(",
"c",
")",
"child",
"(",
"column",
"create",
"(",
"c",
")",
"child",
"(",
"simple",
"state",
"update",
"emulator",
"create",
"(",
"c",
")",
"caller",
"(",
"state",
"updater",
"1",
")",
"width",
"px",
"(",
"100",
")",
"height",
"px",
"(",
"100",
")",
"prefix",
"(",
"\"",
"first",
":",
"\"",
")",
")",
"child",
"(",
"simple",
"state",
"update",
"emulator",
"create",
"(",
"c",
")",
"caller",
"(",
"state",
"updater",
"2",
")",
"width",
"px",
"(",
"100",
")",
"height",
"px",
"(",
"100",
")",
"prefix",
"(",
"\"",
"second",
":",
"\"",
")",
")",
")",
"build",
"(",
")",
")",
";",
"m",
"background",
"layout",
"looper",
"rule",
"run",
"to",
"end",
"of",
"tasks",
"sync",
"(",
")",
";",
"shadow",
"looper",
"idle",
"main",
"looper",
"(",
")",
";",
"litho",
"view",
"layout",
"(",
"0",
",",
"0",
",",
"100",
",",
"100",
")",
";",
"/",
"/",
"do",
"two",
"state",
"updates",
"sequentially",
"without",
"draining",
"the",
"main",
"thread",
"queue",
"state",
"updater",
"1",
"increment",
"async",
"(",
")",
";",
"m",
"background",
"layout",
"looper",
"rule",
"run",
"to",
"end",
"of",
"tasks",
"sync",
"(",
")",
";",
"state",
"updater",
"2",
"increment",
"async",
"(",
")",
";",
"m",
"background",
"layout",
"looper",
"rule",
"run",
"to",
"end",
"of",
"tasks",
"sync",
"(",
")",
";",
"/",
"/",
"now",
"drain",
"the",
"main",
"thread",
"queue",
"and",
"mount",
"the",
"result",
"shadow",
"looper",
"idle",
"main",
"looper",
"(",
")",
";",
"litho",
"view",
"layout",
"(",
"0",
",",
"0",
",",
"100",
",",
"100",
")",
";",
"view",
"assertions",
"assert",
"that",
"(",
"litho",
"view",
")",
"matches",
"(",
"view",
"match",
"node",
"for",
"type",
"(",
"litho",
"view",
"class",
")",
"prop",
"(",
"\"",
"drawables",
"\"",
",",
"match",
"node",
"list",
"(",
"match",
"node",
"for",
"type",
"(",
"text",
"drawable",
"class",
")",
"prop",
"(",
"\"",
"text",
"\"",
",",
"\"",
"first",
":",
"2",
"\"",
")",
",",
"match",
"node",
"for",
"type",
"(",
"text",
"drawable",
"class",
")",
"prop",
"(",
"\"",
"text",
"\"",
",",
"\"",
"second",
":",
"2",
"\"",
")",
")",
")",
")",
";",
"}"
] |
[
"order",
"by",
"task",
"id",
"(",
"needs",
"to",
"be",
"followed",
"by",
"{",
"@",
"link",
"#",
"asc",
"(",
")",
"}",
"or",
"{",
"@",
"link",
"#",
"desc",
"(",
")",
"}",
")"
] | [
"t",
"order",
"by",
"task",
"id",
"(",
")",
";"
] |
[
"encodes",
"the",
"given",
"path",
"as",
"a",
"reference",
"in",
"bytes",
"the",
"path",
"is",
"encoded",
"as",
"a",
"utf",
"-",
"8",
"string",
"and",
"prepended",
"as",
"a",
"magic",
"number"
] | [
"public",
"static",
"checkpoint",
"storage",
"location",
"reference",
"encode",
"path",
"as",
"reference",
"(",
"path",
"path",
")",
"{",
"byte",
"[",
"]",
"ref",
"bytes",
"=",
"path",
"to",
"string",
"(",
")",
"get",
"bytes",
"(",
"standard",
"charsets",
"utf",
"8",
")",
";",
"byte",
"[",
"]",
"bytes",
"=",
"new",
"byte",
"[",
"reference",
"magic",
"number",
"length",
"+",
"ref",
"bytes",
"length",
"]",
";",
"system",
"arraycopy",
"(",
"reference",
"magic",
"number",
",",
"0",
",",
"bytes",
",",
"0",
",",
"reference",
"magic",
"number",
"length",
")",
";",
"system",
"arraycopy",
"(",
"ref",
"bytes",
",",
"0",
",",
"bytes",
",",
"reference",
"magic",
"number",
"length",
",",
"ref",
"bytes",
"length",
")",
";",
"return",
"new",
"checkpoint",
"storage",
"location",
"reference",
"(",
"bytes",
")",
";",
"}"
] |
[
"returns",
"a",
"fully",
"qualified",
"class",
"name",
"to",
"complement",
"{",
"@",
"code",
"type",
"}"
] | [
"public",
"static",
"string",
"adapter",
"name",
"(",
"type",
"element",
"type",
"element",
",",
"string",
"suffix",
")",
"{",
"string",
"builder",
"builder",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"raw",
"type",
"to",
"string",
"(",
"builder",
",",
"type",
"element",
",",
"'",
"$",
"'",
")",
";",
"builder",
"append",
"(",
"suffix",
")",
";",
"return",
"builder",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"decodes",
"the",
"specified",
"character",
"sequence",
",",
"and",
"returns",
"the",
"resulting",
"{",
"@",
"code",
"byte",
"[",
"]",
"}",
"this",
"is",
"the",
"inverse",
"operation",
"to",
"{",
"@",
"link",
"#",
"encode",
"(",
"byte",
"[",
"]",
")",
"}"
] | [
"public",
"final",
"byte",
"[",
"]",
"decode",
"(",
"char",
"sequence",
"chars",
")",
"{",
"try",
"{",
"return",
"decode",
"checked",
"(",
"chars",
")",
";",
"}",
"catch",
"(",
"decoding",
"exception",
"bad",
"input",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"bad",
"input",
")",
";",
"}",
"}"
] |
[
"gets",
"the",
"driver",
"strategy",
"from",
"this",
"node",
"this",
"determines",
"for",
"example",
"for",
"a",
"match",
"pact",
"whether",
"to",
"use",
"a",
"merge",
"or",
"a",
"hybrid",
"hash",
"strategy"
] | [
"public",
"driver",
"strategy",
"get",
"driver",
"strategy",
"(",
")",
"{",
"return",
"this",
"driver",
"strategy",
";",
"}"
] |
[
"label",
"to",
"limit",
"which",
"nodes",
"this",
"installation",
"can",
"be",
"performed",
"on",
"can",
"be",
"null",
"to",
"not",
"impose",
"a",
"limit"
] | [
"public",
"final",
"string",
"get",
"label",
"(",
")",
"{",
"return",
"label",
";",
"}"
] |
[
"get",
"the",
"preferred",
"font",
"data"
] | [
"public",
"font",
"data",
"get",
"font",
"data",
"(",
")",
"{",
"return",
"new",
"font",
"data",
"(",
"sample",
"font",
"data",
"get",
"name",
"(",
")",
",",
"sample",
"font",
"data",
"get",
"height",
"(",
")",
",",
"sample",
"font",
"data",
"get",
"style",
"(",
")",
")",
";",
"}"
] |
[
"test",
":",
"1",
"hash",
"arrays",
"are",
"the",
"same",
"size",
"2",
"hash",
"arrays",
"contain",
"the",
"same",
"elements",
"3",
"elements",
"are",
"in",
"the",
"same",
"order",
"4",
"elements",
"do",
"not",
"contain",
"the",
"same",
"values",
"expected",
"result",
":",
"equal"
] | [
"public",
"void",
"test",
"equality",
"6",
"(",
")",
"{",
"hash",
"entry",
"[",
"]",
"hash",
"entries",
"1",
"=",
"new",
"hash",
"entry",
"[",
"]",
"{",
"entry",
"1",
",",
"entry",
"3",
"}",
";",
"hash",
"entry",
"[",
"]",
"hash",
"entries",
"2",
"=",
"new",
"hash",
"entry",
"[",
"]",
"{",
"entry",
"1",
",",
"entry",
"3",
"}",
";",
"vec",
"1",
"set",
"hash",
"entries",
"(",
"hash",
"entries",
"1",
")",
";",
"vec",
"2",
"set",
"hash",
"entries",
"(",
"hash",
"entries",
"2",
")",
";",
"assert",
"assert",
"true",
"(",
"\"",
"failed",
"to",
"equate",
"vectors",
"with",
"identical",
"hash",
"entries",
"with",
"same",
"ordering",
"\"",
",",
"vec",
"1",
"equals",
"(",
"vec",
"2",
")",
")",
";",
"}"
] |
[
"method",
"called",
"when",
"the",
"action",
"is",
"invoked"
] | [
"public",
"void",
"action",
"performed",
"(",
"navigatable",
"action",
"context",
"context",
")",
"{",
"address",
"set",
"view",
"address",
"set",
"=",
"context",
"has",
"selection",
"(",
")",
"?",
"context",
"get",
"selection",
"(",
")",
":",
"new",
"address",
"set",
"(",
"context",
"get",
"address",
"(",
")",
")",
";",
"program",
"selection",
"selection",
"=",
"get",
"selection",
"(",
"context",
"get",
"program",
"(",
")",
",",
"address",
"set",
")",
";",
"navigation",
"utils",
"set",
"selection",
"(",
"tool",
",",
"context",
"get",
"navigatable",
"(",
")",
",",
"selection",
")",
";",
"}"
] |
[
"sets",
"the",
"x500",
"distinguished",
"name",
"for",
"a",
"user"
] | [
"public",
"synchronized",
"boolean",
"set",
"distinguished",
"name",
"(",
"string",
"username",
",",
"x",
"5",
"0",
"0",
"principal",
"x",
"5",
"0",
"0",
"user",
")",
"throws",
"i",
"o",
"exception",
"{",
"update",
"user",
"list",
"(",
"true",
")",
";",
"user",
"entry",
"old",
"entry",
"=",
"user",
"list",
"remove",
"(",
"username",
")",
";",
"if",
"(",
"old",
"entry",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"old",
"entry",
"x",
"5",
"0",
"0",
"user",
"!",
"=",
"null",
")",
"{",
"dn",
"lookup",
"map",
"remove",
"(",
"old",
"entry",
"x",
"5",
"0",
"0",
"user",
")",
";",
"}",
"user",
"entry",
"entry",
"=",
"new",
"user",
"entry",
"(",
")",
";",
"entry",
"username",
"=",
"username",
";",
"entry",
"password",
"hash",
"=",
"old",
"entry",
"password",
"hash",
";",
"entry",
"x",
"5",
"0",
"0",
"user",
"=",
"x",
"5",
"0",
"0",
"user",
";",
"user",
"list",
"put",
"(",
"username",
",",
"entry",
")",
";",
"if",
"(",
"x",
"5",
"0",
"0",
"user",
"!",
"=",
"null",
")",
"{",
"dn",
"lookup",
"map",
"put",
"(",
"x",
"5",
"0",
"0",
"user",
",",
"entry",
")",
";",
"}",
"write",
"user",
"list",
"(",
")",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}"
] |
[
"tests",
"that",
"we",
"upload",
"consistently",
"if",
"we",
"flush",
"after",
"every",
"little",
"bit",
"of",
"data"
] | [
"public",
"void",
"test",
"consistency",
"after",
"small",
"flushes",
"(",
")",
"throws",
"exception",
"{",
"test",
"consistency",
"after",
"many",
"flushes",
"(",
"flush",
"frequency",
"variation",
"before",
"single",
"buffer",
"full",
")",
";",
"}"
] |
[
"get",
"the",
"inlined",
"properties",
"that",
"were",
"declared",
"via",
"{",
"@",
"code",
"@",
"test",
"property",
"source",
"}",
"note",
":",
"the",
"returned",
"value",
"may",
"represent",
"merged",
"properties",
"that",
"do",
"not",
"match",
"the",
"original",
"value",
"declared",
"via",
"a",
"single",
"{",
"@",
"code",
"@",
"test",
"property",
"source",
"}",
"annotation"
] | [
"string",
"[",
"]",
"get",
"properties",
"(",
")",
"{",
"return",
"string",
"utils",
"to",
"string",
"array",
"(",
"this",
"properties",
")",
";",
"}"
] |
[
"receive",
"{",
"@",
"link",
"op",
"#",
"request",
"short",
"circuit",
"fds",
"}"
] | [
"private",
"void",
"op",
"request",
"short",
"circuit",
"fds",
"(",
"data",
"input",
"stream",
"in",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"op",
"request",
"short",
"circuit",
"access",
"proto",
"proto",
"=",
"op",
"request",
"short",
"circuit",
"access",
"proto",
"parse",
"from",
"(",
"vint",
"prefixed",
"(",
"in",
")",
")",
";",
"slot",
"id",
"slot",
"id",
"=",
"(",
"proto",
"has",
"slot",
"id",
"(",
")",
")",
"?",
"p",
"b",
"helper",
"client",
"convert",
"(",
"proto",
"get",
"slot",
"id",
"(",
")",
")",
":",
"null",
";",
"trace",
"scope",
"trace",
"scope",
"=",
"continue",
"trace",
"span",
"(",
"proto",
"get",
"header",
"(",
")",
",",
"proto",
"get",
"class",
"(",
")",
"get",
"simple",
"name",
"(",
")",
")",
";",
"try",
"{",
"request",
"short",
"circuit",
"fds",
"(",
"p",
"b",
"helper",
"client",
"convert",
"(",
"proto",
"get",
"header",
"(",
")",
"get",
"block",
"(",
")",
")",
",",
"p",
"b",
"helper",
"client",
"convert",
"(",
"proto",
"get",
"header",
"(",
")",
"get",
"token",
"(",
")",
")",
",",
"slot",
"id",
",",
"proto",
"get",
"max",
"version",
"(",
")",
",",
"proto",
"get",
"supports",
"receipt",
"verification",
"(",
")",
")",
";",
"}",
"finally",
"{",
"if",
"(",
"trace",
"scope",
"!",
"=",
"null",
")",
"trace",
"scope",
"close",
"(",
")",
";",
"}",
"}"
] |
[
"get",
"the",
"timestamps",
"of",
"the",
"archives",
"used",
"by",
"internal",
"distributed",
"cache",
"and",
"map",
"reduce",
"code"
] | [
"public",
"static",
"long",
"[",
"]",
"get",
"archive",
"timestamps",
"(",
"configuration",
"conf",
")",
"{",
"return",
"parse",
"timestamps",
"(",
"conf",
"get",
"strings",
"(",
"m",
"r",
"job",
"config",
"cache",
"archives",
"timestamps",
")",
")",
";",
"}"
] |
[
"get",
"prefix",
"array"
] | [
"public",
"list",
"<",
"integer",
">",
"get",
"prefix",
"array",
"(",
")",
"{",
"return",
"prefix",
"array",
";",
"}"
] |
[
"create",
"a",
"{",
"@",
"link",
"compression",
"input",
"stream",
"}",
"that",
"will",
"read",
"from",
"the",
"given",
"input",
"stream"
] | [
"public",
"compression",
"input",
"stream",
"create",
"input",
"stream",
"(",
"input",
"stream",
"in",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"compression",
"codec",
"util",
"create",
"input",
"stream",
"with",
"codec",
"pool",
"(",
"this",
",",
"conf",
",",
"in",
")",
";",
"}"
] |
[
"option",
"to",
"control",
"tagging",
"data",
"types",
"and",
"functions",
"with",
"their",
"dwarf",
"die",
"record",
"number"
] | [
"public",
"void",
"set",
"output",
"d",
"i",
"e",
"info",
"(",
"boolean",
"output",
"dwarf",
"die",
"info",
")",
"{",
"this",
"output",
"d",
"w",
"a",
"r",
"f",
"d",
"i",
"e",
"info",
"=",
"output",
"dwarf",
"die",
"info",
";",
"}"
] |
[
"sets",
"the",
"parameter",
"(",
"0",
"based",
")",
"using",
"the",
"position",
"in",
"which",
"it",
"was",
"added",
"during",
"building",
"the",
"query"
] | [
"public",
"abstract",
"query",
"<",
"t",
">",
"set",
"parameter",
"(",
"int",
"index",
",",
"object",
"parameter",
")",
"{",
"check",
"thread",
"(",
")",
";",
"if",
"(",
"parameter",
"!",
"=",
"null",
")",
"{",
"parameters",
"[",
"index",
"]",
"=",
"parameter",
"to",
"string",
"(",
")",
";",
"}",
"else",
"{",
"parameters",
"[",
"index",
"]",
"=",
"null",
";",
"}",
"return",
"this",
";",
"}"
] |
[
"shut",
"down",
"the",
"checkpointer"
] | [
"void",
"shutdown",
"(",
")",
"{",
"should",
"run",
"=",
"false",
";",
"backup",
"node",
"stop",
"(",
")",
";",
"}"
] |
[
"get",
"the",
"{",
"@",
"link",
"java",
"util",
"collection",
"}",
",",
"{",
"@",
"link",
"java",
"util",
"map",
"}",
"or",
"array",
"of",
"objects",
"used",
"to",
"generate",
"the",
"inner",
"'",
"{",
"@",
"code",
"option",
"}",
"'",
"tags",
"typically",
"a",
"runtime",
"expression"
] | [
"protected",
"object",
"get",
"items",
"(",
")",
"{",
"return",
"this",
"items",
";",
"}"
] |
[
"tests",
"if",
"stream",
"xml",
"record",
"reader",
"will",
"read",
"a",
"record",
"twice",
"if",
"end",
"of",
"a",
"split",
"is",
"after",
"few",
"characters",
"after",
"the",
"end",
"-",
"tag",
"of",
"a",
"record",
"but",
"before",
"the",
"begin",
"-",
"tag",
"of",
"next",
"record",
"tests",
"with",
"slowmatch",
"=",
"false"
] | [
"public",
"void",
"test",
"stream",
"xml",
"multi",
"outer",
"fast",
"(",
")",
"throws",
"exception",
"{",
"if",
"(",
"has",
"perl",
")",
"{",
"block",
"size",
"=",
"80",
";",
"is",
"slow",
"match",
"=",
"\"",
"false",
"\"",
";",
"super",
"test",
"command",
"line",
"(",
")",
";",
"}",
"else",
"{",
"log",
"warn",
"(",
"\"",
"no",
"perl",
";",
"skipping",
"test",
"\"",
")",
";",
"}",
"}"
] |
[
"set",
"this",
"node",
"to",
"be",
"in",
"error",
"the",
"node",
"'",
"s",
"value",
"must",
"not",
"have",
"already",
"been",
"set",
"however",
",",
"all",
"dependencies",
"of",
"this",
"node",
"must",
"already",
"have",
"been",
"registered",
",",
"since",
"this",
"method",
"may",
"register",
"a",
"dependence",
"on",
"the",
"error",
"transience",
"node",
",",
"which",
"should",
"always",
"be",
"the",
"last",
"dep"
] | [
"void",
"set",
"error",
"(",
"node",
"entry",
"state",
",",
"error",
"info",
"error",
"info",
")",
"throws",
"interrupted",
"exception",
"{",
"preconditions",
"check",
"state",
"(",
"value",
"=",
"=",
"null",
",",
"\"",
"%",
"s",
"%",
"s",
"%",
"s",
"\"",
",",
"sky",
"key",
",",
"value",
",",
"error",
"info",
")",
";",
"preconditions",
"check",
"state",
"(",
"this",
"error",
"info",
"=",
"=",
"null",
",",
"\"",
"%",
"s",
"%",
"s",
"%",
"s",
"\"",
",",
"sky",
"key",
",",
"this",
"error",
"info",
",",
"error",
"info",
")",
";",
"if",
"(",
"error",
"info",
"is",
"directly",
"transient",
"(",
")",
")",
"{",
"node",
"entry",
"error",
"transience",
"node",
"=",
"preconditions",
"check",
"not",
"null",
"(",
"evaluator",
"context",
"get",
"graph",
"(",
")",
"get",
"(",
"sky",
"key",
",",
"reason",
"rdep",
"addition",
",",
"error",
"transience",
"value",
"key",
")",
",",
"\"",
"null",
"error",
"value",
"?",
"%",
"s",
"\"",
",",
"sky",
"key",
")",
";",
"dependency",
"state",
"tri",
"state",
";",
"if",
"(",
"old",
"deps",
"contains",
"(",
"error",
"transience",
"value",
"key",
")",
")",
"{",
"tri",
"state",
"=",
"error",
"transience",
"node",
"check",
"if",
"done",
"for",
"dirty",
"reverse",
"dep",
"(",
"sky",
"key",
")",
";",
"}",
"else",
"{",
"tri",
"state",
"=",
"error",
"transience",
"node",
"add",
"reverse",
"dep",
"and",
"check",
"if",
"done",
"(",
"sky",
"key",
")",
";",
"}",
"preconditions",
"check",
"state",
"(",
"tri",
"state",
"=",
"=",
"dependency",
"state",
"done",
",",
"\"",
"%",
"s",
"%",
"s",
"%",
"s",
"\"",
",",
"sky",
"key",
",",
"tri",
"state",
",",
"error",
"info",
")",
";",
"state",
"add",
"temporary",
"direct",
"deps",
"(",
"grouped",
"list",
"helper",
"create",
"(",
"error",
"transience",
"value",
"key",
")",
")",
";",
"state",
"signal",
"dep",
"(",
"evaluator",
"context",
"get",
"graph",
"version",
"(",
")",
",",
"error",
"transience",
"value",
"key",
")",
";",
"max",
"child",
"version",
"=",
"evaluator",
"context",
"get",
"graph",
"version",
"(",
")",
";",
"}",
"this",
"error",
"info",
"=",
"preconditions",
"check",
"not",
"null",
"(",
"error",
"info",
",",
"sky",
"key",
")",
";",
"}"
] |
[
"returns",
"the",
"high",
"water",
"mark",
"for",
"the",
"write",
"buffer"
] | [
"public",
"int",
"high",
"(",
")",
"{",
"return",
"high",
";",
"}"
] |
[
"get",
"anytype",
"1"
] | [
"public",
"object",
"get",
"anytype",
"1",
"(",
")",
"{",
"return",
"anytype",
"1",
";",
"}"
] |
[
"returns",
"the",
"randomly",
"generated",
"server",
"name",
"for",
"this",
"service"
] | [
"public",
"final",
"string",
"get",
"server",
"name",
"(",
")",
"{",
"return",
"server",
"name",
";",
"}"
] |
[
"returns",
"the",
"type",
"of",
"the",
"annotation",
"just",
"returned",
"by",
"{",
"@",
"link",
"#",
"read",
"annotation",
"(",
")",
"}",
"this",
"method",
"'",
"s",
"value",
"is",
"undefined",
"unless",
"the",
"most",
"recent",
"call",
"was",
"to",
"{",
"@",
"link",
"#",
"read",
"annotation",
"(",
")",
"}"
] | [
"public",
"int",
"get",
"annotation",
"type",
"(",
")",
"{",
"return",
"annotation",
"type",
";",
"}"
] |
[
"removes",
"previous",
"installed",
"actions",
"for",
"this",
"component"
] | [
"public",
"void",
"uninstall",
"actions",
"(",
")",
"{",
"if",
"(",
"actions",
"=",
"=",
"null",
")",
"{",
"return",
";",
"}",
"for",
"(",
"docking",
"action",
"if",
"action",
":",
"actions",
")",
"{",
"tool",
"remove",
"action",
"(",
"action",
")",
";",
"}",
"}"
] |
[
"assigns",
"timestamps",
"to",
"the",
"elements",
"in",
"the",
"data",
"stream",
"and",
"creates",
"watermarks",
"based",
"on",
"events",
",",
"to",
"signal",
"event",
"time",
"progress",
"this",
"method",
"uses",
"the",
"deprecated",
"watermark",
"generator",
"interfaces",
"please",
"switch",
"to",
"{",
"@",
"link",
"#",
"assign",
"timestamps",
"and",
"watermarks",
"(",
"watermark",
"strategy",
")",
"}",
"to",
"use",
"the",
"new",
"interfaces",
"instead",
"the",
"new",
"interfaces",
"support",
"watermark",
"idleness",
"and",
"no",
"longer",
"need",
"to",
"differentiate",
"between",
"\"",
"periodic",
"\"",
"and",
"\"",
"punctuated",
"\"",
"watermarks"
] | [
"public",
"single",
"output",
"stream",
"operator",
"<",
"t",
">",
"assign",
"timestamps",
"and",
"watermarks",
"(",
"assigner",
"with",
"punctuated",
"watermarks",
"<",
"t",
">",
"timestamp",
"and",
"watermark",
"assigner",
")",
"{",
"final",
"assigner",
"with",
"punctuated",
"watermarks",
"<",
"t",
">",
"cleaned",
"assigner",
"=",
"clean",
"(",
"timestamp",
"and",
"watermark",
"assigner",
")",
";",
"final",
"watermark",
"strategy",
"<",
"t",
">",
"wms",
"=",
"new",
"assigner",
"with",
"punctuated",
"watermarks",
"adapter",
"strategy",
"<",
">",
"(",
"cleaned",
"assigner",
")",
";",
"return",
"assign",
"timestamps",
"and",
"watermarks",
"(",
"wms",
")",
";",
"}",
"/",
"/",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"/",
"/",
"data",
"sinks",
"/",
"/",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"add",
"a",
"duration"
] | [
"public",
"void",
"add",
"(",
"contract",
"test",
"utils",
"nano",
"timer",
"duration",
")",
"{",
"add",
"(",
"duration",
"elapsed",
"time",
"(",
")",
")",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] | [
"public",
"string",
"insn",
"comment",
"string",
"(",
"dalv",
"insn",
"insn",
",",
"boolean",
"note",
"indices",
")",
"{",
"cst",
"literal",
"bits",
"value",
"=",
"(",
"cst",
"literal",
"bits",
")",
"(",
"(",
"cst",
"insn",
")",
"insn",
")",
"get",
"constant",
"(",
")",
";",
"return",
"literal",
"bits",
"comment",
"(",
"value",
",",
"32",
")",
";",
"}"
] |
[
"sets",
"the",
"maximum",
"weighted",
"size",
"of",
"the",
"cache",
"the",
"caller",
"may",
"need",
"to",
"perform",
"a",
"maintenance",
"cycle",
"to",
"eagerly",
"evicts",
"entries",
"until",
"the",
"cache",
"shrinks",
"to",
"the",
"appropriate",
"size"
] | [
"void",
"set",
"maximum",
"size",
"(",
"long",
"maximum",
")",
"{",
"require",
"argument",
"(",
"maximum",
">",
"=",
"0",
",",
"\"",
"maximum",
"must",
"not",
"be",
"negative",
"\"",
")",
";",
"if",
"(",
"maximum",
"=",
"=",
"maximum",
"(",
")",
")",
"{",
"return",
";",
"}",
"long",
"max",
"=",
"math",
"min",
"(",
"maximum",
",",
"maximum",
"capacity",
")",
";",
"long",
"window",
"=",
"max",
"-",
"(",
"long",
")",
"(",
"percent",
"main",
"*",
"max",
")",
";",
"long",
"main",
"protected",
"=",
"(",
"long",
")",
"(",
"percent",
"main",
"protected",
"*",
"(",
"max",
"-",
"window",
")",
")",
";",
"set",
"maximum",
"(",
"max",
")",
";",
"set",
"window",
"maximum",
"(",
"window",
")",
";",
"set",
"main",
"protected",
"maximum",
"(",
"main",
"protected",
")",
";",
"set",
"hits",
"in",
"sample",
"(",
"0",
")",
";",
"set",
"misses",
"in",
"sample",
"(",
"0",
")",
";",
"set",
"step",
"size",
"(",
"-",
"hill",
"climber",
"step",
"percent",
"*",
"max",
")",
";",
"if",
"(",
"(",
"frequency",
"sketch",
"(",
")",
"!",
"=",
"null",
")",
"&",
"&",
"!",
"is",
"weighted",
"(",
")",
"&",
"&",
"(",
"weighted",
"size",
"(",
")",
">",
"=",
"(",
"max",
">",
">",
">",
"1",
")",
")",
")",
"{",
"/",
"/",
"lazily",
"initialize",
"when",
"close",
"to",
"the",
"maximum",
"size",
"frequency",
"sketch",
"(",
")",
"ensure",
"capacity",
"(",
"max",
")",
";",
"}",
"}"
] |
[
"clear",
"the",
"fast",
"list"
] | [
"public",
"void",
"clear",
"(",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"size",
";",
"i",
"+",
"+",
")",
"{",
"element",
"data",
"[",
"i",
"]",
"=",
"null",
";",
"}",
"size",
"=",
"0",
";",
"}"
] |
[
"the",
"client",
"completed",
"all",
"message",
"sending",
"however",
",",
"the",
"call",
"may",
"still",
"be",
"cancelled"
] | [
"public",
"void",
"on",
"half",
"close",
"(",
")",
"{",
"}"
] |
[
"specifies",
"multiple",
"quantile",
"indexes",
"to",
"be",
"calculated",
",",
"each",
"index",
"being",
"the",
"k",
"in",
"the",
"kth",
"q",
"-",
"quantile"
] | [
"public",
"scale",
"and",
"indexes",
"indexes",
"(",
"int",
"indexes",
")",
"{",
"return",
"new",
"scale",
"and",
"indexes",
"(",
"scale",
",",
"indexes",
"clone",
"(",
")",
")",
";",
"}"
] |
[
"try",
"adding",
"and",
"removing",
"interfaces",
"and",
"interceptors",
"on",
"prototype",
"changes",
"will",
"only",
"affect",
"future",
"references",
"obtained",
"from",
"the",
"factory",
"each",
"instance",
"will",
"be",
"independent"
] | [
"public",
"void",
"test",
"can",
"add",
"and",
"remove",
"aspect",
"interfaces",
"on",
"prototype",
"(",
")",
"{",
"assert",
"that",
"(",
"factory",
"get",
"bean",
"(",
"\"",
"test",
"2",
"\"",
")",
")",
"as",
"(",
"\"",
"shouldn",
"'",
"t",
"implement",
"time",
"stamped",
"before",
"manipulation",
"\"",
")",
"is",
"not",
"instance",
"of",
"(",
"time",
"stamped",
"class",
")",
";",
"proxy",
"factory",
"bean",
"config",
"=",
"(",
"proxy",
"factory",
"bean",
")",
"factory",
"get",
"bean",
"(",
"\"",
"&",
"test",
"2",
"\"",
")",
";",
"long",
"time",
"=",
"666l",
";",
"timestamp",
"introduction",
"interceptor",
"ti",
"=",
"new",
"timestamp",
"introduction",
"interceptor",
"(",
")",
";",
"ti",
"set",
"time",
"(",
"time",
")",
";",
"/",
"/",
"add",
"to",
"head",
"of",
"interceptor",
"chain",
"int",
"old",
"count",
"=",
"config",
"get",
"advisors",
"(",
")",
"length",
";",
"config",
"add",
"advisor",
"(",
"0",
",",
"new",
"default",
"introduction",
"advisor",
"(",
"ti",
",",
"time",
"stamped",
"class",
")",
")",
";",
"assert",
"that",
"(",
"config",
"get",
"advisors",
"(",
")",
"length",
"=",
"=",
"old",
"count",
"+",
"1",
")",
"is",
"true",
"(",
")",
";",
"time",
"stamped",
"ts",
"=",
"(",
"time",
"stamped",
")",
"factory",
"get",
"bean",
"(",
"\"",
"test",
"2",
"\"",
")",
";",
"assert",
"that",
"(",
"ts",
"get",
"time",
"stamp",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"time",
")",
";",
"/",
"/",
"can",
"remove",
"config",
"remove",
"advice",
"(",
"ti",
")",
";",
"assert",
"that",
"(",
"config",
"get",
"advisors",
"(",
")",
"length",
"=",
"=",
"old",
"count",
")",
"is",
"true",
"(",
")",
";",
"/",
"/",
"check",
"no",
"change",
"on",
"existing",
"object",
"reference",
"assert",
"that",
"(",
"ts",
"get",
"time",
"stamp",
"(",
")",
"=",
"=",
"time",
")",
"is",
"true",
"(",
")",
";",
"assert",
"that",
"(",
"factory",
"get",
"bean",
"(",
"\"",
"test",
"2",
"\"",
")",
")",
"as",
"(",
"\"",
"should",
"no",
"longer",
"implement",
"time",
"stamped",
"\"",
")",
"is",
"not",
"instance",
"of",
"(",
"time",
"stamped",
"class",
")",
";",
"/",
"/",
"now",
"check",
"non",
"-",
"effect",
"of",
"removing",
"interceptor",
"that",
"isn",
"'",
"t",
"there",
"config",
"remove",
"advice",
"(",
"new",
"debug",
"interceptor",
"(",
")",
")",
";",
"assert",
"that",
"(",
"config",
"get",
"advisors",
"(",
")",
"length",
"=",
"=",
"old",
"count",
")",
"is",
"true",
"(",
")",
";",
"i",
"test",
"bean",
"it",
"=",
"(",
"i",
"test",
"bean",
")",
"ts",
";",
"debug",
"interceptor",
"debug",
"interceptor",
"=",
"new",
"debug",
"interceptor",
"(",
")",
";",
"config",
"add",
"advice",
"(",
"0",
",",
"debug",
"interceptor",
")",
";",
"it",
"get",
"spouse",
"(",
")",
";",
"/",
"/",
"won",
"'",
"t",
"affect",
"existing",
"reference",
"assert",
"that",
"(",
"debug",
"interceptor",
"get",
"count",
"(",
")",
"=",
"=",
"0",
")",
"is",
"true",
"(",
")",
";",
"it",
"=",
"(",
"i",
"test",
"bean",
")",
"factory",
"get",
"bean",
"(",
"\"",
"test",
"2",
"\"",
")",
";",
"it",
"get",
"spouse",
"(",
")",
";",
"assert",
"that",
"(",
"debug",
"interceptor",
"get",
"count",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"1",
")",
";",
"config",
"remove",
"advice",
"(",
"debug",
"interceptor",
")",
";",
"it",
"get",
"spouse",
"(",
")",
";",
"/",
"/",
"still",
"invoked",
"with",
"old",
"reference",
"assert",
"that",
"(",
"debug",
"interceptor",
"get",
"count",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"2",
")",
";",
"/",
"/",
"not",
"invoked",
"with",
"new",
"object",
"it",
"=",
"(",
"i",
"test",
"bean",
")",
"factory",
"get",
"bean",
"(",
"\"",
"test",
"2",
"\"",
")",
";",
"it",
"get",
"spouse",
"(",
")",
";",
"assert",
"that",
"(",
"debug",
"interceptor",
"get",
"count",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"2",
")",
";",
"/",
"/",
"our",
"own",
"timestamped",
"reference",
"should",
"still",
"work",
"assert",
"that",
"(",
"ts",
"get",
"time",
"stamp",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"time",
")",
";",
"}"
] |
[
"return",
"the",
"underlying",
"value",
",",
"computing",
"the",
"value",
"if",
"necessary",
"all",
"calls",
"to",
"the",
"same",
"{",
"@",
"code",
"lazy",
"}",
"instance",
"will",
"return",
"the",
"same",
"result"
] | [
"t",
"get",
"(",
")",
";"
] |
[
"returns",
"the",
"appropriate",
"{",
"@",
"code",
"add",
"}",
"rop",
"for",
"the",
"given",
"types",
"the",
"result",
"is",
"a",
"shared",
"instance"
] | [
"public",
"static",
"rop",
"op",
"add",
"(",
"type",
"list",
"types",
")",
"{",
"return",
"pick",
"binary",
"op",
"(",
"types",
",",
"add",
"const",
"int",
",",
"add",
"const",
"long",
",",
"add",
"const",
"float",
",",
"add",
"const",
"double",
",",
"add",
"int",
",",
"add",
"long",
",",
"add",
"float",
",",
"add",
"double",
")",
";",
"}"
] |
[
"get",
"foreground",
"color",
"custom",
"property"
] | [
"public",
"final",
"color",
"get",
"foreground",
"color",
"(",
")",
"{",
"return",
"m",
"t",
"color",
"utils",
"contrastify",
"foreground",
"(",
"dark",
",",
"get",
"foreground",
"color",
"resource",
"(",
")",
",",
"is",
"not",
"high",
"contrast",
")",
";",
"}"
] |
Subsets and Splits