docstring_tokens
list | code_tokens
list |
|---|---|
[
"get",
"the",
"best",
"matched",
"{",
"@",
"link",
"request",
"metadata",
"}",
"via",
"specified",
"{",
"@",
"link",
"request",
"metadata",
"}"
]
| [
"public",
"static",
"request",
"metadata",
"get",
"best",
"match",
"(",
"navigable",
"map",
"<",
"request",
"metadata",
",",
"request",
"metadata",
">",
"request",
"metadata",
"map",
",",
"request",
"metadata",
"request",
"metadata",
")",
"{",
"request",
"metadata",
"key",
"=",
"request",
"metadata",
";",
"request",
"metadata",
"result",
"=",
"request",
"metadata",
"map",
"get",
"(",
"key",
")",
";",
"if",
"(",
"result",
"=",
"=",
"null",
")",
"{",
"sorted",
"map",
"<",
"request",
"metadata",
",",
"request",
"metadata",
">",
"head",
"map",
"=",
"request",
"metadata",
"map",
"head",
"map",
"(",
"key",
",",
"true",
")",
";",
"result",
"=",
"head",
"map",
"is",
"empty",
"(",
")",
"?",
"null",
":",
"request",
"metadata",
"map",
"get",
"(",
"head",
"map",
"last",
"key",
"(",
")",
")",
";",
"}",
"return",
"result",
";",
"}"
]
|
[
"post",
"usercreate",
"with",
"array",
":",
"creates",
"list",
"of",
"users",
"with",
"given",
"input",
"array"
]
| [
"default",
"response",
"entity",
"<",
"void",
">",
"create",
"users",
"with",
"array",
"input",
"(",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"list",
"of",
"user",
"object",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"valid",
"@",
"request",
"body",
"list",
"<",
"user",
">",
"body",
")",
"{",
"return",
"new",
"response",
"entity",
"<",
">",
"(",
"http",
"status",
"not",
"implemented",
")",
";",
"}"
]
|
[
"returns",
"the",
"analyzer",
"as",
"the",
"default",
"analyzer",
"in",
"the",
"engines",
"{",
"@",
"link",
"org",
"apache",
"lucene",
"index",
"index",
"writer",
"}"
]
| [
"public",
"analyzer",
"get",
"analyzer",
"(",
")",
"{",
"return",
"analyzer",
";",
"}"
]
|
[
"stop",
"the",
"mini",
"-",
"dfs",
"cluster"
]
| [
"public",
"void",
"stop",
"cluster",
"(",
")",
"{",
"if",
"(",
"cluster",
"!",
"=",
"null",
")",
"{",
"cluster",
"shutdown",
"(",
")",
";",
"}",
"/",
"/",
"restore",
"non",
"-",
"secure",
"conf",
"user",
"group",
"information",
"set",
"configuration",
"(",
"new",
"configuration",
"(",
")",
")",
";",
"rolling",
"file",
"system",
"sink",
"supplied",
"conf",
"=",
"null",
";",
"rolling",
"file",
"system",
"sink",
"supplied",
"filesystem",
"=",
"null",
";",
"}"
]
|
[
"a",
"shortcut",
"for",
"{",
"@",
"link",
"#",
"set",
"wait",
"for",
"active",
"shards",
"(",
"active",
"shard",
"count",
")",
"}",
"where",
"the",
"numerical",
"shard",
"count",
"is",
"passed",
"in",
",",
"instead",
"of",
"having",
"to",
"first",
"call",
"{",
"@",
"link",
"active",
"shard",
"count",
"#",
"from",
"(",
"int",
")",
"}",
"to",
"get",
"the",
"active",
"shard",
"count"
]
| [
"public",
"close",
"index",
"request",
"builder",
"set",
"wait",
"for",
"active",
"shards",
"(",
"final",
"int",
"wait",
"for",
"active",
"shards",
")",
"{",
"return",
"set",
"wait",
"for",
"active",
"shards",
"(",
"active",
"shard",
"count",
"from",
"(",
"wait",
"for",
"active",
"shards",
")",
")",
";",
"}"
]
|
[
"create",
"a",
"dummy",
"jspb",
"support",
"package"
]
| [
"private",
"static",
"void",
"create",
"javascript",
"jspb",
"(",
"mock",
"tools",
"config",
"config",
")",
"throws",
"i",
"o",
"exception",
"{",
"config",
"create",
"(",
"\"",
"net",
"/",
"proto",
"2",
"/",
"compiler",
"/",
"js",
"/",
"internal",
"/",
"build",
"\"",
",",
"\"",
"package",
"(",
"default",
"visibility",
"=",
"[",
"'",
"/",
"/",
"visibility",
":",
"public",
"'",
"]",
")",
"\"",
",",
"\"",
"cc",
"binary",
"(",
"name",
"=",
"'",
"protoc",
"-",
"gen",
"-",
"js",
"'",
",",
"\"",
",",
"\"",
"srcs",
"=",
"[",
"'",
"plugin",
"cc",
"'",
"]",
")",
"\"",
")",
";",
"config",
"create",
"(",
"\"",
"javascript",
"/",
"apps",
"/",
"jspb",
"/",
"build",
"\"",
",",
"\"",
"load",
"(",
"'",
"/",
"/",
"tools",
"/",
"build",
"defs",
"/",
"js",
":",
"rules",
"bzl",
"'",
",",
"'",
"js",
"library",
"'",
")",
"\"",
",",
"\"",
"package",
"(",
"default",
"visibility",
"=",
"[",
"'",
"/",
"/",
"visibility",
":",
"public",
"'",
"]",
")",
"\"",
",",
"\"",
"js",
"library",
"(",
"name",
"=",
"'",
"message",
"'",
",",
"\"",
",",
"\"",
"srcs",
"=",
"[",
"'",
"message",
"js",
"'",
"]",
",",
"\"",
",",
"\"",
"deps",
"mgmt",
"=",
"'",
"legacy",
"'",
")",
"\"",
")",
";",
"config",
"create",
"(",
"\"",
"javascript",
"/",
"closure",
"/",
"array",
"/",
"build",
"\"",
",",
"\"",
"load",
"(",
"'",
"/",
"/",
"tools",
"/",
"build",
"defs",
"/",
"js",
":",
"rules",
"bzl",
"'",
",",
"'",
"js",
"library",
"'",
")",
"\"",
",",
"\"",
"package",
"(",
"default",
"visibility",
"=",
"[",
"'",
"/",
"/",
"visibility",
":",
"public",
"'",
"]",
")",
"\"",
",",
"\"",
"js",
"library",
"(",
"name",
"=",
"'",
"array",
"'",
",",
"\"",
",",
"\"",
"srcs",
"=",
"[",
"'",
"array",
"js",
"'",
"]",
",",
"\"",
",",
"\"",
"deps",
"mgmt",
"=",
"'",
"legacy",
"'",
")",
"\"",
")",
";",
"config",
"create",
"(",
"\"",
"javascript",
"/",
"apps",
"/",
"xid",
"/",
"build",
"\"",
",",
"\"",
"load",
"(",
"'",
"/",
"/",
"tools",
"/",
"build",
"defs",
"/",
"js",
":",
"rules",
"bzl",
"'",
",",
"'",
"js",
"library",
"'",
")",
"\"",
",",
"\"",
"package",
"(",
"default",
"visibility",
"=",
"[",
"'",
"/",
"/",
"visibility",
":",
"public",
"'",
"]",
")",
"\"",
",",
"\"",
"js",
"library",
"(",
"name",
"=",
"'",
"xid",
"'",
",",
"\"",
",",
"\"",
"srcs",
"=",
"[",
"'",
"xid",
"js",
"'",
"]",
",",
"\"",
",",
"\"",
"deps",
"mgmt",
"=",
"'",
"legacy",
"'",
")",
"\"",
")",
";",
"}"
]
|
[
"sets",
"the",
"matrix",
"to",
"a",
"rotation",
"matrix",
"representing",
"the",
"translation",
"and",
"quaternion"
]
| [
"public",
"matrix",
"4",
"set",
"(",
"float",
"translation",
"x",
",",
"float",
"translation",
"y",
",",
"float",
"translation",
"z",
",",
"float",
"quaternion",
"x",
",",
"float",
"quaternion",
"y",
",",
"float",
"quaternion",
"z",
",",
"float",
"quaternion",
"w",
",",
"float",
"scale",
"x",
",",
"float",
"scale",
"y",
",",
"float",
"scale",
"z",
")",
"{",
"final",
"float",
"xs",
"=",
"quaternion",
"x",
"*",
"2f",
",",
"ys",
"=",
"quaternion",
"y",
"*",
"2f",
",",
"zs",
"=",
"quaternion",
"z",
"*",
"2f",
";",
"final",
"float",
"wx",
"=",
"quaternion",
"w",
"*",
"xs",
",",
"wy",
"=",
"quaternion",
"w",
"*",
"ys",
",",
"wz",
"=",
"quaternion",
"w",
"*",
"zs",
";",
"final",
"float",
"xx",
"=",
"quaternion",
"x",
"*",
"xs",
",",
"xy",
"=",
"quaternion",
"x",
"*",
"ys",
",",
"xz",
"=",
"quaternion",
"x",
"*",
"zs",
";",
"final",
"float",
"yy",
"=",
"quaternion",
"y",
"*",
"ys",
",",
"yz",
"=",
"quaternion",
"y",
"*",
"zs",
",",
"zz",
"=",
"quaternion",
"z",
"*",
"zs",
";",
"val",
"[",
"m00",
"]",
"=",
"scale",
"x",
"*",
"(",
"1",
"0f",
"-",
"(",
"yy",
"+",
"zz",
")",
")",
";",
"val",
"[",
"m01",
"]",
"=",
"scale",
"y",
"*",
"(",
"xy",
"-",
"wz",
")",
";",
"val",
"[",
"m02",
"]",
"=",
"scale",
"z",
"*",
"(",
"xz",
"+",
"wy",
")",
";",
"val",
"[",
"m03",
"]",
"=",
"translation",
"x",
";",
"val",
"[",
"m10",
"]",
"=",
"scale",
"x",
"*",
"(",
"xy",
"+",
"wz",
")",
";",
"val",
"[",
"m11",
"]",
"=",
"scale",
"y",
"*",
"(",
"1",
"0f",
"-",
"(",
"xx",
"+",
"zz",
")",
")",
";",
"val",
"[",
"m12",
"]",
"=",
"scale",
"z",
"*",
"(",
"yz",
"-",
"wx",
")",
";",
"val",
"[",
"m13",
"]",
"=",
"translation",
"y",
";",
"val",
"[",
"m20",
"]",
"=",
"scale",
"x",
"*",
"(",
"xz",
"-",
"wy",
")",
";",
"val",
"[",
"m21",
"]",
"=",
"scale",
"y",
"*",
"(",
"yz",
"+",
"wx",
")",
";",
"val",
"[",
"m22",
"]",
"=",
"scale",
"z",
"*",
"(",
"1",
"0f",
"-",
"(",
"xx",
"+",
"yy",
")",
")",
";",
"val",
"[",
"m23",
"]",
"=",
"translation",
"z",
";",
"val",
"[",
"m30",
"]",
"=",
"0",
"f",
";",
"val",
"[",
"m31",
"]",
"=",
"0",
"f",
";",
"val",
"[",
"m32",
"]",
"=",
"0",
"f",
";",
"val",
"[",
"m33",
"]",
"=",
"1",
"0f",
";",
"return",
"this",
";",
"}"
]
|
[
"sets",
"uniform",
"x",
"and",
"uniform",
"y",
"to",
"true"
]
| [
"public",
"cell",
"<",
"t",
">",
"uniform",
"(",
")",
"{",
"uniform",
"x",
"=",
"boolean",
"true",
";",
"uniform",
"y",
"=",
"boolean",
"true",
";",
"return",
"this",
";",
"}"
]
|
[
"test",
"the",
"property",
"'",
"password",
"'"
]
| [
"public",
"void",
"password",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"password",
"}"
]
|
[
"returns",
"a",
"{",
"@",
"link",
"decoder",
"}",
"that",
"decodes",
"using",
"the",
"<",
"a",
"href",
"=",
"\"",
"#",
"mime",
"\"",
">",
"mime",
"type",
"base",
"6",
"4",
"decoding",
"scheme"
]
| [
"public",
"static",
"decoder",
"get",
"mime",
"decoder",
"(",
")",
"{",
"return",
"decoder",
"rfc2045",
";",
"}"
]
|
[
"convert",
"a",
"{",
"@",
"link",
"erasure",
"coding",
"policy",
"info",
"}",
"to",
"protobuf",
"the",
"protobuf",
"will",
"have",
"the",
"policy",
",",
"and",
"state",
"state",
"is",
"relevant",
"when",
":",
"1",
"persisting",
"a",
"policy",
"to",
"fsimage",
"2",
"returning",
"the",
"policy",
"to",
"the",
"rpc",
"call",
"{",
"@",
"link",
"distributed",
"file",
"system",
"#",
"get",
"all",
"erasure",
"coding",
"policies",
"(",
")",
"}"
]
| [
"public",
"static",
"erasure",
"coding",
"policy",
"proto",
"convert",
"erasure",
"coding",
"policy",
"(",
"erasure",
"coding",
"policy",
"info",
"info",
")",
"{",
"final",
"erasure",
"coding",
"policy",
"proto",
"builder",
"builder",
"=",
"create",
"e",
"c",
"policy",
"proto",
"builder",
"(",
"info",
"get",
"policy",
"(",
")",
")",
";",
"builder",
"set",
"state",
"(",
"convert",
"e",
"c",
"state",
"(",
"info",
"get",
"state",
"(",
")",
")",
")",
";",
"return",
"builder",
"build",
"(",
")",
";",
"}"
]
|
[
"returns",
"the",
"internal",
"entry",
"for",
"the",
"specified",
"key",
"the",
"entry",
"may",
"be",
"computing",
"or",
"partially",
"collected",
"does",
"not",
"impact",
"recency",
"ordering"
]
| [
"e",
"get",
"entry",
"(",
"@",
"nullable",
"decl",
"object",
"key",
")",
"{",
"if",
"(",
"key",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"int",
"hash",
"=",
"hash",
"(",
"key",
")",
";",
"return",
"segment",
"for",
"(",
"hash",
")",
"get",
"entry",
"(",
"key",
",",
"hash",
")",
";",
"}"
]
|
[
"resets",
"the",
"state",
"of",
"the",
"writer",
"to",
"write",
"the",
"next",
"batch",
"of",
"fields"
]
| [
"public",
"void",
"reset",
"(",
")",
"{",
"value",
"vector",
"reset",
"(",
")",
";",
"count",
"=",
"0",
";",
"}"
]
|
[
"lenient",
"stubs",
"bypass",
"\"",
"strict",
"stubbing",
"\"",
"validation",
"(",
"see",
"{",
"@",
"link",
"strictness",
"#",
"strict",
"stubs",
"}",
")",
"when",
"stubbing",
"is",
"declared",
"as",
"lenient",
",",
"it",
"will",
"not",
"be",
"checked",
"for",
"potential",
"stubbing",
"problems",
"such",
"as",
"'",
"unnecessary",
"stubbing",
"'",
"(",
"{",
"@",
"link",
"unnecessary",
"stubbing",
"exception",
"}",
")",
"or",
"for",
"'",
"stubbing",
"argument",
"mismatch",
"'",
"{",
"@",
"link",
"potential",
"stubbing",
"problem",
"}",
"<",
"pre",
"class",
"=",
"\"",
"code",
"\"",
">",
"<",
"code",
"class",
"=",
"\"",
"java",
"\"",
">",
"lenient",
"(",
")",
"when",
"(",
"mock",
"foo",
"(",
")",
")",
"then",
"return",
"(",
"\"",
"ok",
"\"",
")",
";",
"<",
"code",
">",
"most",
"mocks",
"in",
"most",
"tests",
"don",
"'",
"t",
"need",
"leniency",
"and",
"should",
"happily",
"prosper",
"with",
"{",
"@",
"link",
"strictness",
"#",
"strict",
"stubs",
"}",
"if",
"a",
"specific",
"stubbing",
"needs",
"to",
"be",
"lenient",
"-",
"use",
"this",
"method",
"if",
"a",
"specific",
"mock",
"need",
"to",
"have",
"stubbings",
"lenient",
"-",
"use",
"{",
"@",
"link",
"mock",
"settings",
"#",
"lenient",
"(",
")",
"}",
"if",
"a",
"specific",
"test",
"method",
"test",
"class",
"needs",
"to",
"have",
"all",
"stubbings",
"lenient",
"-",
"configure",
"strictness",
"using",
"our",
"j",
"unit",
"support",
"(",
"{",
"@",
"link",
"mockito",
"j",
"unit",
"}",
"or",
"mockito",
"session",
"(",
"{",
"@",
"link",
"mockito",
"session",
"}",
")",
"<",
"h",
"3",
">",
"elaborate",
"example",
"<",
"h",
"3",
">",
"in",
"below",
"example",
",",
"'",
"foo",
"foo",
"(",
")",
"'",
"is",
"a",
"stubbing",
"that",
"was",
"moved",
"to",
"'",
"before",
"(",
")",
"'",
"method",
"to",
"avoid",
"duplication",
"doing",
"so",
"makes",
"one",
"of",
"the",
"test",
"methods",
"(",
"'",
"test",
"3",
"(",
")",
"'",
")",
"fail",
"with",
"'",
"unnecessary",
"stubbing",
"'",
"to",
"resolve",
"it",
"we",
"can",
"configure",
"'",
"foo",
"foo",
"(",
")",
"'",
"stubbing",
"in",
"'",
"before",
"(",
")",
"'",
"method",
"to",
"be",
"lenient",
"alternatively",
",",
"we",
"can",
"configure",
"entire",
"'",
"foo",
"'",
"mock",
"as",
"lenient",
"this",
"example",
"is",
"simplified",
"and",
"not",
"realistic",
"pushing",
"stubbings",
"to",
"'",
"before",
"(",
")",
"'",
"method",
"may",
"cause",
"tests",
"to",
"be",
"less",
"readable",
"some",
"repetition",
"in",
"tests",
"is",
"ok",
",",
"use",
"your",
"own",
"judgement",
"to",
"write",
"great",
"tests",
"!",
"it",
"is",
"not",
"desired",
"to",
"eliminate",
"all",
"possible",
"duplication",
"from",
"the",
"test",
"code",
"because",
"it",
"may",
"add",
"complexity",
"and",
"conceal",
"important",
"test",
"information",
"<",
"pre",
"class",
"=",
"\"",
"code",
"\"",
">",
"<",
"code",
"class",
"=",
"\"",
"java",
"\"",
">",
"public",
"class",
"some",
"test",
"{",
"&",
"#",
"064",
";",
"rule",
"public",
"mockito",
"rule",
"mockito",
"=",
"mockito",
"j",
"unit",
"rule",
"(",
")",
"strictness",
"(",
"strict",
"stubs",
")",
";",
"&",
"#",
"064",
";",
"mock",
"foo",
"foo",
";",
"&",
"#",
"064",
";",
"mock",
"bar",
"bar",
";",
"&",
"#",
"064",
";",
"before",
"public",
"void",
"before",
"(",
")",
"{",
"when",
"(",
"foo",
"foo",
"(",
")",
")",
"then",
"return",
"(",
"\"",
"ok",
"\"",
")",
";",
"it",
"is",
"better",
"to",
"configure",
"the",
"stubbing",
"to",
"be",
"lenient",
":",
"lenient",
"(",
")",
"when",
"(",
"foo",
"foo",
"(",
")",
")",
"then",
"return",
"(",
"\"",
"ok",
"\"",
")",
";",
"or",
"the",
"entire",
"mock",
"to",
"be",
"lenient",
":",
"foo",
"=",
"mock",
"(",
"foo",
"class",
",",
"with",
"settings",
"(",
")",
"lenient",
"(",
")",
")",
";",
"}",
"&",
"#",
"064",
";",
"test",
"public",
"void",
"test",
"1",
"(",
")",
"{",
"foo",
"foo",
"(",
")",
";",
"}",
"&",
"#",
"064",
";",
"test",
"public",
"void",
"test",
"2",
"(",
")",
"{",
"foo",
"foo",
"(",
")",
";",
"}",
"&",
"#",
"064",
";",
"test",
"public",
"void",
"test",
"3",
"(",
")",
"{",
"bar",
"bar",
"(",
")",
";",
"}",
"}",
"<",
"code",
">"
]
| [
"public",
"static",
"lenient",
"stubber",
"lenient",
"(",
")",
"{",
"return",
"mockito",
"core",
"lenient",
"(",
")",
";",
"}"
]
|
[
"public",
"version",
"of",
"{",
"@",
"link",
"class",
"loader",
"#",
"get",
"class",
"loading",
"lock",
"(",
"string",
")",
"}"
]
| [
"public",
"object",
"get",
"class",
"loading",
"lock",
"(",
"string",
"class",
"name",
")",
"{",
"return",
"super",
"get",
"class",
"loading",
"lock",
"(",
"class",
"name",
")",
";",
"}"
]
|
[
"the",
"center",
"about",
"which",
"to",
"apply",
"the",
"distortion",
",",
"with",
"a",
"default",
"of",
"(",
"0",
"5",
",",
"0",
"5",
")"
]
| [
"public",
"void",
"set",
"center",
"(",
"point",
"f",
"center",
")",
"{",
"this",
"center",
"=",
"center",
";",
"set",
"point",
"(",
"center",
"location",
",",
"center",
")",
";",
"}"
]
|
[
"return",
"the",
"initial",
"interval",
"in",
"milliseconds"
]
| [
"public",
"long",
"get",
"initial",
"interval",
"(",
")",
"{",
"return",
"this",
"initial",
"interval",
";",
"}"
]
|
[
"get",
"all",
"cached",
"blocks",
"which",
"contain",
"addr"
]
| [
"code",
"block",
"[",
"]",
"get",
"blocks",
"containing",
"(",
"address",
"addr",
")",
"{",
"object",
"[",
"]",
"objs",
"=",
"get",
"objects",
"(",
"addr",
")",
";",
"int",
"length",
"=",
"objs",
"length",
";",
"if",
"(",
"length",
"=",
"=",
"0",
")",
"{",
"return",
"null",
";",
"}",
"code",
"block",
"[",
"]",
"blocks",
"=",
"new",
"code",
"block",
"[",
"objs",
"length",
"]",
";",
"system",
"arraycopy",
"(",
"objs",
",",
"0",
",",
"blocks",
",",
"0",
",",
"length",
")",
";",
"return",
"blocks",
";",
"}"
]
|
[
"formats",
"the",
"specified",
"collection",
"path",
"parameter",
"to",
"a",
"string",
"value"
]
| [
"public",
"string",
"collection",
"path",
"parameter",
"to",
"string",
"(",
"string",
"collection",
"format",
",",
"collection",
"value",
")",
"{",
"/",
"/",
"create",
"the",
"value",
"based",
"on",
"the",
"collection",
"format",
"if",
"(",
"\"",
"multi",
"\"",
"equals",
"(",
"collection",
"format",
")",
")",
"{",
"/",
"/",
"not",
"valid",
"for",
"path",
"params",
"return",
"parameter",
"to",
"string",
"(",
"value",
")",
";",
"}",
"/",
"/",
"collection",
"format",
"is",
"assumed",
"to",
"be",
"\"",
"csv",
"\"",
"by",
"default",
"string",
"delimiter",
"=",
"\"",
",",
"\"",
";",
"if",
"(",
"\"",
"ssv",
"\"",
"equals",
"(",
"collection",
"format",
")",
")",
"{",
"delimiter",
"=",
"\"",
"\"",
";",
"}",
"else",
"if",
"(",
"\"",
"tsv",
"\"",
"equals",
"(",
"collection",
"format",
")",
")",
"{",
"delimiter",
"=",
"\"",
"\\",
"t",
"\"",
";",
"}",
"else",
"if",
"(",
"\"",
"pipes",
"\"",
"equals",
"(",
"collection",
"format",
")",
")",
"{",
"delimiter",
"=",
"\"",
"|",
"\"",
";",
"}",
"string",
"builder",
"sb",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"for",
"(",
"object",
"item",
":",
"value",
")",
"{",
"sb",
"append",
"(",
"delimiter",
")",
";",
"sb",
"append",
"(",
"parameter",
"to",
"string",
"(",
"item",
")",
")",
";",
"}",
"return",
"sb",
"substring",
"(",
"delimiter",
"length",
"(",
")",
")",
";",
"}"
]
|
[
"reset",
"all",
"of",
"the",
"hystrix",
"plugins",
"to",
"null",
"you",
"may",
"invoke",
"this",
"directly",
",",
"or",
"it",
"also",
"gets",
"invoked",
"via",
"<",
"code",
">",
"hystrix",
"reset",
"(",
")",
"<",
"code",
">"
]
| [
"public",
"static",
"void",
"reset",
"(",
")",
"{",
"get",
"instance",
"(",
")",
"notifier",
"set",
"(",
"null",
")",
";",
"get",
"instance",
"(",
")",
"concurrency",
"strategy",
"set",
"(",
"null",
")",
";",
"get",
"instance",
"(",
")",
"metrics",
"publisher",
"set",
"(",
"null",
")",
";",
"get",
"instance",
"(",
")",
"properties",
"factory",
"set",
"(",
"null",
")",
";",
"get",
"instance",
"(",
")",
"command",
"execution",
"hook",
"set",
"(",
"null",
")",
";",
"hystrix",
"metrics",
"publisher",
"factory",
"reset",
"(",
")",
";",
"}"
]
|
[
"{",
"@",
"inherit",
"doc",
"}",
"the",
"default",
"implementation",
"does",
"nothing"
]
| [
"@",
"override",
"public",
"void",
"enter",
"qualified",
"name",
"(",
"sql",
"base",
"parser",
"qualified",
"name",
"context",
"ctx",
")",
"{",
"}"
]
|
[
"returns",
"true",
"if",
"the",
"block",
"scanner",
"is",
"enabled",
"if",
"the",
"block",
"scanner",
"is",
"disabled",
",",
"no",
"volume",
"scanners",
"will",
"be",
"created",
",",
"and",
"no",
"threads",
"will",
"start"
]
| [
"public",
"boolean",
"is",
"enabled",
"(",
")",
"{",
"return",
"(",
"conf",
"scan",
"period",
"ms",
">",
"0",
")",
"&",
"&",
"(",
"conf",
"target",
"bytes",
"per",
"sec",
">",
"0",
")",
";",
"}"
]
|
[
"returns",
"the",
"common",
"super",
"type",
"of",
"the",
"two",
"given",
"types",
"the",
"default",
"implementation",
"of",
"this",
"method",
"loads",
"the",
"two",
"given",
"classes",
"and",
"uses",
"the",
"java",
"lang",
"class",
"methods",
"to",
"find",
"the",
"common",
"super",
"class",
"it",
"can",
"be",
"overridden",
"to",
"compute",
"this",
"common",
"super",
"type",
"in",
"other",
"ways",
",",
"in",
"particular",
"without",
"actually",
"loading",
"any",
"class",
",",
"or",
"to",
"take",
"into",
"account",
"the",
"class",
"that",
"is",
"currently",
"being",
"generated",
"by",
"this",
"class",
"writer",
",",
"which",
"can",
"of",
"course",
"not",
"be",
"loaded",
"since",
"it",
"is",
"under",
"construction"
]
| [
"protected",
"string",
"get",
"common",
"super",
"class",
"(",
"final",
"string",
"type",
"1",
",",
"final",
"string",
"type",
"2",
")",
"{",
"class",
"loader",
"class",
"loader",
"=",
"get",
"class",
"loader",
"(",
")",
";",
"class",
"<",
"?",
">",
"class",
"1",
";",
"try",
"{",
"class",
"1",
"=",
"class",
"for",
"name",
"(",
"type",
"1",
"replace",
"(",
"'",
"/",
"'",
",",
"'",
"'",
")",
",",
"false",
",",
"class",
"loader",
")",
";",
"}",
"catch",
"(",
"class",
"not",
"found",
"exception",
"e",
")",
"{",
"throw",
"new",
"type",
"not",
"present",
"exception",
"(",
"type",
"1",
",",
"e",
")",
";",
"}",
"class",
"<",
"?",
">",
"class",
"2",
";",
"try",
"{",
"class",
"2",
"=",
"class",
"for",
"name",
"(",
"type",
"2",
"replace",
"(",
"'",
"/",
"'",
",",
"'",
"'",
")",
",",
"false",
",",
"class",
"loader",
")",
";",
"}",
"catch",
"(",
"class",
"not",
"found",
"exception",
"e",
")",
"{",
"throw",
"new",
"type",
"not",
"present",
"exception",
"(",
"type",
"2",
",",
"e",
")",
";",
"}",
"if",
"(",
"class",
"1",
"is",
"assignable",
"from",
"(",
"class",
"2",
")",
")",
"{",
"return",
"type",
"1",
";",
"}",
"if",
"(",
"class",
"2",
"is",
"assignable",
"from",
"(",
"class",
"1",
")",
")",
"{",
"return",
"type",
"2",
";",
"}",
"if",
"(",
"class",
"1",
"is",
"interface",
"(",
")",
"|",
"|",
"class",
"2",
"is",
"interface",
"(",
")",
")",
"{",
"return",
"\"",
"java",
"/",
"lang",
"/",
"object",
"\"",
";",
"}",
"else",
"{",
"do",
"{",
"class",
"1",
"=",
"class",
"1",
"get",
"superclass",
"(",
")",
";",
"}",
"while",
"(",
"!",
"class",
"1",
"is",
"assignable",
"from",
"(",
"class",
"2",
")",
")",
";",
"return",
"class",
"1",
"get",
"name",
"(",
")",
"replace",
"(",
"'",
"'",
",",
"'",
"/",
"'",
")",
";",
"}",
"}"
]
|
[
"{",
"@",
"inherit",
"doc",
"}"
]
| [
"public",
"void",
"run",
"(",
")",
"{",
"log",
"info",
"(",
"this",
"get",
"service",
"name",
"(",
")",
"+",
"\"",
"service",
"started",
"\"",
")",
";",
"while",
"(",
"!",
"this",
"is",
"stopped",
"(",
")",
")",
"{",
"try",
"{",
"this",
"selector",
"select",
"(",
"1000",
")",
";",
"set",
"<",
"selection",
"key",
">",
"selected",
"=",
"this",
"selector",
"selected",
"keys",
"(",
")",
";",
"if",
"(",
"selected",
"!",
"=",
"null",
")",
"{",
"for",
"(",
"selection",
"key",
"k",
":",
"selected",
")",
"{",
"if",
"(",
"(",
"k",
"ready",
"ops",
"(",
")",
"&",
"selection",
"key",
"op",
"accept",
")",
"!",
"=",
"0",
")",
"{",
"socket",
"channel",
"sc",
"=",
"(",
"(",
"server",
"socket",
"channel",
")",
"k",
"channel",
"(",
")",
")",
"accept",
"(",
")",
";",
"if",
"(",
"sc",
"!",
"=",
"null",
")",
"{",
"h",
"a",
"service",
"log",
"info",
"(",
"\"",
"h",
"a",
"service",
"receive",
"new",
"connection",
",",
"\"",
"+",
"sc",
"socket",
"(",
")",
"get",
"remote",
"socket",
"address",
"(",
")",
")",
";",
"try",
"{",
"h",
"a",
"connection",
"conn",
"=",
"new",
"h",
"a",
"connection",
"(",
"h",
"a",
"service",
"this",
",",
"sc",
")",
";",
"conn",
"start",
"(",
")",
";",
"h",
"a",
"service",
"this",
"add",
"connection",
"(",
"conn",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"log",
"error",
"(",
"\"",
"new",
"h",
"a",
"connection",
"exception",
"\"",
",",
"e",
")",
";",
"sc",
"close",
"(",
")",
";",
"}",
"}",
"}",
"else",
"{",
"log",
"warn",
"(",
"\"",
"unexpected",
"ops",
"in",
"select",
"\"",
"+",
"k",
"ready",
"ops",
"(",
")",
")",
";",
"}",
"}",
"selected",
"clear",
"(",
")",
";",
"}",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"log",
"error",
"(",
"this",
"get",
"service",
"name",
"(",
")",
"+",
"\"",
"service",
"has",
"exception",
"\"",
",",
"e",
")",
";",
"}",
"}",
"log",
"info",
"(",
"this",
"get",
"service",
"name",
"(",
")",
"+",
"\"",
"service",
"end",
"\"",
")",
";",
"}"
]
|
[
"resumes",
"an",
"auto",
"follow",
"pattern",
"see",
"<",
"a",
"href",
"=",
"\"",
"https",
":",
"www",
"elastic",
"coguideenelasticsearchreferencecurrentccr",
"-",
"resume",
"-",
"auto",
"-",
"follow",
"-",
"pattern",
"html",
"\"",
">",
"the",
"docs",
"for",
"more"
]
| [
"public",
"acknowledged",
"response",
"resume",
"auto",
"follow",
"pattern",
"(",
"resume",
"auto",
"follow",
"pattern",
"request",
"request",
",",
"request",
"options",
"options",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"rest",
"high",
"level",
"client",
"perform",
"request",
"and",
"parse",
"entity",
"(",
"request",
",",
"ccr",
"request",
"converters",
":",
":",
"resume",
"auto",
"follow",
"pattern",
",",
"options",
",",
"acknowledged",
"response",
":",
":",
"from",
"x",
"content",
",",
"collections",
"empty",
"set",
"(",
")",
")",
";",
"}"
]
|
[
"find",
"the",
"fields",
"constant",
"that",
"matches",
"name",
",",
"or",
"null",
"if",
"its",
"not",
"found"
]
| [
"public",
"static",
"fields",
"find",
"by",
"name",
"(",
"string",
"name",
")",
"{",
"return",
"by",
"name",
"get",
"(",
"name",
")",
";",
"}"
]
|
[
"tracks",
"the",
"given",
"new",
"runnable",
"app",
"for",
"purposes",
"of",
"maintaining",
"max",
"running",
"app",
"limits"
]
| [
"public",
"void",
"track",
"runnable",
"app",
"(",
"f",
"s",
"app",
"attempt",
"app",
")",
"{",
"string",
"user",
"=",
"app",
"get",
"user",
"(",
")",
";",
"f",
"s",
"leaf",
"queue",
"queue",
"=",
"app",
"get",
"queue",
"(",
")",
";",
"/",
"/",
"increment",
"running",
"counts",
"for",
"all",
"parent",
"queues",
"f",
"s",
"parent",
"queue",
"parent",
"=",
"queue",
"get",
"parent",
"(",
")",
";",
"while",
"(",
"parent",
"!",
"=",
"null",
")",
"{",
"parent",
"increment",
"runnable",
"apps",
"(",
")",
";",
"parent",
"=",
"parent",
"get",
"parent",
"(",
")",
";",
"}",
"integer",
"user",
"num",
"runnable",
"=",
"users",
"num",
"runnable",
"apps",
"get",
"(",
"user",
")",
";",
"users",
"num",
"runnable",
"apps",
"put",
"(",
"user",
",",
"(",
"user",
"num",
"runnable",
"=",
"=",
"null",
"?",
"0",
":",
"user",
"num",
"runnable",
")",
"+",
"1",
")",
";",
"}"
]
|
[
"get",
"stats",
"about",
"stomp",
"broker",
"relay",
"(",
"when",
"using",
"a",
"full",
"-",
"featured",
"stomp",
"broker",
")"
]
| [
"public",
"string",
"get",
"stomp",
"broker",
"relay",
"stats",
"info",
"(",
")",
"{",
"return",
"(",
"this",
"stomp",
"broker",
"relay",
"!",
"=",
"null",
"?",
"this",
"stomp",
"broker",
"relay",
"get",
"stats",
"info",
"(",
")",
":",
"\"",
"null",
"\"",
")",
";",
"}"
]
|
[
"creates",
"the",
"program",
"'",
"s",
"{",
"@",
"link",
"plan",
"}",
"the",
"plan",
"is",
"a",
"description",
"of",
"all",
"data",
"sources",
",",
"data",
"sinks",
",",
"and",
"operations",
"and",
"how",
"they",
"interact",
",",
"as",
"an",
"isolated",
"unit",
"that",
"can",
"be",
"executed",
"with",
"an",
"{",
"@",
"link",
"pipeline",
"executor",
"}",
"obtaining",
"a",
"plan",
"and",
"starting",
"it",
"with",
"an",
"executor",
"is",
"an",
"alternative",
"way",
"to",
"run",
"a",
"program",
"and",
"is",
"only",
"possible",
"if",
"the",
"program",
"consists",
"only",
"of",
"distributed",
"operations",
"this",
"automatically",
"starts",
"a",
"new",
"stage",
"of",
"execution"
]
| [
"public",
"plan",
"create",
"program",
"plan",
"(",
"string",
"job",
"name",
")",
"{",
"return",
"create",
"program",
"plan",
"(",
"job",
"name",
",",
"true",
")",
";",
"}"
]
|
[
"incorporates",
"a",
"new",
"item",
"this",
"assumes",
"the",
"type",
"name",
"matches"
]
| [
"public",
"void",
"add",
"(",
"item",
"item",
")",
"{",
"int",
"size",
"=",
"item",
"write",
"size",
"(",
")",
";",
"count",
"+",
"+",
";",
"total",
"size",
"+",
"=",
"size",
";",
"if",
"(",
"size",
">",
"largest",
"size",
")",
"{",
"largest",
"size",
"=",
"size",
";",
"}",
"if",
"(",
"size",
"<",
"smallest",
"size",
")",
"{",
"smallest",
"size",
"=",
"size",
";",
"}",
"}"
]
|
[
"the",
"keys",
"that",
",",
"when",
"this",
"diff",
"is",
"applied",
"to",
"a",
"map",
",",
"should",
"be",
"removed",
"from",
"the",
"map"
]
| [
"public",
"list",
"<",
"k",
">",
"get",
"deletes",
"(",
")",
"{",
"return",
"deletes",
";",
"}"
]
|
[
"add",
"an",
"inode",
"into",
"parent",
"'",
"s",
"children",
"list",
"the",
"caller",
"of",
"this",
"method",
"needs",
"to",
"make",
"sure",
"that",
"parent",
"is",
"in",
"the",
"given",
"snapshot",
"\"",
"latest",
"\""
]
| [
"public",
"boolean",
"add",
"child",
"(",
"i",
"node",
"directory",
"parent",
",",
"i",
"node",
"inode",
",",
"boolean",
"set",
"mod",
"time",
",",
"int",
"latest",
"snapshot",
"id",
")",
"{",
"children",
"diff",
"diff",
"=",
"diffs",
"check",
"and",
"add",
"latest",
"snapshot",
"diff",
"(",
"latest",
"snapshot",
"id",
",",
"parent",
")",
"diff",
";",
"final",
"int",
"undo",
"info",
"=",
"diff",
"create",
"(",
"inode",
")",
";",
"boolean",
"added",
"=",
"false",
";",
"try",
"{",
"added",
"=",
"parent",
"add",
"child",
"(",
"inode",
",",
"set",
"mod",
"time",
",",
"snapshot",
"current",
"state",
"id",
")",
";",
"}",
"finally",
"{",
"if",
"(",
"!",
"added",
")",
"{",
"diff",
"undo",
"create",
"(",
"inode",
",",
"undo",
"info",
")",
";",
"}",
"}",
"return",
"added",
";",
"}"
]
|
[
"constructs",
"a",
"{",
"@",
"code",
"hash",
"multimap",
"}",
"with",
"the",
"same",
"mappings",
"as",
"the",
"specified",
"multimap",
"if",
"a",
"key",
"-",
"value",
"mapping",
"appears",
"multiple",
"times",
"in",
"the",
"input",
"multimap",
",",
"it",
"only",
"appears",
"once",
"in",
"the",
"constructed",
"multimap",
"this",
"method",
"will",
"soon",
"be",
"deprecated",
"in",
"favor",
"of",
"{",
"@",
"code",
"multimap",
"builder",
"hash",
"keys",
"(",
")",
"hash",
"set",
"values",
"(",
")",
"build",
"(",
"multimap",
")",
"}"
]
| [
"public",
"static",
"<",
"k",
",",
"v",
">",
"hash",
"multimap",
"<",
"k",
",",
"v",
">",
"create",
"(",
"multimap",
"<",
"?",
"extends",
"k",
",",
"?",
"extends",
"v",
">",
"multimap",
")",
"{",
"return",
"new",
"hash",
"multimap",
"<",
">",
"(",
"multimap",
")",
";",
"}"
]
|
[
"calculate",
"the",
"number",
"of",
"levels",
"needed",
"for",
"a",
"specific",
"precision",
"quadtree",
"cells",
"will",
"not",
"exceed",
"the",
"specified",
"size",
"(",
"diagonal",
")",
"of",
"the",
"precision"
]
| [
"public",
"static",
"int",
"quad",
"tree",
"levels",
"for",
"precision",
"(",
"double",
"meters",
")",
"{",
"assert",
"meters",
">",
"=",
"0",
";",
"if",
"(",
"meters",
"=",
"=",
"0",
")",
"{",
"return",
"quad",
"prefix",
"tree",
"max",
"levels",
"possible",
";",
"}",
"else",
"{",
"final",
"double",
"ratio",
"=",
"1",
"+",
"(",
"earth",
"polar",
"distance",
"/",
"earth",
"equator",
")",
";",
"/",
"/",
"cell",
"ratio",
"final",
"double",
"width",
"=",
"math",
"sqrt",
"(",
"(",
"meters",
"*",
"meters",
")",
"/",
"(",
"ratio",
"*",
"ratio",
")",
")",
";",
"/",
"/",
"convert",
"to",
"cell",
"width",
"final",
"long",
"part",
"=",
"math",
"round",
"(",
"math",
"ceil",
"(",
"earth",
"equator",
"/",
"width",
")",
")",
";",
"final",
"int",
"level",
"=",
"long",
"size",
"-",
"long",
"number",
"of",
"leading",
"zeros",
"(",
"part",
")",
"-",
"1",
";",
"/",
"/",
"(",
"log",
"2",
")",
"return",
"(",
"part",
"<",
"=",
"(",
"1l",
"<",
"<",
"level",
")",
")",
"?",
"level",
":",
"(",
"level",
"+",
"1",
")",
";",
"/",
"/",
"adjust",
"level",
"}",
"}"
]
|
[
"checks",
"a",
"security",
"questions",
"answer"
]
| [
"default",
"boolean",
"is",
"valid",
"security",
"question",
"answer",
"(",
"final",
"string",
"username",
",",
"final",
"string",
"question",
",",
"final",
"string",
"answer",
",",
"final",
"string",
"input",
")",
"{",
"return",
"string",
"utils",
"is",
"not",
"blank",
"(",
"answer",
")",
"&",
"&",
"answer",
"equals",
"(",
"input",
")",
";",
"}"
]
|
[
"read",
"user",
"content",
"type",
"and",
"name",
"from",
"packed",
"file"
]
| [
"private",
"void",
"read",
"content",
"type",
"and",
"name",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"item",
"deserializer",
"item",
"deserializer",
"=",
"null",
";",
"if",
"(",
"packed",
"db",
"lock",
"!",
"=",
"null",
")",
"{",
"lock",
"(",
"packed",
"db",
"lock",
",",
"true",
",",
"true",
")",
";",
"}",
"try",
"{",
"item",
"deserializer",
"=",
"new",
"item",
"deserializer",
"(",
"packed",
"db",
"file",
")",
";",
"if",
"(",
"item",
"deserializer",
"get",
"file",
"type",
"(",
")",
"!",
"=",
"folder",
"item",
"database",
"file",
"type",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"incorrect",
"file",
"type",
"\"",
")",
";",
"}",
"content",
"type",
"=",
"item",
"deserializer",
"get",
"content",
"type",
"(",
")",
";",
"item",
"name",
"=",
"item",
"deserializer",
"get",
"item",
"name",
"(",
")",
";",
"}",
"finally",
"{",
"if",
"(",
"item",
"deserializer",
"!",
"=",
"null",
")",
"{",
"item",
"deserializer",
"dispose",
"(",
")",
";",
"}",
"if",
"(",
"packed",
"db",
"lock",
"!",
"=",
"null",
")",
"{",
"packed",
"db",
"lock",
"remove",
"lock",
"(",
")",
";",
"}",
"}",
"}"
]
|
[
"records",
"the",
"failed",
"load",
"of",
"a",
"new",
"entry",
"this",
"should",
"be",
"called",
"when",
"a",
"cache",
"request",
"causes",
"an",
"entry",
"to",
"be",
"loaded",
",",
"but",
"an",
"exception",
"is",
"thrown",
"while",
"loading",
"the",
"entry",
"in",
"contrast",
"to",
"{",
"@",
"link",
"#",
"record",
"misses",
"}",
",",
"this",
"method",
"should",
"only",
"be",
"called",
"by",
"the",
"loading",
"thread"
]
| [
"void",
"record",
"load",
"exception",
"(",
"long",
"load",
"time",
")",
";"
]
|
[
"write",
"the",
"given",
"source",
"into",
"this",
"buffer",
",",
"starting",
"at",
"the",
"current",
"writing",
"position",
"of",
"this",
"buffer"
]
| [
"data",
"buffer",
"write",
"(",
"byte",
"[",
"]",
"source",
")",
";"
]
|
[
"creates",
"a",
"{",
"@",
"link",
"server",
"stream",
"tracer",
"}",
"for",
"a",
"new",
"server",
"stream",
"called",
"right",
"before",
"the",
"stream",
"is",
"created"
]
| [
"public",
"abstract",
"server",
"stream",
"tracer",
"new",
"server",
"stream",
"tracer",
"(",
"string",
"full",
"method",
"name",
",",
"metadata",
"headers",
")",
";"
]
|
[
"gets",
"the",
"value",
"of",
"the",
"name",
"property",
"this",
"accessor",
"method",
"returns",
"a",
"reference",
"to",
"the",
"live",
"list",
",",
"not",
"a",
"snapshot",
"therefore",
"any",
"modification",
"you",
"make",
"to",
"the",
"returned",
"list",
"will",
"be",
"present",
"inside",
"the",
"jaxb",
"object",
"this",
"is",
"why",
"there",
"is",
"not",
"a",
"<",
"code",
">",
"set",
"<",
"code",
">",
"method",
"for",
"the",
"name",
"property",
"for",
"example",
",",
"to",
"add",
"a",
"new",
"item",
",",
"do",
"as",
"follows",
":",
"get",
"name",
"(",
")",
"add",
"(",
"new",
"item",
")",
";",
"objects",
"of",
"the",
"following",
"type",
"(",
"s",
")",
"are",
"allowed",
"in",
"the",
"list",
"{",
"@",
"link",
"string",
"}"
]
| [
"public",
"list",
"<",
"string",
">",
"get",
"name",
"(",
")",
"{",
"if",
"(",
"name",
"=",
"=",
"null",
")",
"{",
"name",
"=",
"new",
"array",
"list",
"<",
"string",
">",
"(",
")",
";",
"}",
"return",
"this",
"name",
";",
"}"
]
|
[
"enable",
"or",
"disable",
"verbose",
"mode"
]
| [
"public",
"simulate",
"pipeline",
"request",
"builder",
"set",
"verbose",
"(",
"boolean",
"verbose",
")",
"{",
"request",
"set",
"verbose",
"(",
"verbose",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"this",
"gets",
"called",
"when",
"a",
"merge",
"occurs"
]
| [
"void",
"merge",
"(",
"w",
"merge",
"result",
",",
"collection",
"<",
"w",
">",
"merged",
"windows",
",",
"w",
"state",
"window",
"result",
",",
"collection",
"<",
"w",
">",
"merged",
"state",
"windows",
")",
"throws",
"exception",
";"
]
|
[
"derive",
"a",
"default",
"sql",
"type",
"from",
"the",
"given",
"java",
"type"
]
| [
"public",
"static",
"int",
"java",
"type",
"to",
"sql",
"parameter",
"type",
"(",
"@",
"nullable",
"class",
"<",
"?",
">",
"java",
"type",
")",
"{",
"if",
"(",
"java",
"type",
"=",
"=",
"null",
")",
"{",
"return",
"sql",
"type",
"value",
"type",
"unknown",
";",
"}",
"integer",
"sql",
"type",
"=",
"java",
"type",
"to",
"sql",
"type",
"map",
"get",
"(",
"java",
"type",
")",
";",
"if",
"(",
"sql",
"type",
"!",
"=",
"null",
")",
"{",
"return",
"sql",
"type",
";",
"}",
"if",
"(",
"number",
"class",
"is",
"assignable",
"from",
"(",
"java",
"type",
")",
")",
"{",
"return",
"types",
"numeric",
";",
"}",
"if",
"(",
"is",
"string",
"value",
"(",
"java",
"type",
")",
")",
"{",
"return",
"types",
"varchar",
";",
"}",
"if",
"(",
"is",
"date",
"value",
"(",
"java",
"type",
")",
"|",
"|",
"calendar",
"class",
"is",
"assignable",
"from",
"(",
"java",
"type",
")",
")",
"{",
"return",
"types",
"timestamp",
";",
"}",
"return",
"sql",
"type",
"value",
"type",
"unknown",
";",
"}"
]
|
[
"schedules",
"a",
"shuffle",
"setting",
"action",
"to",
"be",
"executed"
]
| [
"public",
"builder",
"set",
"shuffle",
"mode",
"enabled",
"(",
"boolean",
"shuffle",
"mode",
"enabled",
")",
"{",
"return",
"apply",
"(",
"new",
"set",
"shuffle",
"mode",
"enabled",
"(",
"tag",
",",
"shuffle",
"mode",
"enabled",
")",
")",
";",
"}"
]
|
[
"returns",
"the",
"current",
"conflict",
"associated",
"with",
"this",
"block"
]
| [
"public",
"instruction",
"error",
"get",
"instruction",
"conflict",
"(",
")",
"{",
"return",
"instruction",
"error",
";",
"}"
]
|
[
"returns",
"a",
"comment",
"string",
"containing",
"extra",
"information",
"about",
"the",
"export"
]
| [
"public",
"string",
"get",
"comment",
"(",
")",
"{",
"return",
"comment",
";",
"}"
]
|
[
"combine",
"the",
"encodings",
"and",
"backfills",
"of",
"the",
"given",
"resolution",
"into",
"this",
"one",
"this",
"combines",
"corresponding",
"pattern",
"blocks",
"(",
"assuming",
"they",
"agree",
")",
",",
"collects",
"backfill",
"records",
",",
"and",
"collects",
"forbidden",
"patterns"
]
| [
"public",
"assembly",
"resolved",
"constructor",
"combine",
"(",
"assembly",
"resolved",
"constructor",
"that",
")",
"{",
"/",
"/",
"not",
"really",
"a",
"backfill",
",",
"but",
"i",
"would",
"like",
"to",
"re",
"-",
"use",
"code",
"return",
"combine",
"less",
"backfill",
"(",
"that",
",",
"null",
")",
";",
"}"
]
|
[
"calculates",
"the",
"{",
"@",
"link",
"s",
"c",
"m",
"revision",
"state",
"}",
"that",
"represents",
"the",
"state",
"of",
"the",
"workspace",
"of",
"the",
"given",
"build",
"the",
"returned",
"object",
"is",
"then",
"fed",
"into",
"the",
"{",
"@",
"link",
"#",
"compare",
"remote",
"revision",
"with",
"(",
"abstract",
"project",
",",
"launcher",
",",
"file",
"path",
",",
"task",
"listener",
",",
"s",
"c",
"m",
"revision",
"state",
")",
"}",
"method",
"as",
"the",
"baseline",
"{",
"@",
"link",
"s",
"c",
"m",
"revision",
"state",
"}",
"to",
"determine",
"if",
"the",
"build",
"is",
"necessary",
"this",
"method",
"is",
"called",
"after",
"source",
"code",
"is",
"checked",
"out",
"for",
"the",
"given",
"build",
"(",
"that",
"is",
",",
"after",
"{",
"@",
"link",
"scm",
"#",
"checkout",
"(",
"run",
",",
"launcher",
",",
"file",
"path",
",",
"task",
"listener",
",",
"file",
",",
"s",
"c",
"m",
"revision",
"state",
")",
"}",
"has",
"finished",
"successfully",
")",
"the",
"obtained",
"object",
"is",
"added",
"to",
"the",
"build",
"as",
"an",
"{",
"@",
"link",
"action",
"}",
"for",
"later",
"retrieval",
"as",
"an",
"optimization",
",",
"{",
"@",
"link",
"scm",
"}",
"implementation",
"can",
"choose",
"to",
"compute",
"{",
"@",
"link",
"s",
"c",
"m",
"revision",
"state",
"}",
"and",
"add",
"it",
"as",
"an",
"action",
"during",
"check",
"out",
",",
"in",
"which",
"case",
"this",
"method",
"will",
"not",
"called"
]
| [
"public",
"@",
"check",
"for",
"null",
"s",
"c",
"m",
"revision",
"state",
"calc",
"revisions",
"from",
"build",
"(",
"@",
"non",
"null",
"run",
"<",
"?",
",",
"?",
">",
"build",
",",
"@",
"nullable",
"file",
"path",
"workspace",
",",
"@",
"nullable",
"launcher",
"launcher",
",",
"@",
"non",
"null",
"task",
"listener",
"listener",
")",
"throws",
"i",
"o",
"exception",
",",
"interrupted",
"exception",
"{",
"if",
"(",
"build",
"instanceof",
"abstract",
"build",
"&",
"&",
"util",
"is",
"overridden",
"(",
"scm",
"class",
",",
"get",
"class",
"(",
")",
",",
"\"",
"calc",
"revisions",
"from",
"build",
"\"",
",",
"abstract",
"build",
"class",
",",
"launcher",
"class",
",",
"task",
"listener",
"class",
")",
")",
"{",
"return",
"calc",
"revisions",
"from",
"build",
"(",
"(",
"abstract",
"build",
")",
"build",
",",
"launcher",
",",
"listener",
")",
";",
"}",
"else",
"{",
"throw",
"new",
"abstract",
"method",
"error",
"(",
"\"",
"you",
"must",
"override",
"the",
"new",
"calc",
"revisions",
"from",
"build",
"overload",
"\"",
")",
";",
"}",
"}"
]
|
[
"handle",
"case",
"where",
"a",
"disco",
"node",
"cannot",
"be",
"found",
"in",
"the",
"routing",
"table",
"usually",
"means",
"that",
"it",
"'",
"s",
"not",
"a",
"data",
"node"
]
| [
"protected",
"reroute",
"explanation",
"explain",
"or",
"throw",
"missing",
"routing",
"node",
"(",
"routing",
"allocation",
"allocation",
",",
"boolean",
"explain",
",",
"discovery",
"node",
"disco",
"node",
")",
"{",
"if",
"(",
"!",
"disco",
"node",
"is",
"data",
"node",
"(",
")",
")",
"{",
"return",
"explain",
"or",
"throw",
"rejected",
"command",
"(",
"explain",
",",
"allocation",
",",
"\"",
"allocation",
"can",
"only",
"be",
"done",
"on",
"data",
"nodes",
",",
"not",
"[",
"\"",
"+",
"node",
"+",
"\"",
"]",
"\"",
")",
";",
"}",
"else",
"{",
"return",
"explain",
"or",
"throw",
"rejected",
"command",
"(",
"explain",
",",
"allocation",
",",
"\"",
"could",
"not",
"find",
"[",
"\"",
"+",
"node",
"+",
"\"",
"]",
"among",
"the",
"routing",
"nodes",
"\"",
")",
";",
"}",
"}"
]
|
[
"set",
"the",
"motor",
"speed",
",",
"usually",
"in",
"meters",
"per",
"second"
]
| [
"public",
"void",
"set",
"motor",
"speed",
"(",
"float",
"speed",
")",
"{",
"m",
"body",
"a",
"set",
"awake",
"(",
"true",
")",
";",
"m",
"body",
"b",
"set",
"awake",
"(",
"true",
")",
";",
"m",
"motor",
"speed",
"=",
"speed",
";",
"}"
]
|
[
"use",
"alternate",
"mutation",
"accessors",
"instead"
]
| [
"public",
"java",
"util",
"map",
"<",
"java",
"lang",
"string",
",",
"java",
"lang",
"string",
">",
"get",
"mutable",
"selector",
"(",
")",
"{",
"return",
"internal",
"get",
"mutable",
"selector",
"(",
")",
"get",
"mutable",
"map",
"(",
")",
";",
"}"
]
|
[
"returns",
"the",
"number",
"of",
"keys",
"currently",
"in",
"the",
"set"
]
| [
"public",
"int",
"size",
"(",
")",
"{",
"return",
"num",
"keys",
";",
"}"
]
|
[
"assert",
"that",
"an",
"entry",
"does",
"not",
"exist"
]
| [
"protected",
"void",
"assert",
"not",
"found",
"(",
"string",
"path",
"str",
")",
"throws",
"i",
"o",
"exception",
"{",
"path",
"metadata",
"meta",
"=",
"get",
"(",
"path",
"str",
")",
";",
"assert",
"null",
"(",
"\"",
"unexpectedly",
"found",
"entry",
"at",
"path",
"\"",
"+",
"path",
"str",
",",
"meta",
")",
";",
"}"
]
|
[
"method",
"to",
"provide",
"the",
"warning",
"message",
"it",
"gives",
"the",
"custom",
"message",
"if",
"non",
"-",
"null",
",",
"and",
"default",
"message",
"otherwise"
]
| [
"private",
"string",
"get",
"warning",
"message",
"(",
"string",
"key",
",",
"string",
"source",
")",
"{",
"string",
"warning",
"message",
";",
"if",
"(",
"custom",
"message",
"=",
"=",
"null",
")",
"{",
"string",
"builder",
"message",
"=",
"new",
"string",
"builder",
"(",
"key",
")",
";",
"if",
"(",
"source",
"!",
"=",
"null",
")",
"{",
"message",
"append",
"(",
"\"",
"in",
"\"",
"+",
"source",
")",
";",
"}",
"message",
"append",
"(",
"\"",
"is",
"deprecated",
"instead",
",",
"use",
"\"",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"new",
"keys",
"length",
";",
"i",
"+",
"+",
")",
"{",
"message",
"append",
"(",
"new",
"keys",
"[",
"i",
"]",
")",
";",
"if",
"(",
"i",
"!",
"=",
"new",
"keys",
"length",
"-",
"1",
")",
"{",
"message",
"append",
"(",
"\"",
",",
"\"",
")",
";",
"}",
"}",
"warning",
"message",
"=",
"message",
"to",
"string",
"(",
")",
";",
"}",
"else",
"{",
"warning",
"message",
"=",
"custom",
"message",
";",
"}",
"return",
"warning",
"message",
";",
"}"
]
|
[
"this",
"function",
"first",
"tries",
"to",
"apply",
"the",
"delta",
"without",
"any",
"offset",
",",
"if",
"that",
"fails",
",",
"then",
"it",
"tries",
"to",
"apply",
"the",
"delta",
"with",
"an",
"offset",
",",
"starting",
"from",
"1",
",",
"up",
"to",
"the",
"total",
"lines",
"in",
"the",
"original",
"content",
"for",
"every",
"offset",
",",
"we",
"try",
"both",
"forwards",
"and",
"backwards"
]
| [
"private",
"static",
"void",
"apply",
"to",
"(",
"abstract",
"delta",
"<",
"string",
">",
"delta",
",",
"list",
"<",
"string",
">",
"result",
")",
"throws",
"patch",
"failed",
"exception",
"{",
"patch",
"failed",
"exception",
"e",
"=",
"apply",
"delta",
"(",
"delta",
",",
"result",
")",
";",
"if",
"(",
"e",
"=",
"=",
"null",
")",
"{",
"return",
";",
"}",
"chunk",
"<",
"string",
">",
"original",
"=",
"delta",
"get",
"source",
"(",
")",
";",
"chunk",
"<",
"string",
">",
"revised",
"=",
"delta",
"get",
"target",
"(",
")",
";",
"int",
"[",
"]",
"direction",
"=",
"{",
"1",
",",
"-",
"1",
"}",
";",
"int",
"max",
"offset",
"=",
"result",
"size",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"1",
";",
"i",
"<",
"max",
"offset",
";",
"i",
"+",
"+",
")",
"{",
"for",
"(",
"int",
"j",
"=",
"0",
";",
"j",
"<",
"2",
";",
"j",
"+",
"+",
")",
"{",
"int",
"offset",
"=",
"i",
"*",
"direction",
"[",
"j",
"]",
";",
"if",
"(",
"offset",
"+",
"original",
"get",
"position",
"(",
")",
"<",
"0",
"|",
"|",
"offset",
"+",
"revised",
"get",
"position",
"(",
")",
"<",
"0",
")",
"{",
"continue",
";",
"}",
"chunk",
"<",
"string",
">",
"source",
"=",
"new",
"chunk",
"<",
">",
"(",
"original",
"get",
"position",
"(",
")",
"+",
"offset",
",",
"original",
"get",
"lines",
"(",
")",
")",
";",
"chunk",
"<",
"string",
">",
"target",
"=",
"new",
"chunk",
"<",
">",
"(",
"revised",
"get",
"position",
"(",
")",
"+",
"offset",
",",
"revised",
"get",
"lines",
"(",
")",
")",
";",
"abstract",
"delta",
"<",
"string",
">",
"new",
"delta",
"=",
"null",
";",
"switch",
"(",
"delta",
"get",
"type",
"(",
")",
")",
"{",
"case",
"change",
":",
"new",
"delta",
"=",
"new",
"change",
"delta",
"<",
">",
"(",
"source",
",",
"target",
")",
";",
"break",
";",
"case",
"insert",
":",
"new",
"delta",
"=",
"new",
"insert",
"delta",
"<",
">",
"(",
"source",
",",
"target",
")",
";",
"break",
";",
"case",
"delete",
":",
"new",
"delta",
"=",
"new",
"delete",
"delta",
"<",
">",
"(",
"source",
",",
"target",
")",
";",
"break",
";",
"case",
"equal",
":",
"}",
"patch",
"failed",
"exception",
"exception",
"=",
"null",
";",
"if",
"(",
"new",
"delta",
"!",
"=",
"null",
")",
"{",
"exception",
"=",
"apply",
"delta",
"(",
"new",
"delta",
",",
"result",
")",
";",
"}",
"if",
"(",
"exception",
"=",
"=",
"null",
")",
"{",
"return",
";",
"}",
"}",
"}",
"throw",
"e",
";",
"}"
]
|
[
"sets",
"the",
"length",
"of",
"the",
"transition",
"in",
"seconds"
]
| [
"public",
"void",
"set",
"duration",
"(",
"float",
"duration",
")",
"{",
"this",
"duration",
"=",
"duration",
";",
"}"
]
|
[
"copies",
"this",
"record",
"into",
"the",
"new",
"stream",
"record",
"uses",
"the",
"copied",
"value",
"as",
"the",
"value",
"for",
"the",
"new",
"record",
",",
"i",
"e",
",",
"only",
"copies",
"timestamp",
"fields"
]
| [
"public",
"void",
"copy",
"to",
"(",
"t",
"value",
"copy",
",",
"stream",
"record",
"<",
"t",
">",
"target",
")",
"{",
"target",
"value",
"=",
"value",
"copy",
";",
"target",
"timestamp",
"=",
"this",
"timestamp",
";",
"target",
"has",
"timestamp",
"=",
"this",
"has",
"timestamp",
";",
"}"
]
|
[
"get",
"the",
"minimal",
"threshold",
"for",
"the",
"frequency",
"of",
"a",
"term",
"appearing",
"in",
"the",
"document",
"set",
"setting"
]
| [
"public",
"float",
"min",
"doc",
"freq",
"(",
")",
"{",
"return",
"min",
"doc",
"freq",
";",
"}"
]
|
[
"determine",
"a",
"target",
"source",
"for",
"the",
"given",
"target",
"(",
"or",
"target",
"source",
")"
]
| [
"protected",
"target",
"source",
"create",
"target",
"source",
"(",
"object",
"target",
")",
"{",
"if",
"(",
"target",
"instanceof",
"target",
"source",
")",
"{",
"return",
"(",
"target",
"source",
")",
"target",
";",
"}",
"else",
"{",
"return",
"new",
"singleton",
"target",
"source",
"(",
"target",
")",
";",
"}",
"}"
]
|
[
"searches",
"for",
"factories",
"using",
"java",
"service",
"providers"
]
| [
"private",
"static",
"list",
"<",
"table",
"factory",
">",
"discover",
"factories",
"(",
"optional",
"<",
"class",
"loader",
">",
"class",
"loader",
")",
"{",
"try",
"{",
"list",
"<",
"table",
"factory",
">",
"result",
"=",
"new",
"linked",
"list",
"<",
">",
"(",
")",
";",
"class",
"loader",
"cl",
"=",
"class",
"loader",
"or",
"else",
"(",
"thread",
"current",
"thread",
"(",
")",
"get",
"context",
"class",
"loader",
"(",
")",
")",
";",
"service",
"loader",
"load",
"(",
"table",
"factory",
"class",
",",
"cl",
")",
"iterator",
"(",
")",
"for",
"each",
"remaining",
"(",
"result",
":",
":",
"add",
")",
";",
"return",
"result",
";",
"}",
"catch",
"(",
"service",
"configuration",
"error",
"e",
")",
"{",
"log",
"error",
"(",
"\"",
"could",
"not",
"load",
"service",
"provider",
"for",
"table",
"factories",
"\"",
",",
"e",
")",
";",
"throw",
"new",
"table",
"exception",
"(",
"\"",
"could",
"not",
"load",
"service",
"provider",
"for",
"table",
"factories",
"\"",
",",
"e",
")",
";",
"}",
"}"
]
|
[
"path",
"to",
"a",
"file",
"within",
"the",
"apk",
"(",
"typically",
"restype",
"-",
"configentry",
"ext",
")",
"<",
"code",
">",
"optional",
"string",
"path",
"=",
"1",
";",
"<",
"code",
">"
]
| [
"private",
"void",
"clear",
"path",
"(",
")",
"{",
"bit",
"field",
"0",
"=",
"(",
"bit",
"field",
"0",
"&",
"~",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"1",
")",
";",
"path",
"=",
"get",
"default",
"instance",
"(",
")",
"get",
"path",
"(",
")",
";",
"}"
]
|
[
"patch",
"another",
"-",
"fakedummy",
":",
"to",
"test",
"special",
"tags",
"to",
"test",
"special",
"tags",
"and",
"operation",
"id",
"starting",
"with",
"number"
]
| [
"response",
"entity",
"<",
"client",
">",
"call",
"1",
"2",
"3test",
"special",
"tags",
"(",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"client",
"model",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"valid",
"@",
"request",
"body",
"client",
"body",
")",
";"
]
|
[
"dump",
"the",
"filesystem",
"via",
"a",
"treewalk",
"if",
"metastore",
"entries",
"mark",
"directories",
"as",
"deleted",
",",
"this",
"walk",
"will",
"not",
"explore",
"them"
]
| [
"protected",
"long",
"treewalk",
"filesystem",
"(",
"final",
"csv",
"file",
"csv",
",",
"final",
"path",
"base",
")",
"throws",
"i",
"o",
"exception",
"{",
"array",
"deque",
"<",
"path",
">",
"queue",
"=",
"new",
"array",
"deque",
"<",
">",
"(",
")",
";",
"queue",
"add",
"(",
"base",
")",
";",
"long",
"count",
"=",
"0",
";",
"while",
"(",
"!",
"queue",
"is",
"empty",
"(",
")",
")",
"{",
"path",
"path",
"=",
"queue",
"pop",
"(",
")",
";",
"count",
"+",
"+",
";",
"file",
"status",
"[",
"]",
"file",
"statuses",
";",
"try",
"{",
"file",
"statuses",
"=",
"get",
"filesystem",
"(",
")",
"list",
"status",
"(",
"path",
")",
";",
"}",
"catch",
"(",
"file",
"not",
"found",
"exception",
"e",
")",
"{",
"log",
"warn",
"(",
"\"",
"file",
"{",
"}",
"was",
"not",
"found",
"\"",
",",
"path",
")",
";",
"continue",
";",
"}",
"/",
"/",
"entries",
"for",
"(",
"file",
"status",
"file",
"status",
":",
"file",
"statuses",
")",
"{",
"csv",
"entry",
"(",
"(",
"s",
"3",
"a",
"file",
"status",
")",
"file",
"status",
")",
";",
"}",
"/",
"/",
"scan",
"through",
"the",
"list",
",",
"building",
"up",
"a",
"reverse",
"list",
"of",
"all",
"directories",
"/",
"/",
"found",
"list",
"<",
"path",
">",
"dirs",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"file",
"statuses",
"length",
")",
";",
"for",
"(",
"file",
"status",
"file",
"status",
":",
"file",
"statuses",
")",
"{",
"if",
"(",
"file",
"status",
"is",
"directory",
"(",
")",
"&",
"&",
"!",
"(",
"file",
"status",
"get",
"path",
"(",
")",
"equals",
"(",
"path",
")",
")",
")",
"{",
"/",
"/",
"directory",
":",
"add",
"to",
"the",
"end",
"of",
"the",
"queue",
"dirs",
"add",
"(",
"file",
"status",
"get",
"path",
"(",
")",
")",
";",
"}",
"else",
"{",
"/",
"/",
"file",
":",
"just",
"increment",
"the",
"count",
"count",
"+",
"+",
";",
"}",
"/",
"/",
"now",
"push",
"the",
"dirs",
"list",
"in",
"reverse",
"/",
"/",
"so",
"that",
"they",
"have",
"been",
"added",
"in",
"the",
"sort",
"order",
"as",
"returned",
"push",
"all",
"(",
"queue",
",",
"dirs",
")",
";",
"}",
"}",
"return",
"count",
";",
"}"
]
|
[
"transfers",
"the",
"specified",
"input",
"jars",
"to",
"the",
"specified",
"output",
"jars"
]
| [
"private",
"void",
"write",
"output",
"(",
"class",
"pool",
"program",
"class",
"pool",
",",
"class",
"path",
"class",
"path",
",",
"int",
"from",
"input",
"index",
",",
"int",
"from",
"output",
"index",
",",
"int",
"to",
"output",
"index",
")",
"throws",
"i",
"o",
"exception",
"{",
"try",
"{",
"/",
"/",
"construct",
"the",
"writer",
"that",
"can",
"write",
"jars",
",",
"wars",
",",
"ears",
",",
"zips",
",",
"and",
"/",
"/",
"directories",
",",
"cascading",
"over",
"the",
"specified",
"output",
"entries",
"data",
"entry",
"writer",
"writer",
"=",
"data",
"entry",
"writer",
"factory",
"create",
"data",
"entry",
"writer",
"(",
"class",
"path",
",",
"from",
"output",
"index",
",",
"to",
"output",
"index",
")",
";",
"/",
"/",
"the",
"writer",
"will",
"be",
"used",
"to",
"write",
"possibly",
"obfuscated",
"class",
"files",
"data",
"entry",
"reader",
"class",
"rewriter",
"=",
"new",
"class",
"rewriter",
"(",
"program",
"class",
"pool",
",",
"writer",
")",
";",
"/",
"/",
"the",
"writer",
"will",
"also",
"be",
"used",
"to",
"write",
"resource",
"files",
"data",
"entry",
"reader",
"resource",
"copier",
"=",
"new",
"data",
"entry",
"copier",
"(",
"writer",
")",
";",
"data",
"entry",
"reader",
"resource",
"rewriter",
"=",
"resource",
"copier",
";",
"/",
"/",
"adapt",
"resource",
"file",
"contents",
"and",
"names",
",",
"if",
"necessary",
"if",
"(",
"configuration",
"obfuscate",
")",
"{",
"/",
"/",
"wrap",
"the",
"resource",
"writer",
"with",
"a",
"filter",
"and",
"a",
"data",
"entry",
"/",
"/",
"rewriter",
",",
"if",
"required",
"if",
"(",
"configuration",
"adapt",
"resource",
"file",
"contents",
"!",
"=",
"null",
")",
"{",
"resource",
"rewriter",
"=",
"new",
"name",
"filter",
"(",
"configuration",
"adapt",
"resource",
"file",
"contents",
",",
"new",
"name",
"filter",
"(",
"\"",
"meta",
"-",
"inf",
"/",
"manifest",
"mf",
",",
"meta",
"-",
"inf",
"/",
"*",
"sf",
"\"",
",",
"new",
"manifest",
"rewriter",
"(",
"program",
"class",
"pool",
",",
"writer",
")",
",",
"new",
"data",
"entry",
"rewriter",
"(",
"program",
"class",
"pool",
",",
"writer",
")",
")",
",",
"resource",
"rewriter",
")",
";",
"}",
"/",
"/",
"wrap",
"the",
"resource",
"writer",
"with",
"a",
"filter",
"and",
"a",
"data",
"entry",
"/",
"/",
"renamer",
",",
"if",
"required",
"if",
"(",
"configuration",
"adapt",
"resource",
"file",
"names",
"!",
"=",
"null",
")",
"{",
"map",
"package",
"prefix",
"map",
"=",
"create",
"package",
"prefix",
"map",
"(",
"program",
"class",
"pool",
")",
";",
"resource",
"rewriter",
"=",
"new",
"name",
"filter",
"(",
"configuration",
"adapt",
"resource",
"file",
"names",
",",
"new",
"data",
"entry",
"obfuscator",
"(",
"program",
"class",
"pool",
",",
"package",
"prefix",
"map",
",",
"resource",
"rewriter",
")",
",",
"resource",
"rewriter",
")",
";",
"}",
"}",
"data",
"entry",
"reader",
"directory",
"rewriter",
"=",
"null",
";",
"/",
"/",
"wrap",
"the",
"directory",
"writer",
"with",
"a",
"filter",
"and",
"a",
"data",
"entry",
"renamer",
",",
"/",
"/",
"if",
"required",
"if",
"(",
"configuration",
"keep",
"directories",
"!",
"=",
"null",
")",
"{",
"map",
"package",
"prefix",
"map",
"=",
"create",
"package",
"prefix",
"map",
"(",
"program",
"class",
"pool",
")",
";",
"directory",
"rewriter",
"=",
"new",
"name",
"filter",
"(",
"configuration",
"keep",
"directories",
",",
"new",
"data",
"entry",
"renamer",
"(",
"package",
"prefix",
"map",
",",
"resource",
"copier",
",",
"resource",
"copier",
")",
")",
";",
"}",
"/",
"/",
"create",
"the",
"reader",
"that",
"can",
"write",
"class",
"files",
"and",
"copy",
"directories",
"/",
"/",
"and",
"resource",
"files",
"to",
"the",
"main",
"writer",
"data",
"entry",
"reader",
"reader",
"=",
"new",
"class",
"filter",
"(",
"class",
"rewriter",
",",
"new",
"directory",
"filter",
"(",
"directory",
"rewriter",
",",
"resource",
"rewriter",
")",
")",
";",
"/",
"/",
"go",
"over",
"the",
"specified",
"input",
"entries",
"and",
"write",
"their",
"processed",
"/",
"/",
"versions",
"new",
"input",
"reader",
"(",
"configuration",
")",
"read",
"input",
"(",
"\"",
"copying",
"resources",
"from",
"program",
"\"",
",",
"class",
"path",
",",
"from",
"input",
"index",
",",
"from",
"output",
"index",
",",
"reader",
")",
";",
"/",
"/",
"close",
"all",
"output",
"entries",
"writer",
"close",
"(",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"ex",
")",
"{",
"throw",
"(",
"i",
"o",
"exception",
")",
"new",
"i",
"o",
"exception",
"(",
"\"",
"can",
"'",
"t",
"write",
"[",
"\"",
"+",
"class",
"path",
"get",
"(",
"from",
"output",
"index",
")",
"get",
"name",
"(",
")",
"+",
"\"",
"]",
"(",
"\"",
"+",
"ex",
"get",
"message",
"(",
")",
"+",
"\"",
")",
"\"",
")",
"init",
"cause",
"(",
"ex",
")",
";",
"}",
"}"
]
|
[
"returns",
"the",
"{",
"@",
"link",
"property",
"}"
]
| [
"public",
"property",
"get",
"property",
"(",
")",
"{",
"return",
"property",
";",
"}"
]
|
[
"like",
"{",
"@",
"link",
"#",
"real",
"ref",
"cnt",
"(",
"int",
")",
"}",
"but",
"throws",
"if",
"ref",
"cnt",
"=",
"=",
"0"
]
| [
"private",
"static",
"int",
"to",
"live",
"real",
"ref",
"cnt",
"(",
"int",
"raw",
"cnt",
",",
"int",
"decrement",
")",
"{",
"if",
"(",
"raw",
"cnt",
"=",
"=",
"2",
"|",
"|",
"raw",
"cnt",
"=",
"=",
"4",
"|",
"|",
"(",
"raw",
"cnt",
"&",
"1",
")",
"=",
"=",
"0",
")",
"{",
"return",
"raw",
"cnt",
">",
">",
">",
"1",
";",
"}",
"/",
"/",
"odd",
"raw",
"cnt",
"=",
">",
"already",
"deallocated",
"throw",
"new",
"illegal",
"reference",
"count",
"exception",
"(",
"0",
",",
"-",
"decrement",
")",
";",
"}"
]
|
[
"return",
"a",
"future",
"which",
"is",
"completed",
"with",
"true",
"when",
"the",
"rpc",
"endpoint",
"has",
"been",
"terminated",
"in",
"case",
"of",
"a",
"failure",
",",
"this",
"future",
"is",
"completed",
"with",
"the",
"occurring",
"exception"
]
| [
"public",
"completable",
"future",
"<",
"void",
">",
"get",
"termination",
"future",
"(",
")",
"{",
"return",
"rpc",
"server",
"get",
"termination",
"future",
"(",
")",
";",
"}"
]
|
[
"logs",
"user",
"into",
"the",
"system"
]
| [
"public",
"single",
"<",
"string",
">",
"rx",
"login",
"user",
"(",
"string",
"username",
",",
"string",
"password",
",",
"api",
"client",
"auth",
"info",
"auth",
"info",
")",
"{",
"return",
"single",
"create",
"(",
"new",
"io",
"vertx",
"rx",
"java",
"single",
"on",
"subscribe",
"adapter",
"<",
">",
"(",
"fut",
"-",
">",
"delegate",
"login",
"user",
"(",
"username",
",",
"password",
",",
"auth",
"info",
",",
"fut",
")",
")",
")",
";",
"}"
]
|
[
"sets",
"the",
"{",
"@",
"link",
"name",
"resolver",
"}",
"which",
"will",
"resolve",
"the",
"address",
"of",
"the",
"unresolved",
"named",
"address"
]
| [
"public",
"bootstrap",
"resolver",
"(",
"address",
"resolver",
"group",
"<",
"?",
">",
"resolver",
")",
"{",
"this",
"resolver",
"=",
"(",
"address",
"resolver",
"group",
"<",
"socket",
"address",
">",
")",
"(",
"resolver",
"=",
"=",
"null",
"?",
"default",
"resolver",
":",
"resolver",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"there",
"exists",
"a",
"member",
"range",
"in",
"this",
"range",
"set",
"which",
"{",
"@",
"linkplain",
"range",
"#",
"encloses",
"encloses",
"}",
"the",
"specified",
"range"
]
| [
"boolean",
"encloses",
"(",
"range",
"<",
"c",
">",
"other",
"range",
")",
";"
]
|
[
"returns",
"non",
"-",
"ok",
"status",
"if",
"resolved",
"addresses",
"is",
"empty",
"and",
"delegate",
"lb",
"requires",
"address",
"(",
"{",
"@",
"link",
"load",
"balancer",
"#",
"can",
"handle",
"empty",
"address",
"list",
"from",
"name",
"resolution",
"(",
")",
"}",
"returns",
"{",
"@",
"code",
"false",
"}",
")",
"{",
"@",
"code",
"auto",
"configured",
"load",
"balancer",
"}",
"doesn",
"'",
"t",
"expose",
"{",
"@",
"code",
"can",
"handle",
"empty",
"address",
"list",
"from",
"name",
"resolution",
"}",
"because",
"it",
"depends",
"on",
"the",
"delegated",
"lb"
]
| [
"status",
"try",
"handle",
"resolved",
"addresses",
"(",
"resolved",
"addresses",
"resolved",
"addresses",
")",
"{",
"list",
"<",
"equivalent",
"address",
"group",
">",
"servers",
"=",
"resolved",
"addresses",
"get",
"addresses",
"(",
")",
";",
"attributes",
"attributes",
"=",
"resolved",
"addresses",
"get",
"attributes",
"(",
")",
";",
"policy",
"selection",
"policy",
"selection",
"=",
"(",
"policy",
"selection",
")",
"resolved",
"addresses",
"get",
"load",
"balancing",
"policy",
"config",
"(",
")",
";",
"if",
"(",
"policy",
"selection",
"=",
"=",
"null",
")",
"{",
"load",
"balancer",
"provider",
"default",
"provider",
";",
"try",
"{",
"default",
"provider",
"=",
"get",
"provider",
"or",
"throw",
"(",
"default",
"policy",
",",
"\"",
"using",
"default",
"policy",
"\"",
")",
";",
"}",
"catch",
"(",
"policy",
"exception",
"e",
")",
"{",
"status",
"s",
"=",
"status",
"internal",
"with",
"description",
"(",
"e",
"get",
"message",
"(",
")",
")",
";",
"helper",
"update",
"balancing",
"state",
"(",
"connectivity",
"state",
"transient",
"failure",
",",
"new",
"failing",
"picker",
"(",
"s",
")",
")",
";",
"delegate",
"shutdown",
"(",
")",
";",
"delegate",
"provider",
"=",
"null",
";",
"delegate",
"=",
"new",
"noop",
"load",
"balancer",
"(",
")",
";",
"return",
"status",
"ok",
";",
"}",
"policy",
"selection",
"=",
"new",
"policy",
"selection",
"(",
"default",
"provider",
",",
"/",
"*",
"config",
"=",
"*",
"/",
"null",
")",
";",
"}",
"if",
"(",
"delegate",
"provider",
"=",
"=",
"null",
"|",
"|",
"!",
"policy",
"selection",
"provider",
"get",
"policy",
"name",
"(",
")",
"equals",
"(",
"delegate",
"provider",
"get",
"policy",
"name",
"(",
")",
")",
")",
"{",
"helper",
"update",
"balancing",
"state",
"(",
"connectivity",
"state",
"connecting",
",",
"new",
"empty",
"picker",
"(",
")",
")",
";",
"delegate",
"shutdown",
"(",
")",
";",
"delegate",
"provider",
"=",
"policy",
"selection",
"provider",
";",
"load",
"balancer",
"old",
"=",
"delegate",
";",
"delegate",
"=",
"delegate",
"provider",
"new",
"load",
"balancer",
"(",
"helper",
")",
";",
"helper",
"get",
"channel",
"logger",
"(",
")",
"log",
"(",
"channel",
"log",
"level",
"info",
",",
"\"",
"load",
"balancer",
"changed",
"from",
"{",
"0",
"}",
"to",
"{",
"1",
"}",
"\"",
",",
"old",
"get",
"class",
"(",
")",
"get",
"simple",
"name",
"(",
")",
",",
"delegate",
"get",
"class",
"(",
")",
"get",
"simple",
"name",
"(",
")",
")",
";",
"}",
"object",
"lb",
"config",
"=",
"policy",
"selection",
"config",
";",
"if",
"(",
"lb",
"config",
"!",
"=",
"null",
")",
"{",
"helper",
"get",
"channel",
"logger",
"(",
")",
"log",
"(",
"channel",
"log",
"level",
"debug",
",",
"\"",
"load",
"-",
"balancing",
"config",
":",
"{",
"0",
"}",
"\"",
",",
"policy",
"selection",
"config",
")",
";",
"}",
"load",
"balancer",
"delegate",
"=",
"get",
"delegate",
"(",
")",
";",
"if",
"(",
"resolved",
"addresses",
"get",
"addresses",
"(",
")",
"is",
"empty",
"(",
")",
"&",
"&",
"!",
"delegate",
"can",
"handle",
"empty",
"address",
"list",
"from",
"name",
"resolution",
"(",
")",
")",
"{",
"return",
"status",
"unavailable",
"with",
"description",
"(",
"\"",
"name",
"resolver",
"returned",
"no",
"usable",
"address",
"addrs",
"=",
"\"",
"+",
"servers",
"+",
"\"",
",",
"attrs",
"=",
"\"",
"+",
"attributes",
")",
";",
"}",
"else",
"{",
"delegate",
"handle",
"resolved",
"addresses",
"(",
"resolved",
"addresses",
"new",
"builder",
"(",
")",
"set",
"addresses",
"(",
"resolved",
"addresses",
"get",
"addresses",
"(",
")",
")",
"set",
"attributes",
"(",
"attributes",
")",
"set",
"load",
"balancing",
"policy",
"config",
"(",
"lb",
"config",
")",
"build",
"(",
")",
")",
";",
"return",
"status",
"ok",
";",
"}",
"}"
]
|
[
"returns",
"true",
"if",
"the",
"cursor",
"is",
"allowed",
"past",
"the",
"last",
"character",
"this",
"field",
"always",
"returns",
"false",
"since",
"there",
"is",
"no",
"text"
]
| [
"public",
"boolean",
"is",
"allow",
"cursor",
"at",
"end",
"(",
")",
"{",
"return",
"false",
";",
"}"
]
|
[
"for",
"subclasses",
"externalizing",
"the",
"storage",
",",
"for",
"example",
"zookeeper",
"based",
"implementations"
]
| [
"protected",
"void",
"update",
"token",
"(",
"token",
"ident",
"ident",
",",
"delegation",
"token",
"information",
"token",
"info",
")",
"throws",
"i",
"o",
"exception",
"{",
"current",
"tokens",
"put",
"(",
"ident",
",",
"token",
"info",
")",
";",
"update",
"stored",
"token",
"(",
"ident",
",",
"token",
"info",
"get",
"renew",
"date",
"(",
")",
")",
";",
"}"
]
|
[
"create",
"a",
"named",
"parameter",
"jdbc",
"template",
"based",
"on",
"the",
"configured",
"jdbc",
"template"
]
| [
"protected",
"void",
"init",
"template",
"config",
"(",
")",
"{",
"jdbc",
"template",
"jdbc",
"template",
"=",
"get",
"jdbc",
"template",
"(",
")",
";",
"if",
"(",
"jdbc",
"template",
"!",
"=",
"null",
")",
"{",
"this",
"named",
"parameter",
"jdbc",
"template",
"=",
"new",
"named",
"parameter",
"jdbc",
"template",
"(",
"jdbc",
"template",
")",
";",
"}",
"}"
]
|
[
"returns",
"the",
"executable",
"or",
"null",
"if",
"it",
"does",
"not",
"exist"
]
| [
"public",
"artifact",
"get",
"executable",
"(",
")",
"{",
"return",
"executable",
";",
"}"
]
|
[
"add",
"cache",
"data",
"if",
"absent"
]
| [
"public",
"cache",
"data",
"add",
"cache",
"data",
"if",
"absent",
"(",
"string",
"data",
"id",
",",
"string",
"group",
")",
"{",
"string",
"key",
"=",
"group",
"key",
"get",
"key",
"(",
"data",
"id",
",",
"group",
")",
";",
"cache",
"data",
"cache",
"data",
"=",
"cache",
"map",
"get",
"(",
"key",
")",
";",
"if",
"(",
"cache",
"data",
"!",
"=",
"null",
")",
"{",
"return",
"cache",
"data",
";",
"}",
"cache",
"data",
"=",
"new",
"cache",
"data",
"(",
"config",
"filter",
"chain",
"manager",
",",
"agent",
"get",
"name",
"(",
")",
",",
"data",
"id",
",",
"group",
")",
";",
"/",
"/",
"multiple",
"listeners",
"on",
"the",
"same",
"dataid",
"+",
"group",
"and",
"race",
"condition",
"cache",
"data",
"last",
"cache",
"data",
"=",
"cache",
"map",
"put",
"if",
"absent",
"(",
"key",
",",
"cache",
"data",
")",
";",
"if",
"(",
"last",
"cache",
"data",
"=",
"=",
"null",
")",
"{",
"int",
"task",
"id",
"=",
"cache",
"map",
"size",
"(",
")",
"/",
"(",
"int",
")",
"param",
"util",
"get",
"per",
"task",
"config",
"size",
"(",
")",
";",
"last",
"cache",
"data",
"=",
"cache",
"data",
";",
"last",
"cache",
"data",
"set",
"task",
"id",
"(",
"task",
"id",
")",
";",
"}",
"/",
"/",
"reset",
"so",
"that",
"server",
"not",
"hang",
"this",
"check",
"last",
"cache",
"data",
"set",
"initializing",
"(",
"true",
")",
";",
"logger",
"info",
"(",
"\"",
"[",
"{",
"}",
"]",
"[",
"subscribe",
"]",
"{",
"}",
"\"",
",",
"this",
"agent",
"get",
"name",
"(",
")",
",",
"key",
")",
";",
"metrics",
"monitor",
"get",
"listen",
"config",
"count",
"monitor",
"(",
")",
"set",
"(",
"cache",
"map",
"size",
"(",
")",
")",
";",
"return",
"last",
"cache",
"data",
";",
"}"
]
|
[
"changes",
"the",
"\"",
"new",
"\"",
"reconciled",
"cells",
"to",
"their",
"allocated",
"qids",
"for",
"later",
"use"
]
| [
"public",
"void",
"update",
"reconciled",
"cells",
"(",
"project",
"project",
",",
"boolean",
"reset",
")",
"{",
"set",
"<",
"integer",
">",
"impacted",
"columns",
"=",
"new",
"hash",
"set",
"<",
">",
"(",
")",
";",
"/",
"*",
"*",
"note",
"that",
"there",
"is",
"a",
"slight",
"violation",
"of",
"open",
"refine",
"'",
"s",
"model",
"here",
":",
"if",
"we",
"*",
"reconcile",
"multiple",
"cells",
"to",
"the",
"same",
"new",
"item",
",",
"and",
"then",
"perform",
"this",
"*",
"operation",
"on",
"a",
"subset",
"of",
"the",
"corresponding",
"rows",
",",
"we",
"are",
"going",
"to",
"modify",
"cells",
"*",
"that",
"are",
"outside",
"the",
"facet",
"(",
"because",
"they",
"are",
"reconciled",
"to",
"the",
"same",
"cell",
")",
"*",
"but",
"i",
"think",
"this",
"is",
"the",
"right",
"thing",
"to",
"do",
"*",
"/",
"for",
"(",
"row",
"row",
":",
"project",
"rows",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"!",
"=",
"row",
"cells",
"size",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"cell",
"cell",
"=",
"row",
"cells",
"get",
"(",
"i",
")",
";",
"if",
"(",
"cell",
"=",
"=",
"null",
"|",
"|",
"cell",
"recon",
"=",
"=",
"null",
")",
"{",
"continue",
";",
"}",
"recon",
"recon",
"=",
"cell",
"recon",
";",
"boolean",
"changed",
"=",
"false",
";",
"if",
"(",
"recon",
"judgment",
"new",
"equals",
"(",
"recon",
"judgment",
")",
"&",
"&",
"!",
"reset",
"&",
"&",
"map",
"contains",
"key",
"(",
"recon",
"id",
")",
")",
"{",
"recon",
"judgment",
"=",
"recon",
"judgment",
"matched",
";",
"recon",
"match",
"=",
"new",
"recon",
"candidate",
"(",
"map",
"get",
"(",
"recon",
"id",
")",
",",
"cell",
"value",
"to",
"string",
"(",
")",
",",
"new",
"string",
"[",
"0",
"]",
",",
"100",
")",
";",
"recon",
"add",
"candidate",
"(",
"recon",
"match",
")",
";",
"changed",
"=",
"true",
";",
"}",
"else",
"if",
"(",
"recon",
"judgment",
"matched",
"equals",
"(",
"recon",
"judgment",
")",
"&",
"&",
"reset",
"&",
"&",
"map",
"contains",
"key",
"(",
"recon",
"id",
")",
")",
"{",
"recon",
"judgment",
"=",
"recon",
"judgment",
"new",
";",
"if",
"(",
"recon",
"candidates",
"!",
"=",
"null",
")",
"{",
"recon",
"candidates",
"remove",
"(",
"recon",
"candidates",
"size",
"(",
")",
"-",
"1",
")",
";",
"}",
"recon",
"match",
"=",
"null",
";",
"changed",
"=",
"true",
";",
"}",
"if",
"(",
"changed",
")",
"{",
"impacted",
"columns",
"add",
"(",
"i",
")",
";",
"/",
"/",
"compute",
"features",
"column",
"column",
"=",
"project",
"column",
"model",
"get",
"column",
"by",
"cell",
"index",
"(",
"i",
")",
";",
"recon",
"config",
"config",
"=",
"column",
"get",
"recon",
"config",
"(",
")",
";",
"if",
"(",
"config",
"instanceof",
"standard",
"recon",
"config",
")",
"{",
"standard",
"recon",
"config",
"std",
"config",
"=",
"(",
"standard",
"recon",
"config",
")",
"config",
";",
"if",
"(",
"cell",
"get",
"value",
"(",
")",
"instanceof",
"string",
")",
"{",
"std",
"config",
"compute",
"features",
"(",
"recon",
",",
"(",
"string",
")",
"cell",
"get",
"value",
"(",
")",
")",
";",
"}",
"}",
"}",
"}",
"}",
"/",
"/",
"update",
"reconciliation",
"statistics",
"for",
"impacted",
"columns",
"for",
"(",
"integer",
"col",
"id",
":",
"impacted",
"columns",
")",
"{",
"column",
"column",
"=",
"project",
"column",
"model",
"get",
"column",
"by",
"cell",
"index",
"(",
"col",
"id",
")",
";",
"column",
"set",
"recon",
"stats",
"(",
"recon",
"stats",
"create",
"(",
"project",
",",
"col",
"id",
")",
")",
";",
"}",
"}"
]
|
[
"get",
"pet",
"id"
]
| [
"public",
"long",
"get",
"pet",
"id",
"(",
")",
"{",
"return",
"pet",
"id",
";",
"}"
]
|
[
"the",
"the",
"user",
"assoicated",
"with",
"the",
"deletion",
"task"
]
| [
"public",
"string",
"get",
"user",
"(",
")",
"{",
"return",
"user",
";",
"}"
]
|
[
"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",
"whether",
"the",
"given",
"path",
"starts",
"with",
"any",
"of",
"the",
"paths",
"in",
"the",
"given",
"list",
"of",
"prefixes"
]
| [
"public",
"static",
"boolean",
"starts",
"with",
"any",
"(",
"path",
"fragment",
"path",
",",
"iterable",
"<",
"path",
"fragment",
">",
"prefixes",
")",
"{",
"for",
"(",
"path",
"fragment",
"prefix",
":",
"prefixes",
")",
"{",
"if",
"(",
"path",
"starts",
"with",
"(",
"prefix",
")",
")",
"{",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}"
]
|
[
"returns",
"the",
"next",
"code",
"unit",
"whose",
"min",
"address",
"is",
"greater",
"than",
"the",
"specified",
"address"
]
| [
"public",
"code",
"unit",
"get",
"code",
"unit",
"after",
"(",
"address",
"addr",
")",
"{",
"lock",
"acquire",
"(",
")",
";",
"try",
"{",
"code",
"unit",
"cu",
"=",
"get",
"code",
"unit",
"containing",
"(",
"addr",
")",
";",
"if",
"(",
"cu",
"!",
"=",
"null",
")",
"{",
"addr",
"=",
"cu",
"get",
"max",
"address",
"(",
")",
";",
"}",
"memory",
"mem",
"=",
"program",
"get",
"memory",
"(",
")",
";",
"address",
"iterator",
"it",
"=",
"mem",
"get",
"addresses",
"(",
"addr",
",",
"true",
")",
";",
"if",
"(",
"mem",
"contains",
"(",
"addr",
")",
")",
"{",
"it",
"next",
"(",
")",
";",
"}",
"if",
"(",
"it",
"has",
"next",
"(",
")",
")",
"{",
"addr",
"=",
"it",
"next",
"(",
")",
";",
"return",
"get",
"code",
"unit",
"at",
"(",
"addr",
")",
";",
"}",
"}",
"finally",
"{",
"lock",
"release",
"(",
")",
";",
"}",
"return",
"null",
";",
"}"
]
|
[
"gets",
"the",
"raw",
"(",
"uninterpreted",
")",
"high",
"watermark",
"value",
"as",
"found",
"in",
"the",
"settings"
]
| [
"public",
"string",
"get",
"high",
"watermark",
"raw",
"(",
")",
"{",
"return",
"high",
"watermark",
"raw",
";",
"}"
]
|
[
"get",
"name",
"string"
]
| [
"public",
"string",
"get",
"name",
"string",
"(",
")",
"{",
"return",
"name",
"string",
";",
"}"
]
|
[
"returns",
"the",
"user",
"name",
"of",
"the",
"user",
"making",
"this",
"call",
"this",
"call",
"is",
"only",
"available",
"to",
"applications",
"on",
"the",
"system",
"image",
";",
"it",
"requires",
"the",
"manage",
"users",
"permission"
]
| [
"public",
"string",
"get",
"user",
"name",
"(",
")",
"{",
"try",
"{",
"return",
"m",
"service",
"get",
"user",
"info",
"(",
"get",
"user",
"handle",
"(",
")",
")",
"name",
";",
"}",
"catch",
"(",
"remote",
"exception",
"re",
")",
"{",
"log",
"w",
"(",
"tag",
",",
"\"",
"could",
"not",
"get",
"user",
"name",
"\"",
",",
"re",
")",
";",
"return",
"\"",
"\"",
";",
"}",
"}"
]
|
[
"gets",
"the",
"total",
"number",
"of",
"all",
"currently",
"cached",
"items"
]
| [
"public",
"synchronized",
"int",
"get",
"count",
"(",
")",
"{",
"return",
"m",
"cached",
"entries",
"get",
"count",
"(",
")",
";",
"}"
]
|
[
"gets",
"whether",
"image",
"should",
"be",
"scaled",
"down",
"inside",
"borders"
]
| [
"public",
"boolean",
"get",
"scale",
"down",
"inside",
"borders",
"(",
")",
"{",
"return",
"m",
"scale",
"down",
"inside",
"borders",
";",
"}"
]
|
[
"visits",
"an",
"explicit",
"expression",
"which",
"handles",
"an",
"explicit",
"cast",
"checks",
":",
"type",
"validation"
]
| [
"public",
"void",
"visit",
"explicit",
"(",
"e",
"explicit",
"user",
"explicit",
"node",
",",
"semantic",
"scope",
"semantic",
"scope",
")",
"{",
"string",
"canonical",
"type",
"name",
"=",
"user",
"explicit",
"node",
"get",
"canonical",
"type",
"name",
"(",
")",
";",
"if",
"(",
"semantic",
"scope",
"get",
"condition",
"(",
"user",
"explicit",
"node",
",",
"write",
"class",
")",
")",
"{",
"throw",
"user",
"explicit",
"node",
"create",
"error",
"(",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"invalid",
"assignment",
":",
"cannot",
"assign",
"a",
"value",
"to",
"an",
"explicit",
"cast",
"with",
"target",
"type",
"[",
"\"",
"+",
"canonical",
"type",
"name",
"+",
"\"",
"]",
"\"",
")",
")",
";",
"}",
"if",
"(",
"semantic",
"scope",
"get",
"condition",
"(",
"user",
"explicit",
"node",
",",
"read",
"class",
")",
"=",
"=",
"false",
")",
"{",
"throw",
"user",
"explicit",
"node",
"create",
"error",
"(",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"not",
"a",
"statement",
":",
"result",
"not",
"used",
"from",
"explicit",
"cast",
"with",
"target",
"type",
"[",
"\"",
"+",
"canonical",
"type",
"name",
"+",
"\"",
"]",
"\"",
")",
")",
";",
"}",
"class",
"<",
"?",
">",
"value",
"type",
"=",
"semantic",
"scope",
"get",
"script",
"scope",
"(",
")",
"get",
"painless",
"lookup",
"(",
")",
"canonical",
"type",
"name",
"to",
"type",
"(",
"canonical",
"type",
"name",
")",
";",
"if",
"(",
"value",
"type",
"=",
"=",
"null",
")",
"{",
"throw",
"user",
"explicit",
"node",
"create",
"error",
"(",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"cannot",
"resolve",
"type",
"[",
"\"",
"+",
"canonical",
"type",
"name",
"+",
"\"",
"]",
"\"",
")",
")",
";",
"}",
"a",
"expression",
"user",
"child",
"node",
"=",
"user",
"explicit",
"node",
"get",
"child",
"node",
"(",
")",
";",
"semantic",
"scope",
"set",
"condition",
"(",
"user",
"child",
"node",
",",
"read",
"class",
")",
";",
"semantic",
"scope",
"put",
"decoration",
"(",
"user",
"child",
"node",
",",
"new",
"target",
"type",
"(",
"value",
"type",
")",
")",
";",
"semantic",
"scope",
"set",
"condition",
"(",
"user",
"child",
"node",
",",
"explicit",
"class",
")",
";",
"checked",
"visit",
"(",
"user",
"child",
"node",
",",
"semantic",
"scope",
")",
";",
"decorate",
"with",
"cast",
"(",
"user",
"child",
"node",
",",
"semantic",
"scope",
")",
";",
"semantic",
"scope",
"put",
"decoration",
"(",
"user",
"explicit",
"node",
",",
"new",
"value",
"type",
"(",
"value",
"type",
")",
")",
";",
"}"
]
|
[
"get",
"the",
"queue",
"to",
"place",
"the",
"application",
"in"
]
| [
"public",
"abstract",
"void",
"set",
"target",
"queue",
"(",
"string",
"queue",
")",
";"
]
|
[
"this",
"test",
"validates",
"the",
"correctness",
"of",
"{",
"@",
"link",
"r",
"m",
"web",
"service",
"protocol",
"#",
"get",
"cluster",
"info",
"(",
")",
"}",
"inside",
"router"
]
| [
"public",
"void",
"test",
"cluster",
"info",
"x",
"m",
"l",
"(",
")",
"throws",
"exception",
"{",
"list",
"<",
"cluster",
"info",
">",
"responses",
"=",
"perform",
"get",
"calls",
"(",
"rm",
"web",
"service",
"path",
"+",
"info",
",",
"cluster",
"info",
"class",
",",
"null",
",",
"null",
")",
";",
"cluster",
"info",
"router",
"response",
"=",
"responses",
"get",
"(",
"0",
")",
";",
"cluster",
"info",
"rm",
"response",
"=",
"responses",
"get",
"(",
"1",
")",
";",
"assert",
"not",
"null",
"(",
"router",
"response",
")",
";",
"assert",
"not",
"null",
"(",
"rm",
"response",
")",
";",
"assert",
"equals",
"(",
"rm",
"response",
"get",
"r",
"m",
"version",
"(",
")",
",",
"router",
"response",
"get",
"r",
"m",
"version",
"(",
")",
")",
";",
"}"
]
|
[
"return",
"the",
"seeds",
"used",
"in",
"the",
"depth",
"first",
"search"
]
| [
"list",
"<",
"vertex",
">",
"seeds",
"used",
"(",
")",
"{",
"return",
"seeds",
"used",
";",
"}"
]
|
[
"clears",
"the",
"map",
"and",
"reduces",
"the",
"size",
"of",
"the",
"backing",
"arrays",
"to",
"be",
"the",
"specified",
"capacity",
"load",
"factor",
",",
"if",
"they",
"are",
"larger"
]
| [
"public",
"void",
"clear",
"(",
"int",
"maximum",
"capacity",
")",
"{",
"int",
"table",
"size",
"=",
"table",
"size",
"(",
"maximum",
"capacity",
",",
"load",
"factor",
")",
";",
"if",
"(",
"key",
"table",
"length",
"<",
"=",
"table",
"size",
")",
"{",
"clear",
"(",
")",
";",
"return",
";",
"}",
"size",
"=",
"0",
";",
"has",
"zero",
"value",
"=",
"false",
";",
"resize",
"(",
"table",
"size",
")",
";",
"}"
]
|
[
"parses",
"a",
"{",
"@",
"code",
"deprecated",
"}",
"attribute"
]
| [
"private",
"attribute",
"deprecated",
"(",
"direct",
"class",
"file",
"cf",
",",
"int",
"offset",
",",
"int",
"length",
",",
"parse",
"observer",
"observer",
")",
"{",
"if",
"(",
"length",
"!",
"=",
"0",
")",
"{",
"return",
"throw",
"bad",
"length",
"(",
"0",
")",
";",
"}",
"return",
"new",
"att",
"deprecated",
"(",
")",
";",
"}"
]
|
[
"read",
"a",
"{",
"@",
"link",
"download",
"}",
"from",
"a",
"table",
"row",
"of",
"version",
"2"
]
| [
"private",
"static",
"download",
"get",
"download",
"for",
"current",
"row",
"v",
"2",
"(",
"cursor",
"cursor",
")",
"{",
"/",
"*",
"*",
"version",
"2",
"schema",
"*",
"index",
"column",
"type",
"*",
"0",
"id",
"string",
"*",
"1",
"type",
"string",
"*",
"2",
"uri",
"string",
"*",
"3",
"stream",
"keys",
"string",
"*",
"4",
"custom",
"cache",
"key",
"string",
"*",
"5",
"data",
"blob",
"*",
"6",
"state",
"integer",
"*",
"7",
"start",
"time",
"ms",
"integer",
"*",
"8",
"update",
"time",
"ms",
"integer",
"*",
"9",
"content",
"length",
"integer",
"*",
"10",
"stop",
"reason",
"integer",
"*",
"11",
"failure",
"reason",
"integer",
"*",
"12",
"percent",
"downloaded",
"real",
"*",
"13",
"bytes",
"downloaded",
"integer",
"*",
"/",
"download",
"request",
"request",
"=",
"new",
"download",
"request",
"builder",
"(",
"/",
"*",
"id",
"=",
"*",
"/",
"cursor",
"get",
"string",
"(",
"0",
")",
",",
"/",
"*",
"uri",
"=",
"*",
"/",
"uri",
"parse",
"(",
"cursor",
"get",
"string",
"(",
"2",
")",
")",
")",
"set",
"mime",
"type",
"(",
"infer",
"mime",
"type",
"(",
"cursor",
"get",
"string",
"(",
"1",
")",
")",
")",
"set",
"stream",
"keys",
"(",
"decode",
"stream",
"keys",
"(",
"cursor",
"get",
"string",
"(",
"3",
")",
")",
")",
"set",
"custom",
"cache",
"key",
"(",
"cursor",
"get",
"string",
"(",
"4",
")",
")",
"set",
"data",
"(",
"cursor",
"get",
"blob",
"(",
"5",
")",
")",
"build",
"(",
")",
";",
"download",
"progress",
"download",
"progress",
"=",
"new",
"download",
"progress",
"(",
")",
";",
"download",
"progress",
"bytes",
"downloaded",
"=",
"cursor",
"get",
"long",
"(",
"13",
")",
";",
"download",
"progress",
"percent",
"downloaded",
"=",
"cursor",
"get",
"float",
"(",
"12",
")",
";",
"@",
"state",
"int",
"state",
"=",
"cursor",
"get",
"int",
"(",
"6",
")",
";",
"/",
"/",
"it",
"'",
"s",
"possible",
"the",
"database",
"contains",
"failure",
"reasons",
"for",
"non",
"-",
"failed",
"downloads",
",",
"which",
"is",
"/",
"/",
"invalid",
"clear",
"them",
"here",
"see",
"https",
":",
"/",
"/",
"github",
"com",
"/",
"google",
"/",
"exo",
"player",
"/",
"issues",
"/",
"6785",
"@",
"failure",
"reason",
"int",
"failure",
"reason",
"=",
"state",
"=",
"=",
"download",
"state",
"failed",
"?",
"cursor",
"get",
"int",
"(",
"11",
")",
":",
"download",
"failure",
"reason",
"none",
";",
"return",
"new",
"download",
"(",
"request",
",",
"state",
",",
"/",
"*",
"start",
"time",
"ms",
"=",
"*",
"/",
"cursor",
"get",
"long",
"(",
"7",
")",
",",
"/",
"*",
"update",
"time",
"ms",
"=",
"*",
"/",
"cursor",
"get",
"long",
"(",
"8",
")",
",",
"/",
"*",
"content",
"length",
"=",
"*",
"/",
"cursor",
"get",
"long",
"(",
"9",
")",
",",
"/",
"*",
"stop",
"reason",
"=",
"*",
"/",
"cursor",
"get",
"int",
"(",
"10",
")",
",",
"failure",
"reason",
",",
"download",
"progress",
")",
";",
"}"
]
|
[
"converts",
"instructions",
"represented",
"as",
"string"
]
| [
"public",
"static",
"int",
"[",
"]",
"convert",
"to",
"byte",
"code",
"(",
"string",
"instructions",
")",
"{",
"if",
"(",
"instructions",
"=",
"=",
"null",
"|",
"|",
"instructions",
"trim",
"(",
")",
"length",
"(",
")",
"=",
"=",
"0",
")",
"{",
"return",
"new",
"int",
"[",
"0",
"]",
";",
"}",
"var",
"splited",
"instructions",
"=",
"instructions",
"trim",
"(",
")",
"split",
"(",
"\"",
"\"",
")",
";",
"var",
"bytecode",
"=",
"new",
"int",
"[",
"splited",
"instructions",
"length",
"]",
";",
"for",
"(",
"var",
"i",
"=",
"0",
";",
"i",
"<",
"splited",
"instructions",
"length",
";",
"i",
"+",
"+",
")",
"{",
"if",
"(",
"is",
"valid",
"instruction",
"(",
"splited",
"instructions",
"[",
"i",
"]",
")",
")",
"{",
"bytecode",
"[",
"i",
"]",
"=",
"instruction",
"value",
"of",
"(",
"splited",
"instructions",
"[",
"i",
"]",
")",
"get",
"int",
"value",
"(",
")",
";",
"}",
"else",
"if",
"(",
"is",
"valid",
"int",
"(",
"splited",
"instructions",
"[",
"i",
"]",
")",
")",
"{",
"bytecode",
"[",
"i",
"]",
"=",
"integer",
"parse",
"int",
"(",
"splited",
"instructions",
"[",
"i",
"]",
")",
";",
"}",
"else",
"{",
"var",
"error",
"message",
"=",
"\"",
"invalid",
"instruction",
"or",
"number",
":",
"\"",
"+",
"splited",
"instructions",
"[",
"i",
"]",
";",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"error",
"message",
")",
";",
"}",
"}",
"return",
"bytecode",
";",
"}"
]
|
[
"returns",
"all",
"source",
"vertices",
"(",
"those",
"with",
"no",
"incoming",
"edges",
")",
"in",
"the",
"graph"
]
| [
"public",
"static",
"<",
"v",
",",
"e",
"extends",
"g",
"edge",
"<",
"v",
">",
">",
"set",
"<",
"v",
">",
"get",
"sources",
"(",
"g",
"directed",
"graph",
"<",
"v",
",",
"e",
">",
"g",
")",
"{",
"set",
"<",
"v",
">",
"sources",
"=",
"new",
"hash",
"set",
"<",
">",
"(",
")",
";",
"collection",
"<",
"v",
">",
"vertices",
"=",
"g",
"get",
"vertices",
"(",
")",
";",
"for",
"(",
"v",
"v",
":",
"vertices",
")",
"{",
"collection",
"<",
"e",
">",
"in",
"edges",
"=",
"g",
"get",
"in",
"edges",
"(",
"v",
")",
";",
"if",
"(",
"in",
"edges",
"is",
"empty",
"(",
")",
")",
"{",
"sources",
"add",
"(",
"v",
")",
";",
"}",
"}",
"return",
"sources",
";",
"}"
]
|
[
"encode",
"initial",
"swedish",
"\"",
"sj",
"-",
"\"",
"as",
"x",
"(",
"\"",
"sh",
"\"",
")"
]
| [
"boolean",
"encode",
"sj",
"(",
")",
"{",
"if",
"(",
"string",
"at",
"(",
"0",
",",
"2",
",",
"\"",
"sj",
"\"",
",",
"\"",
"\"",
")",
")",
"{",
"metaph",
"add",
"(",
"\"",
"x",
"\"",
")",
";",
"m",
"current",
"+",
"=",
"2",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}"
]
|
[
"imports",
"a",
"library",
"file",
"into",
"a",
"ghidra",
"project"
]
| [
"protected",
"boolean",
"import",
"library",
"(",
"string",
"lib",
"name",
",",
"domain",
"folder",
"lib",
"folder",
",",
"file",
"lib",
"file",
",",
"load",
"spec",
"load",
"spec",
",",
"list",
"<",
"option",
">",
"options",
",",
"message",
"log",
"log",
",",
"object",
"consumer",
",",
"set",
"<",
"string",
">",
"unprocessed",
"libs",
",",
"list",
"<",
"program",
">",
"program",
"list",
",",
"task",
"monitor",
"monitor",
")",
"throws",
"cancelled",
"exception",
",",
"i",
"o",
"exception",
"{",
"if",
"(",
"!",
"lib",
"file",
"is",
"file",
"(",
")",
")",
"{",
"return",
"false",
";",
"}",
"try",
"(",
"random",
"access",
"byte",
"provider",
"provider",
"=",
"new",
"random",
"access",
"byte",
"provider",
"(",
"lib",
"file",
")",
")",
"{",
"return",
"import",
"library",
"(",
"lib",
"name",
",",
"lib",
"folder",
",",
"lib",
"file",
",",
"provider",
",",
"load",
"spec",
",",
"options",
",",
"log",
",",
"consumer",
",",
"unprocessed",
"libs",
",",
"program",
"list",
",",
"monitor",
")",
";",
"}",
"}"
]
|
[
"get",
"the",
"map",
"tasks",
"list"
]
| [
"public",
"job",
"history",
"parser",
"task",
"attempt",
"info",
"[",
"]",
"get",
"map",
"tasks",
"(",
")",
"{",
"return",
"map",
"tasks",
";",
"}"
]
|
[
"returns",
"the",
"apk",
"filter",
"currently",
"represented",
"in",
"this",
"dialog"
]
| [
"public",
"list",
"get",
"apk",
"filter",
"(",
")",
"{",
"string",
"filter",
"=",
"apk",
"filter",
"text",
"field",
"get",
"text",
"(",
")",
";",
"return",
"filter",
"equals",
"(",
"default",
"apk",
"filter",
")",
"?",
"null",
":",
"list",
"util",
"comma",
"separated",
"list",
"(",
"filter",
")",
";",
"}"
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.