docstring_tokens
sequence | code_tokens
sequence |
|---|---|
[
"test",
"the",
"retry",
"count",
"while",
"used",
"in",
"a",
"retry",
"proxy"
] | [
"public",
"void",
"test",
"retry",
"proxy",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"client",
"client",
"=",
"new",
"client",
"(",
"long",
"writable",
"class",
",",
"conf",
")",
";",
"final",
"test",
"server",
"server",
"=",
"new",
"test",
"server",
"(",
"1",
",",
"false",
")",
";",
"server",
"call",
"listener",
"=",
"new",
"runnable",
"(",
")",
"{",
"private",
"int",
"retry",
"count",
"=",
"0",
";",
"@",
"override",
"public",
"void",
"run",
"(",
")",
"{",
"assert",
"assert",
"equals",
"(",
"retry",
"count",
"+",
"+",
",",
"server",
"get",
"call",
"retry",
"count",
"(",
")",
")",
";",
"}",
"}",
";",
"/",
"/",
"try",
"more",
"times",
",",
"so",
"it",
"is",
"easier",
"to",
"find",
"race",
"condition",
"bug",
"/",
"/",
"10000",
"times",
"runs",
"about",
"6s",
"on",
"a",
"core",
"i",
"7",
"machine",
"final",
"int",
"total",
"retry",
"=",
"10000",
";",
"dummy",
"protocol",
"proxy",
"=",
"(",
"dummy",
"protocol",
")",
"proxy",
"new",
"proxy",
"instance",
"(",
"dummy",
"protocol",
"class",
"get",
"class",
"loader",
"(",
")",
",",
"new",
"class",
"[",
"]",
"{",
"dummy",
"protocol",
"class",
"}",
",",
"new",
"test",
"invocation",
"handler",
"(",
"client",
",",
"server",
",",
"total",
"retry",
")",
")",
";",
"dummy",
"protocol",
"retry",
"proxy",
"=",
"(",
"dummy",
"protocol",
")",
"retry",
"proxy",
"create",
"(",
"dummy",
"protocol",
"class",
",",
"proxy",
",",
"retry",
"policies",
"retry",
"forever",
")",
";",
"try",
"{",
"server",
"start",
"(",
")",
";",
"retry",
"proxy",
"dummy",
"run",
"(",
")",
";",
"assert",
"assert",
"equals",
"(",
"test",
"invocation",
"handler",
"retry",
",",
"total",
"retry",
"+",
"1",
")",
";",
"}",
"finally",
"{",
"client",
"set",
"call",
"id",
"and",
"retry",
"count",
"(",
"0",
",",
"0",
",",
"null",
")",
";",
"client",
"stop",
"(",
")",
";",
"server",
"stop",
"(",
")",
";",
"}",
"}"
] |
[
"return",
"the",
"string",
"in",
"file"
] | [
"public",
"static",
"string",
"read",
"file",
"2",
"string",
"(",
"final",
"string",
"file",
"path",
")",
"{",
"return",
"read",
"file",
"2",
"string",
"(",
"utils",
"bridge",
"get",
"file",
"by",
"path",
"(",
"file",
"path",
")",
",",
"null",
")",
";",
"}"
] |
[
"returns",
"a",
"new",
"instance",
"of",
"{",
"@",
"code",
"class",
"name",
"}",
"that",
"is",
"the",
"desugar",
"-",
"mirrored",
"core",
"type",
"(",
"e",
"g",
"{",
"@",
"code",
"j",
"$",
"time",
"month",
"day",
"}",
")",
"of",
"the",
"current",
"shadowed",
"built",
"-",
"in",
"core",
"type",
",",
"assuming",
"{",
"@",
"code",
"this",
"}",
"instance",
"is",
"a",
"desugared",
"-",
"shadowed",
"built",
"-",
"in",
"core",
"type"
] | [
"public",
"final",
"class",
"name",
"shadowed",
"to",
"mirrored",
"(",
")",
"{",
"return",
"shadowed",
"to",
"mirrored",
"type",
"prefix",
"mappings",
"key",
"set",
"(",
")",
"stream",
"(",
")",
"filter",
"(",
"this",
":",
":",
"has",
"package",
"prefix",
")",
"map",
"(",
"prefix",
"-",
">",
"replace",
"package",
"prefix",
"(",
"prefix",
",",
"shadowed",
"to",
"mirrored",
"type",
"prefix",
"mappings",
"get",
"(",
"prefix",
")",
")",
")",
"find",
"any",
"(",
")",
"or",
"else",
"(",
"this",
")",
";",
"}"
] |
[
"forge",
"an",
"invalid",
"session",
"packet",
"as",
"a",
"leader",
"do"
] | [
"private",
"quorum",
"packet",
"create",
"validate",
"session",
"packet",
"response",
"(",
"boolean",
"valid",
")",
"throws",
"exception",
"{",
"quorum",
"packet",
"qp",
"=",
"create",
"validate",
"session",
"packet",
"(",
")",
";",
"byte",
"array",
"input",
"stream",
"bis",
"=",
"new",
"byte",
"array",
"input",
"stream",
"(",
"qp",
"get",
"data",
"(",
")",
")",
";",
"data",
"input",
"stream",
"dis",
"=",
"new",
"data",
"input",
"stream",
"(",
"bis",
")",
";",
"long",
"id",
"=",
"dis",
"read",
"long",
"(",
")",
";",
"byte",
"array",
"output",
"stream",
"bos",
"=",
"new",
"byte",
"array",
"output",
"stream",
"(",
")",
";",
"data",
"output",
"stream",
"dos",
"=",
"new",
"data",
"output",
"stream",
"(",
"bos",
")",
";",
"dos",
"write",
"long",
"(",
"id",
")",
";",
"/",
"/",
"false",
"means",
"that",
"the",
"session",
"has",
"expired",
"dos",
"write",
"boolean",
"(",
"valid",
")",
";",
"qp",
"set",
"data",
"(",
"bos",
"to",
"byte",
"array",
"(",
")",
")",
";",
"return",
"qp",
";",
"}"
] |
[
"returns",
"the",
"key",
"names",
"of",
"any",
"keys",
"or",
"values",
"that",
"are",
"absent"
] | [
"public",
"set",
"<",
"string",
">",
"absent",
"keys",
"or",
"values",
"(",
")",
"{",
"return",
"underlying",
"map",
"entry",
"set",
"(",
")",
"stream",
"(",
")",
"filter",
"(",
"linked",
"optional",
"map",
":",
":",
"key",
"or",
"value",
"is",
"absent",
")",
"map",
"(",
"entry",
":",
":",
"get",
"key",
")",
"collect",
"(",
"collectors",
"to",
"collection",
"(",
"linked",
"hash",
"set",
":",
":",
"new",
")",
")",
";",
"}"
] |
[
"trim",
"string",
",",
"or",
"null",
"if",
"string",
"is",
"null"
] | [
"public",
"static",
"string",
"trim",
"(",
"final",
"string",
"str",
")",
"{",
"return",
"str",
"=",
"=",
"null",
"?",
"null",
":",
"str",
"trim",
"(",
")",
";",
"}"
] |
[
"stops",
"and",
"frees",
"any",
"resources",
"(",
"e",
"g",
"threads",
")",
"acquired",
"during",
"the",
"execution",
"of",
"the",
"bootstrap"
] | [
"void",
"stop",
"(",
")",
"throws",
"exception",
";"
] |
[
"set",
"the",
"branch",
"which",
"contains",
"this",
"node"
] | [
"protected",
"void",
"set",
"parent",
"(",
"assembly",
"parse",
"branch",
"parent",
")",
"{",
"/",
"/",
"note",
":",
"cannot",
"assert",
",",
"since",
"the",
"lr",
"parser",
"may",
"backtrack",
"and",
"reassign",
"this",
"parent",
"=",
"parent",
";",
"}"
] |
[
"take",
"a",
"time",
"step",
"this",
"performs",
"collision",
"detection",
",",
"integration",
",",
"and",
"constraint",
"solution"
] | [
"public",
"void",
"step",
"(",
"float",
"time",
"step",
",",
"int",
"velocity",
"iterations",
",",
"int",
"position",
"iterations",
")",
"{",
"world",
"step",
"(",
"time",
"step",
",",
"velocity",
"iterations",
",",
"position",
"iterations",
")",
";",
"}"
] |
[
"implementation",
"of",
"{",
"@",
"link",
"futures",
"#",
"get",
"checked",
"(",
"future",
",",
"class",
",",
"long",
",",
"time",
"unit",
")",
"}"
] | [
"static",
"<",
"v",
",",
"x",
"extends",
"exception",
">",
"v",
"get",
"checked",
"(",
"future",
"<",
"v",
">",
"future",
",",
"class",
"<",
"x",
">",
"exception",
"class",
",",
"long",
"timeout",
",",
"time",
"unit",
"unit",
")",
"throws",
"x",
"{",
"/",
"/",
"todo",
"(",
"cpovirk",
")",
":",
"benchmark",
"a",
"version",
"of",
"this",
"method",
"that",
"accepts",
"a",
"get",
"checked",
"type",
"validator",
"best",
"get",
"checked",
"type",
"validator",
"(",
")",
"validate",
"class",
"(",
"exception",
"class",
")",
";",
"try",
"{",
"return",
"future",
"get",
"(",
"timeout",
",",
"unit",
")",
";",
"}",
"catch",
"(",
"interrupted",
"exception",
"e",
")",
"{",
"current",
"thread",
"(",
")",
"interrupt",
"(",
")",
";",
"throw",
"new",
"with",
"cause",
"(",
"exception",
"class",
",",
"e",
")",
";",
"}",
"catch",
"(",
"timeout",
"exception",
"e",
")",
"{",
"throw",
"new",
"with",
"cause",
"(",
"exception",
"class",
",",
"e",
")",
";",
"}",
"catch",
"(",
"execution",
"exception",
"e",
")",
"{",
"wrap",
"and",
"throw",
"exception",
"or",
"error",
"(",
"e",
"get",
"cause",
"(",
")",
",",
"exception",
"class",
")",
";",
"throw",
"new",
"assertion",
"error",
"(",
")",
";",
"}",
"}"
] |
[
"creates",
"a",
"format",
"from",
"the",
"given",
"context",
"and",
"format",
"options",
"the",
"format",
"options",
"have",
"been",
"projected",
"to",
"top",
"-",
"level",
"options",
"(",
"e",
"g",
"from",
"{",
"@",
"code",
"format",
"ignore",
"-",
"errors",
"}",
"to",
"{",
"@",
"code",
"ignore",
"-",
"errors",
"}",
")"
] | [
"decoding",
"format",
"<",
"i",
">",
"create",
"decoding",
"format",
"(",
"dynamic",
"table",
"factory",
"context",
"context",
",",
"readable",
"config",
"format",
"options",
")",
";"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] | [
"public",
"string",
"to",
"string",
"(",
")",
"{",
"return",
"\"",
"nat",
"{",
"\"",
"+",
"to",
"human",
"(",
")",
"+",
"'",
"}",
"'",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] | [
"public",
"void",
"execute",
"(",
"runnable",
"command",
")",
"{",
"execute",
"(",
"command",
",",
"0",
",",
"time",
"unit",
"milliseconds",
")",
";",
"}"
] |
[
"the",
"amount",
"completed",
",",
"between",
"zero",
"and",
"one"
] | [
"public",
"float",
"get",
"progress",
"(",
")",
"{",
"return",
"progress",
";",
"}"
] |
[
"returns",
"the",
"parent",
"of",
"this",
"resource",
"file",
"or",
"null",
"if",
"it",
"is",
"a",
"root"
] | [
"public",
"resource",
"file",
"get",
"parent",
"file",
"(",
")",
"{",
"resource",
"parent",
"=",
"resource",
"get",
"parent",
"(",
")",
";",
"return",
"parent",
"=",
"=",
"null",
"?",
"null",
":",
"new",
"resource",
"file",
"(",
"parent",
")",
";",
"}"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"creates",
"the",
"underlying",
"database",
"table"
] | [
"public",
"static",
"void",
"create",
"table",
"(",
"database",
"db",
",",
"boolean",
"if",
"not",
"exists",
")",
"{",
"string",
"constraint",
"=",
"if",
"not",
"exists",
"?",
"\"",
"if",
"not",
"exists",
"\"",
":",
"\"",
"\"",
";",
"db",
"exec",
"s",
"q",
"l",
"(",
"\"",
"create",
"table",
"\"",
"+",
"constraint",
"+",
"\"",
"\\",
"\"",
"an",
"active",
"entity",
"\\",
"\"",
"(",
"\"",
"+",
"/",
"/",
"\"",
"\\",
"\"",
"id",
"\\",
"\"",
"integer",
"primary",
"key",
",",
"\"",
"+",
"/",
"/",
"0",
":",
"id",
"\"",
"\\",
"\"",
"text",
"\\",
"\"",
"text",
")",
";",
"\"",
")",
";",
"/",
"/",
"1",
":",
"text",
"}"
] |
[
"get",
"the",
"preferred",
"parameter",
"location",
"for",
"a",
"new",
"parameter",
"which",
"will",
"appended",
"to",
"the",
"end",
"of",
"an",
"existing",
"set",
"of",
"params",
"if",
"existing",
"parameters",
"use",
"custom",
"storage",
",",
"this",
"method",
"should",
"not",
"be",
"used"
] | [
"public",
"variable",
"storage",
"get",
"next",
"arg",
"location",
"(",
"parameter",
"[",
"]",
"params",
",",
"data",
"type",
"data",
"type",
",",
"program",
"program",
")",
"{",
"return",
"get",
"arg",
"location",
"(",
"params",
"!",
"=",
"null",
"?",
"params",
"length",
":",
"0",
",",
"params",
",",
"data",
"type",
",",
"program",
")",
";",
"}"
] |
[
"returns",
"the",
"top",
"-",
"level",
"media",
"type",
"for",
"example",
",",
"{",
"@",
"code",
"\"",
"text",
"\"",
"}",
"in",
"{",
"@",
"code",
"\"",
"textplain",
"\"",
"}"
] | [
"public",
"string",
"type",
"(",
")",
"{",
"return",
"type",
";",
"}"
] |
[
"enters",
"this",
"monitor",
"if",
"it",
"is",
"possible",
"to",
"do",
"so",
"immediately",
"and",
"the",
"guard",
"is",
"satisfied",
"does",
"not",
"block",
"acquiring",
"the",
"lock",
"and",
"does",
"not",
"wait",
"for",
"the",
"guard",
"to",
"be",
"satisfied",
"<",
"b",
">",
"note",
":",
"<",
"b",
">",
"this",
"method",
"disregards",
"the",
"fairness",
"setting",
"of",
"this",
"monitor"
] | [
"public",
"boolean",
"try",
"enter",
"if",
"(",
"guard",
"guard",
")",
"{",
"if",
"(",
"guard",
"monitor",
"!",
"=",
"this",
")",
"{",
"throw",
"new",
"illegal",
"monitor",
"state",
"exception",
"(",
")",
";",
"}",
"final",
"reentrant",
"lock",
"lock",
"=",
"this",
"lock",
";",
"if",
"(",
"!",
"lock",
"try",
"lock",
"(",
")",
")",
"{",
"return",
"false",
";",
"}",
"boolean",
"satisfied",
"=",
"false",
";",
"try",
"{",
"return",
"satisfied",
"=",
"guard",
"is",
"satisfied",
"(",
")",
";",
"}",
"finally",
"{",
"if",
"(",
"!",
"satisfied",
")",
"{",
"lock",
"unlock",
"(",
")",
";",
"}",
"}",
"}"
] |
[
"randomly",
"updates",
"routing",
"table",
"in",
"the",
"cluster",
"state"
] | [
"private",
"cluster",
"state",
"builder",
"random",
"routing",
"table",
"(",
"cluster",
"state",
"cluster",
"state",
")",
"{",
"routing",
"table",
"builder",
"builder",
"=",
"routing",
"table",
"builder",
"(",
"cluster",
"state",
"routing",
"table",
"(",
")",
")",
";",
"int",
"number",
"of",
"indices",
"=",
"cluster",
"state",
"routing",
"table",
"(",
")",
"indices",
"routing",
"(",
")",
"size",
"(",
")",
";",
"if",
"(",
"number",
"of",
"indices",
">",
"0",
")",
"{",
"list",
"<",
"string",
">",
"random",
"indices",
"=",
"random",
"subset",
"of",
"(",
"random",
"int",
"(",
"number",
"of",
"indices",
"-",
"1",
")",
",",
"cluster",
"state",
"routing",
"table",
"(",
")",
"indices",
"routing",
"(",
")",
"keys",
"(",
")",
"to",
"array",
"(",
"string",
"class",
")",
")",
";",
"for",
"(",
"string",
"index",
":",
"random",
"indices",
")",
"{",
"if",
"(",
"random",
"boolean",
"(",
")",
")",
"{",
"builder",
"remove",
"(",
"index",
")",
";",
"}",
"else",
"{",
"builder",
"add",
"(",
"random",
"change",
"to",
"index",
"routing",
"table",
"(",
"cluster",
"state",
"routing",
"table",
"(",
")",
"indices",
"routing",
"(",
")",
"get",
"(",
"index",
")",
",",
"cluster",
"state",
"nodes",
"(",
")",
"get",
"nodes",
"(",
")",
"keys",
"(",
")",
"to",
"array",
"(",
"string",
"class",
")",
")",
")",
";",
"}",
"}",
"}",
"int",
"additional",
"index",
"count",
"=",
"random",
"int",
"between",
"(",
"1",
",",
"20",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"additional",
"index",
"count",
";",
"i",
"+",
"+",
")",
"{",
"builder",
"add",
"(",
"random",
"index",
"routing",
"table",
"(",
"\"",
"index",
"-",
"\"",
"+",
"random",
"int",
"(",
")",
",",
"cluster",
"state",
"nodes",
"(",
")",
"get",
"nodes",
"(",
")",
"keys",
"(",
")",
"to",
"array",
"(",
"string",
"class",
")",
")",
")",
";",
"}",
"return",
"cluster",
"state",
"builder",
"(",
"cluster",
"state",
")",
"routing",
"table",
"(",
"builder",
"build",
"(",
")",
")",
";",
"}"
] |
[
"create",
"a",
"high",
"symbol",
"based",
"on",
"the",
"id",
"of",
"the",
"underlying",
"ghidra",
"symbol",
"the",
"symbol",
"is",
"looked",
"up",
"in",
"the",
"symbol",
"table",
"and",
"then",
"a",
"high",
"symbol",
"is",
"created",
"with",
"the",
"name",
"and",
"data",
"type",
"associated",
"with",
"the",
"symbol",
"if",
"a",
"symbol",
"cannot",
"be",
"found",
",",
"null",
"is",
"returned"
] | [
"public",
"high",
"symbol",
"populate",
"symbol",
"(",
"long",
"id",
",",
"data",
"type",
"data",
"type",
",",
"int",
"sz",
")",
"{",
"if",
"(",
"(",
"id",
">",
">",
"56",
")",
"=",
"=",
"(",
"high",
"symbol",
"id",
"base",
">",
">",
"56",
")",
")",
"{",
"return",
"null",
";",
"/",
"/",
"this",
"is",
"an",
"internal",
"id",
",",
"not",
"a",
"database",
"key",
"}",
"symbol",
"symbol",
"=",
"symbol",
"table",
"get",
"symbol",
"(",
"id",
")",
";",
"if",
"(",
"symbol",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"high",
"symbol",
"high",
"sym",
"=",
"null",
";",
"if",
"(",
"symbol",
"instanceof",
"code",
"symbol",
")",
"{",
"if",
"(",
"data",
"type",
"=",
"=",
"null",
")",
"{",
"object",
"data",
"obj",
"=",
"symbol",
"get",
"object",
"(",
")",
";",
"if",
"(",
"data",
"obj",
"instanceof",
"data",
")",
"{",
"data",
"type",
"=",
"(",
"(",
"data",
")",
"data",
"obj",
")",
"get",
"data",
"type",
"(",
")",
";",
"sz",
"=",
"data",
"type",
"get",
"length",
"(",
")",
";",
"}",
"else",
"{",
"data",
"type",
"=",
"data",
"type",
"default",
";",
"sz",
"=",
"1",
";",
"}",
"}",
"high",
"sym",
"=",
"new",
"high",
"code",
"symbol",
"(",
"(",
"code",
"symbol",
")",
"symbol",
",",
"data",
"type",
",",
"sz",
",",
"func",
")",
";",
"}",
"else",
"if",
"(",
"symbol",
"instanceof",
"function",
"symbol",
")",
"{",
"high",
"sym",
"=",
"new",
"high",
"function",
"shell",
"symbol",
"(",
"id",
",",
"symbol",
"get",
"name",
"(",
")",
",",
"symbol",
"get",
"address",
"(",
")",
",",
"func",
"get",
"data",
"type",
"manager",
"(",
")",
")",
";",
"}",
"else",
"{",
"return",
"null",
";",
"}",
"insert",
"symbol",
"(",
"high",
"sym",
",",
"symbol",
"get",
"address",
"(",
")",
")",
";",
"return",
"high",
"sym",
";",
"}"
] |
[
"called",
"when",
"part",
"of",
"a",
"result",
"has",
"been",
"computed",
"note",
"that",
"this",
"method",
"can",
"be",
"called",
"several",
"times",
"for",
"a",
"single",
"{",
"@",
"code",
"batch",
"callback",
"}",
"implementations",
"should",
"assume",
"that",
"multiple",
"calls",
"can",
"happen"
] | [
"void",
"process",
"(",
"iterable",
"<",
"t",
">",
"partial",
"result",
")",
"throws",
"e",
",",
"interrupted",
"exception",
";"
] |
[
"sends",
"a",
"sasl",
"client",
"token",
"to",
"server",
"if",
"required",
"this",
"may",
"be",
"an",
"initial",
"token",
"to",
"start",
"sasl",
"token",
"exchange",
"or",
"response",
"to",
"a",
"challenge",
"from",
"the",
"server"
] | [
"private",
"boolean",
"send",
"sasl",
"client",
"token",
"(",
"byte",
"[",
"]",
"server",
"token",
",",
"boolean",
"is",
"initial",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"!",
"sasl",
"client",
"is",
"complete",
"(",
")",
")",
"{",
"byte",
"[",
"]",
"sasl",
"token",
"=",
"create",
"sasl",
"token",
"(",
"server",
"token",
",",
"is",
"initial",
")",
";",
"if",
"(",
"sasl",
"token",
"!",
"=",
"null",
")",
"{",
"byte",
"buffer",
"token",
"buf",
"=",
"byte",
"buffer",
"wrap",
"(",
"sasl",
"token",
")",
";",
"send",
"send",
";",
"if",
"(",
"sasl",
"authenticate",
"version",
"=",
"=",
"disable",
"kafka",
"sasl",
"authenticate",
"header",
")",
"{",
"send",
"=",
"byte",
"buffer",
"send",
"size",
"prefixed",
"(",
"token",
"buf",
")",
";",
"}",
"else",
"{",
"sasl",
"authenticate",
"request",
"data",
"data",
"=",
"new",
"sasl",
"authenticate",
"request",
"data",
"(",
")",
"set",
"auth",
"bytes",
"(",
"token",
"buf",
"array",
"(",
")",
")",
";",
"sasl",
"authenticate",
"request",
"request",
"=",
"new",
"sasl",
"authenticate",
"request",
"builder",
"(",
"data",
")",
"build",
"(",
"sasl",
"authenticate",
"version",
")",
";",
"send",
"=",
"request",
"to",
"send",
"(",
"next",
"request",
"header",
"(",
"api",
"keys",
"sasl",
"authenticate",
",",
"sasl",
"authenticate",
"version",
")",
")",
";",
"}",
"send",
"(",
"send",
")",
";",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}"
] |
[
"get",
"class",
"name"
] | [
"public",
"string",
"get",
"class",
"name",
"(",
")",
"{",
"return",
"class",
"name",
";",
"}"
] |
[
"get",
"the",
"split",
"locations",
",",
"applicable",
"for",
"map",
"tasks"
] | [
"public",
"string",
"get",
"split",
"locations",
"(",
")",
"{",
"return",
"datum",
"get",
"split",
"locations",
"(",
")",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"returns",
"the",
"value",
"of",
"the",
"{",
"@",
"code",
"test",
"runner",
"fail",
"fast",
"}",
"option",
",",
"or",
"<",
"code",
">",
"false",
"<",
"code",
">",
"if",
"it",
"was",
"not",
"specified"
] | [
"boolean",
"get",
"test",
"runner",
"fail",
"fast",
"(",
")",
"{",
"return",
"test",
"runner",
"fail",
"fast",
";",
"}"
] |
[
"register",
"a",
"listener",
"that",
"will",
"be",
"called",
"when",
"this",
"model",
"visibility",
"has",
"changed",
"the",
"listener",
"will",
"contribute",
"to",
"this",
"model",
"'",
"s",
"hash",
"code",
"state",
"per",
"the",
"{",
"@",
"link",
"com",
"airbnb",
"epoxy",
"epoxy",
"attribute",
"option",
"#",
"do",
"not",
"hash",
"}",
"rules"
] | [
"public",
"model",
"with",
"field",
"annotation",
"on",
"visibility",
"changed",
"(",
"on",
"model",
"visibility",
"changed",
"listener",
"<",
"model",
"with",
"field",
"annotation",
",",
"object",
">",
"listener",
")",
"{",
"on",
"mutation",
"(",
")",
";",
"this",
"on",
"model",
"visibility",
"changed",
"listener",
"epoxy",
"generated",
"model",
"=",
"listener",
";",
"return",
"this",
";",
"}"
] |
[
"register",
"a",
"listener",
"that",
"will",
"be",
"called",
"when",
"this",
"model",
"visibility",
"state",
"has",
"changed",
"the",
"listener",
"will",
"contribute",
"to",
"this",
"model",
"'",
"s",
"hash",
"code",
"state",
"per",
"the",
"{",
"@",
"link",
"com",
"airbnb",
"epoxy",
"epoxy",
"attribute",
"option",
"#",
"do",
"not",
"hash",
"}",
"rules"
] | [
"public",
"generate",
"default",
"layout",
"method",
"next",
"parent",
"layout",
"$",
"with",
"layout",
"on",
"visibility",
"state",
"changed",
"(",
"on",
"model",
"visibility",
"state",
"changed",
"listener",
"<",
"generate",
"default",
"layout",
"method",
"next",
"parent",
"layout",
"$",
"with",
"layout",
",",
"object",
">",
"listener",
")",
"{",
"on",
"mutation",
"(",
")",
";",
"this",
"on",
"model",
"visibility",
"state",
"changed",
"listener",
"epoxy",
"generated",
"model",
"=",
"listener",
";",
"return",
"this",
";",
"}"
] |
[
"advances",
"{",
"@",
"code",
"iterator",
"}",
"{",
"@",
"code",
"position",
"+",
"1",
"}",
"times",
",",
"returning",
"the",
"element",
"at",
"the",
"{",
"@",
"code",
"position",
"}",
"th",
"position"
] | [
"public",
"static",
"<",
"t",
">",
"t",
"get",
"(",
"iterator",
"<",
"t",
">",
"iterator",
",",
"int",
"position",
")",
"{",
"check",
"nonnegative",
"(",
"position",
")",
";",
"int",
"skipped",
"=",
"advance",
"(",
"iterator",
",",
"position",
")",
";",
"if",
"(",
"!",
"iterator",
"has",
"next",
"(",
")",
")",
"{",
"throw",
"new",
"index",
"out",
"of",
"bounds",
"exception",
"(",
"\"",
"position",
"(",
"\"",
"+",
"position",
"+",
"\"",
")",
"must",
"be",
"less",
"than",
"the",
"number",
"of",
"elements",
"that",
"remained",
"(",
"\"",
"+",
"skipped",
"+",
"\"",
")",
"\"",
")",
";",
"}",
"return",
"iterator",
"next",
"(",
")",
";",
"}"
] |
[
"returns",
"the",
"value",
"of",
"the",
"named",
"rule",
"attribute",
",",
"which",
"must",
"be",
"of",
"the",
"given",
"type",
"this",
"may",
"be",
"null",
"(",
"for",
"example",
",",
"for",
"an",
"attribute",
"with",
"no",
"default",
"value",
"that",
"isn",
"'",
"t",
"explicitly",
"set",
"in",
"the",
"rule",
"-",
"see",
"{",
"@",
"link",
"type",
"#",
"get",
"default",
"value",
"}",
")",
"if",
"the",
"rule",
"doesn",
"'",
"t",
"have",
"this",
"attribute",
"with",
"the",
"specified",
"type",
",",
"throws",
"an",
"{",
"@",
"link",
"illegal",
"argument",
"exception",
"}"
] | [
"<",
"t",
">",
"t",
"get",
"(",
"string",
"attribute",
"name",
",",
"type",
"<",
"t",
">",
"type",
")",
";"
] |
[
"called",
"when",
"an",
"audio",
"renderer",
"is",
"enabled"
] | [
"default",
"void",
"on",
"audio",
"enabled",
"(",
"event",
"time",
"event",
"time",
",",
"decoder",
"counters",
"counters",
")",
"{",
"}"
] |
[
"check",
"that",
"the",
"deprecated",
"\"",
"n",
"gram",
"\"",
"filter",
"throws",
"exception",
"for",
"indices",
"created",
"since",
"7",
"0",
"0",
"and",
"logs",
"a",
"warning",
"for",
"earlier",
"indices",
"when",
"the",
"filter",
"is",
"used",
"as",
"a",
"custom",
"filter"
] | [
"public",
"void",
"test",
"n",
"gram",
"filter",
"in",
"custom",
"analyzer",
"deprecation",
"error",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"settings",
"settings",
"=",
"settings",
"builder",
"(",
")",
"put",
"(",
"environment",
"path",
"home",
"setting",
"get",
"key",
"(",
")",
",",
"create",
"temp",
"dir",
"(",
")",
")",
"put",
"(",
"index",
"metadata",
"setting",
"version",
"created",
",",
"version",
"utils",
"random",
"version",
"between",
"(",
"random",
"(",
")",
",",
"version",
"v",
"8",
"0",
"0",
",",
"version",
"current",
")",
")",
"put",
"(",
"\"",
"index",
"analysis",
"analyzer",
"custom",
"analyzer",
"type",
"\"",
",",
"\"",
"custom",
"\"",
")",
"put",
"(",
"\"",
"index",
"analysis",
"analyzer",
"custom",
"analyzer",
"tokenizer",
"\"",
",",
"\"",
"standard",
"\"",
")",
"put",
"list",
"(",
"\"",
"index",
"analysis",
"analyzer",
"custom",
"analyzer",
"filter",
"\"",
",",
"\"",
"my",
"ngram",
"\"",
")",
"put",
"(",
"\"",
"index",
"analysis",
"filter",
"my",
"ngram",
"type",
"\"",
",",
"\"",
"n",
"gram",
"\"",
")",
"build",
"(",
")",
";",
"try",
"(",
"common",
"analysis",
"plugin",
"common",
"analysis",
"plugin",
"=",
"new",
"common",
"analysis",
"plugin",
"(",
")",
")",
"{",
"illegal",
"argument",
"exception",
"ex",
"=",
"expect",
"throws",
"(",
"illegal",
"argument",
"exception",
"class",
",",
"(",
")",
"-",
">",
"create",
"test",
"analysis",
"(",
"index",
"settings",
"module",
"new",
"index",
"settings",
"(",
"\"",
"index",
"\"",
",",
"settings",
")",
",",
"settings",
",",
"common",
"analysis",
"plugin",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"the",
"[",
"n",
"gram",
"]",
"token",
"filter",
"name",
"was",
"deprecated",
"in",
"6",
"4",
"and",
"cannot",
"be",
"used",
"in",
"new",
"indices",
"\"",
"+",
"\"",
"please",
"change",
"the",
"filter",
"name",
"to",
"[",
"ngram",
"]",
"instead",
"\"",
",",
"ex",
"get",
"message",
"(",
")",
")",
";",
"}",
"final",
"settings",
"settings",
"pre",
"7",
"=",
"settings",
"builder",
"(",
")",
"put",
"(",
"environment",
"path",
"home",
"setting",
"get",
"key",
"(",
")",
",",
"create",
"temp",
"dir",
"(",
")",
")",
"put",
"(",
"index",
"metadata",
"setting",
"version",
"created",
",",
"version",
"utils",
"random",
"version",
"between",
"(",
"random",
"(",
")",
",",
"version",
"v",
"7",
"0",
"0",
",",
"version",
"v",
"7",
"6",
"0",
")",
")",
"put",
"(",
"\"",
"index",
"analysis",
"analyzer",
"custom",
"analyzer",
"type",
"\"",
",",
"\"",
"custom",
"\"",
")",
"put",
"(",
"\"",
"index",
"analysis",
"analyzer",
"custom",
"analyzer",
"tokenizer",
"\"",
",",
"\"",
"standard",
"\"",
")",
"put",
"list",
"(",
"\"",
"index",
"analysis",
"analyzer",
"custom",
"analyzer",
"filter",
"\"",
",",
"\"",
"my",
"ngram",
"\"",
")",
"put",
"(",
"\"",
"index",
"analysis",
"filter",
"my",
"ngram",
"type",
"\"",
",",
"\"",
"n",
"gram",
"\"",
")",
"build",
"(",
")",
";",
"try",
"(",
"common",
"analysis",
"plugin",
"common",
"analysis",
"plugin",
"=",
"new",
"common",
"analysis",
"plugin",
"(",
")",
")",
"{",
"create",
"test",
"analysis",
"(",
"index",
"settings",
"module",
"new",
"index",
"settings",
"(",
"\"",
"index",
"\"",
",",
"settings",
"pre",
"7",
")",
",",
"settings",
"pre",
"7",
",",
"common",
"analysis",
"plugin",
")",
";",
"assert",
"warnings",
"(",
"\"",
"the",
"[",
"n",
"gram",
"]",
"token",
"filter",
"name",
"is",
"deprecated",
"and",
"will",
"be",
"removed",
"in",
"a",
"future",
"version",
"\"",
"+",
"\"",
"please",
"change",
"the",
"filter",
"name",
"to",
"[",
"ngram",
"]",
"instead",
"\"",
")",
";",
"}",
"}"
] |
[
"this",
"method",
"provide",
"a",
"(",
"partial",
")",
"instantaneous",
"validation",
"by",
"applying",
"business",
"rules",
"(",
"such",
"as",
"max",
"number",
"of",
"parallel",
"containers",
"allowed",
"for",
"a",
"user",
")",
"to",
"provide",
"the",
"agent",
"with",
"more",
"feedback",
"the",
"returned",
"parameter",
"is",
"expressed",
"in",
"number",
"of",
"containers",
"that",
"can",
"be",
"fit",
"in",
"this",
"time",
"according",
"to",
"the",
"business",
"rules"
] | [
"r",
"l",
"e",
"sparse",
"resource",
"allocation",
"available",
"resources",
"(",
"r",
"l",
"e",
"sparse",
"resource",
"allocation",
"available",
",",
"plan",
"plan",
",",
"string",
"user",
",",
"reservation",
"id",
"old",
"id",
",",
"long",
"start",
",",
"long",
"end",
")",
"throws",
"planning",
"exception",
";"
] |
[
"opens",
"the",
"interactive",
"cli",
"shell"
] | [
"public",
"void",
"open",
"(",
")",
"{",
"is",
"running",
"=",
"true",
";",
"/",
"/",
"print",
"welcome",
"terminal",
"writer",
"(",
")",
"append",
"(",
"cli",
"strings",
"message",
"welcome",
")",
";",
"/",
"/",
"begin",
"reading",
"loop",
"while",
"(",
"is",
"running",
")",
"{",
"/",
"/",
"make",
"some",
"space",
"to",
"previous",
"command",
"terminal",
"writer",
"(",
")",
"append",
"(",
"\"",
"\\",
"n",
"\"",
")",
";",
"terminal",
"flush",
"(",
")",
";",
"final",
"string",
"line",
";",
"try",
"{",
"line",
"=",
"line",
"reader",
"read",
"line",
"(",
"prompt",
",",
"null",
",",
"(",
"masking",
"callback",
")",
"null",
",",
"null",
")",
";",
"}",
"catch",
"(",
"user",
"interrupt",
"exception",
"e",
")",
"{",
"/",
"/",
"user",
"cancelled",
"line",
"with",
"ctrl",
"+",
"c",
"continue",
";",
"}",
"catch",
"(",
"end",
"of",
"file",
"exception",
"|",
"i",
"o",
"error",
"e",
")",
"{",
"/",
"/",
"user",
"cancelled",
"application",
"with",
"ctrl",
"+",
"d",
"or",
"kill",
"break",
";",
"}",
"catch",
"(",
"throwable",
"t",
")",
"{",
"throw",
"new",
"sql",
"client",
"exception",
"(",
"\"",
"could",
"not",
"read",
"from",
"command",
"line",
"\"",
",",
"t",
")",
";",
"}",
"if",
"(",
"line",
"=",
"=",
"null",
")",
"{",
"continue",
";",
"}",
"final",
"optional",
"<",
"sql",
"command",
"call",
">",
"cmd",
"call",
"=",
"parse",
"command",
"(",
"line",
")",
";",
"cmd",
"call",
"if",
"present",
"(",
"this",
":",
":",
"call",
"command",
")",
";",
"}",
"}"
] |
[
"route",
"to",
"the",
"supplied",
"router",
"function",
"if",
"the",
"given",
"path",
"prefix",
"pattern",
"applies",
"this",
"method",
"can",
"be",
"used",
"to",
"create",
"nested",
"routes",
",",
"where",
"a",
"group",
"of",
"routes",
"share",
"a",
"common",
"path",
"prefix",
"specifically",
",",
"this",
"method",
"can",
"be",
"used",
"to",
"merge",
"externally",
"defined",
"router",
"functions",
"under",
"a",
"path",
"prefix",
"for",
"instance",
",",
"the",
"following",
"example",
"creates",
"a",
"nested",
"route",
"with",
"a",
"\"",
"user",
"\"",
"path",
"predicate",
"that",
"delegates",
"to",
"the",
"router",
"function",
"defined",
"in",
"{",
"@",
"code",
"user",
"controller",
"}",
",",
"and",
"with",
"a",
"\"",
"order",
"\"",
"path",
"that",
"delegates",
"to",
"{",
"@",
"code",
"order",
"controller",
"}",
"<",
"pre",
"class",
"=",
"\"",
"code",
"\"",
">",
"router",
"function",
"&",
"lt",
";",
"server",
"response",
"&",
"gt",
";",
"nested",
"route",
"=",
"router",
"functions",
"route",
"(",
")",
"path",
"(",
"\"",
"user",
"\"",
",",
"user",
"controller",
":",
":",
"router",
"function",
")",
"path",
"(",
"\"",
"order",
"\"",
",",
"order",
"controller",
":",
":",
"router",
"function",
")",
"build",
"(",
")",
";"
] | [
"builder",
"path",
"(",
"string",
"pattern",
",",
"supplier",
"<",
"router",
"function",
"<",
"server",
"response",
">",
">",
"router",
"function",
"supplier",
")",
";"
] |
[
"removes",
"the",
"elements",
"in",
"<",
"code",
">",
"remove",
"<",
"code",
">",
"from",
"<",
"code",
">",
"collection",
"<",
"code",
">",
"that",
"is",
",",
"this",
"method",
"returns",
"a",
"collection",
"containing",
"all",
"the",
"elements",
"in",
"<",
"code",
">",
"c",
"<",
"code",
">",
"that",
"are",
"not",
"in",
"<",
"code",
">",
"remove",
"<",
"code",
">",
"the",
"cardinality",
"of",
"an",
"element",
"<",
"code",
">",
"e",
"<",
"code",
">",
"in",
"the",
"returned",
"collection",
"is",
"the",
"same",
"as",
"the",
"cardinality",
"of",
"<",
"code",
">",
"e",
"<",
"code",
">",
"in",
"<",
"code",
">",
"collection",
"<",
"code",
">",
"unless",
"<",
"code",
">",
"remove",
"<",
"code",
">",
"contains",
"<",
"code",
">",
"e",
"<",
"code",
">",
",",
"in",
"which",
"case",
"the",
"cardinality",
"is",
"zero",
"this",
"method",
"is",
"useful",
"if",
"you",
"do",
"not",
"wish",
"to",
"modify",
"the",
"collection",
"<",
"code",
">",
"c",
"<",
"code",
">",
"and",
"thus",
"cannot",
"call",
"<",
"code",
">",
"collection",
"remove",
"all",
"(",
"remove",
")",
";",
"<",
"code",
">"
] | [
"public",
"static",
"<",
"e",
">",
"collection",
"<",
"e",
">",
"remove",
"all",
"(",
"collection",
"<",
"e",
">",
"collection",
",",
"collection",
"<",
"e",
">",
"remove",
")",
"{",
"if",
"(",
"collection",
"=",
"=",
"null",
")",
"return",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"if",
"(",
"remove",
"=",
"=",
"null",
")",
"return",
"new",
"array",
"list",
"<",
">",
"(",
"collection",
")",
";",
"list",
"<",
"e",
">",
"list",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"for",
"(",
"e",
"obj",
":",
"collection",
")",
"{",
"if",
"(",
"!",
"remove",
"contains",
"(",
"obj",
")",
")",
"{",
"list",
"add",
"(",
"obj",
")",
";",
"}",
"}",
"return",
"list",
";",
"}"
] |
[
"gets",
"the",
"list",
"of",
"choices",
"as",
"strings",
"based",
"on",
"the",
"current",
"settings"
] | [
"public",
"string",
"[",
"]",
"get",
"display",
"choices",
"(",
"settings",
"settings",
")",
";"
] |
[
"returns",
"the",
"greatest",
"value",
"present",
"in",
"{",
"@",
"code",
"array",
"}",
",",
"using",
"the",
"same",
"rules",
"of",
"comparison",
"as",
"{",
"@",
"link",
"math",
"#",
"max",
"(",
"float",
",",
"float",
")",
"}"
] | [
"public",
"static",
"float",
"max",
"(",
"float",
"array",
")",
"{",
"check",
"argument",
"(",
"array",
"length",
">",
"0",
")",
";",
"float",
"max",
"=",
"array",
"[",
"0",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"1",
";",
"i",
"<",
"array",
"length",
";",
"i",
"+",
"+",
")",
"{",
"max",
"=",
"math",
"max",
"(",
"max",
",",
"array",
"[",
"i",
"]",
")",
";",
"}",
"return",
"max",
";",
"}"
] |
[
"test",
"for",
"the",
"high",
"priority",
"blocks",
"are",
"processed",
"before",
"the",
"low",
"priority",
"blocks"
] | [
"public",
"void",
"test",
"replication",
"with",
"priority",
"(",
")",
"throws",
"exception",
"{",
"int",
"dfs",
"namenode",
"replication",
"interval",
"=",
"1000",
";",
"int",
"high",
"priority",
"=",
"0",
";",
"configuration",
"conf",
"=",
"new",
"configuration",
"(",
")",
";",
"conf",
"set",
"int",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"namenode",
"redundancy",
"interval",
"seconds",
"key",
",",
"1",
")",
";",
"mini",
"d",
"f",
"s",
"cluster",
"cluster",
"=",
"new",
"mini",
"d",
"f",
"s",
"cluster",
"builder",
"(",
"conf",
")",
"num",
"data",
"nodes",
"(",
"2",
")",
"format",
"(",
"true",
")",
"build",
"(",
")",
";",
"try",
"{",
"cluster",
"wait",
"active",
"(",
")",
";",
"final",
"low",
"redundancy",
"blocks",
"needed",
"reconstruction",
"=",
"cluster",
"get",
"name",
"node",
"(",
")",
"get",
"namesystem",
"(",
")",
"get",
"block",
"manager",
"(",
")",
"needed",
"reconstruction",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"100",
";",
"i",
"+",
"+",
")",
"{",
"/",
"/",
"adding",
"the",
"blocks",
"directly",
"to",
"normal",
"priority",
"needed",
"reconstruction",
"add",
"(",
"gen",
"block",
"info",
"(",
"thread",
"local",
"random",
"current",
"(",
")",
"next",
"long",
"(",
")",
",",
"true",
")",
",",
"2",
",",
"0",
",",
"0",
",",
"3",
")",
";",
"}",
"/",
"/",
"lets",
"wait",
"for",
"the",
"replication",
"interval",
",",
"to",
"start",
"process",
"normal",
"/",
"/",
"priority",
"blocks",
"thread",
"sleep",
"(",
"dfs",
"namenode",
"replication",
"interval",
")",
";",
"/",
"/",
"adding",
"the",
"block",
"directly",
"to",
"high",
"priority",
"list",
"needed",
"reconstruction",
"add",
"(",
"gen",
"block",
"info",
"(",
"thread",
"local",
"random",
"current",
"(",
")",
"next",
"long",
"(",
")",
",",
"true",
")",
",",
"1",
",",
"0",
",",
"0",
",",
"3",
")",
";",
"/",
"/",
"lets",
"wait",
"for",
"the",
"replication",
"interval",
"thread",
"sleep",
"(",
"dfs",
"namenode",
"replication",
"interval",
")",
";",
"/",
"/",
"check",
"replication",
"completed",
"successfully",
"need",
"not",
"wait",
"till",
"it",
"process",
"/",
"/",
"all",
"the",
"100",
"normal",
"blocks",
"assert",
"false",
"(",
"\"",
"not",
"able",
"to",
"clear",
"the",
"element",
"from",
"high",
"priority",
"list",
"\"",
",",
"needed",
"reconstruction",
"iterator",
"(",
"high",
"priority",
")",
"has",
"next",
"(",
")",
")",
";",
"}",
"finally",
"{",
"cluster",
"shutdown",
"(",
")",
";",
"}",
"}"
] |
[
"adds",
"includes",
"to",
"be",
"passed",
"into",
"compile",
"actions",
"with",
"{",
"@",
"code",
"-",
"i",
"}"
] | [
"public",
"builder",
"add",
"includes",
"(",
"nested",
"set",
"<",
"path",
"fragment",
">",
"includes",
")",
"{",
"/",
"/",
"the",
"includes",
"are",
"copied",
"to",
"a",
"new",
"list",
"in",
"the",
"build",
"(",
")",
"method",
",",
"so",
"flattening",
"here",
"should",
"be",
"/",
"/",
"benign",
"this",
"includes",
"=",
"iterables",
"concat",
"(",
"this",
"includes",
",",
"includes",
"to",
"list",
"(",
")",
")",
";",
"return",
"this",
";",
"}"
] |
[
"fill",
"the",
"column",
"vector",
"with",
"the",
"provided",
"value"
] | [
"void",
"fill",
"(",
"double",
"value",
")",
";"
] |
[
"create",
"{",
"@",
"link",
"cache",
"invocation",
"context",
"}",
"parametrized",
"with",
"{",
"@",
"link",
"cache",
"remove",
"}",
"annotation"
] | [
"public",
"static",
"cache",
"invocation",
"context",
"<",
"cache",
"remove",
">",
"create",
"cache",
"remove",
"invocation",
"context",
"(",
"meta",
"holder",
"meta",
"holder",
")",
"{",
"method",
"method",
"=",
"meta",
"holder",
"get",
"method",
"(",
")",
";",
"if",
"(",
"method",
"is",
"annotation",
"present",
"(",
"cache",
"remove",
"class",
")",
")",
"{",
"cache",
"remove",
"cache",
"remove",
"=",
"method",
"get",
"annotation",
"(",
"cache",
"remove",
"class",
")",
";",
"method",
"execution",
"action",
"cache",
"key",
"method",
"=",
"create",
"cache",
"key",
"action",
"(",
"cache",
"remove",
"cache",
"key",
"method",
"(",
")",
",",
"meta",
"holder",
")",
";",
"return",
"new",
"cache",
"invocation",
"context",
"<",
"cache",
"remove",
">",
"(",
"cache",
"remove",
",",
"cache",
"key",
"method",
",",
"meta",
"holder",
"get",
"obj",
"(",
")",
",",
"method",
",",
"meta",
"holder",
"get",
"args",
"(",
")",
")",
";",
"}",
"return",
"null",
";",
"}"
] |
[
"stress",
"once",
"you",
"get",
"the",
"notification",
"from",
"stats",
"collector",
"collect",
"the",
"clustermetrics",
"update",
"current",
"load",
"status",
"with",
"new",
"load",
"status",
"of",
"jt"
] | [
"public",
"void",
"update",
"(",
"statistics",
"cluster",
"stats",
"item",
")",
"{",
"cluster",
"status",
"cluster",
"status",
"=",
"item",
"get",
"status",
"(",
")",
";",
"try",
"{",
"/",
"/",
"update",
"the",
"max",
"cluster",
"map",
"/",
"reduce",
"task",
"capacity",
"load",
"status",
"update",
"map",
"capacity",
"(",
"cluster",
"status",
"get",
"max",
"map",
"tasks",
"(",
")",
")",
";",
"load",
"status",
"update",
"reduce",
"capacity",
"(",
"cluster",
"status",
"get",
"max",
"reduce",
"tasks",
"(",
")",
")",
";",
"int",
"num",
"trackers",
"=",
"cluster",
"status",
"get",
"task",
"trackers",
"(",
")",
";",
"int",
"job",
"load",
"=",
"(",
"int",
")",
"(",
"max",
"job",
"tracker",
"ratio",
"*",
"num",
"trackers",
")",
"-",
"item",
"get",
"num",
"running",
"job",
"(",
")",
";",
"load",
"status",
"update",
"job",
"load",
"(",
"job",
"load",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"log",
"error",
"(",
"\"",
"couldn",
"'",
"t",
"get",
"the",
"new",
"status",
"\"",
",",
"e",
")",
";",
"}",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] | [
"public",
"gl30",
"get",
"g",
"l",
"3",
"0",
"(",
")",
"{",
"return",
"gl",
"3",
"0",
";",
"}"
] |
[
"returns",
"the",
"user",
"item",
"stored",
"in",
"this",
"terminal",
"node",
"at",
"add",
"time"
] | [
"public",
"t",
"get",
"item",
"(",
")",
"{",
"return",
"item",
";",
"}"
] |
[
"delete",
"user",
"this",
"can",
"only",
"be",
"done",
"by",
"the",
"logged",
"in",
"user"
] | [
"public",
"single",
"<",
"void",
">",
"rx",
"delete",
"user",
"(",
"string",
"username",
",",
"api",
"client",
"auth",
"info",
"auth",
"info",
")",
"{",
"return",
"single",
"create",
"(",
"new",
"io",
"vertx",
"rx",
"java",
"single",
"on",
"subscribe",
"adapter",
"<",
">",
"(",
"fut",
"-",
">",
"delegate",
"delete",
"user",
"(",
"username",
",",
"auth",
"info",
",",
"fut",
")",
")",
")",
";",
"}"
] |
[
"if",
"{",
"@",
"code",
"(",
"key",
",",
"expected",
"old",
"value",
")",
"}",
"is",
"currently",
"in",
"the",
"map",
",",
"this",
"method",
"replaces",
"{",
"@",
"code",
"expected",
"old",
"value",
"}",
"with",
"{",
"@",
"code",
"new",
"value",
"}",
"and",
"returns",
"true",
";",
"otherwise",
",",
"this",
"method",
"returns",
"false",
"if",
"{",
"@",
"code",
"expected",
"old",
"value",
"}",
"is",
"zero",
",",
"this",
"method",
"will",
"succeed",
"if",
"{",
"@",
"code",
"(",
"key",
",",
"zero",
")",
"}",
"is",
"currently",
"in",
"the",
"map",
",",
"or",
"if",
"{",
"@",
"code",
"key",
"}",
"is",
"not",
"in",
"the",
"map",
"at",
"all"
] | [
"boolean",
"replace",
"(",
"k",
"key",
",",
"long",
"expected",
"old",
"value",
",",
"long",
"new",
"value",
")",
"{",
"if",
"(",
"expected",
"old",
"value",
"=",
"=",
"0l",
")",
"{",
"return",
"put",
"if",
"absent",
"(",
"key",
",",
"new",
"value",
")",
"=",
"=",
"0l",
";",
"}",
"else",
"{",
"atomic",
"long",
"atomic",
"=",
"map",
"get",
"(",
"key",
")",
";",
"return",
"(",
"atomic",
"=",
"=",
"null",
")",
"?",
"false",
":",
"atomic",
"compare",
"and",
"set",
"(",
"expected",
"old",
"value",
",",
"new",
"value",
")",
";",
"}",
"}"
] |
[
"return",
"the",
"stomp",
"message",
"broker",
"host"
] | [
"public",
"string",
"get",
"relay",
"host",
"(",
")",
"{",
"return",
"this",
"relay",
"host",
";",
"}"
] |
[
"test",
"the",
"async",
"wait",
"operator",
"with",
"unordered",
"mode",
"and",
"processing",
"time"
] | [
"public",
"void",
"test",
"processing",
"unordered",
"(",
")",
"throws",
"exception",
"{",
"test",
"processing",
"time",
"(",
"async",
"data",
"stream",
"output",
"mode",
"unordered",
")",
";",
"}"
] |
[
"delete",
"any",
"character",
"in",
"a",
"given",
"{",
"@",
"code",
"string",
"}"
] | [
"public",
"static",
"string",
"delete",
"any",
"(",
"string",
"in",
"string",
",",
"@",
"nullable",
"string",
"chars",
"to",
"delete",
")",
"{",
"if",
"(",
"!",
"has",
"length",
"(",
"in",
"string",
")",
"|",
"|",
"!",
"has",
"length",
"(",
"chars",
"to",
"delete",
")",
")",
"{",
"return",
"in",
"string",
";",
"}",
"int",
"last",
"char",
"index",
"=",
"0",
";",
"char",
"[",
"]",
"result",
"=",
"new",
"char",
"[",
"in",
"string",
"length",
"(",
")",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"in",
"string",
"length",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"char",
"c",
"=",
"in",
"string",
"char",
"at",
"(",
"i",
")",
";",
"if",
"(",
"chars",
"to",
"delete",
"index",
"of",
"(",
"c",
")",
"=",
"=",
"-",
"1",
")",
"{",
"result",
"[",
"last",
"char",
"index",
"+",
"+",
"]",
"=",
"c",
";",
"}",
"}",
"if",
"(",
"last",
"char",
"index",
"=",
"=",
"in",
"string",
"length",
"(",
")",
")",
"{",
"return",
"in",
"string",
";",
"}",
"return",
"new",
"string",
"(",
"result",
",",
"0",
",",
"last",
"char",
"index",
")",
";",
"}",
"/",
"/",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"/",
"/",
"convenience",
"methods",
"for",
"working",
"with",
"formatted",
"strings",
"/",
"/",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-"
] |
[
"executes",
"the",
"given",
"task",
"in",
"a",
"cpu",
"thread",
"pool",
"at",
"fix",
"rate"
] | [
"public",
"static",
"<",
"t",
">",
"void",
"execute",
"by",
"cpu",
"at",
"fix",
"rate",
"(",
"final",
"task",
"<",
"t",
">",
"task",
",",
"long",
"initial",
"delay",
",",
"final",
"long",
"period",
",",
"final",
"time",
"unit",
"unit",
")",
"{",
"execute",
"at",
"fixed",
"rate",
"(",
"get",
"pool",
"by",
"type",
"and",
"priority",
"(",
"type",
"cpu",
")",
",",
"task",
",",
"initial",
"delay",
",",
"period",
",",
"unit",
")",
";",
"}"
] |
[
"sets",
"data",
"type"
] | [
"public",
"void",
"set",
"data",
"type",
"(",
"int",
"data",
"type",
")",
"{",
"this",
"data",
"type",
"=",
"data",
"type",
";",
"}"
] |
[
"unregister",
"the",
"status",
"of",
"battery",
"changed",
"listener"
] | [
"public",
"static",
"void",
"unregister",
"battery",
"status",
"changed",
"listener",
"(",
"final",
"on",
"battery",
"status",
"changed",
"listener",
"listener",
")",
"{",
"battery",
"changed",
"receiver",
"get",
"instance",
"(",
")",
"unregister",
"listener",
"(",
"listener",
")",
";",
"}"
] |
[
"see",
"{",
"@",
"link",
"socket",
"#",
"get",
"send",
"buffer",
"size",
"(",
")",
"}",
"calling",
"this",
"method",
"does",
"not",
"trigger",
"mode",
"detection"
] | [
"public",
"synchronized",
"int",
"get",
"send",
"buffer",
"size",
"(",
")",
"throws",
"socket",
"exception",
"{",
"return",
"get",
"socket",
"allow",
"unknown",
"mode",
"(",
")",
"get",
"send",
"buffer",
"size",
"(",
")",
";",
"}"
] |
[
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"this",
"deque",
"contains",
"the",
"specified",
"element",
"more",
"formally",
",",
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"and",
"only",
"if",
"this",
"deque",
"contains",
"at",
"least",
"one",
"element",
"{",
"@",
"code",
"e",
"}",
"such",
"that",
"{",
"@",
"code",
"o",
"equals",
"(",
"e",
")",
"}"
] | [
"public",
"boolean",
"contains",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"return",
"false",
";",
"final",
"reentrant",
"lock",
"lock",
"=",
"this",
"lock",
";",
"lock",
"lock",
"(",
")",
";",
"try",
"{",
"for",
"(",
"node",
"<",
"e",
">",
"p",
"=",
"first",
";",
"p",
"!",
"=",
"null",
";",
"p",
"=",
"p",
"next",
")",
"if",
"(",
"o",
"equals",
"(",
"p",
"item",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"finally",
"{",
"lock",
"unlock",
"(",
")",
";",
"}",
"}",
"/",
"*",
"*",
"todo",
":",
"add",
"support",
"for",
"more",
"efficient",
"bulk",
"operations",
"*",
"*",
"we",
"don",
"'",
"t",
"want",
"to",
"acquire",
"the",
"lock",
"for",
"every",
"iteration",
",",
"but",
"we",
"*",
"also",
"want",
"other",
"threads",
"a",
"chance",
"to",
"interact",
"with",
"the",
"*",
"collection",
",",
"especially",
"when",
"count",
"is",
"close",
"to",
"capacity",
"*",
"/",
"/",
"/"
] |
[
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"a",
"header",
"with",
"the",
"name",
"and",
"value",
"exists"
] | [
"boolean",
"contains",
"long",
"(",
"k",
"name",
",",
"long",
"value",
")",
";"
] |
[
"exit",
"a",
"parse",
"tree",
"produced",
"by",
"the",
"{",
"@",
"code",
"date",
"escaped",
"literal",
"}",
"labeled",
"alternative",
"in",
"{",
"@",
"link",
"sql",
"base",
"parser",
"#",
"constant",
"}"
] | [
"void",
"exit",
"date",
"escaped",
"literal",
"(",
"sql",
"base",
"parser",
"date",
"escaped",
"literal",
"context",
"ctx",
")",
";"
] |
[
"returns",
"the",
"{",
"@",
"code",
"type",
"information",
"}",
"for",
"the",
"elements",
"from",
"the",
"second",
"input"
] | [
"public",
"type",
"information",
"<",
"in2",
">",
"get",
"input",
"type",
"2",
"(",
")",
"{",
"return",
"input",
"2",
"get",
"output",
"type",
"(",
")",
";",
"}"
] |
[
"configures",
"to",
"start",
"reading",
"from",
"partition",
"offsets",
"of",
"the",
"specified",
"timestamp"
] | [
"public",
"kafka",
"start",
"from",
"timestamp",
"(",
"long",
"start",
"timestamp",
"millis",
")",
"{",
"this",
"startup",
"mode",
"=",
"startup",
"mode",
"timestamp",
";",
"this",
"specific",
"offsets",
"=",
"null",
";",
"this",
"start",
"timestamp",
"millis",
"=",
"start",
"timestamp",
"millis",
";",
"return",
"this",
";",
"}"
] |
[
"get",
"number",
"item"
] | [
"public",
"big",
"decimal",
"get",
"number",
"item",
"(",
")",
"{",
"return",
"number",
"item",
";",
"}"
] |
[
"obtains",
"the",
"acl",
"associated",
"with",
"this",
"object"
] | [
"@",
"non",
"null",
"acl",
"get",
"a",
"c",
"l",
"(",
")",
";"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] | [
"public",
"boolean",
"matches",
"(",
"string",
"name",
",",
"metric",
"metric",
")",
"{",
"return",
"\"",
"test",
"metric",
"wait",
"pool",
"wait",
"\"",
"equals",
"(",
"metric",
"registry",
"name",
"(",
"\"",
"test",
"metric",
"wait",
"\"",
",",
"\"",
"pool",
"\"",
",",
"\"",
"wait",
"\"",
")",
")",
";",
"}"
] |
[
"given",
"an",
"index",
"in",
"the",
"range",
"<",
"code",
">",
"0",
"size",
"(",
")",
"-",
"1",
"<",
"code",
">",
",",
"returns",
"the",
"value",
"from",
"the",
"<",
"code",
">",
"index",
"<",
"code",
">",
"th",
"key",
"-",
"value",
"mapping",
"that",
"this",
"sparse",
"float",
"array",
"stores",
"the",
"values",
"corresponding",
"to",
"indices",
"in",
"ascending",
"order",
"are",
"guaranteed",
"to",
"be",
"associated",
"with",
"keys",
"in",
"ascending",
"order",
",",
"e",
"g",
",",
"<",
"code",
">",
"value",
"at",
"(",
"0",
")",
"<",
"code",
">",
"will",
"return",
"the",
"value",
"associated",
"with",
"the",
"smallest",
"key",
"and",
"<",
"code",
">",
"value",
"at",
"(",
"size",
"(",
")",
"-",
"1",
")",
"<",
"code",
">",
"will",
"return",
"the",
"value",
"associated",
"with",
"the",
"largest",
"key"
] | [
"public",
"float",
"value",
"at",
"(",
"int",
"index",
")",
"{",
"return",
"m",
"values",
"[",
"index",
"]",
";",
"}"
] |
[
"set",
"the",
"level",
"of",
"the",
"logger",
"if",
"the",
"new",
"level",
"is",
"null",
",",
"the",
"logger",
"will",
"inherit",
"it",
"'",
"s",
"level",
"from",
"its",
"nearest",
"ancestor",
"with",
"a",
"non",
"-",
"null",
"level"
] | [
"public",
"static",
"void",
"set",
"level",
"(",
"logger",
"logger",
",",
"string",
"level",
")",
"{",
"final",
"level",
"l",
";",
"if",
"(",
"level",
"=",
"=",
"null",
")",
"{",
"l",
"=",
"null",
";",
"}",
"else",
"{",
"l",
"=",
"level",
"value",
"of",
"(",
"level",
")",
";",
"}",
"set",
"level",
"(",
"logger",
",",
"l",
")",
";",
"}"
] |
[
"<",
"code",
">",
"map",
"&",
"lt",
";",
"string",
",",
"org",
"apache",
"dubbo",
"common",
"serialize",
"protobuf",
"model",
"phone",
"number",
"&",
"gt",
";",
"double",
"map",
"=",
"9",
";",
"<",
"code",
">"
] | [
"public",
"google",
"p",
"b",
"phone",
"number",
"get",
"double",
"map",
"or",
"default",
"(",
"string",
"key",
",",
"google",
"p",
"b",
"phone",
"number",
"default",
"value",
")",
"{",
"if",
"(",
"key",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"null",
"pointer",
"exception",
"(",
")",
";",
"}",
"java",
"util",
"map",
"<",
"string",
",",
"phone",
"number",
">",
"map",
"=",
"internal",
"get",
"double",
"map",
"(",
")",
"get",
"map",
"(",
")",
";",
"return",
"map",
"contains",
"key",
"(",
"key",
")",
"?",
"map",
"get",
"(",
"key",
")",
":",
"default",
"value",
";",
"}"
] |
[
"adds",
"a",
"mapping",
"from",
"a",
"jar",
"to",
"its",
"desugared",
"version"
] | [
"public",
"builder",
"add",
"desugared",
"jar",
"(",
"artifact",
"jar",
",",
"artifact",
"desugared",
")",
"{",
"newly",
"desugared",
"put",
"(",
"check",
"not",
"null",
"(",
"jar",
",",
"\"",
"jar",
"\"",
")",
",",
"check",
"not",
"null",
"(",
"desugared",
",",
"\"",
"desugared",
"\"",
")",
")",
";",
"return",
"this",
";",
"}"
] |
[
"whether",
"to",
"use",
"registered",
"suffixes",
"for",
"pattern",
"matching"
] | [
"public",
"boolean",
"is",
"use",
"registered",
"suffix",
"pattern",
"match",
"(",
")",
"{",
"return",
"this",
"registered",
"suffix",
"pattern",
"match",
";",
"}"
] |
[
"return",
"the",
"maximum",
"number",
"of",
"concurrent",
"access",
"attempts",
"allowed"
] | [
"public",
"int",
"get",
"concurrency",
"limit",
"(",
")",
"{",
"return",
"this",
"concurrency",
"limit",
";",
"}"
] |
[
"this",
"is",
"the",
"{",
"get",
"data",
"array",
"position",
"}",
"reverse",
"from",
"data",
"position",
"to",
"layout",
"position"
] | [
"protected",
"int",
"get",
"reverse",
"data",
"array",
"position",
"(",
"final",
"int",
"data",
"pos",
")",
"{",
"int",
"shift",
"=",
"0",
";",
"if",
"(",
"has",
"header",
"view",
"(",
")",
")",
"shift",
"+",
"+",
";",
"if",
"(",
"adfrequency",
">",
"0",
")",
"{",
"if",
"(",
"once",
")",
"{",
"if",
"(",
"data",
"pos",
">",
"=",
"adfrequency",
")",
"shift",
"+",
"+",
";",
"}",
"else",
"{",
"shift",
"+",
"=",
"at",
"ad",
"pos",
"(",
"data",
"pos",
")",
";",
"}",
"}",
"return",
"data",
"pos",
"+",
"shift",
";",
"}"
] |
[
"example",
"for",
"testing",
"blocking",
"unary",
"call"
] | [
"public",
"void",
"get",
"feature",
"error",
"(",
")",
"{",
"point",
"request",
"point",
"=",
"point",
"new",
"builder",
"(",
")",
"set",
"latitude",
"(",
"-",
"1",
")",
"set",
"longitude",
"(",
"-",
"1",
")",
"build",
"(",
")",
";",
"final",
"atomic",
"reference",
"<",
"point",
">",
"point",
"delivered",
"=",
"new",
"atomic",
"reference",
"<",
"point",
">",
"(",
")",
";",
"final",
"status",
"runtime",
"exception",
"fake",
"error",
"=",
"new",
"status",
"runtime",
"exception",
"(",
"status",
"data",
"loss",
")",
";",
"/",
"/",
"implement",
"the",
"fake",
"service",
"route",
"guide",
"impl",
"base",
"get",
"feature",
"impl",
"=",
"new",
"route",
"guide",
"impl",
"base",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"get",
"feature",
"(",
"point",
"point",
",",
"stream",
"observer",
"<",
"feature",
">",
"response",
"observer",
")",
"{",
"point",
"delivered",
"set",
"(",
"point",
")",
";",
"response",
"observer",
"on",
"error",
"(",
"fake",
"error",
")",
";",
"}",
"}",
";",
"service",
"registry",
"add",
"service",
"(",
"get",
"feature",
"impl",
")",
";",
"client",
"get",
"feature",
"(",
"-",
"1",
",",
"-",
"1",
")",
";",
"assert",
"equals",
"(",
"request",
"point",
",",
"point",
"delivered",
"get",
"(",
")",
")",
";",
"argument",
"captor",
"<",
"throwable",
">",
"error",
"captor",
"=",
"argument",
"captor",
"for",
"class",
"(",
"throwable",
"class",
")",
";",
"verify",
"(",
"test",
"helper",
")",
"on",
"rpc",
"error",
"(",
"error",
"captor",
"capture",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"fake",
"error",
"get",
"status",
"(",
")",
",",
"status",
"from",
"throwable",
"(",
"error",
"captor",
"get",
"value",
"(",
")",
")",
")",
";",
"}"
] |
[
"creates",
"a",
"new",
"component",
"context",
"based",
"on",
"the",
"given",
"component",
"context",
",",
"propagating",
"log",
"tag",
",",
"logger",
",",
"and",
"tree",
"props",
"this",
"should",
"be",
"used",
"when",
"creating",
"a",
"component",
"context",
"for",
"a",
"nested",
"component",
"tree",
"(",
"e",
"g",
"see",
"horizontal",
"scroll",
"spec",
")"
] | [
"public",
"static",
"component",
"context",
"make",
"copy",
"for",
"nested",
"tree",
"(",
"component",
"context",
"parent",
"tree",
"context",
")",
"{",
"return",
"new",
"component",
"context",
"(",
"parent",
"tree",
"context",
"get",
"android",
"context",
"(",
")",
",",
"parent",
"tree",
"context",
"get",
"log",
"tag",
"(",
")",
",",
"parent",
"tree",
"context",
"get",
"logger",
"(",
")",
",",
"parent",
"tree",
"context",
"get",
"tree",
"props",
"copy",
"(",
")",
")",
";",
"}"
] |
[
"test",
"serialization",
"of",
"outer",
"string",
"types"
] | [
"public",
"void",
"fake",
"outer",
"string",
"serialize",
"test",
"(",
")",
"throws",
"api",
"exception",
"{",
"string",
"body",
"=",
"null",
";",
"string",
"response",
"=",
"api",
"fake",
"outer",
"string",
"serialize",
"(",
"body",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
] |
[
"visit",
"a",
"parse",
"tree",
"produced",
"by",
"the",
"{",
"@",
"code",
"dereference",
"}",
"labeled",
"alternative",
"in",
"{",
"@",
"link",
"eql",
"base",
"parser",
"#",
"primary",
"expression",
"}"
] | [
"t",
"visit",
"dereference",
"(",
"eql",
"base",
"parser",
"dereference",
"context",
"ctx",
")",
";"
] |
[
"deserializes",
"a",
"compressed",
"set",
"of",
"hash",
"buckets",
"from",
"the",
"{",
"@",
"link",
"pdb",
"byte",
"reader",
"}",
"provided",
"the",
"data",
"comes",
"as",
"a",
"bit",
"-",
"mapped",
"representation",
"of",
"which",
"indices",
"should",
"contain",
"the",
"data",
"followed",
"by",
"a",
"flat",
"set",
"of",
"hash",
"buckets",
"that",
"will",
"be",
"set",
"at",
"those",
"indices",
"in",
"the",
"order",
"provided"
] | [
"private",
"void",
"deserialized",
"compressed",
"hash",
"buckets",
"(",
"pdb",
"byte",
"reader",
"reader",
",",
"task",
"monitor",
"monitor",
")",
"throws",
"pdb",
"exception",
",",
"cancelled",
"exception",
"{",
"pdb",
"byte",
"reader",
"bit",
"encoder",
"reader",
"=",
"reader",
"get",
"sub",
"pdb",
"byte",
"reader",
"(",
"hash",
"records",
"bit",
"map",
"length",
")",
";",
"/",
"/",
"throw",
"away",
"extra",
"bytes",
"between",
"bit",
"map",
"and",
"buckets",
"reader",
"get",
"sub",
"pdb",
"byte",
"reader",
"(",
"num",
"extra",
"bytes",
")",
";",
"while",
"(",
"bit",
"encoder",
"reader",
"has",
"more",
"(",
")",
"&",
"&",
"reader",
"has",
"more",
"(",
")",
")",
"{",
"monitor",
"check",
"canceled",
"(",
")",
";",
"long",
"val",
"=",
"bit",
"encoder",
"reader",
"parse",
"unsigned",
"int",
"val",
"(",
")",
";",
"/",
"/",
"bit",
"encoded",
"[",
"index",
"+",
"+",
"]",
"=",
"val",
";",
"for",
"(",
"int",
"bit",
"=",
"0",
";",
"bit",
"<",
"32",
"&",
"&",
"reader",
"has",
"more",
"(",
")",
";",
"bit",
"+",
"+",
")",
"{",
"monitor",
"check",
"canceled",
"(",
")",
";",
"if",
"(",
"(",
"val",
"&",
"0x",
"0",
"1",
"l",
")",
"=",
"=",
"0x",
"0",
"1",
"l",
")",
"{",
"hash",
"bucket",
"offsets",
"add",
"(",
"reader",
"parse",
"int",
"(",
")",
")",
";",
"}",
"else",
"{",
"hash",
"bucket",
"offsets",
"add",
"(",
"-",
"1",
")",
";",
"}",
"val",
">",
">",
"=",
"1",
";",
"}",
"}",
"/",
"/",
"both",
"readers",
"should",
"run",
"out",
"of",
"data",
"at",
"the",
"same",
"time",
"we",
"can",
"have",
"more",
"bit",
"encoder",
"/",
"/",
"data",
"as",
"long",
"as",
"there",
"are",
"not",
"more",
"bits",
"set",
"in",
"the",
"values",
"the",
"following",
"logic",
"/",
"/",
"checks",
"this",
"integrity",
"if",
"(",
"reader",
"has",
"more",
"(",
")",
")",
"{",
"throw",
"new",
"pdb",
"exception",
"(",
"\"",
"compressed",
"gsi",
"hash",
"buckets",
"corrupt",
"\"",
")",
";",
"}",
"while",
"(",
"bit",
"encoder",
"reader",
"has",
"more",
"(",
")",
")",
"{",
"monitor",
"check",
"canceled",
"(",
")",
";",
"if",
"(",
"bit",
"encoder",
"reader",
"parse",
"unsigned",
"int",
"val",
"(",
")",
"!",
"=",
"0",
")",
"{",
"throw",
"new",
"pdb",
"exception",
"(",
"\"",
"compressed",
"gsi",
"hash",
"buckets",
"corrupt",
"\"",
")",
";",
"}",
"}",
"}"
] |
[
"indicates",
"whether",
"this",
"domain",
"name",
"ends",
"in",
"a",
"{",
"@",
"linkplain",
"#",
"is",
"public",
"suffix",
"(",
")",
"public",
"suffix",
"}",
",",
"while",
"not",
"being",
"a",
"public",
"suffix",
"itself",
"for",
"example",
",",
"returns",
"{",
"@",
"code",
"true",
"}",
"for",
"{",
"@",
"code",
"www",
"google",
"com",
"}",
",",
"{",
"@",
"code",
"foo",
"co",
"uk",
"}",
"and",
"{",
"@",
"code",
"myblog",
"blogspot",
"com",
"}",
",",
"but",
"not",
"for",
"{",
"@",
"code",
"com",
"}",
",",
"{",
"@",
"code",
"co",
"uk",
"}",
",",
"{",
"@",
"code",
"google",
"invalid",
"}",
",",
"or",
"{",
"@",
"code",
"blogspot",
"com",
"}",
"this",
"method",
"can",
"be",
"used",
"to",
"determine",
"whether",
"it",
"will",
"probably",
"be",
"possible",
"to",
"set",
"cookies",
"on",
"the",
"domain",
",",
"though",
"even",
"that",
"depends",
"on",
"individual",
"browsers",
"'",
"implementations",
"of",
"cookie",
"controls",
"see",
"<",
"a",
"href",
"=",
"\"",
"http",
":",
"www",
"ietf",
"orgrfcrfc",
"2",
"1",
"0",
"9",
"txt",
"\"",
">",
"rfc",
"2109",
"for",
"details"
] | [
"public",
"boolean",
"is",
"under",
"public",
"suffix",
"(",
")",
"{",
"return",
"public",
"suffix",
"index",
">",
"0",
";",
"}"
] |
[
"returns",
"the",
"object",
"or",
"<",
"code",
">",
"null",
"<",
"code",
">",
"if",
"the",
"given",
"key",
"does",
"not",
"have",
"a",
"value",
"in",
"the",
"context"
] | [
"public",
"<",
"t",
">",
"t",
"get",
"from",
"context",
"(",
"string",
"key",
")",
"{",
"return",
"context",
"!",
"=",
"null",
"?",
"(",
"t",
")",
"context",
"get",
"(",
"key",
")",
":",
"null",
";",
"}"
] |
[
"store",
"a",
"subset",
"of",
"the",
"given",
"attributes",
"in",
"the",
"session",
"attributes",
"not",
"declared",
"as",
"session",
"attributes",
"via",
"{",
"@",
"code",
"@",
"session",
"attributes",
"}",
"are",
"ignored"
] | [
"public",
"void",
"store",
"attributes",
"(",
"web",
"request",
"request",
",",
"map",
"<",
"string",
",",
"?",
">",
"attributes",
")",
"{",
"attributes",
"for",
"each",
"(",
"(",
"name",
",",
"value",
")",
"-",
">",
"{",
"if",
"(",
"value",
"!",
"=",
"null",
"&",
"&",
"is",
"handler",
"session",
"attribute",
"(",
"name",
",",
"value",
"get",
"class",
"(",
")",
")",
")",
"{",
"this",
"session",
"attribute",
"store",
"store",
"attribute",
"(",
"request",
",",
"name",
",",
"value",
")",
";",
"}",
"}",
")",
";",
"}"
] |
[
"when",
"in",
"strict",
"mode",
",",
"compiling",
"the",
"source",
"-",
"jars",
"passed",
"to",
"this",
"java",
"library",
"helper",
"will",
"break",
"if",
"they",
"depend",
"on",
"classes",
"not",
"in",
"any",
"of",
"the",
"{",
"@",
"link",
"java",
"compilation",
"args",
"provider",
"#",
"get",
"direct",
"compile",
"time",
"jars",
"(",
")",
"}",
"passed",
"in",
"{",
"@",
"link",
"#",
"add",
"dep",
"}",
",",
"even",
"if",
"they",
"do",
"appear",
"in",
"{",
"@",
"link",
"java",
"compilation",
"args",
"provider",
"#",
"get",
"transitive",
"compile",
"time",
"jars",
"(",
")",
"}",
"that",
"is",
",",
"depending",
"on",
"a",
"class",
"requires",
"a",
"direct",
"dependency",
"on",
"it",
"contrast",
"this",
"with",
"the",
"strictness",
"-",
"parameter",
"to",
"{",
"@",
"link",
"#",
"build",
"compilation",
"args",
"provider",
"}",
",",
"which",
"controls",
"whether",
"others",
"depending",
"on",
"the",
"result",
"of",
"this",
"compilation",
",",
"can",
"perform",
"strict",
"-",
"deps",
"checks",
"at",
"all",
"defaults",
"to",
"{",
"@",
"link",
"strict",
"deps",
"mode",
"#",
"error",
"}"
] | [
"public",
"java",
"library",
"helper",
"set",
"compilation",
"strict",
"deps",
"mode",
"(",
"strict",
"deps",
"mode",
"strict",
"deps",
"mode",
")",
"{",
"this",
"strict",
"deps",
"mode",
"=",
"strict",
"deps",
"mode",
";",
"return",
"this",
";",
"}"
] |
[
"returns",
"true",
"if",
"{",
"@",
"link",
"#",
"exec",
"}",
"was",
"called",
"and",
"completed",
"successfully",
";",
"does",
"not",
"block"
] | [
"boolean",
"succeeded",
"(",
")",
"{",
"return",
"succeeded",
"get",
"count",
"(",
")",
"=",
"=",
"0",
";",
"}"
] |
[
"tests",
"that",
"python",
"scripts",
"are",
"running",
"correctly"
] | [
"public",
"void",
"test",
"python",
"interpreter",
"gone",
"from",
"state",
"(",
")",
"throws",
"exception",
"{",
"string",
"script",
"=",
"\"",
"ghidra",
"scripts",
"/",
"python",
"basics",
"py",
"\"",
";",
"try",
"{",
"ghidra",
"state",
"state",
"=",
"new",
"ghidra",
"state",
"(",
"env",
"get",
"tool",
"(",
")",
",",
"env",
"get",
"project",
"(",
")",
",",
"null",
",",
"null",
",",
"null",
",",
"null",
")",
";",
"run",
"python",
"script",
"(",
"application",
"get",
"module",
"file",
"(",
"\"",
"python",
"\"",
",",
"script",
")",
",",
"state",
")",
";",
"assert",
"true",
"(",
"state",
"get",
"environment",
"var",
"(",
"python",
"script",
"python",
"interpreter",
")",
"=",
"=",
"null",
")",
";",
"}",
"catch",
"(",
"file",
"not",
"found",
"exception",
"e",
")",
"{",
"fail",
"(",
"\"",
"could",
"not",
"find",
"python",
"script",
":",
"\"",
"+",
"script",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"fail",
"(",
"\"",
"exception",
"occurred",
"trying",
"to",
"run",
"script",
":",
"\"",
"+",
"e",
"get",
"message",
"(",
")",
")",
";",
"}",
"}"
] |
[
"an",
"app",
"can",
"set",
"a",
"single",
"{",
"@",
"link",
"kafka",
"streams",
"state",
"listener",
"}",
"so",
"that",
"the",
"app",
"is",
"notified",
"when",
"state",
"changes"
] | [
"public",
"void",
"set",
"state",
"listener",
"(",
"final",
"kafka",
"streams",
"state",
"listener",
"listener",
")",
"{",
"synchronized",
"(",
"state",
"lock",
")",
"{",
"if",
"(",
"state",
"=",
"=",
"state",
"created",
")",
"{",
"state",
"listener",
"=",
"listener",
";",
"}",
"else",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"can",
"only",
"set",
"state",
"listener",
"in",
"created",
"state",
"current",
"state",
"is",
":",
"\"",
"+",
"state",
")",
";",
"}",
"}",
"}"
] |
[
"testing",
"{",
"@",
"code",
"increment",
"read",
"ops",
"(",
")",
"}",
"in",
"class",
"{",
"@",
"code",
"abfs",
"input",
"stream",
"}",
"and",
"{",
"@",
"code",
"increment",
"write",
"ops",
"(",
")",
"}",
"in",
"class",
"{",
"@",
"code",
"abfs",
"output",
"stream",
"}"
] | [
"public",
"void",
"test",
"abfs",
"stream",
"ops",
"(",
")",
"throws",
"exception",
"{",
"describe",
"(",
"\"",
"test",
"to",
"see",
"correct",
"population",
"of",
"read",
"and",
"write",
"operations",
"in",
"\"",
"+",
"\"",
"abfs",
"\"",
")",
";",
"final",
"azure",
"blob",
"file",
"system",
"fs",
"=",
"get",
"file",
"system",
"(",
")",
";",
"path",
"small",
"operations",
"file",
"=",
"new",
"path",
"(",
"\"",
"test",
"one",
"read",
"write",
"ops",
"\"",
")",
";",
"path",
"large",
"operations",
"file",
"=",
"new",
"path",
"(",
"\"",
"test",
"large",
"read",
"write",
"ops",
"\"",
")",
";",
"file",
"system",
"statistics",
"statistics",
"=",
"fs",
"get",
"fs",
"statistics",
"(",
")",
";",
"string",
"test",
"read",
"write",
"ops",
"=",
"\"",
"test",
"this",
"\"",
";",
"statistics",
"reset",
"(",
")",
";",
"/",
"/",
"test",
"for",
"zero",
"write",
"operation",
"assert",
"read",
"write",
"ops",
"(",
"\"",
"write",
"\"",
",",
"0",
",",
"statistics",
"get",
"write",
"ops",
"(",
")",
")",
";",
"/",
"/",
"test",
"for",
"zero",
"read",
"operation",
"assert",
"read",
"write",
"ops",
"(",
"\"",
"read",
"\"",
",",
"0",
",",
"statistics",
"get",
"read",
"ops",
"(",
")",
")",
";",
"f",
"s",
"data",
"output",
"stream",
"out",
"for",
"one",
"operation",
"=",
"null",
";",
"f",
"s",
"data",
"input",
"stream",
"in",
"for",
"one",
"operation",
"=",
"null",
";",
"try",
"{",
"out",
"for",
"one",
"operation",
"=",
"fs",
"create",
"(",
"small",
"operations",
"file",
")",
";",
"statistics",
"reset",
"(",
")",
";",
"out",
"for",
"one",
"operation",
"write",
"(",
"test",
"read",
"write",
"ops",
"get",
"bytes",
"(",
")",
")",
";",
"/",
"/",
"test",
"for",
"a",
"single",
"write",
"operation",
"assert",
"read",
"write",
"ops",
"(",
"\"",
"write",
"\"",
",",
"1",
",",
"statistics",
"get",
"write",
"ops",
"(",
")",
")",
";",
"/",
"/",
"flushing",
"output",
"stream",
"to",
"see",
"content",
"to",
"read",
"out",
"for",
"one",
"operation",
"hflush",
"(",
")",
";",
"in",
"for",
"one",
"operation",
"=",
"fs",
"open",
"(",
"small",
"operations",
"file",
")",
";",
"statistics",
"reset",
"(",
")",
";",
"int",
"result",
"=",
"in",
"for",
"one",
"operation",
"read",
"(",
"test",
"read",
"write",
"ops",
"get",
"bytes",
"(",
")",
",",
"0",
",",
"test",
"read",
"write",
"ops",
"get",
"bytes",
"(",
")",
"length",
")",
";",
"log",
"info",
"(",
"\"",
"result",
"of",
"read",
"operation",
":",
"{",
"}",
"\"",
",",
"result",
")",
";",
"/",
"*",
"*",
"testing",
"if",
"2",
"read",
"ops",
"value",
"is",
"coming",
"after",
"reading",
"full",
"content",
"*",
"from",
"a",
"file",
"(",
"3",
"if",
"anything",
"to",
"read",
"from",
"buffer",
"too",
")",
"reason",
":",
"read",
"(",
")",
"*",
"call",
"gives",
"read",
"ops",
"=",
"1",
",",
"reading",
"from",
"abfs",
"client",
"(",
"http",
"get",
")",
"gives",
"*",
"read",
"ops",
"=",
"2",
"*",
"*",
"in",
"some",
"cases",
"abfs",
"-",
"prefetch",
"thread",
"runs",
"in",
"the",
"background",
"which",
"*",
"returns",
"some",
"bytes",
"from",
"buffer",
"and",
"gives",
"an",
"extra",
"read",
"op",
"*",
"thus",
",",
"making",
"read",
"ops",
"values",
"arbitrary",
"and",
"giving",
"intermittent",
"*",
"failures",
"in",
"some",
"cases",
"hence",
",",
"read",
"ops",
"values",
"of",
"2",
"or",
"3",
"is",
"seen",
"in",
"*",
"different",
"setups",
"*",
"*",
"/",
"assert",
"true",
"(",
"string",
"format",
"(",
"\"",
"the",
"actual",
"value",
"of",
"%",
"d",
"was",
"not",
"equal",
"to",
"the",
"\"",
"+",
"\"",
"expected",
"value",
"of",
"2",
"or",
"3",
"\"",
",",
"statistics",
"get",
"read",
"ops",
"(",
")",
")",
",",
"statistics",
"get",
"read",
"ops",
"(",
")",
"=",
"=",
"2",
"|",
"|",
"statistics",
"get",
"read",
"ops",
"(",
")",
"=",
"=",
"3",
")",
";",
"}",
"finally",
"{",
"i",
"o",
"utils",
"cleanup",
"with",
"logger",
"(",
"log",
",",
"in",
"for",
"one",
"operation",
",",
"out",
"for",
"one",
"operation",
")",
";",
"}",
"/",
"/",
"validating",
"if",
"content",
"is",
"being",
"written",
"in",
"the",
"small",
"operations",
"file",
"assert",
"true",
"(",
"\"",
"mismatch",
"in",
"content",
"validation",
"\"",
",",
"validate",
"content",
"(",
"fs",
",",
"small",
"operations",
"file",
",",
"test",
"read",
"write",
"ops",
"get",
"bytes",
"(",
")",
")",
")",
";",
"f",
"s",
"data",
"output",
"stream",
"out",
"for",
"large",
"operations",
"=",
"null",
";",
"f",
"s",
"data",
"input",
"stream",
"in",
"for",
"large",
"operations",
"=",
"null",
";",
"string",
"builder",
"large",
"operations",
"validation",
"string",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"try",
"{",
"out",
"for",
"large",
"operations",
"=",
"fs",
"create",
"(",
"large",
"operations",
"file",
")",
";",
"statistics",
"reset",
"(",
")",
";",
"int",
"large",
"value",
"=",
"large",
"number",
"of",
"ops",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"large",
"value",
";",
"i",
"+",
"+",
")",
"{",
"out",
"for",
"large",
"operations",
"write",
"(",
"test",
"read",
"write",
"ops",
"get",
"bytes",
"(",
")",
")",
";",
"/",
"/",
"creating",
"the",
"string",
"for",
"content",
"validation",
"large",
"operations",
"validation",
"string",
"append",
"(",
"test",
"read",
"write",
"ops",
")",
";",
"}",
"log",
"info",
"(",
"\"",
"number",
"of",
"bytes",
"of",
"large",
"data",
"written",
":",
"{",
"}",
"\"",
",",
"large",
"operations",
"validation",
"string",
"to",
"string",
"(",
")",
"get",
"bytes",
"(",
")",
"length",
")",
";",
"/",
"/",
"test",
"for",
"1000000",
"write",
"operations",
"assert",
"read",
"write",
"ops",
"(",
"\"",
"write",
"\"",
",",
"large",
"value",
",",
"statistics",
"get",
"write",
"ops",
"(",
")",
")",
";",
"in",
"for",
"large",
"operations",
"=",
"fs",
"open",
"(",
"large",
"operations",
"file",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"large",
"value",
";",
"i",
"+",
"+",
")",
"{",
"in",
"for",
"large",
"operations",
"read",
"(",
"test",
"read",
"write",
"ops",
"get",
"bytes",
"(",
")",
",",
"0",
",",
"test",
"read",
"write",
"ops",
"get",
"bytes",
"(",
")",
"length",
")",
";",
"}",
"if",
"(",
"fs",
"get",
"abfs",
"store",
"(",
")",
"is",
"append",
"blob",
"key",
"(",
"fs",
"make",
"qualified",
"(",
"large",
"operations",
"file",
")",
"to",
"string",
"(",
")",
")",
")",
"{",
"/",
"/",
"for",
"appendblob",
"data",
"is",
"already",
"flushed",
",",
"so",
"there",
"is",
"more",
"data",
"to",
"read",
"assert",
"true",
"(",
"string",
"format",
"(",
"\"",
"the",
"actual",
"value",
"of",
"%",
"d",
"was",
"not",
"equal",
"to",
"the",
"\"",
"+",
"\"",
"expected",
"value",
"\"",
",",
"statistics",
"get",
"read",
"ops",
"(",
")",
")",
",",
"statistics",
"get",
"read",
"ops",
"(",
")",
"=",
"=",
"(",
"large",
"value",
"+",
"3",
")",
"|",
"|",
"statistics",
"get",
"read",
"ops",
"(",
")",
"=",
"=",
"(",
"large",
"value",
"+",
"4",
")",
")",
";",
"}",
"else",
"{",
"/",
"/",
"test",
"for",
"1000000",
"read",
"operations",
"assert",
"read",
"write",
"ops",
"(",
"\"",
"read",
"\"",
",",
"large",
"value",
",",
"statistics",
"get",
"read",
"ops",
"(",
")",
")",
";",
"}",
"}",
"finally",
"{",
"i",
"o",
"utils",
"cleanup",
"with",
"logger",
"(",
"log",
",",
"in",
"for",
"large",
"operations",
",",
"out",
"for",
"large",
"operations",
")",
";",
"}",
"/",
"/",
"validating",
"if",
"content",
"is",
"being",
"written",
"in",
"large",
"operations",
"file",
"assert",
"true",
"(",
"\"",
"mismatch",
"in",
"content",
"validation",
"\"",
",",
"validate",
"content",
"(",
"fs",
",",
"large",
"operations",
"file",
",",
"large",
"operations",
"validation",
"string",
"to",
"string",
"(",
")",
"get",
"bytes",
"(",
")",
")",
")",
";",
"}"
] |
[
"create",
"a",
"metric",
"registry",
"configuration",
"object",
"from",
"the",
"given",
"{",
"@",
"link",
"configuration",
"}"
] | [
"public",
"static",
"metric",
"registry",
"configuration",
"from",
"configuration",
"(",
"configuration",
"configuration",
")",
"{",
"scope",
"formats",
"scope",
"formats",
";",
"try",
"{",
"scope",
"formats",
"=",
"scope",
"formats",
"from",
"config",
"(",
"configuration",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"log",
"warn",
"(",
"\"",
"failed",
"to",
"parse",
"scope",
"format",
",",
"using",
"default",
"scope",
"formats",
"\"",
",",
"e",
")",
";",
"scope",
"formats",
"=",
"scope",
"formats",
"from",
"config",
"(",
"new",
"configuration",
"(",
")",
")",
";",
"}",
"char",
"delim",
";",
"try",
"{",
"delim",
"=",
"configuration",
"get",
"string",
"(",
"metric",
"options",
"scope",
"delimiter",
")",
"char",
"at",
"(",
"0",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"log",
"warn",
"(",
"\"",
"failed",
"to",
"parse",
"delimiter",
",",
"using",
"default",
"delimiter",
"\"",
",",
"e",
")",
";",
"delim",
"=",
"'",
"'",
";",
"}",
"final",
"long",
"maximum",
"frame",
"size",
"=",
"akka",
"rpc",
"service",
"utils",
"extract",
"maximum",
"framesize",
"(",
"configuration",
")",
";",
"/",
"/",
"padding",
"to",
"account",
"for",
"serialization",
"overhead",
"final",
"long",
"message",
"size",
"limit",
"padding",
"=",
"256",
";",
"return",
"new",
"metric",
"registry",
"configuration",
"(",
"scope",
"formats",
",",
"delim",
",",
"maximum",
"frame",
"size",
"-",
"message",
"size",
"limit",
"padding",
")",
";",
"}"
] |
[
"is",
"the",
"calling",
"user",
"an",
"admin",
"for",
"the",
"mapreduce",
"cluster",
"i",
"e",
"member",
"of",
"mapreduce",
"cluster",
"administrators"
] | [
"boolean",
"is",
"m",
"r",
"admin",
"(",
"user",
"group",
"information",
"caller",
"u",
"g",
"i",
")",
"{",
"if",
"(",
"admin",
"acl",
"is",
"user",
"allowed",
"(",
"caller",
"u",
"g",
"i",
")",
")",
"{",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}"
] |
[
"notifies",
"this",
"actor",
"'",
"s",
"listeners",
"of",
"the",
"event",
"the",
"event",
"is",
"not",
"propagated",
"to",
"any",
"ascendants",
"the",
"event",
"{",
"@",
"link",
"event",
"#",
"set",
"target",
"(",
"actor",
")",
"target",
"}",
"must",
"be",
"set",
"before",
"calling",
"this",
"method",
"before",
"notifying",
"the",
"listeners",
",",
"this",
"actor",
"is",
"set",
"as",
"the",
"{",
"@",
"link",
"event",
"#",
"get",
"listener",
"actor",
"(",
")",
"listener",
"actor",
"}",
"if",
"this",
"actor",
"is",
"not",
"in",
"the",
"stage",
",",
"the",
"stage",
"must",
"be",
"set",
"before",
"calling",
"this",
"method"
] | [
"public",
"boolean",
"notify",
"(",
"event",
"event",
",",
"boolean",
"capture",
")",
"{",
"if",
"(",
"event",
"get",
"target",
"(",
")",
"=",
"=",
"null",
")",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"the",
"event",
"target",
"cannot",
"be",
"null",
"\"",
")",
";",
"delayed",
"removal",
"array",
"<",
"event",
"listener",
">",
"listeners",
"=",
"capture",
"?",
"capture",
"listeners",
":",
"this",
"listeners",
";",
"if",
"(",
"listeners",
"size",
"=",
"=",
"0",
")",
"return",
"event",
"is",
"cancelled",
"(",
")",
";",
"event",
"set",
"listener",
"actor",
"(",
"this",
")",
";",
"event",
"set",
"capture",
"(",
"capture",
")",
";",
"if",
"(",
"event",
"get",
"stage",
"(",
")",
"=",
"=",
"null",
")",
"event",
"set",
"stage",
"(",
"stage",
")",
";",
"try",
"{",
"listeners",
"begin",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
",",
"n",
"=",
"listeners",
"size",
";",
"i",
"<",
"n",
";",
"i",
"+",
"+",
")",
"if",
"(",
"listeners",
"get",
"(",
"i",
")",
"handle",
"(",
"event",
")",
")",
"event",
"handle",
"(",
")",
";",
"listeners",
"end",
"(",
")",
";",
"}",
"catch",
"(",
"runtime",
"exception",
"ex",
")",
"{",
"string",
"context",
"=",
"to",
"string",
"(",
")",
";",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"actor",
":",
"\"",
"+",
"context",
"substring",
"(",
"0",
",",
"math",
"min",
"(",
"context",
"length",
"(",
")",
",",
"128",
")",
")",
",",
"ex",
")",
";",
"}",
"return",
"event",
"is",
"cancelled",
"(",
")",
";",
"}"
] |
[
"decrease",
"the",
"reference",
"count",
"for",
"this",
"buffer",
"by",
"one",
",",
"and",
"deallocate",
"it",
"once",
"the",
"count",
"reaches",
"zero"
] | [
"boolean",
"release",
"(",
")",
";"
] |
[
"sets",
"the",
"indices",
"for",
"the",
"shard",
"stores",
"request"
] | [
"public",
"indices",
"shard",
"store",
"request",
"builder",
"set",
"indices",
"(",
"string",
"indices",
")",
"{",
"request",
"indices",
"(",
"indices",
")",
";",
"return",
"this",
";",
"}"
] |
[
"get",
"small",
"camel"
] | [
"public",
"string",
"get",
"small",
"camel",
"(",
")",
"{",
"return",
"small",
"camel",
";",
"}"
] |
[
"build",
"the",
"{",
"@",
"link",
"web",
"test",
"client",
"}",
"instance"
] | [
"web",
"test",
"client",
"build",
"(",
")",
";"
] |
[
"<",
"code",
">",
"optional",
"string",
"prefix",
"=",
"1",
";",
"<",
"code",
">"
] | [
"public",
"builder",
"set",
"prefix",
"(",
"java",
"lang",
"string",
"value",
")",
"{",
"copy",
"on",
"write",
"(",
")",
";",
"instance",
"set",
"prefix",
"(",
"value",
")",
";",
"return",
"this",
";",
"}"
] |
[
"return",
"true",
"is",
"search",
"should",
"be",
"case",
"sensitive"
] | [
"public",
"boolean",
"is",
"case",
"sensitive",
"(",
")",
"{",
"return",
"case",
"sensitive",
";",
"}"
] |
[
"determine",
"the",
"first",
"(",
"or",
"last",
")",
"nested",
"property",
"separator",
"in",
"the",
"given",
"property",
"path",
",",
"ignoring",
"dots",
"in",
"keys",
"(",
"like",
"\"",
"map",
"[",
"my",
"key",
"]",
"\"",
")"
] | [
"private",
"static",
"int",
"get",
"nested",
"property",
"separator",
"index",
"(",
"string",
"property",
"path",
",",
"boolean",
"last",
")",
"{",
"boolean",
"in",
"key",
"=",
"false",
";",
"int",
"length",
"=",
"property",
"path",
"length",
"(",
")",
";",
"int",
"i",
"=",
"(",
"last",
"?",
"length",
"-",
"1",
":",
"0",
")",
";",
"while",
"(",
"last",
"?",
"i",
">",
"=",
"0",
":",
"i",
"<",
"length",
")",
"{",
"switch",
"(",
"property",
"path",
"char",
"at",
"(",
"i",
")",
")",
"{",
"case",
"property",
"accessor",
"property",
"key",
"prefix",
"char",
":",
"case",
"property",
"accessor",
"property",
"key",
"suffix",
"char",
":",
"in",
"key",
"=",
"!",
"in",
"key",
";",
"break",
";",
"case",
"property",
"accessor",
"nested",
"property",
"separator",
"char",
":",
"if",
"(",
"!",
"in",
"key",
")",
"{",
"return",
"i",
";",
"}",
"}",
"if",
"(",
"last",
")",
"{",
"i",
"-",
"-",
";",
"}",
"else",
"{",
"i",
"+",
"+",
";",
"}",
"}",
"return",
"-",
"1",
";",
"}"
] |
[
"checks",
"if",
"this",
"permission",
"is",
"contained",
"in",
"the",
"specified",
"scope",
",",
"(",
"either",
"directly",
"or",
"indirectly",
")"
] | [
"public",
"boolean",
"is",
"contained",
"by",
"(",
"@",
"non",
"null",
"permission",
"scope",
"s",
")",
"{",
"for",
"(",
"permission",
"scope",
"c",
":",
"scopes",
")",
"{",
"if",
"(",
"c",
"is",
"contained",
"by",
"(",
"s",
")",
")",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}"
] |
[
"returns",
"the",
"length",
"of",
"the",
"resource",
"name"
] | [
"public",
"byte",
"get",
"length",
"(",
")",
"{",
"return",
"lns",
"get",
"length",
"(",
")",
";",
"}"
] |
[
"this",
"neat",
"test",
"shows",
"that",
"no",
"matter",
"what",
"weights",
"we",
"use",
"in",
"our",
"requests",
",",
"if",
"we",
"push",
"x",
"amount",
"of",
"permits",
"in",
"a",
"cool",
"state",
",",
"where",
"x",
"=",
"rate",
"time",
"to",
"cool",
"down",
",",
"and",
"we",
"have",
"specified",
"a",
"time",
"to",
"warm",
"up",
"(",
")",
"period",
",",
"it",
"will",
"cost",
"as",
"the",
"prescribed",
"amount",
"of",
"time",
"e",
"g",
",",
"calling",
"[",
"acquire",
"(",
"5",
")",
",",
"acquire",
"(",
"1",
")",
"]",
"takes",
"exactly",
"the",
"same",
"time",
"as",
"[",
"acquire",
"(",
"2",
")",
",",
"acquire",
"(",
"3",
")",
",",
"acquire",
"(",
"1",
")",
"]"
] | [
"public",
"void",
"test",
"time",
"to",
"warm",
"up",
"is",
"honoured",
"even",
"with",
"weights",
"(",
")",
"{",
"random",
"random",
"=",
"new",
"random",
"(",
")",
";",
"int",
"warmup",
"permits",
"=",
"10",
";",
"double",
"[",
"]",
"cold",
"factors",
"to",
"test",
"=",
"{",
"2",
"0",
",",
"3",
"0",
",",
"10",
"0",
"}",
";",
"double",
"[",
"]",
"qps",
"to",
"test",
"=",
"{",
"4",
"0",
",",
"2",
"0",
",",
"1",
"0",
",",
"0",
"5",
",",
"0",
"1",
"}",
";",
"for",
"(",
"int",
"trial",
"=",
"0",
";",
"trial",
"<",
"100",
";",
"trial",
"+",
"+",
")",
"{",
"for",
"(",
"double",
"cold",
"factor",
":",
"cold",
"factors",
"to",
"test",
")",
"{",
"for",
"(",
"double",
"qps",
":",
"qps",
"to",
"test",
")",
"{",
"/",
"/",
"if",
"warmup",
"permits",
"=",
"max",
"permits",
"-",
"threshold",
"permits",
"then",
"/",
"/",
"warmup",
"period",
"=",
"(",
"1",
"+",
"cold",
"factor",
")",
"*",
"warmup",
"permits",
"*",
"stable",
"interval",
"/",
"2",
"long",
"warmup",
"millis",
"=",
"(",
"long",
")",
"(",
"(",
"1",
"+",
"cold",
"factor",
")",
"*",
"warmup",
"permits",
"/",
"(",
"2",
"0",
"*",
"qps",
")",
"*",
"1000",
"0",
")",
";",
"rate",
"limiter",
"rate",
"limiter",
"=",
"rate",
"limiter",
"create",
"(",
"qps",
",",
"warmup",
"millis",
",",
"milliseconds",
",",
"cold",
"factor",
",",
"stopwatch",
")",
";",
"assert",
"equals",
"(",
"warmup",
"millis",
",",
"measure",
"total",
"time",
"millis",
"(",
"rate",
"limiter",
",",
"warmup",
"permits",
",",
"random",
")",
")",
";",
"}",
"}",
"}",
"}"
] |
[
"set",
"the",
"mock",
"execute",
"handler"
] | [
"public",
"void",
"set",
"mock",
"execute",
"handler",
"(",
"mock",
"execute",
"handler",
"mock",
"execute",
"handler",
")",
"{",
"this",
"mock",
"execute",
"handler",
"=",
"mock",
"execute",
"handler",
";",
"}"
] |
[
"returns",
"true",
"if",
"the",
"task",
"for",
"this",
"result",
"was",
"cancelled"
] | [
"public",
"boolean",
"was",
"cancelled",
"(",
")",
"{",
"return",
"exception",
"instanceof",
"cancelled",
"exception",
";",
"}"
] |
[
"add",
"an",
"annotation",
"for",
"the",
"subsequent",
"output",
"any",
"previously",
"open",
"annotation",
"will",
"be",
"closed",
"by",
"this",
"call",
",",
"and",
"the",
"new",
"annotation",
"marks",
"all",
"subsequent",
"output",
"until",
"another",
"annotation",
"call"
] | [
"public",
"void",
"annotate",
"(",
"string",
"msg",
")",
";"
] |
[
"add",
"listeners",
"for",
"tenant",
"with",
"content"
] | [
"public",
"void",
"add",
"tenant",
"listeners",
"with",
"content",
"(",
"string",
"data",
"id",
",",
"string",
"group",
",",
"string",
"content",
",",
"list",
"<",
"?",
"extends",
"listener",
">",
"listeners",
")",
"throws",
"nacos",
"exception",
"{",
"group",
"=",
"null",
"2default",
"group",
"(",
"group",
")",
";",
"string",
"tenant",
"=",
"agent",
"get",
"tenant",
"(",
")",
";",
"cache",
"data",
"cache",
"=",
"add",
"cache",
"data",
"if",
"absent",
"(",
"data",
"id",
",",
"group",
",",
"tenant",
")",
";",
"cache",
"set",
"content",
"(",
"content",
")",
";",
"for",
"(",
"listener",
"listener",
":",
"listeners",
")",
"{",
"cache",
"add",
"listener",
"(",
"listener",
")",
";",
"}",
"}"
] |