docstring_tokens
list | code_tokens
list |
|---|---|
[
"checks",
"whether",
"native",
"statistics",
"collection",
"is",
"enabled",
"in",
"this",
"cache",
"the",
"default",
"value",
"is",
"<",
"code",
">",
"false",
"<",
"code",
">"
] |
[
"public",
"boolean",
"is",
"native",
"statistics",
"enabled",
"(",
")",
"{",
"return",
"native",
"statistics",
";",
"}"
] |
[
"build",
"http",
"call",
"with",
"the",
"given",
"options"
] |
[
"public",
"call",
"build",
"call",
"(",
"string",
"path",
",",
"string",
"method",
",",
"list",
"<",
"pair",
">",
"query",
"params",
",",
"list",
"<",
"pair",
">",
"collection",
"query",
"params",
",",
"object",
"body",
",",
"map",
"<",
"string",
",",
"string",
">",
"header",
"params",
",",
"map",
"<",
"string",
",",
"string",
">",
"cookie",
"params",
",",
"map",
"<",
"string",
",",
"object",
">",
"form",
"params",
",",
"string",
"[",
"]",
"auth",
"names",
",",
"api",
"callback",
"callback",
")",
"throws",
"api",
"exception",
"{",
"request",
"request",
"=",
"build",
"request",
"(",
"path",
",",
"method",
",",
"query",
"params",
",",
"collection",
"query",
"params",
",",
"body",
",",
"header",
"params",
",",
"cookie",
"params",
",",
"form",
"params",
",",
"auth",
"names",
",",
"callback",
")",
";",
"return",
"http",
"client",
"new",
"call",
"(",
"request",
")",
";",
"}"
] |
[
"applies",
"the",
"given",
"constant",
"pool",
"visitor",
"to",
"the",
"argument",
"constants",
"of",
"the",
"bootstrap",
"method"
] |
[
"public",
"void",
"method",
"arguments",
"accept",
"(",
"clazz",
"clazz",
",",
"constant",
"visitor",
"constant",
"visitor",
")",
"{",
"for",
"(",
"int",
"index",
"=",
"0",
";",
"index",
"<",
"u",
"2method",
"argument",
"count",
";",
"index",
"+",
"+",
")",
"{",
"clazz",
"constant",
"pool",
"entry",
"accept",
"(",
"u",
"2method",
"arguments",
"[",
"index",
"]",
",",
"constant",
"visitor",
")",
";",
"}",
"}"
] |
[
"invokes",
"{",
"@",
"link",
"audio",
"renderer",
"event",
"listener",
"#",
"on",
"audio",
"decoder",
"initialized",
"(",
"string",
",",
"long",
",",
"long",
")",
"}"
] |
[
"public",
"void",
"decoder",
"initialized",
"(",
"string",
"decoder",
"name",
",",
"long",
"initialized",
"timestamp",
"ms",
",",
"long",
"initialization",
"duration",
"ms",
")",
"{",
"if",
"(",
"handler",
"!",
"=",
"null",
")",
"{",
"handler",
"post",
"(",
"(",
")",
"-",
">",
"cast",
"non",
"null",
"(",
"listener",
")",
"on",
"audio",
"decoder",
"initialized",
"(",
"decoder",
"name",
",",
"initialized",
"timestamp",
"ms",
",",
"initialization",
"duration",
"ms",
")",
")",
";",
"}",
"}"
] |
[
"test",
"the",
"property",
"'",
"enum",
"number",
"'"
] |
[
"public",
"void",
"enum",
"number",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"enum",
"number",
"}"
] |
[
"assert",
"a",
"double",
"gauge",
"metric",
"as",
"expected"
] |
[
"public",
"static",
"void",
"assert",
"gauge",
"(",
"string",
"name",
",",
"double",
"expected",
",",
"metrics",
"record",
"builder",
"rb",
")",
"{",
"assert",
"assert",
"equals",
"(",
"\"",
"bad",
"value",
"for",
"metric",
"\"",
"+",
"name",
",",
"expected",
",",
"get",
"double",
"gauge",
"(",
"name",
",",
"rb",
")",
",",
"epsilon",
")",
";",
"}"
] |
[
"returns",
"the",
"set",
"of",
"{",
"@",
"link",
"fragment",
"}",
"classes",
"required",
"to",
"configure",
"a",
"rule",
"'",
"s",
"transitive",
"closure",
"these",
"are",
"used",
"to",
"instantiate",
"the",
"right",
"{",
"@",
"link",
"build",
"configuration",
"value",
"}",
"this",
"provides",
"the",
"basis",
"for",
"rule",
"-",
"scoped",
"configurations",
"for",
"example",
",",
"java",
"-",
"related",
"build",
"flags",
"have",
"nothing",
"to",
"do",
"with",
"c",
"+",
"+",
"so",
"changing",
"a",
"java",
"flag",
"shouldn",
"'",
"t",
"invalidate",
"a",
"c",
"+",
"+",
"rule",
"(",
"unless",
"it",
"has",
"transitive",
"dependencies",
"on",
"other",
"java",
"rules",
")",
"likewise",
",",
"a",
"c",
"+",
"+",
"rule",
"shouldn",
"'",
"t",
"fail",
"because",
"the",
"java",
"configuration",
"doesn",
"'",
"t",
"recognize",
"the",
"chosen",
"architecture",
"the",
"general",
"principle",
"is",
"that",
"a",
"rule",
"can",
"be",
"influenced",
"by",
"the",
"configuration",
"parameters",
"it",
"directly",
"uses",
"and",
"the",
"configuration",
"parameters",
"its",
"transitive",
"dependencies",
"use",
"(",
"since",
"it",
"reads",
"its",
"dependencies",
"as",
"part",
"of",
"analysis",
")",
"so",
"we",
"need",
"to",
"1",
")",
"determine",
"which",
"configuration",
"fragments",
"provide",
"these",
"parameters",
",",
"2",
")",
"load",
"those",
"fragments",
",",
"then",
"3",
")",
"create",
"a",
"configuration",
"from",
"them",
"to",
"feed",
"the",
"rule",
"'",
"s",
"configured",
"target",
"this",
"provides",
"the",
"first",
"step",
"see",
"{",
"@",
"link",
"com",
"google",
"devtools",
"build",
"lib",
"packages",
"rule",
"class",
"builder",
"#",
"requires",
"configuration",
"fragments",
"}"
] |
[
"public",
"nested",
"set",
"<",
"class",
"<",
"?",
"extends",
"fragment",
">",
">",
"get",
"transitive",
"config",
"fragments",
"(",
")",
"{",
"return",
"transitive",
"config",
"fragments",
";",
"}"
] |
[
"add",
"a",
"set",
"of",
"known",
"good",
"code",
"locations",
"to",
"be",
"protected",
"from",
"clearing",
"for",
"this",
"analysis",
"run",
"only"
] |
[
"public",
"void",
"set",
"protected",
"locations",
"(",
"address",
"set",
"set",
")",
"{",
"protected",
"locations",
"add",
"(",
"set",
")",
";",
"}"
] |
[
"when",
"an",
"interceptor",
"throws",
"an",
"unexpected",
"exception",
",",
"asynchronous",
"calls",
"are",
"canceled",
"the",
"exception",
"goes",
"to",
"the",
"uncaught",
"exception",
"handler"
] |
[
"private",
"void",
"interceptor",
"throws",
"runtime",
"exception",
"asynchronous",
"(",
"boolean",
"network",
")",
"throws",
"exception",
"{",
"runtime",
"exception",
"boom",
"=",
"new",
"runtime",
"exception",
"(",
"\"",
"boom",
"!",
"\"",
")",
";",
"add",
"interceptor",
"(",
"network",
",",
"chain",
"-",
">",
"{",
"throw",
"boom",
";",
"}",
")",
";",
"exception",
"catching",
"executor",
"executor",
"=",
"new",
"exception",
"catching",
"executor",
"(",
")",
";",
"client",
"=",
"client",
"new",
"builder",
"(",
")",
"dispatcher",
"(",
"new",
"dispatcher",
"(",
"executor",
")",
")",
"build",
"(",
")",
";",
"request",
"request",
"=",
"new",
"request",
"builder",
"(",
")",
"url",
"(",
"server",
"url",
"(",
"\"",
"/",
"\"",
")",
")",
"build",
"(",
")",
";",
"call",
"call",
"=",
"client",
"new",
"call",
"(",
"request",
")",
";",
"call",
"enqueue",
"(",
"callback",
")",
";",
"recorded",
"response",
"recorded",
"response",
"=",
"callback",
"await",
"(",
"server",
"url",
"(",
"\"",
"/",
"\"",
")",
")",
";",
"assert",
"that",
"(",
"recorded",
"response",
"failure",
")",
"has",
"message",
"(",
"\"",
"canceled",
"due",
"to",
"java",
"lang",
"runtime",
"exception",
":",
"boom",
"!",
"\"",
")",
";",
"assert",
"suppressed",
"(",
"recorded",
"response",
"failure",
",",
"throwables",
"-",
">",
"{",
"assert",
"that",
"(",
"throwables",
")",
"contains",
"(",
"boom",
")",
";",
"return",
"unit",
"instance",
";",
"}",
")",
";",
"assert",
"that",
"(",
"call",
"is",
"canceled",
"(",
")",
")",
"is",
"true",
"(",
")",
";",
"assert",
"that",
"(",
"executor",
"take",
"exception",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"boom",
")",
";",
"}"
] |
[
"gets",
"source",
"parameter"
] |
[
"protected",
"static",
"string",
"get",
"source",
"parameter",
"(",
"final",
"http",
"servlet",
"request",
"request",
",",
"final",
"string",
"param",
"names",
")",
"{",
"if",
"(",
"request",
"!",
"=",
"null",
")",
"{",
"val",
"parameter",
"map",
"=",
"request",
"get",
"parameter",
"map",
"(",
")",
";",
"return",
"stream",
"of",
"(",
"param",
"names",
")",
"filter",
"(",
"p",
"-",
">",
"parameter",
"map",
"contains",
"key",
"(",
"p",
")",
"|",
"|",
"request",
"get",
"attribute",
"(",
"p",
")",
"!",
"=",
"null",
")",
"find",
"first",
"(",
")",
"or",
"else",
"(",
"null",
")",
";",
"}",
"return",
"null",
";",
"}"
] |
[
"accepts",
"the",
"update",
"for",
"the",
"given",
"resource",
"type",
"by",
"updating",
"the",
"latest",
"resource",
"version",
"and",
"sends",
"an",
"ack",
"request",
"to",
"the",
"management",
"server"
] |
[
"protected",
"final",
"void",
"ack",
"response",
"(",
"resource",
"type",
"type",
",",
"string",
"version",
"info",
",",
"string",
"nonce",
")",
"{",
"switch",
"(",
"type",
")",
"{",
"case",
"lds",
":",
"lds",
"version",
"=",
"version",
"info",
";",
"break",
";",
"case",
"rds",
":",
"rds",
"version",
"=",
"version",
"info",
";",
"break",
";",
"case",
"cds",
":",
"cds",
"version",
"=",
"version",
"info",
";",
"break",
";",
"case",
"eds",
":",
"eds",
"version",
"=",
"version",
"info",
";",
"break",
";",
"case",
"unknown",
":",
"default",
":",
"throw",
"new",
"assertion",
"error",
"(",
"\"",
"unknown",
"resource",
"type",
":",
"\"",
"+",
"type",
")",
";",
"}",
"logger",
"log",
"(",
"xds",
"log",
"level",
"info",
",",
"\"",
"sending",
"ack",
"for",
"{",
"0",
"}",
"update",
",",
"nonce",
":",
"{",
"1",
"}",
",",
"current",
"version",
":",
"{",
"2",
"}",
"\"",
",",
"type",
",",
"nonce",
",",
"version",
"info",
")",
";",
"collection",
"<",
"string",
">",
"resources",
"=",
"get",
"subscribed",
"resources",
"(",
"type",
")",
";",
"if",
"(",
"resources",
"=",
"=",
"null",
")",
"{",
"resources",
"=",
"collections",
"empty",
"list",
"(",
")",
";",
"}",
"ads",
"stream",
"send",
"discovery",
"request",
"(",
"type",
",",
"version",
"info",
",",
"resources",
",",
"nonce",
",",
"null",
")",
";",
"}"
] |
[
"subscribe",
"to",
"all",
"topics",
"matching",
"specified",
"pattern",
"to",
"get",
"dynamically",
"assigned",
"partitions",
"the",
"pattern",
"matching",
"will",
"be",
"done",
"periodically",
"against",
"topics",
"existing",
"at",
"the",
"time",
"of",
"check",
"this",
"is",
"a",
"short",
"-",
"hand",
"for",
"{",
"@",
"link",
"#",
"subscribe",
"(",
"pattern",
",",
"consumer",
"rebalance",
"listener",
")",
"}",
",",
"which",
"uses",
"a",
"no",
"-",
"op",
"listener",
"if",
"you",
"need",
"the",
"ability",
"to",
"seek",
"to",
"particular",
"offsets",
",",
"you",
"should",
"prefer",
"{",
"@",
"link",
"#",
"subscribe",
"(",
"pattern",
",",
"consumer",
"rebalance",
"listener",
")",
"}",
",",
"since",
"group",
"rebalances",
"will",
"cause",
"partition",
"offsets",
"to",
"be",
"reset",
"you",
"should",
"also",
"provide",
"your",
"own",
"listener",
"if",
"you",
"are",
"doing",
"your",
"own",
"offset",
"management",
"since",
"the",
"listener",
"gives",
"you",
"an",
"opportunity",
"to",
"commit",
"offsets",
"before",
"a",
"rebalance",
"finishes"
] |
[
"public",
"void",
"subscribe",
"(",
"pattern",
"pattern",
")",
"{",
"subscribe",
"(",
"pattern",
",",
"new",
"no",
"op",
"consumer",
"rebalance",
"listener",
"(",
")",
")",
";",
"}"
] |
[
"returns",
"a",
"random",
"number",
"between",
"0",
"(",
"inclusive",
")",
"and",
"the",
"specified",
"value",
"(",
"inclusive",
")"
] |
[
"static",
"public",
"long",
"random",
"(",
"long",
"range",
")",
"{",
"return",
"(",
"long",
")",
"(",
"random",
"next",
"double",
"(",
")",
"*",
"range",
")",
";",
"}"
] |
[
"lookup",
"and",
"if",
"not",
"found",
"create",
"a",
"future",
"register",
"flow",
"state"
] |
[
"private",
"map",
"<",
"register",
",",
"register",
"value",
">",
"find",
"future",
"flow",
"state",
"map",
"(",
"address",
"from",
"addr",
",",
"address",
"dest",
"addr",
")",
"{",
"map",
"<",
"register",
",",
"register",
"value",
">",
"state",
"map",
"=",
"null",
";",
"map",
"<",
"address",
",",
"map",
"<",
"register",
",",
"register",
"value",
">",
">",
"future",
"register",
"state",
"map",
"=",
"no",
"address",
"future",
"register",
"state",
"map",
";",
"if",
"(",
"from",
"addr",
"=",
"=",
"address",
"no",
"address",
")",
"{",
"/",
"/",
"for",
"no",
"address",
"flow",
"from",
",",
"always",
"look",
"up",
"by",
"the",
"dest",
"addr",
",",
"state",
"map",
"=",
"future",
"register",
"state",
"map",
"get",
"(",
"dest",
"addr",
")",
";",
"/",
"/",
"didn",
"'",
"t",
"find",
"a",
"flow",
"from",
"map",
",",
"create",
"it",
"if",
"(",
"state",
"map",
"=",
"=",
"null",
")",
"{",
"state",
"map",
"=",
"new",
"hash",
"map",
"<",
"register",
",",
"register",
"value",
">",
"(",
")",
";",
"future",
"register",
"state",
"map",
"put",
"(",
"dest",
"addr",
",",
"state",
"map",
")",
";",
"}",
"}",
"else",
"{",
"/",
"/",
"for",
"flows",
"where",
"the",
"flow",
"from",
"addr",
"is",
"known",
",",
"look",
"up",
"by",
"dest",
"addr",
"first",
",",
"then",
"flow",
"from",
"addr",
"future",
"register",
"state",
"map",
"=",
"future",
"flow",
"register",
"state",
"maps",
"get",
"(",
"dest",
"addr",
")",
";",
"/",
"/",
"didn",
"'",
"t",
"find",
"a",
"flow",
"to",
"map",
",",
"create",
"it",
"if",
"(",
"future",
"register",
"state",
"map",
"=",
"=",
"null",
")",
"{",
"future",
"register",
"state",
"map",
"=",
"new",
"hash",
"map",
"<",
"address",
",",
"map",
"<",
"register",
",",
"register",
"value",
">",
">",
"(",
")",
";",
"future",
"flow",
"register",
"state",
"maps",
"put",
"(",
"dest",
"addr",
",",
"future",
"register",
"state",
"map",
")",
";",
"}",
"else",
"{",
"state",
"map",
"=",
"future",
"register",
"state",
"map",
"get",
"(",
"from",
"addr",
")",
";",
"}",
"/",
"/",
"didn",
"'",
"t",
"find",
"a",
"flow",
"from",
"map",
",",
"create",
"it",
"if",
"(",
"state",
"map",
"=",
"=",
"null",
")",
"{",
"state",
"map",
"=",
"new",
"hash",
"map",
"<",
"register",
",",
"register",
"value",
">",
"(",
")",
";",
"future",
"register",
"state",
"map",
"put",
"(",
"from",
"addr",
",",
"state",
"map",
")",
";",
"}",
"}",
"return",
"state",
"map",
";",
"}"
] |
[
"registers",
"this",
"{",
"@",
"link",
"computer",
"listener",
"}",
"so",
"that",
"it",
"will",
"start",
"receiving",
"events"
] |
[
"public",
"final",
"void",
"register",
"(",
")",
"{",
"all",
"(",
")",
"add",
"(",
"this",
")",
";",
"}"
] |
[
"return",
"whether",
"the",
"http",
"1",
"1",
"cache",
"-",
"control",
"header",
"is",
"used"
] |
[
"public",
"final",
"boolean",
"is",
"use",
"cache",
"control",
"header",
"(",
")",
"{",
"return",
"this",
"use",
"cache",
"control",
"header",
";",
"}"
] |
[
"if",
"enabled",
",",
"any",
"prop",
"updates",
"done",
"with",
"set",
"root",
"will",
"be",
"on",
"a",
"background",
"thread",
"this",
"excludes",
"the",
"very",
"first",
"set",
"root",
"where",
"there",
"isn",
"'",
"t",
"an",
"existing",
"section",
"that",
"one",
"will",
"still",
"be",
"on",
"the",
"main",
"thread"
] |
[
"public",
"builder",
"async",
"prop",
"updates",
"(",
"boolean",
"async",
"prop",
"updates",
")",
"{",
"m",
"async",
"prop",
"updates",
"=",
"async",
"prop",
"updates",
";",
"return",
"this",
";",
"}"
] |
[
"tests",
"if",
"any",
"view",
"in",
"the",
"hierarchy",
"under",
"the",
"root",
",",
"for",
"which",
"the",
"path",
"is",
"visible",
",",
"has",
"text",
"that",
"matches",
"the",
"given",
"regular",
"expression"
] |
[
"public",
"view",
"tree",
"assert",
"has",
"visible",
"text",
"matching",
"(",
"final",
"string",
"pattern",
")",
"{",
"final",
"immutable",
"list",
"<",
"view",
">",
"path",
"=",
"get",
"path",
"to",
"visible",
"matching",
"text",
"(",
"pattern",
")",
";",
"java",
"6",
"assertions",
"assert",
"that",
"(",
"path",
")",
"overriding",
"error",
"message",
"(",
"\"",
"cannot",
"find",
"text",
"matching",
"\\",
"\"",
"%",
"s",
"\\",
"\"",
"in",
"view",
"hierarchy",
":",
"%",
"n",
"%",
"s",
"\"",
",",
"pattern",
",",
"actual",
"make",
"string",
"(",
"get",
"text",
"function",
")",
")",
"is",
"not",
"null",
"(",
")",
";",
"return",
"this",
";",
"}"
] |
[
"adds",
"the",
"given",
"defines",
"to",
"the",
"compiler",
"command",
"line",
"of",
"this",
"target",
"as",
"well",
"as",
"its",
"dependent",
"targets"
] |
[
"public",
"cc",
"compilation",
"helper",
"add",
"defines",
"(",
"iterable",
"<",
"string",
">",
"defines",
")",
"{",
"iterables",
"add",
"all",
"(",
"this",
"defines",
",",
"defines",
")",
";",
"return",
"this",
";",
"}"
] |
[
"the",
"last",
"time",
"the",
"state",
"store",
"cache",
"was",
"fully",
"updated"
] |
[
"public",
"long",
"get",
"cache",
"update",
"time",
"(",
")",
"{",
"return",
"this",
"cache",
"last",
"update",
"time",
";",
"}"
] |
[
"returns",
"the",
"index",
"of",
"the",
"type",
"parameter",
"referenced",
"by",
"this",
"type",
"reference",
"this",
"method",
"must",
"only",
"be",
"used",
"for",
"type",
"references",
"whose",
"sort",
"is",
"{",
"@",
"link",
"#",
"class",
"type",
"parameter",
"}",
",",
"{",
"@",
"link",
"#",
"method",
"type",
"parameter",
"}",
",",
"{",
"@",
"link",
"#",
"class",
"type",
"parameter",
"bound",
"}",
"or",
"{",
"@",
"link",
"#",
"method",
"type",
"parameter",
"bound",
"}"
] |
[
"public",
"int",
"get",
"type",
"parameter",
"index",
"(",
")",
"{",
"return",
"(",
"target",
"type",
"and",
"info",
"&",
"0x",
"0",
"0",
"f",
"f",
"0",
"0",
"0",
"0",
")",
">",
">",
"16",
";",
"}"
] |
[
"build",
"a",
"proper",
"{",
"@",
"link",
"task",
"info",
"}",
"for",
"this",
"task"
] |
[
"protected",
"final",
"task",
"info",
"task",
"info",
"(",
"string",
"local",
"node",
"id",
",",
"string",
"description",
",",
"status",
"status",
")",
"{",
"return",
"new",
"task",
"info",
"(",
"new",
"task",
"id",
"(",
"local",
"node",
"id",
",",
"get",
"id",
"(",
")",
")",
",",
"get",
"type",
"(",
")",
",",
"get",
"action",
"(",
")",
",",
"description",
",",
"status",
",",
"start",
"time",
",",
"system",
"nano",
"time",
"(",
")",
"-",
"start",
"time",
"nanos",
",",
"this",
"instanceof",
"cancellable",
"task",
",",
"parent",
"task",
",",
"headers",
")",
";",
"}"
] |
[
"emit",
"the",
"value",
"with",
"the",
"highest",
"position",
"in",
"the",
"tuple"
] |
[
"protected",
"v",
"emit",
"(",
"tuple",
"writable",
"dst",
")",
"{",
"return",
"(",
"v",
")",
"dst",
"iterator",
"(",
")",
"next",
"(",
")",
";",
"}"
] |
[
"returns",
"the",
"value",
"associated",
"with",
"{",
"@",
"code",
"key",
"}",
"in",
"this",
"cache",
",",
"obtaining",
"that",
"value",
"from",
"{",
"@",
"code",
"loader",
"}",
"if",
"necessary",
"the",
"method",
"improves",
"upon",
"the",
"conventional",
"\"",
"if",
"cached",
",",
"return",
";",
"otherwise",
"create",
",",
"cache",
"and",
"return",
"\"",
"pattern",
"for",
"further",
"improvements",
",",
"use",
"{",
"@",
"link",
"loading",
"cache",
"}",
"and",
"its",
"{",
"@",
"link",
"loading",
"cache",
"#",
"get",
"(",
"object",
")",
"get",
"(",
"k",
")",
"}",
"method",
"instead",
"of",
"this",
"one",
"among",
"the",
"improvements",
"that",
"this",
"method",
"and",
"{",
"@",
"code",
"loading",
"cache",
"get",
"(",
"k",
")",
"}",
"both",
"provide",
"are",
":",
"{",
"@",
"linkplain",
"loading",
"cache",
"#",
"get",
"(",
"object",
")",
"awaiting",
"the",
"result",
"of",
"a",
"pending",
"load",
"}",
"rather",
"than",
"starting",
"a",
"redundant",
"one",
"eliminating",
"the",
"error",
"-",
"prone",
"caching",
"boilerplate",
"tracking",
"load",
"{",
"@",
"linkplain",
"#",
"stats",
"statistics",
"}",
"among",
"the",
"further",
"improvements",
"that",
"{",
"@",
"code",
"loading",
"cache",
"}",
"can",
"provide",
"but",
"this",
"method",
"cannot",
":",
"consolidation",
"of",
"the",
"loader",
"logic",
"to",
"{",
"@",
"linkplain",
"cache",
"builder",
"#",
"build",
"(",
"cache",
"loader",
")",
"a",
"single",
"authoritative",
"location",
"}",
"{",
"@",
"linkplain",
"loading",
"cache",
"#",
"refresh",
"refreshing",
"of",
"entries",
"}",
",",
"including",
"{",
"@",
"linkplain",
"cache",
"builder",
"#",
"refresh",
"after",
"write",
"automated",
"refreshing",
"}",
"{",
"@",
"linkplain",
"loading",
"cache",
"#",
"get",
"all",
"bulk",
"loading",
"requests",
"}",
",",
"including",
"{",
"@",
"linkplain",
"cache",
"loader",
"#",
"load",
"all",
"bulk",
"loading",
"implementations",
"}",
"<",
"b",
">",
"warning",
":",
"<",
"b",
">",
"for",
"any",
"given",
"key",
",",
"every",
"{",
"@",
"code",
"loader",
"}",
"used",
"with",
"it",
"should",
"compute",
"the",
"same",
"value",
"otherwise",
",",
"a",
"call",
"that",
"passes",
"one",
"{",
"@",
"code",
"loader",
"}",
"may",
"return",
"the",
"result",
"of",
"another",
"call",
"with",
"a",
"differently",
"behaving",
"{",
"@",
"code",
"loader",
"}",
"for",
"example",
",",
"a",
"call",
"that",
"requests",
"a",
"short",
"timeout",
"for",
"an",
"rpc",
"may",
"wait",
"for",
"a",
"similar",
"call",
"that",
"requests",
"a",
"long",
"timeout",
",",
"or",
"a",
"call",
"by",
"an",
"unprivileged",
"user",
"may",
"return",
"a",
"resource",
"accessible",
"only",
"to",
"a",
"privileged",
"user",
"making",
"a",
"similar",
"call",
"to",
"prevent",
"this",
"problem",
",",
"create",
"a",
"key",
"object",
"that",
"includes",
"all",
"values",
"that",
"affect",
"the",
"result",
"of",
"the",
"query",
"or",
"use",
"{",
"@",
"code",
"loading",
"cache",
"get",
"(",
"k",
")",
"}",
",",
"which",
"lacks",
"the",
"ability",
"to",
"refer",
"to",
"state",
"other",
"than",
"that",
"in",
"the",
"key",
"<",
"b",
">",
"warning",
":",
"<",
"b",
">",
"as",
"with",
"{",
"@",
"link",
"cache",
"loader",
"#",
"load",
"}",
",",
"{",
"@",
"code",
"loader",
"}",
"<",
"b",
">",
"must",
"not",
"<",
"b",
">",
"return",
"{",
"@",
"code",
"null",
"}",
";",
"it",
"may",
"either",
"return",
"a",
"non",
"-",
"null",
"value",
"or",
"throw",
"an",
"exception",
"no",
"observable",
"state",
"associated",
"with",
"this",
"cache",
"is",
"modified",
"until",
"loading",
"completes"
] |
[
"v",
"get",
"(",
"k",
"key",
",",
"callable",
"<",
"?",
"extends",
"v",
">",
"loader",
")",
"throws",
"execution",
"exception",
";"
] |
[
"load",
"bean",
"definitions",
"from",
"the",
"specified",
"properties",
"file"
] |
[
"public",
"int",
"load",
"bean",
"definitions",
"(",
"encoded",
"resource",
"encoded",
"resource",
",",
"@",
"nullable",
"string",
"prefix",
")",
"throws",
"bean",
"definition",
"store",
"exception",
"{",
"if",
"(",
"logger",
"is",
"trace",
"enabled",
"(",
")",
")",
"{",
"logger",
"trace",
"(",
"\"",
"loading",
"properties",
"bean",
"definitions",
"from",
"\"",
"+",
"encoded",
"resource",
")",
";",
"}",
"properties",
"props",
"=",
"new",
"properties",
"(",
")",
";",
"try",
"{",
"try",
"(",
"input",
"stream",
"is",
"=",
"encoded",
"resource",
"get",
"resource",
"(",
")",
"get",
"input",
"stream",
"(",
")",
")",
"{",
"if",
"(",
"encoded",
"resource",
"get",
"encoding",
"(",
")",
"!",
"=",
"null",
")",
"{",
"get",
"properties",
"persister",
"(",
")",
"load",
"(",
"props",
",",
"new",
"input",
"stream",
"reader",
"(",
"is",
",",
"encoded",
"resource",
"get",
"encoding",
"(",
")",
")",
")",
";",
"}",
"else",
"{",
"get",
"properties",
"persister",
"(",
")",
"load",
"(",
"props",
",",
"is",
")",
";",
"}",
"}",
"int",
"count",
"=",
"register",
"bean",
"definitions",
"(",
"props",
",",
"prefix",
",",
"encoded",
"resource",
"get",
"resource",
"(",
")",
"get",
"description",
"(",
")",
")",
";",
"if",
"(",
"logger",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"logger",
"debug",
"(",
"\"",
"loaded",
"\"",
"+",
"count",
"+",
"\"",
"bean",
"definitions",
"from",
"\"",
"+",
"encoded",
"resource",
")",
";",
"}",
"return",
"count",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"ex",
")",
"{",
"throw",
"new",
"bean",
"definition",
"store",
"exception",
"(",
"\"",
"could",
"not",
"parse",
"properties",
"from",
"\"",
"+",
"encoded",
"resource",
"get",
"resource",
"(",
")",
",",
"ex",
")",
";",
"}",
"}"
] |
[
"creates",
"a",
"new",
"{",
"@",
"link",
"published",
"events",
"}",
"instance",
"for",
"the",
"given",
"events"
] |
[
"public",
"static",
"published",
"events",
"of",
"(",
"object",
"events",
")",
"{",
"return",
"of",
"(",
"arrays",
"as",
"list",
"(",
"events",
")",
")",
";",
"}"
] |
[
"returns",
"the",
"average",
"size",
"in",
"bytes",
"of",
"all",
"documents",
"in",
"this",
"stats"
] |
[
"public",
"long",
"get",
"average",
"size",
"in",
"bytes",
"(",
")",
"{",
"long",
"total",
"docs",
"=",
"count",
"+",
"deleted",
";",
"return",
"total",
"docs",
"=",
"=",
"0",
"?",
"0",
":",
"total",
"size",
"in",
"bytes",
"/",
"total",
"docs",
";",
"}"
] |
[
"returns",
"all",
"the",
"registered",
"{",
"@",
"link",
"id",
"strategy",
"}",
"descriptors"
] |
[
"public",
"static",
"descriptor",
"extension",
"list",
"<",
"id",
"strategy",
",",
"id",
"strategy",
"descriptor",
">",
"all",
"(",
")",
"{",
"return",
"jenkins",
"get",
"(",
")",
"get",
"descriptor",
"list",
"(",
"id",
"strategy",
"class",
")",
";",
"}"
] |
[
"inspect",
"the",
"instruction",
"and",
"return",
"how",
"it",
"affects",
"the",
"stack",
"depth",
"if",
"the",
"depth",
"cannot",
"be",
"determined",
",",
"then",
"return",
"that",
"the",
"stack",
"depth",
"change",
"is",
"unknown"
] |
[
"int",
"get",
"instruction",
"stack",
"depth",
"change",
"(",
"instruction",
"instr",
",",
"processor",
"context",
"proc",
"context",
",",
"int",
"current",
"stack",
"depth",
")",
"{",
"/",
"/",
"see",
"if",
"there",
"is",
"an",
"override",
"at",
"this",
"address",
"integer",
"override",
"=",
"override",
"map",
"get",
"(",
"instr",
"get",
"min",
"address",
"(",
")",
")",
";",
"if",
"(",
"override",
"!",
"=",
"null",
")",
"{",
"return",
"override",
"int",
"value",
"(",
")",
";",
"}",
"int",
"depth",
"change",
"=",
"0",
";",
"if",
"(",
"!",
"trans",
"supports",
"pcode",
"(",
")",
")",
"{",
"return",
"function",
"unknown",
"stack",
"depth",
"change",
";",
"}",
"int",
"possible",
"depth",
"change",
"=",
"0",
";",
"/",
"/",
"todo",
":",
"this",
"is",
"hack",
",",
"a",
"call",
"instruction",
"can",
"modify",
"the",
"stack",
"while",
"/",
"/",
"in",
"progress",
",",
"it",
"matters",
"what",
"happens",
"upon",
"return",
"/",
"/",
"what",
"we",
"care",
"about",
"here",
"is",
"what",
"is",
"the",
"result",
"after",
"execution",
"on",
"the",
"/",
"/",
"stack",
"pointer",
"flow",
"type",
"flow",
"type",
"=",
"instr",
"get",
"flow",
"type",
"(",
")",
";",
"if",
"(",
"flow",
"type",
"is",
"call",
"(",
")",
")",
"{",
"/",
"/",
"depth",
"change",
"=",
"get",
"call",
"purge",
"(",
"instr",
")",
";",
"/",
"/",
"if",
"(",
"depth",
"change",
"=",
"=",
"function",
"unknown",
"stack",
"depth",
"change",
")",
"/",
"/",
"return",
"0",
";",
"/",
"/",
"return",
"depth",
"change",
";",
"return",
"0",
";",
"}",
"pcode",
"op",
"[",
"]",
"pcode",
"=",
"instr",
"get",
"pcode",
"(",
")",
";",
"varnode",
"out",
"var",
"node",
"=",
"null",
";",
"for",
"(",
"pcode",
"op",
"op",
":",
"pcode",
")",
"{",
"varnode",
"input",
"0",
"=",
"op",
"get",
"input",
"(",
"0",
")",
";",
"varnode",
"input",
"1",
"=",
"op",
"get",
"input",
"(",
"1",
")",
";",
"varnode",
"output",
"=",
"op",
"get",
"output",
"(",
")",
";",
"switch",
"(",
"op",
"get",
"opcode",
"(",
")",
")",
"{",
"case",
"pcode",
"op",
"int",
"add",
":",
"if",
"(",
"is",
"stack",
"pointer",
"(",
"input",
"0",
")",
")",
"{",
"possible",
"depth",
"change",
"=",
"(",
"int",
")",
"input",
"1",
"get",
"offset",
"(",
")",
";",
"out",
"var",
"node",
"=",
"output",
";",
"}",
"else",
"if",
"(",
"input",
"0",
"equals",
"(",
"out",
"var",
"node",
")",
")",
"{",
"possible",
"depth",
"change",
"+",
"=",
"(",
"int",
")",
"input",
"1",
"get",
"offset",
"(",
")",
";",
"out",
"var",
"node",
"=",
"output",
";",
"}",
"else",
"if",
"(",
"is",
"stack",
"pointer",
"(",
"input",
"1",
")",
")",
"{",
"possible",
"depth",
"change",
"=",
"(",
"int",
")",
"input",
"0",
"get",
"offset",
"(",
")",
";",
"out",
"var",
"node",
"=",
"output",
";",
"}",
"else",
"if",
"(",
"input",
"1",
"equals",
"(",
"out",
"var",
"node",
")",
")",
"{",
"possible",
"depth",
"change",
"+",
"=",
"(",
"int",
")",
"input",
"0",
"get",
"offset",
"(",
")",
";",
"out",
"var",
"node",
"=",
"output",
";",
"}",
"break",
";",
"case",
"pcode",
"op",
"int",
"sub",
":",
"if",
"(",
"is",
"stack",
"pointer",
"(",
"input",
"0",
")",
")",
"{",
"possible",
"depth",
"change",
"=",
"(",
"int",
")",
"-",
"input",
"1",
"get",
"offset",
"(",
")",
";",
"out",
"var",
"node",
"=",
"output",
";",
"}",
"else",
"if",
"(",
"input",
"0",
"equals",
"(",
"out",
"var",
"node",
")",
")",
"{",
"possible",
"depth",
"change",
"+",
"=",
"(",
"int",
")",
"-",
"input",
"1",
"get",
"offset",
"(",
")",
";",
"out",
"var",
"node",
"=",
"output",
";",
"}",
"else",
"if",
"(",
"is",
"stack",
"pointer",
"(",
"input",
"1",
")",
")",
"{",
"possible",
"depth",
"change",
"=",
"(",
"int",
")",
"-",
"input",
"0",
"get",
"offset",
"(",
")",
";",
"out",
"var",
"node",
"=",
"output",
";",
"}",
"else",
"if",
"(",
"input",
"1",
"equals",
"(",
"out",
"var",
"node",
")",
")",
"{",
"possible",
"depth",
"change",
"+",
"=",
"(",
"int",
")",
"-",
"input",
"0",
"get",
"offset",
"(",
")",
";",
"out",
"var",
"node",
"=",
"output",
";",
"}",
"break",
";",
"case",
"pcode",
"op",
"int",
"and",
":",
"/",
"/",
"assume",
"this",
"is",
"a",
"stack",
"alignment",
"and",
"do",
"the",
"and",
"if",
"(",
"is",
"stack",
"pointer",
"(",
"input",
"0",
")",
")",
"{",
"if",
"(",
"current",
"stack",
"depth",
"!",
"=",
"function",
"unknown",
"stack",
"depth",
"change",
")",
"{",
"possible",
"depth",
"change",
"=",
"(",
"int",
")",
"(",
"current",
"stack",
"depth",
"&",
"input",
"1",
"get",
"offset",
"(",
")",
")",
"-",
"current",
"stack",
"depth",
";",
"}",
"out",
"var",
"node",
"=",
"output",
";",
"}",
"else",
"if",
"(",
"input",
"0",
"equals",
"(",
"out",
"var",
"node",
")",
")",
"{",
"possible",
"depth",
"change",
"=",
"0",
";",
"out",
"var",
"node",
"=",
"output",
";",
"}",
"else",
"if",
"(",
"is",
"stack",
"pointer",
"(",
"input",
"1",
")",
")",
"{",
"if",
"(",
"current",
"stack",
"depth",
"!",
"=",
"function",
"unknown",
"stack",
"depth",
"change",
")",
"{",
"possible",
"depth",
"change",
"=",
"(",
"int",
")",
"(",
"current",
"stack",
"depth",
"&",
"input",
"0",
"get",
"offset",
"(",
")",
")",
"-",
"current",
"stack",
"depth",
";",
"}",
"out",
"var",
"node",
"=",
"output",
";",
"}",
"else",
"if",
"(",
"input",
"1",
"equals",
"(",
"out",
"var",
"node",
")",
")",
"{",
"possible",
"depth",
"change",
"=",
"0",
";",
"out",
"var",
"node",
"=",
"output",
";",
"}",
"break",
";",
"}",
"if",
"(",
"!",
"is",
"stack",
"pointer",
"(",
"output",
")",
")",
"{",
"/",
"/",
"possible",
"depth",
"change",
"=",
"0",
";",
"continue",
";",
"}",
"switch",
"(",
"op",
"get",
"opcode",
"(",
")",
")",
"{",
"case",
"pcode",
"op",
"int",
"add",
":",
"case",
"pcode",
"op",
"int",
"sub",
":",
"case",
"pcode",
"op",
"int",
"and",
":",
"depth",
"change",
"+",
"=",
"possible",
"depth",
"change",
";",
"break",
";",
"case",
"pcode",
"op",
"store",
":",
"break",
";",
"case",
"pcode",
"op",
"int",
"or",
":",
"/",
"/",
"if",
"the",
"op",
"is",
"an",
"or",
",",
"then",
"this",
"could",
"be",
"a",
"copy",
"varnode",
"or",
"input",
"1",
"=",
"op",
"get",
"input",
"(",
"0",
")",
";",
"varnode",
"or",
"input",
"2",
"=",
"op",
"get",
"input",
"(",
"1",
")",
";",
"if",
"(",
"!",
"or",
"input",
"1",
"equals",
"(",
"or",
"input",
"2",
")",
")",
"{",
"break",
";",
"}",
"msg",
"debug",
"(",
"this",
",",
"\"",
"int",
"or",
"\"",
"+",
"instr",
"get",
"min",
"address",
"(",
")",
")",
";",
"case",
"pcode",
"op",
"copy",
":",
"varnode",
"input",
"=",
"op",
"get",
"input",
"(",
"0",
")",
";",
"/",
"/",
"if",
"we",
"know",
"the",
"processor",
"context",
",",
"find",
"the",
"value",
"if",
"(",
"proc",
"context",
"!",
"=",
"null",
"&",
"&",
"input",
"is",
"register",
"(",
")",
")",
"{",
"register",
"reg",
"=",
"null",
";",
"reg",
"=",
"trans",
"get",
"register",
"(",
"input",
")",
";",
"if",
"(",
"proc",
"context",
"has",
"value",
"(",
"reg",
")",
")",
"{",
"long",
"value",
"=",
"proc",
"context",
"get",
"value",
"(",
"reg",
",",
"true",
")",
"long",
"value",
"(",
")",
";",
"depth",
"change",
"=",
"(",
"int",
")",
"(",
"value",
"-",
"current",
"stack",
"depth",
")",
";",
"current",
"stack",
"depth",
"+",
"=",
"depth",
"change",
";",
"continue",
";",
"}",
"}",
"if",
"(",
"!",
"input",
"equals",
"(",
"out",
"var",
"node",
")",
")",
"{",
"return",
"function",
"unknown",
"stack",
"depth",
"change",
";",
"}",
"depth",
"change",
"=",
"possible",
"depth",
"change",
";",
"break",
";",
"default",
":",
"return",
"function",
"unknown",
"stack",
"depth",
"change",
";",
"}",
"}",
"/",
"/",
"todo",
":",
"modify",
"return",
"by",
"normal",
"stack",
"shift",
"if",
"(",
"flow",
"type",
"is",
"terminal",
"(",
")",
")",
"{",
"depth",
"change",
"-",
"=",
"program",
"get",
"compiler",
"spec",
"(",
")",
"get",
"default",
"calling",
"convention",
"(",
")",
"get",
"stackshift",
"(",
")",
";",
"}",
"/",
"/",
"if",
"the",
"current",
"stack",
"depth",
"is",
"still",
"bad",
",",
"don",
"'",
"t",
"return",
"a",
"depth",
"change",
"if",
"(",
"current",
"stack",
"depth",
"=",
"=",
"function",
"unknown",
"stack",
"depth",
"change",
"|",
"|",
"current",
"stack",
"depth",
"=",
"=",
"function",
"invalid",
"stack",
"depth",
"change",
")",
"{",
"return",
"function",
"unknown",
"stack",
"depth",
"change",
";",
"}",
"return",
"depth",
"change",
";",
"}"
] |
[
"converts",
"an",
"internal",
"class",
"name",
"into",
"an",
"external",
"class",
"name"
] |
[
"public",
"static",
"string",
"external",
"class",
"name",
"(",
"string",
"internal",
"class",
"name",
")",
"{",
"return",
"/",
"/",
"internal",
"class",
"name",
"starts",
"with",
"(",
"class",
"constants",
"package",
"java",
"lang",
")",
"&",
"&",
"/",
"/",
"internal",
"class",
"name",
"index",
"of",
"(",
"class",
"constants",
"package",
"separator",
",",
"class",
"constants",
"package",
"java",
"lang",
"length",
"(",
")",
"+",
"1",
")",
"<",
"0",
"?",
"/",
"/",
"internal",
"class",
"name",
"substring",
"(",
"class",
"constants",
"package",
"java",
"lang",
"length",
"(",
")",
")",
":",
"internal",
"class",
"name",
"replace",
"(",
"class",
"constants",
"package",
"separator",
",",
"java",
"constants",
"package",
"separator",
")",
";",
"}"
] |
[
"add",
"to",
"this",
"collection",
"a",
"{",
"@",
"link",
"header",
"}",
"with",
"the",
"given",
"key",
"and",
"value"
] |
[
"headers",
"add",
"map",
"(",
"string",
"key",
",",
"map",
"<",
"?",
",",
"?",
">",
"value",
",",
"schema",
"schema",
")",
";"
] |
[
"define",
"a",
"new",
"bolt",
"in",
"this",
"topology",
"with",
"parallelism",
"of",
"just",
"one",
"thread"
] |
[
"public",
"bolt",
"declarer",
"set",
"bolt",
"(",
"string",
"id",
",",
"i",
"rich",
"bolt",
"bolt",
")",
"{",
"return",
"set",
"bolt",
"(",
"id",
",",
"bolt",
",",
"null",
")",
";",
"}"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"executes",
"a",
"batch",
"using",
"the",
"supplied",
"sql",
"statement",
"with",
"the",
"batch",
"of",
"supplied",
"arguments"
] |
[
"int",
"[",
"]",
"batch",
"update",
"(",
"string",
"sql",
",",
"map",
"<",
"string",
",",
"?",
">",
"[",
"]",
"batch",
"values",
")",
";"
] |
[
"returns",
"a",
"new",
"{",
"@",
"code",
"closing",
"future",
"}",
"pipeline",
"step",
"derived",
"from",
"the",
"inputs",
"by",
"applying",
"a",
"combining",
"function",
"to",
"their",
"values",
"the",
"function",
"can",
"use",
"a",
"{",
"@",
"link",
"deferred",
"closer",
"}",
"to",
"capture",
"objects",
"to",
"be",
"closed",
"when",
"the",
"pipeline",
"is",
"done",
"if",
"this",
"combiner",
"was",
"returned",
"by",
"{",
"@",
"link",
"#",
"when",
"all",
"succeed",
"(",
"closing",
"future",
",",
"closing",
"future",
",",
"closing",
"future",
",",
"closing",
"future",
")",
"}",
"and",
"any",
"of",
"the",
"inputs",
"fail",
",",
"so",
"will",
"the",
"returned",
"step",
"if",
"the",
"function",
"throws",
"a",
"{",
"@",
"code",
"cancellation",
"exception",
"}",
",",
"the",
"pipeline",
"will",
"be",
"cancelled",
"if",
"the",
"function",
"throws",
"an",
"{",
"@",
"code",
"execution",
"exception",
"}",
",",
"the",
"cause",
"of",
"the",
"thrown",
"{",
"@",
"code",
"execution",
"exception",
"}",
"will",
"be",
"extracted",
"and",
"used",
"as",
"the",
"failure",
"of",
"the",
"derived",
"step"
] |
[
"public",
"<",
"u",
"extends",
"object",
">",
"closing",
"future",
"<",
"u",
">",
"call",
"(",
"final",
"closing",
"function",
"4",
"<",
"v1",
",",
"v2",
",",
"v3",
",",
"v4",
",",
"u",
">",
"function",
",",
"executor",
"executor",
")",
"{",
"return",
"call",
"(",
"new",
"combining",
"callable",
"<",
"u",
">",
"(",
")",
"{",
"@",
"override",
"@",
"nullable",
"decl",
"public",
"u",
"call",
"(",
"deferred",
"closer",
"closer",
",",
"peeker",
"peeker",
")",
"throws",
"exception",
"{",
"return",
"function",
"apply",
"(",
"closer",
",",
"peeker",
"get",
"done",
"(",
"future",
"1",
")",
",",
"peeker",
"get",
"done",
"(",
"future",
"2",
")",
",",
"peeker",
"get",
"done",
"(",
"future",
"3",
")",
",",
"peeker",
"get",
"done",
"(",
"future",
"4",
")",
")",
";",
"}",
"@",
"override",
"public",
"string",
"to",
"string",
"(",
")",
"{",
"return",
"function",
"to",
"string",
"(",
")",
";",
"}",
"}",
",",
"executor",
")",
";",
"}"
] |
[
"returns",
"pet",
"inventories",
"by",
"status",
"returns",
"a",
"map",
"of",
"status",
"codes",
"to",
"quantities"
] |
[
"public",
"map",
"<",
"string",
",",
"integer",
">",
"get",
"inventory",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"implement",
"return",
"null",
";",
"}"
] |
[
"creates",
"list",
"of",
"users",
"with",
"given",
"input",
"array"
] |
[
"public",
"void",
"create",
"users",
"with",
"array",
"input",
"test",
"(",
")",
"{",
"list",
"<",
"user",
">",
"user",
"=",
"null",
";",
"/",
"/",
"api",
"create",
"users",
"with",
"array",
"input",
"(",
"user",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
] |
[
"are",
"the",
"resources",
"that",
"should",
"be",
"added",
"to",
"the",
"classpath",
"?",
"should",
"be",
"called",
"after",
"setup",
"(",
")"
] |
[
"public",
"synchronized",
"boolean",
"has",
"local",
"classpaths",
"(",
")",
"{",
"if",
"(",
"!",
"setup",
"called",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"has",
"local",
"classpaths",
"(",
")",
"should",
"be",
"called",
"after",
"setup",
"(",
")",
"\"",
")",
";",
"}",
"return",
"!",
"local",
"classpaths",
"is",
"empty",
"(",
")",
";",
"}"
] |
[
"does",
"not",
"require",
"the",
"argument"
] |
[
"string",
"get",
"execution",
"argument",
"(",
"int",
"daemon",
"id",
")",
"{",
"return",
"null",
";",
"}"
] |
[
"waits",
"for",
"the",
"{",
"@",
"link",
"service",
"}",
"to",
"reach",
"the",
"{",
"@",
"linkplain",
"state",
"#",
"running",
"running",
"state",
"}",
"for",
"no",
"more",
"than",
"the",
"given",
"time"
] |
[
"void",
"await",
"running",
"(",
"long",
"timeout",
",",
"time",
"unit",
"unit",
")",
"throws",
"timeout",
"exception",
";"
] |
[
"test",
"-",
"setrep",
"with",
"a",
"replication",
"factor",
"that",
"is",
"too",
"low",
"we",
"have",
"to",
"test",
"this",
"here",
"because",
"the",
"mini",
"-",
"mini",
"cluster",
"used",
"with",
"test",
"h",
"d",
"f",
"s",
"conf",
"xml",
"uses",
"a",
"replication",
"factor",
"of",
"1",
"(",
"for",
"good",
"reason",
")"
] |
[
"public",
"void",
"test",
"setrep",
"low",
"(",
")",
"throws",
"exception",
"{",
"configuration",
"conf",
"=",
"new",
"configuration",
"(",
")",
";",
"conf",
"set",
"int",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"namenode",
"replication",
"min",
"key",
",",
"2",
")",
";",
"mini",
"d",
"f",
"s",
"cluster",
"builder",
"builder",
"=",
"new",
"mini",
"d",
"f",
"s",
"cluster",
"builder",
"(",
"conf",
")",
";",
"mini",
"d",
"f",
"s",
"cluster",
"cluster",
"=",
"builder",
"num",
"data",
"nodes",
"(",
"2",
")",
"format",
"(",
"true",
")",
"build",
"(",
")",
";",
"fs",
"shell",
"shell",
"=",
"new",
"fs",
"shell",
"(",
"conf",
")",
";",
"cluster",
"wait",
"active",
"(",
")",
";",
"final",
"string",
"testdir",
"=",
"\"",
"/",
"tmp",
"/",
"test",
"d",
"f",
"s",
"shell",
"-",
"test",
"setrep",
"low",
"\"",
";",
"final",
"path",
"hdfs",
"file",
"=",
"new",
"path",
"(",
"testdir",
",",
"\"",
"test",
"file",
"for",
"setrep",
"low",
"\"",
")",
";",
"final",
"print",
"stream",
"orig",
"out",
"=",
"system",
"out",
";",
"final",
"print",
"stream",
"orig",
"err",
"=",
"system",
"err",
";",
"try",
"{",
"final",
"file",
"system",
"fs",
"=",
"cluster",
"get",
"file",
"system",
"(",
")",
";",
"assert",
"true",
"(",
"\"",
"unable",
"to",
"create",
"test",
"directory",
"\"",
",",
"fs",
"mkdirs",
"(",
"new",
"path",
"(",
"testdir",
")",
")",
")",
";",
"fs",
"create",
"(",
"hdfs",
"file",
",",
"true",
")",
"close",
"(",
")",
";",
"/",
"/",
"capture",
"the",
"command",
"output",
"so",
"we",
"can",
"examine",
"it",
"final",
"byte",
"array",
"output",
"stream",
"bao",
"=",
"new",
"byte",
"array",
"output",
"stream",
"(",
")",
";",
"final",
"print",
"stream",
"capture",
"=",
"new",
"print",
"stream",
"(",
"bao",
")",
";",
"system",
"set",
"out",
"(",
"capture",
")",
";",
"system",
"set",
"err",
"(",
"capture",
")",
";",
"final",
"string",
"[",
"]",
"argv",
"=",
"new",
"string",
"[",
"]",
"{",
"\"",
"-",
"setrep",
"\"",
",",
"\"",
"1",
"\"",
",",
"hdfs",
"file",
"to",
"string",
"(",
")",
"}",
";",
"try",
"{",
"assert",
"equals",
"(",
"\"",
"command",
"did",
"not",
"return",
"the",
"expected",
"exit",
"code",
"\"",
",",
"1",
",",
"shell",
"run",
"(",
"argv",
")",
")",
";",
"}",
"finally",
"{",
"system",
"set",
"out",
"(",
"orig",
"out",
")",
";",
"system",
"set",
"err",
"(",
"orig",
"err",
")",
";",
"}",
"assert",
"true",
"(",
"\"",
"error",
"message",
"is",
"not",
"the",
"expected",
"error",
"message",
"\"",
"+",
"bao",
"to",
"string",
"(",
")",
",",
"bao",
"to",
"string",
"(",
")",
"starts",
"with",
"(",
"\"",
"setrep",
":",
"requested",
"replication",
"factor",
"of",
"1",
"is",
"less",
"than",
"\"",
"+",
"\"",
"the",
"required",
"minimum",
"of",
"2",
"for",
"/",
"tmp",
"/",
"test",
"d",
"f",
"s",
"shell",
"-",
"\"",
"+",
"\"",
"test",
"setrep",
"low",
"/",
"test",
"file",
"for",
"setrep",
"low",
"\"",
")",
")",
";",
"}",
"finally",
"{",
"shell",
"close",
"(",
")",
";",
"cluster",
"shutdown",
"(",
")",
";",
"}",
"}"
] |
[
"build",
"call",
"for",
"update",
"pet"
] |
[
"public",
"okhttp",
"3",
"call",
"update",
"pet",
"call",
"(",
"pet",
"body",
",",
"final",
"api",
"callback",
"callback",
")",
"throws",
"api",
"exception",
"{",
"object",
"local",
"var",
"post",
"body",
"=",
"body",
";",
"/",
"/",
"create",
"path",
"and",
"map",
"variables",
"string",
"local",
"var",
"path",
"=",
"\"",
"/",
"pet",
"\"",
";",
"list",
"<",
"pair",
">",
"local",
"var",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
"pair",
">",
"(",
")",
";",
"list",
"<",
"pair",
">",
"local",
"var",
"collection",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
"pair",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"header",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"cookie",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"object",
">",
"local",
"var",
"form",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"object",
">",
"(",
")",
";",
"final",
"string",
"[",
"]",
"local",
"var",
"accepts",
"=",
"{",
"}",
";",
"final",
"string",
"local",
"var",
"accept",
"=",
"local",
"var",
"api",
"client",
"select",
"header",
"accept",
"(",
"local",
"var",
"accepts",
")",
";",
"if",
"(",
"local",
"var",
"accept",
"!",
"=",
"null",
")",
"{",
"local",
"var",
"header",
"params",
"put",
"(",
"\"",
"accept",
"\"",
",",
"local",
"var",
"accept",
")",
";",
"}",
"final",
"string",
"[",
"]",
"local",
"var",
"content",
"types",
"=",
"{",
"\"",
"application",
"/",
"json",
"\"",
",",
"\"",
"application",
"/",
"xml",
"\"",
"}",
";",
"final",
"string",
"local",
"var",
"content",
"type",
"=",
"local",
"var",
"api",
"client",
"select",
"header",
"content",
"type",
"(",
"local",
"var",
"content",
"types",
")",
";",
"local",
"var",
"header",
"params",
"put",
"(",
"\"",
"content",
"-",
"type",
"\"",
",",
"local",
"var",
"content",
"type",
")",
";",
"string",
"[",
"]",
"local",
"var",
"auth",
"names",
"=",
"new",
"string",
"[",
"]",
"{",
"\"",
"petstore",
"auth",
"\"",
"}",
";",
"return",
"local",
"var",
"api",
"client",
"build",
"call",
"(",
"local",
"var",
"path",
",",
"\"",
"put",
"\"",
",",
"local",
"var",
"query",
"params",
",",
"local",
"var",
"collection",
"query",
"params",
",",
"local",
"var",
"post",
"body",
",",
"local",
"var",
"header",
"params",
",",
"local",
"var",
"cookie",
"params",
",",
"local",
"var",
"form",
"params",
",",
"local",
"var",
"auth",
"names",
",",
"callback",
")",
";",
"}"
] |
[
"define",
"a",
"token",
"channel",
"with",
"a",
"specified",
"name",
"if",
"a",
"channel",
"with",
"the",
"specified",
"name",
"already",
"exists",
",",
"the",
"previously",
"assigned",
"channel",
"value",
"is",
"not",
"altered"
] |
[
"public",
"int",
"define",
"channel",
"name",
"(",
"string",
"name",
",",
"int",
"value",
")",
"{",
"integer",
"prev",
"=",
"channel",
"name",
"to",
"value",
"map",
"get",
"(",
"name",
")",
";",
"if",
"(",
"prev",
"!",
"=",
"null",
")",
"{",
"return",
"prev",
";",
"}",
"channel",
"name",
"to",
"value",
"map",
"put",
"(",
"name",
",",
"value",
")",
";",
"set",
"channel",
"name",
"for",
"value",
"(",
"value",
",",
"name",
")",
";",
"max",
"channel",
"type",
"=",
"math",
"max",
"(",
"max",
"channel",
"type",
",",
"value",
")",
";",
"return",
"value",
";",
"}"
] |
[
"get",
"the",
"date",
"format",
"used",
"to",
"parseformat",
"date",
"parameters"
] |
[
"public",
"date",
"format",
"get",
"date",
"format",
"(",
")",
"{",
"return",
"date",
"format",
";",
"}"
] |
[
"the",
"connections",
"that",
"finished",
"disconnecting",
"on",
"the",
"last",
"{",
"@",
"link",
"#",
"poll",
"(",
"long",
")",
"poll",
"(",
")",
"}",
"call",
"channel",
"state",
"indicates",
"the",
"local",
"channel",
"state",
"at",
"the",
"time",
"of",
"disconnection"
] |
[
"map",
"<",
"string",
",",
"channel",
"state",
">",
"disconnected",
"(",
")",
";"
] |
[
"sets",
"the",
"{",
"@",
"link",
"channel",
"option",
"#",
"so",
"linger",
"}",
"option"
] |
[
"udt",
"channel",
"config",
"set",
"so",
"linger",
"(",
"int",
"so",
"linger",
")",
";"
] |
[
"replaces",
"the",
"instruction",
"at",
"a",
"given",
"offset",
"by",
"a",
"given",
"push",
"instruction",
"of",
"a",
"variable"
] |
[
"private",
"void",
"replace",
"variable",
"push",
"instruction",
"(",
"clazz",
"clazz",
",",
"int",
"offset",
",",
"instruction",
"instruction",
",",
"byte",
"replacement",
"opcode",
",",
"int",
"variable",
"index",
")",
"{",
"instruction",
"replacement",
"instruction",
"=",
"new",
"variable",
"instruction",
"(",
"replacement",
"opcode",
",",
"variable",
"index",
")",
";",
"replace",
"instruction",
"(",
"clazz",
",",
"offset",
",",
"instruction",
",",
"replacement",
"instruction",
")",
";",
"}"
] |
[
"picks",
"up",
"extensions",
"that",
"we",
"care",
"from",
"the",
"given",
"list"
] |
[
"protected",
"collection",
"<",
"extension",
"component",
"<",
"t",
">",
">",
"load",
"(",
"extension",
"component",
"set",
"delta",
")",
"{",
"return",
"delta",
"find",
"(",
"extension",
"type",
")",
";",
"}"
] |
[
"warning",
":",
"drops",
"all",
"table",
"on",
"upgrade",
"!",
"use",
"only",
"during",
"development",
"convenience",
"method",
"using",
"a",
"{",
"@",
"link",
"dev",
"open",
"helper",
"}"
] |
[
"public",
"static",
"dao",
"session",
"new",
"dev",
"session",
"(",
"context",
"context",
",",
"string",
"name",
")",
"{",
"database",
"db",
"=",
"new",
"dev",
"open",
"helper",
"(",
"context",
",",
"name",
")",
"get",
"writable",
"db",
"(",
")",
";",
"dao",
"master",
"dao",
"master",
"=",
"new",
"dao",
"master",
"(",
"db",
")",
";",
"return",
"dao",
"master",
"new",
"session",
"(",
")",
";",
"}"
] |
[
"creates",
"a",
"builder",
"for",
"a",
"{",
"@",
"link",
"distinct",
"type",
"}"
] |
[
"public",
"static",
"distinct",
"type",
"builder",
"new",
"builder",
"(",
"object",
"identifier",
"object",
"identifier",
",",
"logical",
"type",
"source",
"type",
")",
"{",
"return",
"new",
"distinct",
"type",
"builder",
"(",
"object",
"identifier",
",",
"source",
"type",
")",
";",
"}"
] |
[
"for",
"the",
"framework",
"to",
"setup",
"the",
"job",
"output",
"during",
"initialization",
"this",
"is",
"called",
"from",
"the",
"application",
"master",
"process",
"for",
"the",
"entire",
"job",
"this",
"will",
"be",
"called",
"multiple",
"times",
",",
"once",
"per",
"job",
"attempt"
] |
[
"public",
"abstract",
"void",
"setup",
"job",
"(",
"job",
"context",
"job",
"context",
")",
"throws",
"i",
"o",
"exception",
";"
] |
[
"add",
"a",
"mount",
"table",
"entry",
"to",
"the",
"mount",
"table",
"through",
"the",
"admin",
"api"
] |
[
"private",
"boolean",
"add",
"mount",
"table",
"(",
"final",
"mount",
"table",
"entry",
")",
"throws",
"i",
"o",
"exception",
"{",
"router",
"client",
"client",
"=",
"router",
"context",
"get",
"admin",
"client",
"(",
")",
";",
"mount",
"table",
"manager",
"mount",
"table",
"manager",
"=",
"client",
"get",
"mount",
"table",
"manager",
"(",
")",
";",
"add",
"mount",
"table",
"entry",
"request",
"add",
"request",
"=",
"add",
"mount",
"table",
"entry",
"request",
"new",
"instance",
"(",
"entry",
")",
";",
"add",
"mount",
"table",
"entry",
"response",
"add",
"response",
"=",
"mount",
"table",
"manager",
"add",
"mount",
"table",
"entry",
"(",
"add",
"request",
")",
";",
"/",
"/",
"reload",
"the",
"router",
"cache",
"mount",
"table",
"load",
"cache",
"(",
"true",
")",
";",
"return",
"add",
"response",
"get",
"status",
"(",
")",
";",
"}"
] |
[
"get",
"all",
"directly",
"declared",
"annotations",
"of",
"the",
"the",
"annotated",
"element",
",",
"not",
"including",
"meta",
"annotations"
] |
[
"static",
"list",
"<",
"annotation",
">",
"get",
"all",
"declared",
"annotations",
"(",
"annotated",
"element",
"annotated",
"element",
",",
"predicate",
"<",
"annotation",
">",
"annotations",
"to",
"filter",
")",
"{",
"if",
"(",
"is",
"type",
"(",
"annotated",
"element",
")",
")",
"{",
"return",
"get",
"all",
"declared",
"annotations",
"(",
"(",
"class",
")",
"annotated",
"element",
",",
"annotations",
"to",
"filter",
")",
";",
"}",
"else",
"{",
"return",
"get",
"declared",
"annotations",
"(",
"annotated",
"element",
",",
"annotations",
"to",
"filter",
")",
";",
"}",
"}"
] |
[
"sets",
"the",
"transient",
"settings",
"to",
"be",
"updated",
"they",
"will",
"not",
"survive",
"a",
"full",
"cluster",
"restart"
] |
[
"public",
"cluster",
"update",
"settings",
"request",
"builder",
"set",
"transient",
"settings",
"(",
"settings",
"builder",
"settings",
")",
"{",
"request",
"transient",
"settings",
"(",
"settings",
")",
";",
"return",
"this",
";",
"}"
] |
[
"if",
"the",
"server",
"is",
"non",
"null",
",",
"stop",
"it"
] |
[
"public",
"static",
"void",
"stop",
"(",
"http",
"server",
"2",
"server",
")",
"throws",
"exception",
"{",
"if",
"(",
"server",
"!",
"=",
"null",
")",
"{",
"server",
"stop",
"(",
")",
";",
"}",
"}"
] |
[
"apply",
"global",
"debouncing",
"for",
"the",
"view",
"'",
"s",
"click"
] |
[
"public",
"static",
"void",
"apply",
"global",
"debouncing",
"(",
"final",
"view",
"view",
",",
"final",
"view",
"on",
"click",
"listener",
"listener",
")",
"{",
"apply",
"global",
"debouncing",
"(",
"new",
"view",
"[",
"]",
"{",
"view",
"}",
",",
"listener",
")",
";",
"}"
] |
[
"get",
"the",
"value",
"of",
"sigma"
] |
[
"public",
"double",
"get",
"value",
"(",
")",
"{",
"if",
"(",
"sigma",
"get",
"value",
"(",
")",
"=",
"=",
"null",
")",
"{",
"double",
"d",
"=",
"0",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"parts",
"length",
";",
"i",
"+",
"+",
")",
"d",
"=",
"modular",
"add",
"mod",
"(",
"d",
",",
"parts",
"[",
"i",
"]",
"compute",
"(",
")",
")",
";",
"sigma",
"set",
"value",
"(",
"d",
")",
";",
"}",
"final",
"double",
"s",
"=",
"modular",
"add",
"mod",
"(",
"sigma",
"get",
"value",
"(",
")",
",",
"tail",
"compute",
"(",
")",
")",
";",
"return",
"parameter",
"isplus",
"?",
"s",
":",
"-",
"s",
";",
"}"
] |
[
"parse",
"the",
"sls",
"trace",
"file",
",",
"return",
"each",
"host",
"name"
] |
[
"public",
"static",
"set",
"<",
"node",
"details",
">",
"parse",
"nodes",
"from",
"s",
"l",
"s",
"trace",
"(",
"string",
"job",
"trace",
")",
"throws",
"i",
"o",
"exception",
"{",
"set",
"<",
"node",
"details",
">",
"node",
"set",
"=",
"new",
"hash",
"set",
"<",
">",
"(",
")",
";",
"json",
"factory",
"json",
"f",
"=",
"new",
"json",
"factory",
"(",
")",
";",
"object",
"mapper",
"mapper",
"=",
"new",
"object",
"mapper",
"(",
")",
";",
"reader",
"input",
"=",
"new",
"input",
"stream",
"reader",
"(",
"new",
"file",
"input",
"stream",
"(",
"job",
"trace",
")",
",",
"\"",
"utf",
"-",
"8",
"\"",
")",
";",
"try",
"{",
"iterator",
"<",
"map",
">",
"i",
"=",
"mapper",
"read",
"values",
"(",
"json",
"f",
"create",
"parser",
"(",
"input",
")",
",",
"map",
"class",
")",
";",
"while",
"(",
"i",
"has",
"next",
"(",
")",
")",
"{",
"add",
"nodes",
"(",
"node",
"set",
",",
"i",
"next",
"(",
")",
")",
";",
"}",
"}",
"finally",
"{",
"input",
"close",
"(",
")",
";",
"}",
"return",
"node",
"set",
";",
"}"
] |
[
"returns",
"true",
"if",
"one",
"of",
"the",
"programs",
"is",
"locked",
"note",
":",
"calling",
"{",
"@",
"link",
"program",
"#",
"is",
"locked",
"(",
")",
"}",
"does",
"not",
"work",
"here",
";",
"we",
"must",
"check",
"to",
"see",
"if",
"one",
"of",
"the",
"programs",
"is",
"the",
"currently",
"-",
"open",
"program"
] |
[
"private",
"boolean",
"are",
"programs",
"locked",
"(",
"program",
"p",
"1",
",",
"program",
"p",
"2",
")",
"{",
"return",
"p",
"1",
"=",
"=",
"current",
"program",
"|",
"|",
"p",
"2",
"=",
"=",
"current",
"program",
";",
"}"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"gets",
"the",
"value",
"of",
"the",
"provided",
"attribute"
] |
[
"public",
"<",
"t",
">",
"t",
"attribute",
"(",
"string",
"attribute",
")",
"{",
"return",
"(",
"t",
")",
"servlet",
"request",
"get",
"attribute",
"(",
"attribute",
")",
";",
"}"
] |
[
"the",
"package",
"id",
"of",
"this",
"package",
",",
"in",
"the",
"range",
"[",
"0x",
"0",
"0",
",",
"0xff",
"]",
"the",
"id",
"0x",
"0",
"0",
"is",
"reserved",
"for",
"shared",
"libraries",
",",
"or",
"when",
"the",
"id",
"is",
"assigned",
"at",
"run",
"-",
"time",
"the",
"id",
"0x",
"0",
"1",
"is",
"reserved",
"for",
"the",
"'",
"android",
"'",
"package",
"(",
"framework",
")",
"the",
"id",
"range",
"[",
"0x",
"0",
"2",
",",
"0x",
"7f",
")",
"is",
"reserved",
"for",
"auto",
"-",
"assignment",
"to",
"shared",
"libraries",
"at",
"run",
"-",
"time",
"the",
"id",
"0x",
"7f",
"is",
"reserved",
"for",
"the",
"application",
"package",
"i",
"ds",
"&",
"gt",
";",
"0x",
"7f",
"are",
"reserved",
"for",
"the",
"application",
"as",
"well",
"and",
"are",
"treated",
"as",
"feature",
"splits",
"<",
"code",
">",
"optional",
"uint",
"3",
"2",
"package",
"id",
"=",
"1",
";",
"<",
"code",
">"
] |
[
"public",
"boolean",
"has",
"package",
"id",
"(",
")",
"{",
"return",
"instance",
"has",
"package",
"id",
"(",
")",
";",
"}"
] |
[
"refresh",
"super",
"user",
"groups",
"configuration",
"{",
"@",
"link",
"name",
"node",
"}"
] |
[
"public",
"int",
"refresh",
"super",
"user",
"groups",
"configuration",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"/",
"/",
"get",
"the",
"current",
"configuration",
"configuration",
"conf",
"=",
"get",
"conf",
"(",
")",
";",
"/",
"/",
"for",
"security",
"authorization",
"/",
"/",
"server",
"principal",
"for",
"this",
"call",
"/",
"/",
"should",
"be",
"namenode",
"'",
"s",
"one",
"conf",
"set",
"(",
"common",
"configuration",
"keys",
"hadoop",
"security",
"service",
"user",
"name",
"key",
",",
"conf",
"get",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"namenode",
"kerberos",
"principal",
"key",
",",
"\"",
"\"",
")",
")",
";",
"distributed",
"file",
"system",
"dfs",
"=",
"get",
"d",
"f",
"s",
"(",
")",
";",
"uri",
"dfs",
"uri",
"=",
"dfs",
"get",
"uri",
"(",
")",
";",
"boolean",
"is",
"ha",
"enabled",
"=",
"h",
"a",
"util",
"client",
"is",
"logical",
"uri",
"(",
"conf",
",",
"dfs",
"uri",
")",
";",
"if",
"(",
"is",
"ha",
"enabled",
")",
"{",
"/",
"/",
"run",
"refresh",
"super",
"user",
"groups",
"configuration",
"for",
"all",
"n",
"ns",
"if",
"ha",
"is",
"enabled",
"string",
"ns",
"id",
"=",
"dfs",
"uri",
"get",
"host",
"(",
")",
";",
"list",
"<",
"proxy",
"and",
"info",
"<",
"refresh",
"user",
"mappings",
"protocol",
">",
">",
"proxies",
"=",
"h",
"a",
"util",
"get",
"proxies",
"for",
"all",
"name",
"nodes",
"in",
"nameservice",
"(",
"conf",
",",
"ns",
"id",
",",
"refresh",
"user",
"mappings",
"protocol",
"class",
")",
";",
"list",
"<",
"i",
"o",
"exception",
">",
"exceptions",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"for",
"(",
"proxy",
"and",
"info",
"<",
"refresh",
"user",
"mappings",
"protocol",
">",
"proxy",
":",
"proxies",
")",
"{",
"try",
"{",
"proxy",
"get",
"proxy",
"(",
")",
"refresh",
"super",
"user",
"groups",
"configuration",
"(",
")",
";",
"system",
"out",
"println",
"(",
"\"",
"refresh",
"super",
"user",
"groups",
"configuration",
"\"",
"+",
"\"",
"successful",
"for",
"\"",
"+",
"proxy",
"get",
"address",
"(",
")",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"ioe",
")",
"{",
"system",
"out",
"println",
"(",
"\"",
"refresh",
"super",
"user",
"groups",
"configuration",
"\"",
"+",
"\"",
"failed",
"for",
"\"",
"+",
"proxy",
"get",
"address",
"(",
")",
")",
";",
"exceptions",
"add",
"(",
"ioe",
")",
";",
"}",
"}",
"if",
"(",
"!",
"exceptions",
"is",
"empty",
"(",
")",
")",
"{",
"throw",
"multiple",
"i",
"o",
"exception",
"create",
"i",
"o",
"exception",
"(",
"exceptions",
")",
";",
"}",
"}",
"else",
"{",
"/",
"/",
"create",
"the",
"client",
"refresh",
"user",
"mappings",
"protocol",
"refresh",
"protocol",
"=",
"name",
"node",
"proxies",
"create",
"proxy",
"(",
"conf",
",",
"file",
"system",
"get",
"default",
"uri",
"(",
"conf",
")",
",",
"refresh",
"user",
"mappings",
"protocol",
"class",
")",
"get",
"proxy",
"(",
")",
";",
"/",
"/",
"refresh",
"the",
"user",
"-",
"to",
"-",
"groups",
"mappings",
"refresh",
"protocol",
"refresh",
"super",
"user",
"groups",
"configuration",
"(",
")",
";",
"system",
"out",
"println",
"(",
"\"",
"refresh",
"super",
"user",
"groups",
"configuration",
"successful",
"\"",
")",
";",
"}",
"return",
"0",
";",
"}"
] |
[
"if",
"{",
"@",
"linkplain",
"#",
"get",
"current",
"executable",
"(",
")",
"current",
"executable",
"}",
"is",
"{",
"@",
"link",
"abstract",
"build",
"}",
",",
"return",
"the",
"workspace",
"that",
"this",
"executor",
"is",
"using",
",",
"or",
"null",
"if",
"the",
"build",
"hasn",
"'",
"t",
"gotten",
"to",
"that",
"point",
"yet"
] |
[
"public",
"file",
"path",
"get",
"current",
"workspace",
"(",
")",
"{",
"lock",
"read",
"lock",
"(",
")",
"lock",
"(",
")",
";",
"try",
"{",
"if",
"(",
"executable",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"if",
"(",
"executable",
"instanceof",
"abstract",
"build",
")",
"{",
"abstract",
"build",
"ab",
"=",
"(",
"abstract",
"build",
")",
"executable",
";",
"return",
"ab",
"get",
"workspace",
"(",
")",
";",
"}",
"return",
"null",
";",
"}",
"finally",
"{",
"lock",
"read",
"lock",
"(",
")",
"unlock",
"(",
")",
";",
"}",
"}"
] |
[
"return",
"whether",
"the",
"parameter",
"is",
"nullable"
] |
[
"public",
"boolean",
"is",
"nullable",
"(",
")",
"{",
"return",
"this",
"nullable",
";",
"}"
] |
[
"source",
"for",
"messages"
] |
[
"public",
"string",
"get",
"text",
"(",
")",
"{",
"return",
"text",
";",
"}"
] |
[
"we",
"definitely",
"don",
"'",
"t",
"support",
"marks"
] |
[
"public",
"boolean",
"mark",
"supported",
"(",
")",
"{",
"return",
"false",
";",
"}"
] |
[
"this",
"test",
"instantiates",
"multiple",
"channels",
"and",
"writes",
"to",
"them",
"in",
"parallel",
"and",
"re",
"-",
"reads",
"the",
"data",
"in",
"parallel",
"it",
"is",
"designed",
"to",
"check",
"the",
"ability",
"of",
"the",
"io",
"manager",
"to",
"correctly",
"handle",
"multiple",
"threads"
] |
[
"public",
"void",
"parallel",
"channels",
"test",
"(",
")",
"throws",
"exception",
"{",
"final",
"random",
"rnd",
"=",
"new",
"random",
"(",
"seed",
")",
";",
"final",
"abstract",
"invokable",
"mem",
"owner",
"=",
"new",
"dummy",
"invokable",
"(",
")",
";",
"file",
"i",
"o",
"channel",
"id",
"[",
"]",
"ids",
"=",
"new",
"file",
"i",
"o",
"channel",
"id",
"[",
"num",
"channels",
"]",
";",
"block",
"channel",
"writer",
"<",
"memory",
"segment",
">",
"[",
"]",
"writers",
"=",
"new",
"block",
"channel",
"writer",
"[",
"num",
"channels",
"]",
";",
"block",
"channel",
"reader",
"<",
"memory",
"segment",
">",
"[",
"]",
"readers",
"=",
"new",
"block",
"channel",
"reader",
"[",
"num",
"channels",
"]",
";",
"channel",
"writer",
"output",
"view",
"[",
"]",
"outs",
"=",
"new",
"channel",
"writer",
"output",
"view",
"[",
"num",
"channels",
"]",
";",
"channel",
"reader",
"input",
"view",
"[",
"]",
"ins",
"=",
"new",
"channel",
"reader",
"input",
"view",
"[",
"num",
"channels",
"]",
";",
"int",
"[",
"]",
"writing",
"counters",
"=",
"new",
"int",
"[",
"num",
"channels",
"]",
";",
"int",
"[",
"]",
"reading",
"counters",
"=",
"new",
"int",
"[",
"num",
"channels",
"]",
";",
"/",
"/",
"instantiate",
"the",
"channels",
"and",
"writers",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"num",
"channels",
";",
"i",
"+",
"+",
")",
"{",
"ids",
"[",
"i",
"]",
"=",
"this",
"io",
"manager",
"create",
"channel",
"(",
")",
";",
"writers",
"[",
"i",
"]",
"=",
"this",
"io",
"manager",
"create",
"block",
"channel",
"writer",
"(",
"ids",
"[",
"i",
"]",
")",
";",
"list",
"<",
"memory",
"segment",
">",
"mem",
"segs",
"=",
"this",
"memory",
"manager",
"allocate",
"pages",
"(",
"mem",
"owner",
",",
"rnd",
"next",
"int",
"(",
"maximum",
"number",
"of",
"segments",
"per",
"channel",
"-",
"1",
")",
"+",
"1",
")",
";",
"outs",
"[",
"i",
"]",
"=",
"new",
"channel",
"writer",
"output",
"view",
"(",
"writers",
"[",
"i",
"]",
",",
"mem",
"segs",
",",
"this",
"memory",
"manager",
"get",
"page",
"size",
"(",
")",
")",
";",
"}",
"value",
"val",
"=",
"new",
"value",
"(",
")",
";",
"/",
"/",
"write",
"a",
"lot",
"of",
"values",
"unevenly",
"distributed",
"over",
"the",
"channels",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"numbers",
"to",
"be",
"written",
";",
"i",
"+",
"+",
")",
"{",
"int",
"channel",
"=",
"skewed",
"sample",
"(",
"rnd",
",",
"num",
"channels",
"-",
"1",
")",
";",
"val",
"value",
"=",
"string",
"value",
"of",
"(",
"writing",
"counters",
"[",
"channel",
"]",
"+",
"+",
")",
";",
"val",
"write",
"(",
"outs",
"[",
"channel",
"]",
")",
";",
"}",
"/",
"/",
"close",
"all",
"writers",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"num",
"channels",
";",
"i",
"+",
"+",
")",
"{",
"this",
"memory",
"manager",
"release",
"(",
"outs",
"[",
"i",
"]",
"close",
"(",
")",
")",
";",
"}",
"outs",
"=",
"null",
";",
"writers",
"=",
"null",
";",
"/",
"/",
"instantiate",
"the",
"readers",
"for",
"sequential",
"read",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"num",
"channels",
";",
"i",
"+",
"+",
")",
"{",
"list",
"<",
"memory",
"segment",
">",
"mem",
"segs",
"=",
"this",
"memory",
"manager",
"allocate",
"pages",
"(",
"mem",
"owner",
",",
"rnd",
"next",
"int",
"(",
"maximum",
"number",
"of",
"segments",
"per",
"channel",
"-",
"1",
")",
"+",
"1",
")",
";",
"final",
"block",
"channel",
"reader",
"<",
"memory",
"segment",
">",
"reader",
"=",
"this",
"io",
"manager",
"create",
"block",
"channel",
"reader",
"(",
"ids",
"[",
"i",
"]",
")",
";",
"final",
"channel",
"reader",
"input",
"view",
"in",
"=",
"new",
"channel",
"reader",
"input",
"view",
"(",
"reader",
",",
"mem",
"segs",
",",
"false",
")",
";",
"int",
"next",
"val",
"=",
"0",
";",
"try",
"{",
"while",
"(",
"true",
")",
"{",
"val",
"read",
"(",
"in",
")",
";",
"int",
"int",
"value",
"=",
"0",
";",
"try",
"{",
"int",
"value",
"=",
"integer",
"parse",
"int",
"(",
"val",
"value",
")",
";",
"}",
"catch",
"(",
"number",
"format",
"exception",
"nfex",
")",
"{",
"assert",
"fail",
"(",
"\"",
"invalid",
"value",
"read",
"from",
"reader",
"valid",
"decimal",
"number",
"expected",
"\"",
")",
";",
"}",
"assert",
"assert",
"equals",
"(",
"\"",
"written",
"and",
"read",
"values",
"do",
"not",
"match",
"during",
"sequential",
"read",
"\"",
",",
"next",
"val",
",",
"int",
"value",
")",
";",
"next",
"val",
"+",
"+",
";",
"}",
"}",
"catch",
"(",
"e",
"o",
"f",
"exception",
"eofex",
")",
"{",
"/",
"/",
"expected",
"}",
"assert",
"assert",
"equals",
"(",
"\"",
"n",
"umber",
"of",
"written",
"numbers",
"differs",
"from",
"number",
"of",
"read",
"numbers",
"\"",
",",
"writing",
"counters",
"[",
"i",
"]",
",",
"next",
"val",
")",
";",
"this",
"memory",
"manager",
"release",
"(",
"in",
"close",
"(",
")",
")",
";",
"}",
"/",
"/",
"instantiate",
"the",
"readers",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"num",
"channels",
";",
"i",
"+",
"+",
")",
"{",
"list",
"<",
"memory",
"segment",
">",
"mem",
"segs",
"=",
"this",
"memory",
"manager",
"allocate",
"pages",
"(",
"mem",
"owner",
",",
"rnd",
"next",
"int",
"(",
"maximum",
"number",
"of",
"segments",
"per",
"channel",
"-",
"1",
")",
"+",
"1",
")",
";",
"readers",
"[",
"i",
"]",
"=",
"this",
"io",
"manager",
"create",
"block",
"channel",
"reader",
"(",
"ids",
"[",
"i",
"]",
")",
";",
"ins",
"[",
"i",
"]",
"=",
"new",
"channel",
"reader",
"input",
"view",
"(",
"readers",
"[",
"i",
"]",
",",
"mem",
"segs",
",",
"false",
")",
";",
"}",
"/",
"/",
"read",
"a",
"lot",
"of",
"values",
"in",
"a",
"mixed",
"order",
"from",
"the",
"channels",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"numbers",
"to",
"be",
"written",
";",
"i",
"+",
"+",
")",
"{",
"while",
"(",
"true",
")",
"{",
"final",
"int",
"channel",
"=",
"skewed",
"sample",
"(",
"rnd",
",",
"num",
"channels",
"-",
"1",
")",
";",
"if",
"(",
"ins",
"[",
"channel",
"]",
"!",
"=",
"null",
")",
"{",
"try",
"{",
"val",
"read",
"(",
"ins",
"[",
"channel",
"]",
")",
";",
"int",
"int",
"value",
";",
"try",
"{",
"int",
"value",
"=",
"integer",
"parse",
"int",
"(",
"val",
"value",
")",
";",
"}",
"catch",
"(",
"number",
"format",
"exception",
"nfex",
")",
"{",
"assert",
"fail",
"(",
"\"",
"invalid",
"value",
"read",
"from",
"reader",
"valid",
"decimal",
"number",
"expected",
"\"",
")",
";",
"return",
";",
"}",
"assert",
"assert",
"equals",
"(",
"\"",
"written",
"and",
"read",
"values",
"do",
"not",
"match",
"\"",
",",
"reading",
"counters",
"[",
"channel",
"]",
"+",
"+",
",",
"int",
"value",
")",
";",
"break",
";",
"}",
"catch",
"(",
"e",
"o",
"f",
"exception",
"eofex",
")",
"{",
"this",
"memory",
"manager",
"release",
"(",
"ins",
"[",
"channel",
"]",
"close",
"(",
")",
")",
";",
"ins",
"[",
"channel",
"]",
"=",
"null",
";",
"}",
"}",
"}",
"}",
"/",
"/",
"close",
"all",
"readers",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"num",
"channels",
";",
"i",
"+",
"+",
")",
"{",
"if",
"(",
"ins",
"[",
"i",
"]",
"!",
"=",
"null",
")",
"{",
"this",
"memory",
"manager",
"release",
"(",
"ins",
"[",
"i",
"]",
"close",
"(",
")",
")",
";",
"}",
"readers",
"[",
"i",
"]",
"close",
"and",
"delete",
"(",
")",
";",
"}",
"ins",
"=",
"null",
";",
"readers",
"=",
"null",
";",
"/",
"/",
"check",
"that",
"files",
"are",
"deleted",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"num",
"channels",
";",
"i",
"+",
"+",
")",
"{",
"file",
"f",
"=",
"new",
"file",
"(",
"ids",
"[",
"i",
"]",
"get",
"path",
"(",
")",
")",
";",
"assert",
"assert",
"false",
"(",
"\"",
"channel",
"file",
"has",
"not",
"been",
"deleted",
"\"",
",",
"f",
"exists",
"(",
")",
")",
";",
"}",
"}"
] |
[
"returns",
"the",
"archive",
"file",
"name",
"suffix"
] |
[
"public",
"string",
"archive",
"file",
"name",
"suffix",
"(",
")",
"{",
"return",
"archive",
"file",
"name",
"suffix",
";",
"}"
] |
[
"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",
"the",
"count",
"of",
"entries",
"evicted"
] |
[
"private",
"int",
"evict",
"to",
"recover",
"bytes",
"(",
"int",
"bytes",
"to",
"recover",
")",
"{",
"int",
"entries",
"to",
"evict",
"=",
"0",
";",
"if",
"(",
"bytes",
"to",
"recover",
">",
"0",
")",
"{",
"/",
"/",
"determine",
"how",
"many",
"headers",
"need",
"to",
"be",
"evicted",
"for",
"(",
"int",
"j",
"=",
"dynamic",
"table",
"length",
"-",
"1",
";",
"j",
">",
"=",
"next",
"dynamic",
"table",
"index",
"&",
"&",
"bytes",
"to",
"recover",
">",
"0",
";",
"j",
"-",
"-",
")",
"{",
"bytes",
"to",
"recover",
"-",
"=",
"dynamic",
"table",
"[",
"j",
"]",
"hpack",
"size",
";",
"dynamic",
"table",
"byte",
"count",
"-",
"=",
"dynamic",
"table",
"[",
"j",
"]",
"hpack",
"size",
";",
"dynamic",
"table",
"header",
"count",
"-",
"-",
";",
"entries",
"to",
"evict",
"+",
"+",
";",
"}",
"system",
"arraycopy",
"(",
"dynamic",
"table",
",",
"next",
"dynamic",
"table",
"index",
"+",
"1",
",",
"dynamic",
"table",
",",
"next",
"dynamic",
"table",
"index",
"+",
"1",
"+",
"entries",
"to",
"evict",
",",
"dynamic",
"table",
"header",
"count",
")",
";",
"next",
"dynamic",
"table",
"index",
"+",
"=",
"entries",
"to",
"evict",
";",
"}",
"return",
"entries",
"to",
"evict",
";",
"}"
] |
[
"returns",
"an",
"iterator",
"over",
"active",
"and",
"initializing",
"shards",
",",
"ordered",
"by",
"the",
"adaptive",
"replica",
"selection",
"formula",
"making",
"sure",
"though",
"that",
"its",
"random",
"within",
"the",
"active",
"shards",
"of",
"the",
"same",
"(",
"or",
"missing",
")",
"rank",
",",
"and",
"initializing",
"shards",
"are",
"the",
"last",
"to",
"iterate",
"through"
] |
[
"public",
"shard",
"iterator",
"active",
"initializing",
"shards",
"ranked",
"it",
"(",
"@",
"nullable",
"response",
"collector",
"service",
"collector",
",",
"@",
"nullable",
"map",
"<",
"string",
",",
"long",
">",
"node",
"search",
"counts",
")",
"{",
"final",
"int",
"seed",
"=",
"shuffler",
"next",
"seed",
"(",
")",
";",
"if",
"(",
"all",
"initializing",
"shards",
"is",
"empty",
"(",
")",
")",
"{",
"return",
"new",
"plain",
"shard",
"iterator",
"(",
"shard",
"id",
",",
"rank",
"shards",
"and",
"update",
"stats",
"(",
"shuffler",
"shuffle",
"(",
"active",
"shards",
",",
"seed",
")",
",",
"collector",
",",
"node",
"search",
"counts",
")",
")",
";",
"}",
"array",
"list",
"<",
"shard",
"routing",
">",
"ordered",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"active",
"shards",
"size",
"(",
")",
"+",
"all",
"initializing",
"shards",
"size",
"(",
")",
")",
";",
"list",
"<",
"shard",
"routing",
">",
"ranked",
"active",
"shards",
"=",
"rank",
"shards",
"and",
"update",
"stats",
"(",
"shuffler",
"shuffle",
"(",
"active",
"shards",
",",
"seed",
")",
",",
"collector",
",",
"node",
"search",
"counts",
")",
";",
"ordered",
"add",
"all",
"(",
"ranked",
"active",
"shards",
")",
";",
"list",
"<",
"shard",
"routing",
">",
"ranked",
"initializing",
"shards",
"=",
"rank",
"shards",
"and",
"update",
"stats",
"(",
"all",
"initializing",
"shards",
",",
"collector",
",",
"node",
"search",
"counts",
")",
";",
"ordered",
"add",
"all",
"(",
"ranked",
"initializing",
"shards",
")",
";",
"return",
"new",
"plain",
"shard",
"iterator",
"(",
"shard",
"id",
",",
"ordered",
")",
";",
"}"
] |
[
"sets",
"the",
"maximum",
"size",
"of",
"header",
"list",
"allowed",
"to",
"be",
"received",
"this",
"is",
"cumulative",
"size",
"of",
"the",
"headers",
"with",
"some",
"overhead",
",",
"as",
"defined",
"for",
"<",
"a",
"href",
"=",
"\"",
"http",
":",
"httpwg",
"orgspecsrfc",
"7",
"5",
"4",
"0",
"html",
"#",
"rfc",
"section",
"6",
"5",
"2",
"\"",
">",
"http2",
"'",
"s",
"settings",
"max",
"header",
"list",
"size",
"the",
"default",
"is",
"8",
"ki",
"b"
] |
[
"public",
"netty",
"server",
"builder",
"max",
"header",
"list",
"size",
"(",
"int",
"max",
"header",
"list",
"size",
")",
"{",
"return",
"max",
"inbound",
"metadata",
"size",
"(",
"max",
"header",
"list",
"size",
")",
";",
"}"
] |
[
"returns",
"the",
"annotation",
"on",
"{",
"@",
"code",
"element",
"}",
"formatted",
"as",
"a",
"map",
"this",
"returns",
"a",
"map",
"rather",
"than",
"an",
"instance",
"of",
"the",
"annotation",
"interface",
"to",
"work",
"-",
"around",
"the",
"fact",
"that",
"class",
"and",
"class",
"[",
"]",
"fields",
"won",
"'",
"t",
"work",
"at",
"code",
"generation",
"time",
"see",
"http",
":",
"bugs",
"sun",
"combugdatabaseview",
"bug",
"do",
"?",
"bug",
"id",
"=",
"5089128"
] |
[
"public",
"static",
"map",
"<",
"string",
",",
"object",
">",
"get",
"annotation",
"(",
"class",
"<",
"?",
">",
"annotation",
"type",
",",
"element",
"element",
")",
"{",
"for",
"(",
"annotation",
"mirror",
"annotation",
":",
"element",
"get",
"annotation",
"mirrors",
"(",
")",
")",
"{",
"if",
"(",
"!",
"raw",
"type",
"to",
"string",
"(",
"annotation",
"get",
"annotation",
"type",
"(",
")",
",",
"'",
"$",
"'",
")",
"equals",
"(",
"annotation",
"type",
"get",
"name",
"(",
")",
")",
")",
"{",
"continue",
";",
"}",
"map",
"<",
"string",
",",
"object",
">",
"result",
"=",
"new",
"linked",
"hash",
"map",
"<",
"string",
",",
"object",
">",
"(",
")",
";",
"for",
"(",
"method",
"m",
":",
"annotation",
"type",
"get",
"methods",
"(",
")",
")",
"{",
"result",
"put",
"(",
"m",
"get",
"name",
"(",
")",
",",
"m",
"get",
"default",
"value",
"(",
")",
")",
";",
"}",
"for",
"(",
"map",
"entry",
"<",
"?",
"extends",
"executable",
"element",
",",
"?",
"extends",
"annotation",
"value",
">",
"e",
":",
"annotation",
"get",
"element",
"values",
"(",
")",
"entry",
"set",
"(",
")",
")",
"{",
"string",
"name",
"=",
"e",
"get",
"key",
"(",
")",
"get",
"simple",
"name",
"(",
")",
"to",
"string",
"(",
")",
";",
"object",
"value",
"=",
"e",
"get",
"value",
"(",
")",
"accept",
"(",
"value",
"extractor",
",",
"null",
")",
";",
"object",
"default",
"value",
"=",
"result",
"get",
"(",
"name",
")",
";",
"if",
"(",
"!",
"lenient",
"is",
"instance",
"(",
"default",
"value",
"get",
"class",
"(",
")",
",",
"value",
")",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"string",
"format",
"(",
"\"",
"value",
"of",
"%",
"s",
"%",
"s",
"is",
"a",
"%",
"s",
"but",
"expected",
"a",
"%",
"s",
"\\",
"n",
"value",
":",
"%",
"s",
"\"",
",",
"annotation",
"type",
",",
"name",
",",
"value",
"get",
"class",
"(",
")",
"get",
"name",
"(",
")",
",",
"default",
"value",
"get",
"class",
"(",
")",
"get",
"name",
"(",
")",
",",
"value",
"instanceof",
"object",
"[",
"]",
"?",
"arrays",
"to",
"string",
"(",
"(",
"object",
"[",
"]",
")",
"value",
")",
":",
"value",
")",
")",
";",
"}",
"result",
"put",
"(",
"name",
",",
"value",
")",
";",
"}",
"return",
"result",
";",
"}",
"return",
"null",
";",
"/",
"/",
"annotation",
"not",
"found",
"}"
] |
[
"test",
"the",
"property",
"'",
"$",
"special",
"property",
"name",
"'"
] |
[
"public",
"void",
"$",
"special",
"property",
"name",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"$",
"special",
"property",
"name",
"}"
] |
[
"returns",
"a",
"map",
"from",
"configuration",
"fragment",
"name",
"to",
"configuration",
"fragment",
"class"
] |
[
"public",
"immutable",
"map",
"<",
"string",
",",
"class",
"<",
"?",
">",
">",
"get",
"fragment",
"name",
"to",
"class",
"(",
")",
"{",
"return",
"fragment",
"name",
"to",
"class",
";",
"}"
] |
[
"sets",
"the",
"indices",
"to",
"be",
"closed"
] |
[
"public",
"close",
"index",
"request",
"indices",
"(",
"string",
"indices",
")",
"{",
"this",
"indices",
"=",
"indices",
";",
"return",
"this",
";",
"}"
] |
[
"gets",
"the",
"information",
"about",
"the",
"queue",
"item",
"for",
"the",
"given",
"project"
] |
[
"public",
"list",
"<",
"item",
">",
"get",
"items",
"(",
"task",
"t",
")",
"{",
"snapshot",
"snapshot",
"=",
"this",
"snapshot",
";",
"list",
"<",
"item",
">",
"result",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"for",
"(",
"item",
"item",
":",
"snapshot",
"blocked",
"projects",
")",
"{",
"if",
"(",
"item",
"task",
"equals",
"(",
"t",
")",
")",
"{",
"result",
"add",
"(",
"item",
")",
";",
"}",
"}",
"for",
"(",
"item",
"item",
":",
"snapshot",
"buildables",
")",
"{",
"if",
"(",
"item",
"task",
"equals",
"(",
"t",
")",
")",
"{",
"result",
"add",
"(",
"item",
")",
";",
"}",
"}",
"for",
"(",
"item",
"item",
":",
"snapshot",
"pendings",
")",
"{",
"if",
"(",
"item",
"task",
"equals",
"(",
"t",
")",
")",
"{",
"result",
"add",
"(",
"item",
")",
";",
"}",
"}",
"for",
"(",
"item",
"item",
":",
"snapshot",
"waiting",
"list",
")",
"{",
"if",
"(",
"item",
"task",
"equals",
"(",
"t",
")",
")",
"{",
"result",
"add",
"(",
"item",
")",
";",
"}",
"}",
"return",
"result",
";",
"}"
] |
[
"the",
"class",
"of",
"the",
"object",
"that",
"was",
"not",
"found",
"contains",
"the",
"interface",
"-",
"class",
"of",
"the",
"activiti",
"-",
"object",
"that",
"was",
"not",
"found"
] |
[
"public",
"class",
"<",
"?",
">",
"get",
"object",
"class",
"(",
")",
"{",
"return",
"object",
"class",
";",
"}"
] |
[
"verify",
"snapshots",
"with",
"open",
"files",
"captured",
"are",
"safe",
"even",
"when",
"the",
"'",
"current",
"'",
"version",
"of",
"the",
"file",
"is",
"truncated",
"and",
"appended",
"later"
] |
[
"public",
"void",
"test",
"open",
"files",
"snap",
"checksum",
"with",
"trunk",
"and",
"append",
"(",
")",
"throws",
"exception",
"{",
"/",
"/",
"construct",
"the",
"directory",
"tree",
"final",
"path",
"dir",
"=",
"new",
"path",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"\"",
")",
";",
"fs",
"mkdirs",
"(",
"dir",
")",
";",
"/",
"/",
"string",
"constants",
"final",
"path",
"hbase",
"snap",
"root",
"dir",
"=",
"dir",
";",
"final",
"string",
"hbase",
"file",
"name",
"=",
"\"",
"hbase",
"wal",
"\"",
";",
"final",
"string",
"hbase",
"snap",
"1",
"name",
"=",
"\"",
"hbase",
"snap",
"s",
"1",
"\"",
";",
"final",
"string",
"hbase",
"snap",
"2",
"name",
"=",
"\"",
"hbase",
"snap",
"s",
"2",
"\"",
";",
"final",
"string",
"hbase",
"snap",
"3",
"name",
"=",
"\"",
"hbase",
"snap",
"s",
"3",
"\"",
";",
"final",
"string",
"hbase",
"snap",
"4",
"name",
"=",
"\"",
"hbase",
"snap",
"s",
"4",
"\"",
";",
"/",
"/",
"create",
"files",
"and",
"open",
"a",
"stream",
"final",
"path",
"hbase",
"file",
"=",
"new",
"path",
"(",
"dir",
",",
"hbase",
"file",
"name",
")",
";",
"create",
"file",
"(",
"hbase",
"file",
")",
";",
"final",
"file",
"checksum",
"hbase",
"w",
"a",
"l",
"file",
"cksum",
"0",
"=",
"fs",
"get",
"file",
"checksum",
"(",
"hbase",
"file",
")",
";",
"f",
"s",
"data",
"output",
"stream",
"hbase",
"output",
"stream",
"=",
"fs",
"append",
"(",
"hbase",
"file",
")",
";",
"/",
"/",
"create",
"snapshot",
"s1",
"final",
"path",
"hbase",
"s",
"1",
"dir",
"=",
"snapshot",
"test",
"helper",
"create",
"snapshot",
"(",
"fs",
",",
"hbase",
"snap",
"root",
"dir",
",",
"hbase",
"snap",
"1",
"name",
")",
";",
"final",
"path",
"hbase",
"s",
"1",
"path",
"=",
"new",
"path",
"(",
"hbase",
"s",
"1",
"dir",
",",
"hbase",
"file",
"name",
")",
";",
"final",
"file",
"checksum",
"hbase",
"file",
"cksum",
"s",
"1",
"=",
"fs",
"get",
"file",
"checksum",
"(",
"hbase",
"s",
"1",
"path",
")",
";",
"/",
"/",
"verify",
"if",
"snap",
"s1",
"checksum",
"is",
"same",
"as",
"the",
"current",
"version",
"one",
"assert",
"assert",
"equals",
"(",
"\"",
"live",
"and",
"snap",
"1",
"file",
"checksum",
"doesn",
"'",
"t",
"match",
"!",
"\"",
",",
"hbase",
"w",
"a",
"l",
"file",
"cksum",
"0",
",",
"fs",
"get",
"file",
"checksum",
"(",
"hbase",
"s",
"1",
"path",
")",
")",
";",
"int",
"new",
"write",
"length",
"=",
"(",
"int",
")",
"(",
"blocksize",
"*",
"1",
"5",
")",
";",
"byte",
"[",
"]",
"buf",
"=",
"new",
"byte",
"[",
"new",
"write",
"length",
"]",
";",
"random",
"random",
"=",
"new",
"random",
"(",
")",
";",
"random",
"next",
"bytes",
"(",
"buf",
")",
";",
"write",
"to",
"stream",
"(",
"hbase",
"output",
"stream",
",",
"buf",
")",
";",
"/",
"/",
"create",
"snapshot",
"s2",
"final",
"path",
"hbase",
"s",
"2",
"dir",
"=",
"snapshot",
"test",
"helper",
"create",
"snapshot",
"(",
"fs",
",",
"hbase",
"snap",
"root",
"dir",
",",
"hbase",
"snap",
"2",
"name",
")",
";",
"final",
"path",
"hbase",
"s",
"2",
"path",
"=",
"new",
"path",
"(",
"hbase",
"s",
"2",
"dir",
",",
"hbase",
"file",
"name",
")",
";",
"final",
"file",
"checksum",
"hbase",
"file",
"cksum",
"s",
"2",
"=",
"fs",
"get",
"file",
"checksum",
"(",
"hbase",
"s",
"2",
"path",
")",
";",
"/",
"/",
"verify",
"if",
"the",
"s",
"1",
"checksum",
"is",
"still",
"the",
"same",
"assert",
"assert",
"equals",
"(",
"\"",
"snap",
"file",
"checksum",
"has",
"changed",
"!",
"\"",
",",
"hbase",
"file",
"cksum",
"s",
"1",
",",
"fs",
"get",
"file",
"checksum",
"(",
"hbase",
"s",
"1",
"path",
")",
")",
";",
"/",
"/",
"verify",
"if",
"the",
"s",
"2",
"checksum",
"is",
"different",
"from",
"the",
"s",
"1",
"checksum",
"assert",
"assert",
"not",
"equals",
"(",
"\"",
"snap",
"1",
"and",
"snap",
"2",
"file",
"checksum",
"should",
"differ",
"!",
"\"",
",",
"hbase",
"file",
"cksum",
"s",
"1",
",",
"hbase",
"file",
"cksum",
"s",
"2",
")",
";",
"new",
"write",
"length",
"=",
"(",
"int",
")",
"(",
"blocksize",
"*",
"2",
"5",
")",
";",
"buf",
"=",
"new",
"byte",
"[",
"new",
"write",
"length",
"]",
";",
"random",
"next",
"bytes",
"(",
"buf",
")",
";",
"write",
"to",
"stream",
"(",
"hbase",
"output",
"stream",
",",
"buf",
")",
";",
"/",
"/",
"create",
"snapshot",
"s3",
"final",
"path",
"hbase",
"s",
"3",
"dir",
"=",
"snapshot",
"test",
"helper",
"create",
"snapshot",
"(",
"fs",
",",
"hbase",
"snap",
"root",
"dir",
",",
"hbase",
"snap",
"3",
"name",
")",
";",
"final",
"path",
"hbase",
"s",
"3",
"path",
"=",
"new",
"path",
"(",
"hbase",
"s",
"3",
"dir",
",",
"hbase",
"file",
"name",
")",
";",
"file",
"checksum",
"hbase",
"file",
"cksum",
"s",
"3",
"=",
"fs",
"get",
"file",
"checksum",
"(",
"hbase",
"s",
"3",
"path",
")",
";",
"/",
"/",
"record",
"the",
"checksum",
"for",
"the",
"before",
"truncate",
"current",
"file",
"hbase",
"output",
"stream",
"close",
"(",
")",
";",
"final",
"file",
"checksum",
"hbase",
"file",
"cksum",
"before",
"truncate",
"=",
"fs",
"get",
"file",
"checksum",
"(",
"hbase",
"file",
")",
";",
"assert",
"assert",
"equals",
"(",
"\"",
"snap",
"3",
"and",
"before",
"truncate",
"file",
"checksum",
"should",
"match",
"!",
"\"",
",",
"hbase",
"file",
"cksum",
"before",
"truncate",
",",
"hbase",
"file",
"cksum",
"s",
"3",
")",
";",
"/",
"/",
"truncate",
"the",
"current",
"file",
"and",
"record",
"the",
"after",
"truncate",
"checksum",
"long",
"current",
"file",
"len",
"=",
"fs",
"get",
"file",
"status",
"(",
"hbase",
"file",
")",
"get",
"len",
"(",
")",
";",
"boolean",
"file",
"truncated",
"=",
"fs",
"truncate",
"(",
"hbase",
"file",
",",
"current",
"file",
"len",
"/",
"2",
")",
";",
"assert",
"assert",
"true",
"(",
"\"",
"file",
"truncation",
"failed",
"!",
"\"",
",",
"file",
"truncated",
")",
";",
"final",
"file",
"checksum",
"hbase",
"file",
"cksum",
"after",
"truncate",
"=",
"fs",
"get",
"file",
"checksum",
"(",
"hbase",
"file",
")",
";",
"assert",
"assert",
"not",
"equals",
"(",
"\"",
"snap",
"3",
"and",
"after",
"truncate",
"checksum",
"shouldn",
"'",
"t",
"match",
"!",
"\"",
",",
"hbase",
"file",
"cksum",
"s",
"3",
",",
"hbase",
"file",
"cksum",
"after",
"truncate",
")",
";",
"/",
"/",
"append",
"more",
"data",
"to",
"the",
"current",
"file",
"hbase",
"output",
"stream",
"=",
"fs",
"append",
"(",
"hbase",
"file",
")",
";",
"new",
"write",
"length",
"=",
"(",
"int",
")",
"(",
"blocksize",
"*",
"5",
"5",
")",
";",
"buf",
"=",
"new",
"byte",
"[",
"new",
"write",
"length",
"]",
";",
"random",
"next",
"bytes",
"(",
"buf",
")",
";",
"write",
"to",
"stream",
"(",
"hbase",
"output",
"stream",
",",
"buf",
")",
";",
"/",
"/",
"create",
"snapshot",
"s4",
"final",
"path",
"hbase",
"s",
"4",
"dir",
"=",
"snapshot",
"test",
"helper",
"create",
"snapshot",
"(",
"fs",
",",
"hbase",
"snap",
"root",
"dir",
",",
"hbase",
"snap",
"4",
"name",
")",
";",
"final",
"path",
"hbase",
"s",
"4",
"path",
"=",
"new",
"path",
"(",
"hbase",
"s",
"4",
"dir",
",",
"hbase",
"file",
"name",
")",
";",
"final",
"file",
"checksum",
"hbase",
"file",
"cksum",
"s",
"4",
"=",
"fs",
"get",
"file",
"checksum",
"(",
"hbase",
"s",
"4",
"path",
")",
";",
"/",
"/",
"record",
"the",
"checksum",
"for",
"the",
"current",
"file",
"after",
"append",
"hbase",
"output",
"stream",
"close",
"(",
")",
";",
"final",
"file",
"checksum",
"hbase",
"file",
"cksum",
"after",
"append",
"=",
"fs",
"get",
"file",
"checksum",
"(",
"hbase",
"file",
")",
";",
"assert",
"assert",
"equals",
"(",
"\"",
"snap",
"4",
"and",
"after",
"append",
"file",
"checksum",
"should",
"match",
"!",
"\"",
",",
"hbase",
"file",
"cksum",
"after",
"append",
",",
"hbase",
"file",
"cksum",
"s",
"4",
")",
";",
"/",
"/",
"recompute",
"checksum",
"for",
"s3",
"path",
"and",
"verify",
"it",
"has",
"not",
"changed",
"hbase",
"file",
"cksum",
"s",
"3",
"=",
"fs",
"get",
"file",
"checksum",
"(",
"hbase",
"s",
"3",
"path",
")",
";",
"assert",
"assert",
"equals",
"(",
"\"",
"snap",
"3",
"and",
"before",
"truncate",
"file",
"checksum",
"should",
"match",
"!",
"\"",
",",
"hbase",
"file",
"cksum",
"before",
"truncate",
",",
"hbase",
"file",
"cksum",
"s",
"3",
")",
";",
"}"
] |
[
"map",
"of",
"string",
"keys",
"and",
"values",
"that",
"can",
"be",
"used",
"to",
"organize",
"and",
"categorize",
"resources",
"within",
"a",
"collection",
"<",
"code",
">",
"map",
"&",
"lt",
";",
"string",
",",
"string",
"&",
"gt",
";",
"labels",
"=",
"4",
";",
"<",
"code",
">"
] |
[
"boolean",
"contains",
"labels",
"(",
"java",
"lang",
"string",
"key",
")",
";"
] |
[
"concatenates",
"an",
"array",
"of",
"path",
"segments",
"into",
"a",
"path",
"string"
] |
[
"private",
"string",
"create",
"path",
"(",
"string",
"segments",
")",
"{",
"string",
"builder",
"buf",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"for",
"(",
"string",
"segment",
":",
"segments",
")",
"{",
"if",
"(",
"!",
"string",
"utils",
"is",
"empty",
"(",
"segment",
")",
"&",
"&",
"!",
"segment",
"equals",
"(",
"\"",
"\"",
")",
")",
"{",
"if",
"(",
"buf",
"length",
"(",
")",
"!",
"=",
"0",
")",
"buf",
"append",
"(",
"file",
"separator",
"char",
")",
";",
"buf",
"append",
"(",
"segment",
")",
";",
"}",
"}",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"buf",
"length",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"char",
"c",
"=",
"buf",
"char",
"at",
"(",
"i",
")",
";",
"if",
"(",
"(",
"c",
"=",
"=",
"'",
"/",
"'",
"|",
"|",
"c",
"=",
"=",
"'",
"\\",
"\\",
"'",
")",
"&",
"&",
"c",
"!",
"=",
"file",
"separator",
"char",
")",
"buf",
"set",
"char",
"at",
"(",
"i",
",",
"file",
"separator",
"char",
")",
";",
"}",
"return",
"buf",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"ensures",
"that",
"schema",
"exists",
",",
"if",
"enabled",
"tries",
"to",
"execute",
":",
"io",
"zipkin",
"zipkin",
"2",
":",
"zipkin",
"-",
"storage",
"-",
"cassandrazipkin",
"2",
"-",
"schema",
"cql",
"io",
"zipkin",
"zipkin",
"2",
":",
"zipkin",
"-",
"storage",
"-",
"cassandrazipkin",
"2",
"-",
"indexes",
"cql",
"defaults",
"to",
"true"
] |
[
"@",
"override",
"public",
"builder",
"ensure",
"schema",
"(",
"boolean",
"ensure",
"schema",
")",
"{",
"return",
"super",
"ensure",
"schema",
"(",
"ensure",
"schema",
")",
";",
"}"
] |
[
"adds",
"key",
"value",
"pairs",
"as",
"\"",
"-",
"dkey",
"=",
"value",
"-",
"dkey",
"=",
"value",
"\"",
"by",
"parsing",
"a",
"given",
"string",
"using",
"{",
"@",
"link",
"properties",
"}",
"with",
"masking"
] |
[
"public",
"argument",
"list",
"builder",
"add",
"key",
"value",
"pairs",
"from",
"property",
"string",
"(",
"string",
"prefix",
",",
"string",
"properties",
",",
"variable",
"resolver",
"<",
"string",
">",
"vr",
",",
"set",
"<",
"string",
">",
"props",
"to",
"mask",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"properties",
"=",
"=",
"null",
")",
"return",
"this",
";",
"properties",
"=",
"util",
"replace",
"macro",
"(",
"properties",
",",
"properties",
"generating",
"resolver",
"(",
"vr",
")",
")",
";",
"for",
"(",
"entry",
"<",
"object",
",",
"object",
">",
"entry",
":",
"util",
"load",
"properties",
"(",
"properties",
")",
"entry",
"set",
"(",
")",
")",
"{",
"add",
"key",
"value",
"pair",
"(",
"prefix",
",",
"(",
"string",
")",
"entry",
"get",
"key",
"(",
")",
",",
"entry",
"get",
"value",
"(",
")",
"to",
"string",
"(",
")",
",",
"(",
"props",
"to",
"mask",
"!",
"=",
"null",
")",
"&",
"&",
"props",
"to",
"mask",
"contains",
"(",
"entry",
"get",
"key",
"(",
")",
")",
")",
";",
"}",
"return",
"this",
";",
"}"
] |
[
"get",
"attribute",
"integer"
] |
[
"public",
"integer",
"get",
"attribute",
"integer",
"(",
")",
"{",
"return",
"attribute",
"integer",
";",
"}"
] |
[
"get",
"map",
"integer"
] |
[
"public",
"map",
"<",
"string",
",",
"integer",
">",
"get",
"map",
"integer",
"(",
")",
"{",
"return",
"map",
"integer",
";",
"}"
] |
[
"defines",
"the",
"size",
"of",
"a",
"long",
"double",
"primitive",
"data",
"type"
] |
[
"public",
"void",
"set",
"long",
"double",
"size",
"(",
"int",
"long",
"double",
"size",
")",
"{",
"this",
"long",
"double",
"size",
"=",
"long",
"double",
"size",
";",
"if",
"(",
"double",
"size",
">",
"long",
"double",
"size",
")",
"{",
"set",
"double",
"size",
"(",
"long",
"double",
"size",
")",
";",
"}",
"}"
] |
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
] |
[
"private",
"string",
"to",
"indented",
"string",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
] |
[
"sets",
"whether",
"to",
"request",
"field",
"statistics"
] |
[
"public",
"void",
"set",
"field",
"statistics",
"(",
"boolean",
"request",
"field",
"statistics",
")",
"{",
"this",
"request",
"field",
"statistics",
"=",
"request",
"field",
"statistics",
";",
"}"
] |
[
"ensures",
"the",
"truth",
"of",
"an",
"expression",
"involving",
"one",
"or",
"more",
"parameters",
"to",
"the",
"calling",
"method"
] |
[
"public",
"static",
"void",
"check",
"argument",
"(",
"boolean",
"expression",
",",
"@",
"nullable",
"object",
"error",
"message",
")",
"{",
"if",
"(",
"!",
"expression",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"string",
"value",
"of",
"(",
"error",
"message",
")",
")",
";",
"}",
"}"
] |
[
"gets",
"a",
"little",
"endian",
"short",
"at",
"value",
"at",
"{",
"@",
"code",
"internal",
"position",
"-",
"get",
"offset",
"base",
"(",
")",
"}"
] |
[
"default",
"short",
"get",
"short",
"unchecked",
"(",
"int",
"internal",
"position",
")",
"{",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
"get",
"class",
"(",
")",
"get",
"name",
"(",
")",
")",
";",
"}"
] |
[
"finds",
"the",
"string",
"in",
"the",
"{",
"@",
"code",
"group",
"}",
"closest",
"to",
"{",
"@",
"code",
"key",
"}",
"and",
"returns",
"it"
] |
[
"public",
"static",
"string",
"find",
"nearest",
"(",
"string",
"key",
",",
"string",
"[",
"]",
"group",
")",
"{",
"return",
"find",
"nearest",
"(",
"key",
",",
"arrays",
"as",
"list",
"(",
"group",
")",
")",
";",
"}"
] |
[
"sets",
"whether",
"the",
"view",
"should",
"allow",
"pinch",
"-",
"to",
"-",
"zoom",
"when",
"enabled",
",",
"the",
"user",
"can",
"pinch",
"the",
"camera",
"to",
"zoom",
"inout",
"this",
"only",
"has",
"an",
"effect",
"if",
"the",
"bound",
"camera",
"supports",
"zoom"
] |
[
"public",
"void",
"set",
"pinch",
"to",
"zoom",
"enabled",
"(",
"boolean",
"enabled",
")",
"{",
"m",
"is",
"pinch",
"to",
"zoom",
"enabled",
"=",
"enabled",
";",
"}"
] |
[
"add",
"the",
"given",
"elements",
"to",
"the",
"queue",
",",
"possibly",
"forcing",
"evictions",
"from",
"the",
"head",
"if",
"{",
"@",
"link",
"#",
"remaining",
"capacity",
"(",
")",
"}",
"is",
"zero",
"or",
"becomes",
"zero",
"during",
"the",
"execution",
"of",
"this",
"method"
] |
[
"public",
"boolean",
"add",
"all",
"(",
"collection",
"<",
"?",
"extends",
"t",
">",
"c",
")",
"{",
"boolean",
"modified",
"=",
"false",
";",
"for",
"(",
"t",
"e",
":",
"c",
")",
"if",
"(",
"add",
"(",
"e",
")",
")",
"modified",
"=",
"true",
";",
"return",
"modified",
";",
"}"
] |
[
"clean",
"up",
"all",
"the",
"filters",
"supplied",
",",
"calling",
"each",
"one",
"'",
"s",
"destroy",
"method",
"in",
"turn",
",",
"but",
"in",
"reverse",
"order"
] |
[
"public",
"void",
"destroy",
"(",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"this",
"filters",
"size",
"(",
")",
";",
"i",
"-",
"-",
">",
"0",
";",
")",
"{",
"filter",
"filter",
"=",
"this",
"filters",
"get",
"(",
"i",
")",
";",
"filter",
"destroy",
"(",
")",
";",
"}",
"}"
] |
[
"@",
"inherit",
"doc"
] |
[
"public",
"decoded",
"instruction",
"with",
"index",
"(",
"int",
"new",
"index",
")",
"{",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
"\"",
"no",
"index",
"in",
"instruction",
"\"",
")",
";",
"}"
] |
[
"returns",
"an",
"unmodifiable",
"snapshot",
"map",
"roughly",
"ordered",
"by",
"the",
"expiration",
"time",
"the",
"wheels",
"are",
"evaluated",
"in",
"order",
",",
"but",
"the",
"timers",
"that",
"fall",
"within",
"the",
"bucket",
"'",
"s",
"range",
"are",
"not",
"sorted",
"beware",
"that",
"obtaining",
"the",
"mappings",
"is",
"not",
"a",
"constant",
"-",
"time",
"operation"
] |
[
"public",
"map",
"<",
"k",
",",
"v",
">",
"snapshot",
"(",
"boolean",
"ascending",
",",
"int",
"limit",
",",
"@",
"non",
"null",
"function",
"<",
"v",
",",
"v",
">",
"transformer",
")",
"{",
"require",
"argument",
"(",
"limit",
">",
"=",
"0",
")",
";",
"map",
"<",
"k",
",",
"v",
">",
"map",
"=",
"new",
"linked",
"hash",
"map",
"<",
">",
"(",
"math",
"min",
"(",
"limit",
",",
"cache",
"size",
"(",
")",
")",
")",
";",
"int",
"start",
"level",
"=",
"ascending",
"?",
"0",
":",
"wheel",
"length",
"-",
"1",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"wheel",
"length",
";",
"i",
"+",
"+",
")",
"{",
"int",
"index",
"offset",
"=",
"ascending",
"?",
"i",
":",
"-",
"i",
";",
"int",
"index",
"=",
"start",
"level",
"+",
"index",
"offset",
";",
"int",
"ticks",
"=",
"(",
"int",
")",
"(",
"nanos",
">",
">",
">",
"shift",
"[",
"index",
"]",
")",
";",
"int",
"bucket",
"mask",
"=",
"(",
"wheel",
"[",
"index",
"]",
"length",
"-",
"1",
")",
";",
"int",
"start",
"bucket",
"=",
"(",
"ticks",
"&",
"bucket",
"mask",
")",
"+",
"(",
"ascending",
"?",
"1",
":",
"0",
")",
";",
"for",
"(",
"int",
"j",
"=",
"0",
";",
"j",
"<",
"wheel",
"[",
"index",
"]",
"length",
";",
"j",
"+",
"+",
")",
"{",
"int",
"bucket",
"offset",
"=",
"ascending",
"?",
"j",
":",
"-",
"j",
";",
"node",
"<",
"k",
",",
"v",
">",
"sentinel",
"=",
"wheel",
"[",
"index",
"]",
"[",
"(",
"start",
"bucket",
"+",
"bucket",
"offset",
")",
"&",
"bucket",
"mask",
"]",
";",
"for",
"(",
"node",
"<",
"k",
",",
"v",
">",
"node",
"=",
"traverse",
"(",
"ascending",
",",
"sentinel",
")",
";",
"node",
"!",
"=",
"sentinel",
";",
"node",
"=",
"traverse",
"(",
"ascending",
",",
"node",
")",
")",
"{",
"if",
"(",
"map",
"size",
"(",
")",
">",
"=",
"limit",
")",
"{",
"break",
";",
"}",
"k",
"key",
"=",
"node",
"get",
"key",
"(",
")",
";",
"v",
"value",
"=",
"transformer",
"apply",
"(",
"node",
"get",
"value",
"(",
")",
")",
";",
"if",
"(",
"(",
"key",
"!",
"=",
"null",
")",
"&",
"&",
"(",
"value",
"!",
"=",
"null",
")",
"&",
"&",
"node",
"is",
"alive",
"(",
")",
")",
"{",
"map",
"put",
"(",
"key",
",",
"value",
")",
";",
"}",
"}",
"}",
"}",
"return",
"collections",
"unmodifiable",
"map",
"(",
"map",
")",
";",
"}"
] |
[
"gets",
"the",
"child",
"drawable"
] |
[
"drawable",
"get",
"drawable",
"(",
")",
";"
] |
[
"summarizes",
"the",
"current",
"{",
"@",
"link",
"gridmix",
"}",
"run"
] |
[
"public",
"string",
"to",
"string",
"(",
")",
"{",
"string",
"builder",
"builder",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"builder",
"append",
"(",
"\"",
"execution",
"summary",
":",
"-",
"\"",
")",
";",
"builder",
"append",
"(",
"\"",
"\\",
"n",
"input",
"trace",
":",
"\"",
")",
"append",
"(",
"get",
"input",
"trace",
"location",
"(",
")",
")",
";",
"builder",
"append",
"(",
"\"",
"\\",
"n",
"input",
"trace",
"signature",
":",
"\"",
")",
"append",
"(",
"get",
"input",
"trace",
"signature",
"(",
")",
")",
";",
"builder",
"append",
"(",
"\"",
"\\",
"n",
"total",
"number",
"of",
"jobs",
"in",
"trace",
":",
"\"",
")",
"append",
"(",
"get",
"num",
"jobs",
"in",
"trace",
"(",
")",
")",
";",
"builder",
"append",
"(",
"\"",
"\\",
"n",
"expected",
"input",
"data",
"size",
":",
"\"",
")",
"append",
"(",
"get",
"expected",
"data",
"size",
"(",
")",
")",
";",
"builder",
"append",
"(",
"\"",
"\\",
"n",
"input",
"data",
"statistics",
":",
"\"",
")",
"append",
"(",
"get",
"input",
"data",
"statistics",
"(",
")",
")",
";",
"builder",
"append",
"(",
"\"",
"\\",
"n",
"total",
"number",
"of",
"jobs",
"processed",
":",
"\"",
")",
"append",
"(",
"get",
"num",
"submitted",
"jobs",
"(",
")",
")",
";",
"builder",
"append",
"(",
"\"",
"\\",
"n",
"total",
"number",
"of",
"successful",
"jobs",
":",
"\"",
")",
"append",
"(",
"get",
"num",
"successful",
"jobs",
"(",
")",
")",
";",
"builder",
"append",
"(",
"\"",
"\\",
"n",
"total",
"number",
"of",
"failed",
"jobs",
":",
"\"",
")",
"append",
"(",
"get",
"num",
"failed",
"jobs",
"(",
")",
")",
";",
"builder",
"append",
"(",
"\"",
"\\",
"n",
"total",
"number",
"of",
"lost",
"jobs",
":",
"\"",
")",
"append",
"(",
"get",
"num",
"lost",
"jobs",
"(",
")",
")",
";",
"builder",
"append",
"(",
"\"",
"\\",
"n",
"total",
"number",
"of",
"map",
"tasks",
"launched",
":",
"\"",
")",
"append",
"(",
"get",
"num",
"map",
"tasks",
"launched",
"(",
")",
")",
";",
"builder",
"append",
"(",
"\"",
"\\",
"n",
"total",
"number",
"of",
"reduce",
"task",
"launched",
":",
"\"",
")",
"append",
"(",
"get",
"num",
"reduce",
"tasks",
"launched",
"(",
")",
")",
";",
"builder",
"append",
"(",
"\"",
"\\",
"n",
"gridmix",
"start",
"time",
":",
"\"",
")",
"append",
"(",
"util",
"format",
"(",
"get",
"start",
"time",
"(",
")",
")",
")",
";",
"builder",
"append",
"(",
"\"",
"\\",
"n",
"gridmix",
"end",
"time",
":",
"\"",
")",
"append",
"(",
"util",
"format",
"(",
"get",
"end",
"time",
"(",
")",
")",
")",
";",
"builder",
"append",
"(",
"\"",
"\\",
"n",
"gridmix",
"simulation",
"start",
"time",
":",
"\"",
")",
"append",
"(",
"util",
"format",
"(",
"get",
"start",
"time",
"(",
")",
")",
")",
";",
"builder",
"append",
"(",
"\"",
"\\",
"n",
"gridmix",
"runtime",
":",
"\"",
")",
"append",
"(",
"string",
"utils",
"format",
"time",
"(",
"get",
"runtime",
"(",
")",
")",
")",
";",
"builder",
"append",
"(",
"\"",
"\\",
"n",
"time",
"spent",
"in",
"initialization",
"(",
"data",
"-",
"gen",
"etc",
")",
":",
"\"",
")",
"append",
"(",
"string",
"utils",
"format",
"time",
"(",
"get",
"init",
"time",
"(",
")",
")",
")",
";",
"builder",
"append",
"(",
"\"",
"\\",
"n",
"time",
"spent",
"in",
"simulation",
":",
"\"",
")",
"append",
"(",
"string",
"utils",
"format",
"time",
"(",
"get",
"simulation",
"time",
"(",
")",
")",
")",
";",
"builder",
"append",
"(",
"\"",
"\\",
"n",
"gridmix",
"configuration",
"parameters",
":",
"\"",
")",
"append",
"(",
"get",
"command",
"line",
"args",
"string",
"(",
")",
")",
";",
"builder",
"append",
"(",
"\"",
"\\",
"n",
"gridmix",
"job",
"submission",
"policy",
":",
"\"",
")",
"append",
"(",
"get",
"job",
"submission",
"policy",
"(",
")",
")",
";",
"builder",
"append",
"(",
"\"",
"\\",
"n",
"gridmix",
"resolver",
":",
"\"",
")",
"append",
"(",
"get",
"user",
"resolver",
"(",
")",
")",
";",
"builder",
"append",
"(",
"\"",
"\\",
"n",
"\\",
"n",
"\"",
")",
";",
"return",
"builder",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"get",
"the",
"length",
"of",
"a",
"stored",
"record"
] |
[
"private",
"int",
"get",
"record",
"length",
"(",
"int",
"index",
")",
"{",
"if",
"(",
"index",
"=",
"=",
"0",
")",
"{",
"return",
"buffer",
"length",
"(",
")",
"-",
"get",
"record",
"data",
"offset",
"(",
"0",
")",
";",
"}",
"return",
"get",
"record",
"data",
"offset",
"(",
"index",
"-",
"1",
")",
"-",
"get",
"record",
"data",
"offset",
"(",
"index",
")",
";",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.