docstring_tokens
list | code_tokens
list |
|---|---|
[
"get",
"fake",
":",
"to",
"test",
"enum",
"parameters",
"to",
"test",
"enum",
"parameters"
] | [
"public",
"response",
"entity",
"<",
"void",
">",
"test",
"enum",
"parameters",
"(",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"header",
"parameter",
"enum",
"test",
"(",
"string",
"array",
")",
"\"",
",",
"allowable",
"values",
"=",
"\"",
">",
",",
"$",
"\"",
")",
"@",
"request",
"header",
"(",
"value",
"=",
"\"",
"enum",
"header",
"string",
"array",
"\"",
",",
"required",
"=",
"false",
")",
"list",
"<",
"string",
">",
"enum",
"header",
"string",
"array",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"header",
"parameter",
"enum",
"test",
"(",
"string",
")",
"\"",
",",
"allowable",
"values",
"=",
"\"",
"abc",
",",
"-",
"efg",
",",
"(",
"xyz",
")",
"\"",
",",
"default",
"value",
"=",
"\"",
"-",
"efg",
"\"",
")",
"@",
"request",
"header",
"(",
"value",
"=",
"\"",
"enum",
"header",
"string",
"\"",
",",
"required",
"=",
"false",
")",
"string",
"enum",
"header",
"string",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"query",
"parameter",
"enum",
"test",
"(",
"string",
"array",
")",
"\"",
",",
"allowable",
"values",
"=",
"\"",
">",
",",
"$",
"\"",
")",
"@",
"valid",
"@",
"request",
"param",
"(",
"value",
"=",
"\"",
"enum",
"query",
"string",
"array",
"\"",
",",
"required",
"=",
"false",
")",
"list",
"<",
"string",
">",
"enum",
"query",
"string",
"array",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"query",
"parameter",
"enum",
"test",
"(",
"string",
")",
"\"",
",",
"allowable",
"values",
"=",
"\"",
"abc",
",",
"-",
"efg",
",",
"(",
"xyz",
")",
"\"",
",",
"default",
"value",
"=",
"\"",
"-",
"efg",
"\"",
")",
"@",
"valid",
"@",
"request",
"param",
"(",
"value",
"=",
"\"",
"enum",
"query",
"string",
"\"",
",",
"required",
"=",
"false",
",",
"default",
"value",
"=",
"\"",
"-",
"efg",
"\"",
")",
"string",
"enum",
"query",
"string",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"query",
"parameter",
"enum",
"test",
"(",
"double",
")",
"\"",
",",
"allowable",
"values",
"=",
"\"",
"1",
",",
"-",
"2",
"\"",
")",
"@",
"valid",
"@",
"request",
"param",
"(",
"value",
"=",
"\"",
"enum",
"query",
"integer",
"\"",
",",
"required",
"=",
"false",
")",
"integer",
"enum",
"query",
"integer",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"query",
"parameter",
"enum",
"test",
"(",
"double",
")",
"\"",
",",
"allowable",
"values",
"=",
"\"",
"1",
"1",
",",
"-",
"1",
"2",
"\"",
")",
"@",
"valid",
"@",
"request",
"param",
"(",
"value",
"=",
"\"",
"enum",
"query",
"double",
"\"",
",",
"required",
"=",
"false",
")",
"double",
"enum",
"query",
"double",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"form",
"parameter",
"enum",
"test",
"(",
"string",
"array",
")",
"\"",
",",
"allowable",
"values",
"=",
"\"",
">",
",",
"$",
"\"",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"enum",
"form",
"string",
"array",
"\"",
",",
"required",
"=",
"false",
")",
"list",
"<",
"string",
">",
"enum",
"form",
"string",
"array",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"form",
"parameter",
"enum",
"test",
"(",
"string",
")",
"\"",
",",
"allowable",
"values",
"=",
"\"",
"abc",
",",
"-",
"efg",
",",
"(",
"xyz",
")",
"\"",
",",
"default",
"value",
"=",
"\"",
"-",
"efg",
"\"",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"enum",
"form",
"string",
"\"",
",",
"required",
"=",
"false",
")",
"string",
"enum",
"form",
"string",
")",
"{",
"return",
"new",
"response",
"entity",
"<",
">",
"(",
"http",
"status",
"not",
"implemented",
")",
";",
"}"
] |
[
"@",
"t",
"c",
"description",
":",
"beta",
"=",
"，",
"@",
"test",
"step",
":",
"@",
"expect",
"result",
":"
] | [
"public",
"void",
"delete",
"beta",
"config",
"delete",
"beta",
"false",
"(",
")",
"throws",
"exception",
"{",
"http",
"headers",
"headers",
"=",
"new",
"http",
"headers",
"(",
")",
";",
"headers",
"add",
"(",
"\"",
"beta",
"ips",
"\"",
",",
"\"",
"127",
"0",
"0",
"1",
",",
"127",
"0",
"0",
"2",
"\"",
")",
";",
"response",
"entity",
"<",
"string",
">",
"response",
"=",
"request",
"(",
"config",
"controller",
"path",
"+",
"\"",
"/",
"configs",
"\"",
",",
"headers",
",",
"params",
"new",
"params",
"(",
")",
"append",
"param",
"(",
"\"",
"data",
"id",
"\"",
",",
"data",
"id",
")",
"append",
"param",
"(",
"\"",
"group",
"\"",
",",
"group",
")",
"append",
"param",
"(",
"\"",
"tenant",
"\"",
",",
"tenant",
")",
"append",
"param",
"(",
"\"",
"content",
"\"",
",",
"content",
")",
"append",
"param",
"(",
"\"",
"config",
"tags",
"\"",
",",
"\"",
"\"",
")",
"append",
"param",
"(",
"\"",
"app",
"name",
"\"",
",",
"app",
"name",
")",
"done",
"(",
")",
",",
"string",
"class",
",",
"http",
"method",
"post",
")",
";",
"system",
"out",
"println",
"(",
"\"",
"delete",
"beta",
"config",
"delete",
"beta",
"false",
"post",
":",
"\"",
"+",
"response",
")",
";",
"assert",
"assert",
"true",
"(",
"response",
"get",
"status",
"code",
"(",
")",
"is",
"2xx",
"successful",
"(",
")",
")",
";",
"assert",
"assert",
"equals",
"(",
"\"",
"true",
"\"",
",",
"response",
"get",
"body",
"(",
")",
")",
";",
"response",
"=",
"request",
"(",
"config",
"controller",
"path",
"+",
"\"",
"/",
"configs",
"?",
"beta",
"=",
"true",
"\"",
",",
"params",
"new",
"params",
"(",
")",
"append",
"param",
"(",
"\"",
"data",
"id",
"\"",
",",
"data",
"id",
")",
"append",
"param",
"(",
"\"",
"group",
"\"",
",",
"group",
")",
"append",
"param",
"(",
"\"",
"tenant",
"\"",
",",
"tenant",
")",
"done",
"(",
")",
",",
"string",
"class",
",",
"http",
"method",
"get",
")",
";",
"system",
"out",
"println",
"(",
"\"",
"delete",
"beta",
"config",
"delete",
"beta",
"false",
"get",
":",
"\"",
"+",
"response",
")",
";",
"assert",
"assert",
"true",
"(",
"response",
"get",
"status",
"code",
"(",
")",
"is",
"2xx",
"successful",
"(",
")",
")",
";",
"assert",
"assert",
"equals",
"(",
"\"",
"com",
"dungu",
"test",
"\"",
",",
"jackson",
"utils",
"to",
"obj",
"(",
"response",
"get",
"body",
"(",
")",
")",
"get",
"(",
"\"",
"data",
"\"",
")",
"get",
"(",
"\"",
"data",
"id",
"\"",
")",
"as",
"text",
"(",
")",
")",
";",
"response",
"=",
"request",
"(",
"config",
"controller",
"path",
"+",
"\"",
"/",
"configs",
"?",
"beta",
"=",
"false",
"\"",
",",
"params",
"new",
"params",
"(",
")",
"append",
"param",
"(",
"\"",
"data",
"id",
"\"",
",",
"data",
"id",
")",
"append",
"param",
"(",
"\"",
"group",
"\"",
",",
"group",
")",
"append",
"param",
"(",
"\"",
"tenant",
"\"",
",",
"tenant",
")",
"done",
"(",
")",
",",
"string",
"class",
",",
"http",
"method",
"delete",
")",
";",
"system",
"out",
"println",
"(",
"\"",
"delete",
"beta",
"config",
"delete",
"beta",
"false",
"delete",
":",
"\"",
"+",
"response",
")",
";",
"assert",
"assert",
"true",
"(",
"response",
"get",
"status",
"code",
"(",
")",
"is",
"2xx",
"successful",
"(",
")",
")",
";",
"assert",
"assert",
"equals",
"(",
"\"",
"true",
"\"",
",",
"response",
"get",
"body",
"(",
")",
")",
";",
"response",
"=",
"request",
"(",
"config",
"controller",
"path",
"+",
"\"",
"/",
"configs",
"?",
"beta",
"=",
"true",
"\"",
",",
"params",
"new",
"params",
"(",
")",
"append",
"param",
"(",
"\"",
"data",
"id",
"\"",
",",
"data",
"id",
")",
"append",
"param",
"(",
"\"",
"group",
"\"",
",",
"group",
")",
"append",
"param",
"(",
"\"",
"tenant",
"\"",
",",
"tenant",
")",
"done",
"(",
")",
",",
"string",
"class",
",",
"http",
"method",
"get",
")",
";",
"system",
"out",
"println",
"(",
"\"",
"delete",
"beta",
"config",
"delete",
"beta",
"false",
"after",
"delete",
"then",
"get",
":",
"\"",
"+",
"response",
")",
";",
"assert",
"assert",
"true",
"(",
"response",
"get",
"status",
"code",
"(",
")",
"is",
"2xx",
"successful",
"(",
")",
")",
";",
"assert",
"assert",
"equals",
"(",
"\"",
"com",
"dungu",
"test",
"\"",
",",
"jackson",
"utils",
"to",
"obj",
"(",
"response",
"get",
"body",
"(",
")",
")",
"get",
"(",
"\"",
"data",
"\"",
")",
"get",
"(",
"\"",
"data",
"id",
"\"",
")",
"as",
"text",
"(",
")",
")",
";",
"}"
] |
[
"returns",
"if",
"the",
"entry",
"is",
"in",
"the",
"main",
"space",
"'",
"s",
"probation",
"queue"
] | [
"public",
"boolean",
"in",
"main",
"probation",
"(",
")",
"{",
"return",
"get",
"queue",
"type",
"(",
")",
"=",
"=",
"probation",
";",
"}"
] |
[
"declare",
"that",
"the",
"tool",
"is",
"to",
"be",
"closed",
"in",
"teardown"
] | [
"protected",
"<",
"t",
"extends",
"s",
"3",
"guard",
"tool",
">",
"t",
"to",
"close",
"(",
"t",
"tool",
")",
"{",
"tools",
"to",
"close",
"add",
"(",
"tool",
")",
";",
"return",
"tool",
";",
"}"
] |
[
"test",
"to",
"verify",
"that",
"the",
"checksum",
"can",
"be",
"computed",
"by",
"giving",
"strip",
"size",
"length",
"of",
"file",
"range",
"for",
"checksum",
"calculation"
] | [
"public",
"void",
"test",
"striped",
"file",
"checksum",
"with",
"missed",
"data",
"blocks",
"range",
"query",
"8",
"(",
")",
"throws",
"exception",
"{",
"test",
"striped",
"file",
"checksum",
"with",
"missed",
"data",
"blocks",
"range",
"query",
"(",
"striped",
"file",
"1",
",",
"strip",
"size",
")",
";",
"}"
] |
[
"discards",
"the",
"insertion",
"process",
"if",
"resource",
"was",
"already",
"committed",
"the",
"call",
"is",
"ignored"
] | [
"boolean",
"clean",
"up",
"(",
")",
";"
] |
[
"determines",
"if",
"the",
"rtti",
"1",
"pointer",
"in",
"the",
"rtti2",
"structure",
"is",
"valid"
] | [
"public",
"boolean",
"is",
"valid",
"rtti",
"1",
"pointer",
"(",
"program",
"program",
",",
"address",
"start",
"address",
",",
"int",
"pointer",
"index",
",",
"data",
"validation",
"options",
"validation",
"options",
")",
"{",
"address",
"pointer",
"address",
"=",
"start",
"address",
"add",
"(",
"4",
"*",
"pointer",
"index",
")",
";",
"return",
"is",
"valid",
"(",
"program",
",",
"pointer",
"address",
",",
"validation",
"options",
")",
";",
"}"
] |
[
"this",
"is",
"the",
"main",
"encoding",
"method",
"it",
"'",
"s",
"only",
"visible",
"for",
"testing"
] | [
"static",
"byte",
"buf",
"do",
"encode",
"(",
"channel",
"handler",
"context",
"ctx",
",",
"mqtt",
"message",
"message",
")",
"{",
"switch",
"(",
"message",
"fixed",
"header",
"(",
")",
"message",
"type",
"(",
")",
")",
"{",
"case",
"connect",
":",
"return",
"encode",
"connect",
"message",
"(",
"ctx",
",",
"(",
"mqtt",
"connect",
"message",
")",
"message",
")",
";",
"case",
"connack",
":",
"return",
"encode",
"conn",
"ack",
"message",
"(",
"ctx",
",",
"(",
"mqtt",
"conn",
"ack",
"message",
")",
"message",
")",
";",
"case",
"publish",
":",
"return",
"encode",
"publish",
"message",
"(",
"ctx",
",",
"(",
"mqtt",
"publish",
"message",
")",
"message",
")",
";",
"case",
"subscribe",
":",
"return",
"encode",
"subscribe",
"message",
"(",
"ctx",
",",
"(",
"mqtt",
"subscribe",
"message",
")",
"message",
")",
";",
"case",
"unsubscribe",
":",
"return",
"encode",
"unsubscribe",
"message",
"(",
"ctx",
",",
"(",
"mqtt",
"unsubscribe",
"message",
")",
"message",
")",
";",
"case",
"suback",
":",
"return",
"encode",
"sub",
"ack",
"message",
"(",
"ctx",
",",
"(",
"mqtt",
"sub",
"ack",
"message",
")",
"message",
")",
";",
"case",
"unsuback",
":",
"if",
"(",
"message",
"instanceof",
"mqtt",
"unsub",
"ack",
"message",
")",
"{",
"return",
"encode",
"unsub",
"ack",
"message",
"(",
"ctx",
",",
"(",
"mqtt",
"unsub",
"ack",
"message",
")",
"message",
")",
";",
"}",
"return",
"encode",
"message",
"with",
"only",
"single",
"byte",
"fixed",
"header",
"and",
"message",
"id",
"(",
"ctx",
"alloc",
"(",
")",
",",
"message",
")",
";",
"case",
"puback",
":",
"case",
"pubrec",
":",
"case",
"pubrel",
":",
"case",
"pubcomp",
":",
"return",
"encode",
"pub",
"reply",
"message",
"(",
"ctx",
",",
"message",
")",
";",
"case",
"disconnect",
":",
"case",
"auth",
":",
"return",
"encode",
"reason",
"code",
"plus",
"properties",
"message",
"(",
"ctx",
",",
"message",
")",
";",
"case",
"pingreq",
":",
"case",
"pingresp",
":",
"return",
"encode",
"message",
"with",
"only",
"single",
"byte",
"fixed",
"header",
"(",
"ctx",
"alloc",
"(",
")",
",",
"message",
")",
";",
"default",
":",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"unknown",
"message",
"type",
":",
"\"",
"+",
"message",
"fixed",
"header",
"(",
")",
"message",
"type",
"(",
")",
"value",
"(",
")",
")",
";",
"}",
"}"
] |
[
"whether",
"an",
"e",
"tag",
"should",
"be",
"calculated",
"for",
"the",
"given",
"request",
"and",
"response",
"exchange",
"by",
"default",
"this",
"is",
"{",
"@",
"code",
"true",
"}",
"if",
"all",
"of",
"the",
"following",
"match",
":",
"response",
"is",
"not",
"committed",
"response",
"status",
"codes",
"is",
"in",
"the",
"{",
"@",
"code",
"2xx",
"}",
"series",
"request",
"method",
"is",
"a",
"get",
"response",
"cache",
"-",
"control",
"header",
"does",
"not",
"contain",
"\"",
"no",
"-",
"store",
"\"",
"(",
"or",
"is",
"not",
"present",
"at",
"all",
")"
] | [
"protected",
"boolean",
"is",
"eligible",
"for",
"etag",
"(",
"http",
"servlet",
"request",
"request",
",",
"http",
"servlet",
"response",
"response",
",",
"int",
"response",
"status",
"code",
",",
"input",
"stream",
"input",
"stream",
")",
"{",
"if",
"(",
"!",
"response",
"is",
"committed",
"(",
")",
"&",
"&",
"response",
"status",
"code",
">",
"=",
"200",
"&",
"&",
"response",
"status",
"code",
"<",
"300",
"&",
"&",
"http",
"method",
"get",
"matches",
"(",
"request",
"get",
"method",
"(",
")",
")",
")",
"{",
"string",
"cache",
"control",
"=",
"response",
"get",
"header",
"(",
"http",
"headers",
"cache",
"control",
")",
";",
"return",
"(",
"cache",
"control",
"=",
"=",
"null",
"|",
"|",
"!",
"cache",
"control",
"contains",
"(",
"directive",
"no",
"store",
")",
")",
";",
"}",
"return",
"false",
";",
"}"
] |
[
"returns",
"the",
"http",
"status",
"code",
"or",
"-",
"1",
"if",
"it",
"is",
"unknown"
] | [
"public",
"int",
"get",
"response",
"code",
"(",
")",
"{",
"return",
"response",
"code",
";",
"}"
] |
[
"sets",
"the",
"pattern",
"for",
"the",
"log",
"file",
"name",
"the",
"pattern",
"may",
"contain",
"the",
"following",
"variables",
":",
"<",
"code",
">",
"%",
"u",
"<",
"code",
">",
"will",
"be",
"expanded",
"to",
"the",
"username",
"<",
"code",
">",
"%",
"h",
"<",
"code",
">",
"will",
"be",
"expanded",
"to",
"the",
"hostname",
"<",
"code",
">",
"%",
"%",
"<",
"code",
">",
"will",
"be",
"expanded",
"to",
"%",
"the",
"log",
"file",
"name",
"will",
"be",
"constructed",
"by",
"appending",
"the",
"expanded",
"pattern",
"to",
"the",
"prefix",
"and",
"then",
"by",
"appending",
"a",
"timestamp",
"and",
"the",
"extension",
"if",
"unset",
",",
"the",
"value",
"of",
"\"",
"pattern",
"\"",
"from",
"the",
"jvm",
"logging",
"configuration",
"for",
"{",
"@",
"link",
"simple",
"log",
"handler",
"}",
"will",
"be",
"used",
";",
"and",
"if",
"that",
"'",
"s",
"unset",
",",
"{",
"@",
"link",
"#",
"default",
"base",
"file",
"name",
"pattern",
"}",
"will",
"be",
"used"
] | [
"public",
"builder",
"set",
"pattern",
"(",
"string",
"pattern",
")",
"{",
"this",
"pattern",
"=",
"pattern",
";",
"return",
"this",
";",
"}"
] |
[
"where",
"the",
"entry",
"was",
"defined",
"<",
"code",
">",
"optional",
"aapt",
"pb",
"source",
"source",
"=",
"1",
";",
"<",
"code",
">"
] | [
"private",
"void",
"clear",
"source",
"(",
")",
"{",
"source",
"=",
"null",
";",
"bit",
"field",
"0",
"=",
"(",
"bit",
"field",
"0",
"&",
"~",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"1",
")",
";",
"}"
] |
[
"adds",
"invocation",
"and",
"elapsed",
"time",
"of",
"send",
"packet",
"downstream",
"for",
"peer",
"the",
"caller",
"should",
"pass",
"in",
"a",
"well",
"-",
"formatted",
"peer",
"addr",
"e",
"g",
"\"",
"[",
"192",
"168",
"1",
"110",
":",
"1010",
"]",
"\"",
"is",
"good",
"this",
"will",
"be",
"translated",
"into",
"a",
"full",
"qualified",
"metric",
"name",
",",
"e",
"g",
"\"",
"[",
"192",
"168",
"1",
"110",
":",
"1010",
"]",
"avg",
"time",
"\""
] | [
"public",
"void",
"add",
"send",
"packet",
"downstream",
"(",
"final",
"string",
"peer",
"addr",
",",
"final",
"long",
"elapsed",
"ms",
")",
"{",
"send",
"packet",
"downstream",
"rolling",
"averages",
"add",
"(",
"peer",
"addr",
",",
"elapsed",
"ms",
")",
";",
"}"
] |
[
"creates",
"a",
"{",
"@",
"code",
"directory",
"entry",
"}",
"over",
"a",
"writable",
"buffer",
"the",
"given",
"buffers",
"position",
"is",
"advanced",
"by",
"the",
"number",
"of",
"bytes",
"consumed",
"by",
"the",
"view",
"apart",
"from",
"the",
"signature",
",",
"and",
"provided",
"extra",
"data",
"and",
"comment",
"data",
",",
"the",
"returned",
"view",
"is",
"uninitialized"
] | [
"public",
"static",
"directory",
"entry",
"view",
"(",
"byte",
"buffer",
"buffer",
",",
"string",
"name",
",",
"byte",
"[",
"]",
"extra",
"data",
",",
"string",
"comment",
")",
"{",
"byte",
"[",
"]",
"name",
"data",
"=",
"name",
"get",
"bytes",
"(",
"utf",
"8",
")",
";",
"byte",
"[",
"]",
"comment",
"data",
"=",
"comment",
"!",
"=",
"null",
"?",
"comment",
"get",
"bytes",
"(",
"utf",
"8",
")",
":",
"empty",
";",
"if",
"(",
"extra",
"data",
"=",
"=",
"null",
")",
"{",
"extra",
"data",
"=",
"empty",
";",
"}",
"int",
"size",
"=",
"size",
"+",
"name",
"data",
"length",
"+",
"extra",
"data",
"length",
"+",
"comment",
"data",
"length",
";",
"directory",
"entry",
"view",
"=",
"new",
"directory",
"entry",
"(",
"buffer",
"slice",
"(",
")",
")",
"init",
"(",
"name",
"data",
",",
"extra",
"data",
",",
"comment",
"data",
",",
"size",
")",
";",
"buffer",
"position",
"(",
"buffer",
"position",
"(",
")",
"+",
"size",
")",
";",
"return",
"view",
";",
"}"
] |
[
"reads",
"file",
"inside",
"a",
"zip",
"archive"
] | [
"public",
"byte",
"[",
"]",
"read",
"file",
"(",
"string",
"file",
"name",
")",
"throws",
"i",
"o",
"exception",
"{",
"zip",
"file",
"entry",
"entry",
"=",
"zip",
"data",
"get",
"entry",
"(",
"file",
"name",
")",
";",
"if",
"(",
"entry",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"presto",
"exception",
"(",
"druid",
"segment",
"load",
"error",
",",
"format",
"(",
"\"",
"zip",
"doesn",
"'",
"t",
"contain",
"file",
":",
"%",
"s",
"\"",
",",
"file",
"name",
")",
")",
";",
"}",
"byte",
"[",
"]",
"file",
"data",
"=",
"new",
"byte",
"[",
"(",
"int",
")",
"entry",
"get",
"size",
"(",
")",
"]",
";",
"read",
"fully",
"(",
"entry",
",",
"0",
",",
"file",
"data",
",",
"0",
",",
"file",
"data",
"length",
")",
";",
"return",
"file",
"data",
";",
"}"
] |
[
"if",
"is",
"intercept",
"method",
"is",
"true",
"intercept",
"the",
"given",
"request",
",",
"and",
"return",
"a",
"response",
"otherwise",
",",
"the",
"{",
"@",
"link",
"http",
"client",
"request",
"}",
"will",
"be",
"used",
"for",
"execution"
] | [
"http",
"client",
"response",
"intercept",
"(",
")",
";"
] |
[
"gets",
"a",
"decoded",
"frame",
"this",
"will",
"only",
"return",
"non",
"-",
"null",
"if",
"the",
"{",
"@",
"code",
"image",
"decode",
"options",
"}",
"were",
"configured",
"to",
"decode",
"all",
"frames",
"at",
"decode",
"time"
] | [
"public",
"synchronized",
"@",
"nullable",
"closeable",
"reference",
"<",
"bitmap",
">",
"get",
"decoded",
"frame",
"(",
"int",
"index",
")",
"{",
"if",
"(",
"m",
"decoded",
"frames",
"!",
"=",
"null",
")",
"{",
"return",
"closeable",
"reference",
"clone",
"or",
"null",
"(",
"m",
"decoded",
"frames",
"get",
"(",
"index",
")",
")",
";",
"}",
"return",
"null",
";",
"}"
] |
[
"returns",
"true",
"if",
"the",
"input",
"string",
"is",
"a",
"glob",
"of",
"the",
"form",
":",
"{",
"@",
"code",
"<",
"package",
"-",
"service",
">",
"}"
] | [
"static",
"boolean",
"is",
"service",
"glob",
"(",
"string",
"input",
")",
"{",
"return",
"input",
"ends",
"with",
"(",
"\"",
"/",
"*",
"\"",
")",
";",
"}"
] |
[
"return",
"an",
"instance",
"on",
"an",
"unmapped",
"field"
] | [
"protected",
"t",
"create",
"unmapped",
"instance",
"(",
"string",
"name",
",",
"map",
"<",
"string",
",",
"object",
">",
"metadata",
")",
"{",
"/",
"/",
"for",
"most",
"impls",
",",
"we",
"use",
"the",
"same",
"instance",
"in",
"the",
"unmapped",
"case",
"and",
"in",
"the",
"mapped",
"case",
"return",
"create",
"test",
"instance",
"(",
"name",
",",
"metadata",
")",
";",
"}"
] |
[
"display",
"text",
"in",
"the",
"middle",
"of",
"the",
"screen",
",",
"then",
"fade",
"out"
] | [
"public",
"void",
"announce",
"(",
"string",
"text",
")",
"{",
"announce",
"(",
"text",
",",
"3",
")",
";",
"}"
] |
[
"converts",
"parquet",
"schema",
"to",
"flink",
"internal",
"type"
] | [
"public",
"static",
"type",
"information",
"<",
"?",
">",
"from",
"parquet",
"type",
"(",
"message",
"type",
"type",
")",
"{",
"return",
"convert",
"fields",
"(",
"type",
"get",
"fields",
"(",
")",
")",
";",
"}"
] |
[
"compresses",
"the",
"data",
"using",
"the",
"provided",
"hadoop",
"{",
"@",
"link",
"compression",
"codec",
"}"
] | [
"public",
"compress",
"writer",
"factory",
"<",
"in",
">",
"with",
"hadoop",
"compression",
"(",
"string",
"codec",
"name",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"with",
"hadoop",
"compression",
"(",
"codec",
"name",
",",
"new",
"configuration",
"(",
")",
")",
";",
"}"
] |
[
"cancel",
"the",
"given",
"token"
] | [
"public",
"abstract",
"void",
"cancel",
"(",
"token",
"<",
"?",
">",
"token",
",",
"configuration",
"conf",
")",
"throws",
"i",
"o",
"exception",
",",
"interrupted",
"exception",
";"
] |
[
"a",
"convenience",
"method",
"to",
"increment",
"the",
"current",
"progress",
"by",
"the",
"given",
"value"
] | [
"public",
"void",
"increment",
"progress",
"(",
"long",
"increment",
"amount",
")",
";"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] | [
"public",
"void",
"get",
"item",
"offsets",
"(",
"@",
"non",
"null",
"rect",
"out",
"rect",
",",
"@",
"non",
"null",
"view",
"view",
",",
"@",
"non",
"null",
"recycler",
"view",
"parent",
",",
"@",
"non",
"null",
"recycler",
"view",
"state",
"state",
")",
"{",
"int",
"position",
"=",
"parent",
"get",
"child",
"adapter",
"position",
"(",
"view",
")",
";",
"int",
"header",
"height",
"=",
"0",
";",
"if",
"(",
"position",
"!",
"=",
"recycler",
"view",
"no",
"position",
"&",
"&",
"has",
"header",
"(",
"parent",
",",
"adapter",
",",
"position",
")",
")",
"{",
"view",
"header",
"=",
"get",
"header",
"(",
"parent",
",",
"adapter",
",",
"position",
")",
"item",
"view",
";",
"header",
"height",
"=",
"get",
"header",
"height",
"for",
"layout",
"(",
"header",
")",
";",
"}",
"out",
"rect",
"set",
"(",
"0",
",",
"header",
"height",
",",
"0",
",",
"0",
")",
";",
"}"
] |
[
"called",
"after",
"all",
"visit",
"(",
")",
"calls"
] | [
"public",
"void",
"end",
"(",
"project",
"project",
")",
";"
] |
[
"get",
"name",
"array"
] | [
"public",
"list",
"<",
"integer",
">",
"get",
"name",
"array",
"(",
")",
"{",
"return",
"name",
"array",
";",
"}"
] |
[
"renders",
"the",
"'",
"{",
"@",
"code",
"input",
"type",
"=",
"\"",
"radio",
"\"",
"}",
"'",
"element",
"with",
"the",
"configured",
"{",
"@",
"link",
"#",
"set",
"items",
"(",
"object",
")",
"}",
"values",
"marks",
"the",
"element",
"as",
"checked",
"if",
"the",
"value",
"matches",
"the",
"bound",
"value"
] | [
"protected",
"int",
"write",
"tag",
"content",
"(",
"tag",
"writer",
"tag",
"writer",
")",
"throws",
"jsp",
"exception",
"{",
"object",
"items",
"=",
"get",
"items",
"(",
")",
";",
"object",
"items",
"object",
"=",
"(",
"items",
"instanceof",
"string",
"?",
"evaluate",
"(",
"\"",
"items",
"\"",
",",
"items",
")",
":",
"items",
")",
";",
"string",
"item",
"value",
"=",
"get",
"item",
"value",
"(",
")",
";",
"string",
"item",
"label",
"=",
"get",
"item",
"label",
"(",
")",
";",
"string",
"value",
"property",
"=",
"(",
"item",
"value",
"!",
"=",
"null",
"?",
"object",
"utils",
"get",
"display",
"string",
"(",
"evaluate",
"(",
"\"",
"item",
"value",
"\"",
",",
"item",
"value",
")",
")",
":",
"null",
")",
";",
"string",
"label",
"property",
"=",
"(",
"item",
"label",
"!",
"=",
"null",
"?",
"object",
"utils",
"get",
"display",
"string",
"(",
"evaluate",
"(",
"\"",
"item",
"label",
"\"",
",",
"item",
"label",
")",
")",
":",
"null",
")",
";",
"class",
"<",
"?",
">",
"bound",
"type",
"=",
"get",
"bind",
"status",
"(",
")",
"get",
"value",
"type",
"(",
")",
";",
"if",
"(",
"items",
"object",
"=",
"=",
"null",
"&",
"&",
"bound",
"type",
"!",
"=",
"null",
"&",
"&",
"bound",
"type",
"is",
"enum",
"(",
")",
")",
"{",
"items",
"object",
"=",
"bound",
"type",
"get",
"enum",
"constants",
"(",
")",
";",
"}",
"if",
"(",
"items",
"object",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"attribute",
"'",
"items",
"'",
"is",
"required",
"and",
"must",
"be",
"a",
"collection",
",",
"an",
"array",
"or",
"a",
"map",
"\"",
")",
";",
"}",
"if",
"(",
"items",
"object",
"get",
"class",
"(",
")",
"is",
"array",
"(",
")",
")",
"{",
"object",
"[",
"]",
"items",
"array",
"=",
"(",
"object",
"[",
"]",
")",
"items",
"object",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"items",
"array",
"length",
";",
"i",
"+",
"+",
")",
"{",
"object",
"item",
"=",
"items",
"array",
"[",
"i",
"]",
";",
"write",
"object",
"entry",
"(",
"tag",
"writer",
",",
"value",
"property",
",",
"label",
"property",
",",
"item",
",",
"i",
")",
";",
"}",
"}",
"else",
"if",
"(",
"items",
"object",
"instanceof",
"collection",
")",
"{",
"final",
"collection",
"<",
"?",
">",
"option",
"collection",
"=",
"(",
"collection",
"<",
"?",
">",
")",
"items",
"object",
";",
"int",
"item",
"index",
"=",
"0",
";",
"for",
"(",
"iterator",
"<",
"?",
">",
"it",
"=",
"option",
"collection",
"iterator",
"(",
")",
";",
"it",
"has",
"next",
"(",
")",
";",
"item",
"index",
"+",
"+",
")",
"{",
"object",
"item",
"=",
"it",
"next",
"(",
")",
";",
"write",
"object",
"entry",
"(",
"tag",
"writer",
",",
"value",
"property",
",",
"label",
"property",
",",
"item",
",",
"item",
"index",
")",
";",
"}",
"}",
"else",
"if",
"(",
"items",
"object",
"instanceof",
"map",
")",
"{",
"final",
"map",
"<",
"?",
",",
"?",
">",
"option",
"map",
"=",
"(",
"map",
"<",
"?",
",",
"?",
">",
")",
"items",
"object",
";",
"int",
"item",
"index",
"=",
"0",
";",
"for",
"(",
"iterator",
"it",
"=",
"option",
"map",
"entry",
"set",
"(",
")",
"iterator",
"(",
")",
";",
"it",
"has",
"next",
"(",
")",
";",
"item",
"index",
"+",
"+",
")",
"{",
"map",
"entry",
"entry",
"=",
"(",
"map",
"entry",
")",
"it",
"next",
"(",
")",
";",
"write",
"map",
"entry",
"(",
"tag",
"writer",
",",
"value",
"property",
",",
"label",
"property",
",",
"entry",
",",
"item",
"index",
")",
";",
"}",
"}",
"else",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"attribute",
"'",
"items",
"'",
"must",
"be",
"an",
"array",
",",
"a",
"collection",
"or",
"a",
"map",
"\"",
")",
";",
"}",
"return",
"skip",
"body",
";",
"}"
] |
[
"test",
"that",
"xattrs",
"are",
"properly",
"tracked",
"by",
"the",
"standby"
] | [
"public",
"void",
"test",
"x",
"attrs",
"tracked",
"on",
"standby",
"(",
")",
"throws",
"exception",
"{",
"fs",
"create",
"(",
"path",
")",
"close",
"(",
")",
";",
"fs",
"set",
"x",
"attr",
"(",
"path",
",",
"name",
"1",
",",
"value",
"1",
",",
"enum",
"set",
"of",
"(",
"x",
"attr",
"set",
"flag",
"create",
")",
")",
";",
"fs",
"set",
"x",
"attr",
"(",
"path",
",",
"name",
"2",
",",
"value",
"2",
",",
"enum",
"set",
"of",
"(",
"x",
"attr",
"set",
"flag",
"create",
")",
")",
";",
"h",
"a",
"test",
"util",
"wait",
"for",
"standby",
"to",
"catch",
"up",
"(",
"nn",
"0",
",",
"nn",
"1",
")",
";",
"list",
"<",
"x",
"attr",
">",
"x",
"attrs",
"=",
"nn",
"1",
"get",
"rpc",
"server",
"(",
")",
"get",
"x",
"attrs",
"(",
"\"",
"/",
"file",
"\"",
",",
"null",
")",
";",
"assert",
"equals",
"(",
"2",
",",
"x",
"attrs",
"size",
"(",
")",
")",
";",
"cluster",
"shutdown",
"name",
"node",
"(",
"0",
")",
";",
"/",
"/",
"failover",
"the",
"current",
"standby",
"to",
"active",
"cluster",
"shutdown",
"name",
"node",
"(",
"0",
")",
";",
"cluster",
"transition",
"to",
"active",
"(",
"1",
")",
";",
"map",
"<",
"string",
",",
"byte",
"[",
"]",
">",
"xattrs",
"=",
"fs",
"get",
"x",
"attrs",
"(",
"path",
")",
";",
"assert",
"assert",
"equals",
"(",
"xattrs",
"size",
"(",
")",
",",
"2",
")",
";",
"assert",
"assert",
"array",
"equals",
"(",
"value",
"1",
",",
"xattrs",
"get",
"(",
"name",
"1",
")",
")",
";",
"assert",
"assert",
"array",
"equals",
"(",
"value",
"2",
",",
"xattrs",
"get",
"(",
"name",
"2",
")",
")",
";",
"fs",
"delete",
"(",
"path",
",",
"true",
")",
";",
"}"
] |
[
"get",
"the",
"header",
"flag",
"of",
"ith",
"reply"
] | [
"public",
"int",
"get",
"header",
"flag",
"(",
"int",
"i",
")",
"{",
"if",
"(",
"proto",
"get",
"flag",
"count",
"(",
")",
">",
"0",
")",
"{",
"return",
"proto",
"get",
"flag",
"(",
"i",
")",
";",
"}",
"else",
"{",
"return",
"combine",
"header",
"(",
"ecn",
"disabled",
",",
"proto",
"get",
"reply",
"(",
"i",
")",
")",
";",
"}",
"}"
] |
[
"set",
"the",
"{",
"@",
"code",
"unmarshaller",
"listener",
"}",
"to",
"be",
"registered",
"with",
"the",
"jaxb",
"{",
"@",
"code",
"unmarshaller",
"}"
] | [
"public",
"void",
"set",
"unmarshaller",
"listener",
"(",
"unmarshaller",
"listener",
"unmarshaller",
"listener",
")",
"{",
"this",
"unmarshaller",
"listener",
"=",
"unmarshaller",
"listener",
";",
"}"
] |
[
"patch",
"fake",
":",
"to",
"test",
"\\",
"&",
"quot",
";",
"client",
"\\",
"&",
"quot",
";",
"model",
"to",
"test",
"\\",
"&",
"quot",
";",
"client",
"\\",
"&",
"quot",
";",
"model"
] | [
"default",
"response",
"entity",
"<",
"client",
">",
"test",
"client",
"model",
"(",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"client",
"model",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"valid",
"@",
"request",
"body",
"client",
"body",
")",
"{",
"return",
"get",
"delegate",
"(",
")",
"test",
"client",
"model",
"(",
"body",
")",
";",
"}"
] |
[
"returns",
"an",
"entry",
"with",
"a",
"key",
"less",
"than",
"the",
"keys",
"of",
"the",
"{",
"@",
"link",
"#",
"samples",
"(",
")",
"}",
"and",
"less",
"than",
"the",
"key",
"of",
"{",
"@",
"link",
"#",
"below",
"samples",
"greater",
"(",
")",
"}"
] | [
"entry",
"<",
"k",
",",
"v",
">",
"below",
"samples",
"lesser",
"(",
")",
";"
] |
[
"get",
"the",
"parts",
"of",
"a",
"multipart",
"request",
"if",
"the",
"content",
"-",
"type",
"is",
"{",
"@",
"code",
"\"",
"multipartform",
"-",
"data",
"\"",
"}",
"or",
"an",
"empty",
"map",
"otherwise",
"note",
":",
"calling",
"this",
"method",
"causes",
"the",
"request",
"body",
"to",
"be",
"read",
"and",
"parsed",
"in",
"full",
",",
"and",
"the",
"resulting",
"{",
"@",
"code",
"multi",
"value",
"map",
"}",
"is",
"cached",
"so",
"that",
"this",
"method",
"is",
"safe",
"to",
"call",
"more",
"than",
"once"
] | [
"mono",
"<",
"multi",
"value",
"map",
"<",
"string",
",",
"part",
">",
">",
"multipart",
"data",
"(",
")",
";"
] |
[
"test",
"get",
"sys",
"property"
] | [
"public",
"void",
"test",
"get",
"sys",
"property",
"(",
")",
"{",
"assertions",
"assert",
"null",
"(",
"sys",
"config",
"get",
"internal",
"property",
"(",
"mock",
"key",
")",
")",
";",
"assertions",
"assert",
"false",
"(",
"sys",
"config",
"contains",
"key",
"(",
"mock",
"key",
")",
")",
";",
"assertions",
"assert",
"null",
"(",
"sys",
"config",
"get",
"string",
"(",
"mock",
"key",
")",
")",
";",
"assertions",
"assert",
"null",
"(",
"sys",
"config",
"get",
"property",
"(",
"mock",
"key",
")",
")",
";",
"system",
"set",
"property",
"(",
"mock",
"key",
",",
"mock",
"string",
"value",
")",
";",
"assertions",
"assert",
"true",
"(",
"sys",
"config",
"contains",
"key",
"(",
"mock",
"key",
")",
")",
";",
"assertions",
"assert",
"equals",
"(",
"mock",
"string",
"value",
",",
"sys",
"config",
"get",
"internal",
"property",
"(",
"mock",
"key",
")",
")",
";",
"assertions",
"assert",
"equals",
"(",
"mock",
"string",
"value",
",",
"sys",
"config",
"get",
"string",
"(",
"mock",
"key",
",",
"mock",
"string",
"value",
")",
")",
";",
"assertions",
"assert",
"equals",
"(",
"mock",
"string",
"value",
",",
"sys",
"config",
"get",
"property",
"(",
"mock",
"key",
",",
"mock",
"string",
"value",
")",
")",
";",
"}"
] |
[
"clears",
"the",
"background",
"of",
"the",
"listing",
"at",
"the",
"given",
"address",
"to",
"the",
"given",
"color",
"see",
"the",
"listing",
"help",
"page",
"in",
"ghidra",
"help",
"for",
"more",
"information",
"this",
"method",
"is",
"unavailable",
"in",
"headless",
"mode",
"note",
":",
"you",
"can",
"use",
"the",
"{",
"@",
"link",
"colorizing",
"service",
"}",
"directly",
"to",
"access",
"more",
"color",
"changing",
"functionality",
"see",
"the",
"source",
"code",
"of",
"this",
"method",
"to",
"learn",
"how",
"to",
"access",
"services",
"from",
"a",
"script"
] | [
"public",
"void",
"clear",
"background",
"color",
"(",
"address",
"address",
")",
"throws",
"improper",
"use",
"exception",
"{",
"if",
"(",
"is",
"running",
"headless",
"(",
")",
")",
"{",
"throw",
"new",
"improper",
"use",
"exception",
"(",
"\"",
"the",
"clear",
"background",
"color",
"(",
")",
"method",
"can",
"only",
"be",
"used",
"when",
"running",
"headed",
"ghidra",
"\"",
")",
";",
"}",
"plugin",
"tool",
"tool",
"=",
"state",
"get",
"tool",
"(",
")",
";",
"colorizing",
"service",
"service",
"=",
"tool",
"get",
"service",
"(",
"colorizing",
"service",
"class",
")",
";",
"if",
"(",
"service",
"=",
"=",
"null",
")",
"{",
"printerr",
"(",
"\"",
"cannot",
"clear",
"background",
"colors",
"without",
"the",
"\"",
"+",
"colorizing",
"service",
"class",
"get",
"simple",
"name",
"(",
")",
"+",
"\"",
"installed",
"\"",
")",
";",
"return",
";",
"}",
"service",
"clear",
"background",
"color",
"(",
"address",
",",
"address",
")",
";",
"}"
] |
[
"default",
"function",
"for",
"constructing",
"{",
"@",
"link",
"thread",
"pool",
"executor",
"}",
"s",
"the",
"{",
"@",
"link",
"thread",
"pool",
"executor",
"}",
"s",
"this",
"creates",
"have",
"the",
"same",
"value",
"for",
"{",
"@",
"code",
"core",
"pool",
"size",
"}",
"and",
"{",
"@",
"code",
"maximum",
"pool",
"size",
"}",
"because",
"that",
"results",
"in",
"a",
"fixed",
"-",
"size",
"thread",
"pool",
",",
"and",
"the",
"current",
"use",
"cases",
"for",
"{",
"@",
"link",
"abstract",
"queue",
"visitor",
"}",
"don",
"'",
"t",
"require",
"any",
"more",
"sophisticated",
"thread",
"pool",
"size",
"management",
"if",
"client",
"use",
"cases",
"change",
",",
"they",
"may",
"invoke",
"one",
"of",
"the",
"{",
"@",
"link",
"abstract",
"queue",
"visitor",
"#",
"abstract",
"queue",
"visitor",
"}",
"constructors",
"that",
"accepts",
"a",
"pre",
"-",
"constructed",
"{",
"@",
"link",
"thread",
"pool",
"executor",
"}"
] | [
"private",
"static",
"executor",
"service",
"create",
"executor",
"service",
"(",
"int",
"parallelism",
",",
"long",
"keep",
"alive",
"time",
",",
"time",
"unit",
"units",
",",
"blocking",
"queue",
"<",
"runnable",
">",
"work",
"queue",
",",
"string",
"pool",
"name",
")",
"{",
"if",
"(",
"\"",
"1",
"\"",
"equals",
"(",
"system",
"get",
"property",
"(",
"\"",
"experimental",
"use",
"fork",
"join",
"pool",
"\"",
")",
")",
")",
"{",
"return",
"new",
"named",
"fork",
"join",
"pool",
"(",
"pool",
"name",
",",
"parallelism",
")",
";",
"}",
"return",
"new",
"thread",
"pool",
"executor",
"(",
"/",
"*",
"core",
"pool",
"size",
"=",
"*",
"/",
"parallelism",
",",
"/",
"*",
"maximum",
"pool",
"size",
"=",
"*",
"/",
"parallelism",
",",
"keep",
"alive",
"time",
",",
"units",
",",
"work",
"queue",
",",
"new",
"thread",
"factory",
"builder",
"(",
")",
"set",
"name",
"format",
"(",
"preconditions",
"check",
"not",
"null",
"(",
"pool",
"name",
")",
"+",
"\"",
"%",
"d",
"\"",
")",
"build",
"(",
")",
")",
";",
"}"
] |
[
"puts",
"the",
"given",
"entry",
"into",
"the",
"map"
] | [
"v",
"put",
"(",
"int",
"key",
",",
"v",
"value",
")",
";"
] |
[
"test",
"the",
"property",
"'",
"att",
"name",
"'"
] | [
"public",
"void",
"att",
"n",
"a",
"m",
"e",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"att",
"name",
"}"
] |
[
"set",
"the",
"strategy",
"that",
"will",
"be",
"used",
"to",
"configure",
"the",
"embedded",
"database",
"instance",
"call",
"this",
"when",
"you",
"wish",
"to",
"use",
"an",
"embedded",
"database",
"type",
"not",
"already",
"supported"
] | [
"public",
"void",
"set",
"database",
"configurer",
"(",
"embedded",
"database",
"configurer",
"configurer",
")",
"{",
"this",
"database",
"configurer",
"=",
"configurer",
";",
"}"
] |
[
"only",
"use",
"when",
"getting",
"all",
"columns",
"and",
"meanwhile",
"do",
"not",
"want",
"to",
"do",
"per",
"-",
"column",
"estimation"
] | [
"public",
"double",
"get",
"output",
"size",
"in",
"bytes",
"(",
")",
"{",
"return",
"total",
"size",
";",
"}"
] |
[
"gets",
"this",
"table",
"'",
"s",
"table",
"type"
] | [
"public",
"cli",
"type",
"table",
"get",
"table",
"type",
"(",
")",
"{",
"return",
"table",
"type",
";",
"}"
] |
[
"save",
"the",
"workspace",
"'",
"s",
"data",
"out",
"to",
"file",
"in",
"a",
"safe",
"way",
":",
"save",
"to",
"a",
"temporary",
"file",
"first",
"and",
"rename",
"it",
"to",
"the",
"real",
"file"
] | [
"protected",
"void",
"save",
"workspace",
"(",
")",
"{",
"synchronized",
"(",
"this",
")",
"{",
"/",
"/",
"todo",
"refactor",
"this",
"so",
"that",
"we",
"check",
"if",
"the",
"save",
"is",
"needed",
"before",
"writing",
"to",
"the",
"file",
"!",
"file",
"temp",
"file",
"=",
"new",
"file",
"(",
"workspace",
"dir",
",",
"\"",
"workspace",
"temp",
"json",
"\"",
")",
";",
"try",
"{",
"if",
"(",
"!",
"save",
"to",
"file",
"(",
"temp",
"file",
")",
")",
"{",
"/",
"/",
"if",
"the",
"save",
"wasn",
"'",
"t",
"really",
"needed",
",",
"just",
"keep",
"what",
"we",
"had",
"temp",
"file",
"delete",
"(",
")",
";",
"logger",
"info",
"(",
"\"",
"skipping",
"unnecessary",
"workspace",
"save",
"\"",
")",
";",
"return",
";",
"}",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"e",
"print",
"stack",
"trace",
"(",
")",
";",
"logger",
"warn",
"(",
"\"",
"failed",
"to",
"save",
"workspace",
"\"",
")",
";",
"return",
";",
"}",
"file",
"file",
"=",
"new",
"file",
"(",
"workspace",
"dir",
",",
"\"",
"workspace",
"json",
"\"",
")",
";",
"file",
"old",
"file",
"=",
"new",
"file",
"(",
"workspace",
"dir",
",",
"\"",
"workspace",
"old",
"json",
"\"",
")",
";",
"if",
"(",
"old",
"file",
"exists",
"(",
")",
")",
"{",
"old",
"file",
"delete",
"(",
")",
";",
"}",
"if",
"(",
"file",
"exists",
"(",
")",
")",
"{",
"file",
"rename",
"to",
"(",
"old",
"file",
")",
";",
"}",
"temp",
"file",
"rename",
"to",
"(",
"file",
")",
";",
"logger",
"info",
"(",
"\"",
"saved",
"workspace",
"\"",
")",
";",
"}",
"}"
] |
[
"exit",
"a",
"parse",
"tree",
"produced",
"by",
"the",
"{",
"@",
"code",
"boolean",
"literal",
"}",
"labeled",
"alternative",
"in",
"{",
"@",
"link",
"sql",
"base",
"parser",
"#",
"constant",
"}"
] | [
"void",
"exit",
"boolean",
"literal",
"(",
"sql",
"base",
"parser",
"boolean",
"literal",
"context",
"ctx",
")",
";"
] |
[
"short",
"for",
"{",
"@",
"code",
"validate",
"file",
"mask",
"(",
"value",
",",
"error",
"if",
"not",
"exist",
",",
"true",
")",
"}"
] | [
"public",
"form",
"validation",
"validate",
"file",
"mask",
"(",
"string",
"value",
",",
"boolean",
"error",
"if",
"not",
"exist",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"validate",
"file",
"mask",
"(",
"value",
",",
"error",
"if",
"not",
"exist",
",",
"true",
")",
";",
"}"
] |
[
"computes",
"the",
"start",
"and",
"end",
"of",
"a",
"region",
"of",
"pixels",
",",
"either",
"horizontally",
"or",
"vertically",
",",
"that",
"could",
"be",
"part",
"of",
"a",
"data",
"matrix",
"barcode"
] | [
"private",
"int",
"[",
"]",
"black",
"white",
"range",
"(",
"int",
"fixed",
"dimension",
",",
"int",
"max",
"white",
"run",
",",
"int",
"min",
"dim",
",",
"int",
"max",
"dim",
",",
"boolean",
"horizontal",
")",
"{",
"int",
"center",
"=",
"(",
"min",
"dim",
"+",
"max",
"dim",
")",
"/",
"2",
";",
"/",
"/",
"scan",
"left",
"/",
"up",
"first",
"int",
"start",
"=",
"center",
";",
"while",
"(",
"start",
">",
"=",
"min",
"dim",
")",
"{",
"if",
"(",
"horizontal",
"?",
"image",
"get",
"(",
"start",
",",
"fixed",
"dimension",
")",
":",
"image",
"get",
"(",
"fixed",
"dimension",
",",
"start",
")",
")",
"{",
"start",
"-",
"-",
";",
"}",
"else",
"{",
"int",
"white",
"run",
"start",
"=",
"start",
";",
"do",
"{",
"start",
"-",
"-",
";",
"}",
"while",
"(",
"start",
">",
"=",
"min",
"dim",
"&",
"&",
"!",
"(",
"horizontal",
"?",
"image",
"get",
"(",
"start",
",",
"fixed",
"dimension",
")",
":",
"image",
"get",
"(",
"fixed",
"dimension",
",",
"start",
")",
")",
")",
";",
"int",
"white",
"run",
"size",
"=",
"white",
"run",
"start",
"-",
"start",
";",
"if",
"(",
"start",
"<",
"min",
"dim",
"|",
"|",
"white",
"run",
"size",
">",
"max",
"white",
"run",
")",
"{",
"start",
"=",
"white",
"run",
"start",
";",
"break",
";",
"}",
"}",
"}",
"start",
"+",
"+",
";",
"/",
"/",
"then",
"try",
"right",
"/",
"down",
"int",
"end",
"=",
"center",
";",
"while",
"(",
"end",
"<",
"max",
"dim",
")",
"{",
"if",
"(",
"horizontal",
"?",
"image",
"get",
"(",
"end",
",",
"fixed",
"dimension",
")",
":",
"image",
"get",
"(",
"fixed",
"dimension",
",",
"end",
")",
")",
"{",
"end",
"+",
"+",
";",
"}",
"else",
"{",
"int",
"white",
"run",
"start",
"=",
"end",
";",
"do",
"{",
"end",
"+",
"+",
";",
"}",
"while",
"(",
"end",
"<",
"max",
"dim",
"&",
"&",
"!",
"(",
"horizontal",
"?",
"image",
"get",
"(",
"end",
",",
"fixed",
"dimension",
")",
":",
"image",
"get",
"(",
"fixed",
"dimension",
",",
"end",
")",
")",
")",
";",
"int",
"white",
"run",
"size",
"=",
"end",
"-",
"white",
"run",
"start",
";",
"if",
"(",
"end",
">",
"=",
"max",
"dim",
"|",
"|",
"white",
"run",
"size",
">",
"max",
"white",
"run",
")",
"{",
"end",
"=",
"white",
"run",
"start",
";",
"break",
";",
"}",
"}",
"}",
"end",
"-",
"-",
";",
"return",
"end",
">",
"start",
"?",
"new",
"int",
"[",
"]",
"{",
"start",
",",
"end",
"}",
":",
"null",
";",
"}"
] |
[
"compares",
"two",
"maps",
"generated",
"from",
"x",
"content",
"objects",
"the",
"order",
"of",
"elements",
"in",
"arrays",
"is",
"ignored"
] | [
"public",
"static",
"string",
"difference",
"between",
"maps",
"ignoring",
"array",
"order",
"(",
"map",
"<",
"string",
",",
"object",
">",
"first",
",",
"map",
"<",
"string",
",",
"object",
">",
"second",
")",
"{",
"return",
"difference",
"between",
"maps",
"ignoring",
"array",
"order",
"(",
"\"",
"\"",
",",
"first",
",",
"second",
")",
";",
"}"
] |
[
"links",
"a",
"{",
"@",
"link",
"dynamic",
"value",
"}",
"object",
"to",
"the",
"rotation",
"value",
"for",
"this",
"component"
] | [
"public",
"t",
"rotation",
"(",
"dynamic",
"value",
"<",
"float",
">",
"rotation",
")",
"{",
"m",
"component",
"get",
"or",
"create",
"common",
"dynamic",
"props",
"(",
")",
"put",
"(",
"key",
"rotation",
",",
"rotation",
")",
";",
"return",
"get",
"this",
"(",
")",
";",
"}"
] |
[
"parse",
"parameters",
"from",
"the",
"given",
"list",
"of",
"args",
"the",
"list",
"is",
"destructively",
"modified",
"to",
"remove",
"the",
"options"
] | [
"public",
"void",
"parse",
"(",
"list",
"<",
"string",
">",
"args",
")",
"{",
"int",
"pos",
"=",
"0",
";",
"while",
"(",
"pos",
"<",
"args",
"size",
"(",
")",
")",
"{",
"string",
"arg",
"=",
"args",
"get",
"(",
"pos",
")",
";",
"/",
"/",
"stop",
"if",
"not",
"an",
"opt",
",",
"or",
"the",
"stdin",
"arg",
"\"",
"-",
"\"",
"is",
"found",
"if",
"(",
"!",
"arg",
"starts",
"with",
"(",
"\"",
"-",
"\"",
")",
"|",
"|",
"arg",
"equals",
"(",
"\"",
"-",
"\"",
")",
")",
"{",
"break",
";",
"}",
"else",
"if",
"(",
"arg",
"equals",
"(",
"\"",
"-",
"-",
"\"",
")",
")",
"{",
"/",
"/",
"force",
"end",
"of",
"option",
"processing",
"args",
"remove",
"(",
"pos",
")",
";",
"break",
";",
"}",
"string",
"opt",
"=",
"arg",
"substring",
"(",
"1",
")",
";",
"if",
"(",
"options",
"contains",
"key",
"(",
"opt",
")",
")",
"{",
"args",
"remove",
"(",
"pos",
")",
";",
"options",
"put",
"(",
"opt",
",",
"boolean",
"true",
")",
";",
"}",
"else",
"if",
"(",
"options",
"with",
"value",
"contains",
"key",
"(",
"opt",
")",
")",
"{",
"args",
"remove",
"(",
"pos",
")",
";",
"if",
"(",
"pos",
"<",
"args",
"size",
"(",
")",
"&",
"&",
"(",
"args",
"size",
"(",
")",
">",
"min",
"par",
")",
"&",
"&",
"!",
"args",
"get",
"(",
"pos",
")",
"starts",
"with",
"(",
"\"",
"-",
"\"",
")",
")",
"{",
"arg",
"=",
"args",
"get",
"(",
"pos",
")",
";",
"args",
"remove",
"(",
"pos",
")",
";",
"}",
"else",
"{",
"arg",
"=",
"\"",
"\"",
";",
"}",
"if",
"(",
"!",
"arg",
"starts",
"with",
"(",
"\"",
"-",
"\"",
")",
"|",
"|",
"arg",
"equals",
"(",
"\"",
"-",
"\"",
")",
")",
"{",
"options",
"with",
"value",
"put",
"(",
"opt",
",",
"arg",
")",
";",
"}",
"}",
"else",
"if",
"(",
"ignore",
"unknown",
"opts",
")",
"{",
"pos",
"+",
"+",
";",
"}",
"else",
"{",
"throw",
"new",
"unknown",
"option",
"exception",
"(",
"arg",
")",
";",
"}",
"}",
"int",
"psize",
"=",
"args",
"size",
"(",
")",
";",
"if",
"(",
"psize",
"<",
"min",
"par",
")",
"{",
"throw",
"new",
"not",
"enough",
"arguments",
"exception",
"(",
"min",
"par",
",",
"psize",
")",
";",
"}",
"if",
"(",
"psize",
">",
"max",
"par",
")",
"{",
"throw",
"new",
"too",
"many",
"arguments",
"exception",
"(",
"max",
"par",
",",
"psize",
")",
";",
"}",
"}"
] |
[
"sets",
"the",
"no",
"usage",
"statistics",
"flag"
] | [
"public",
"void",
"set",
"no",
"usage",
"statistics",
"(",
"boolean",
"no",
"usage",
"statistics",
")",
"throws",
"i",
"o",
"exception",
"{",
"this",
"no",
"usage",
"statistics",
"=",
"no",
"usage",
"statistics",
";",
"save",
"(",
")",
";",
"}"
] |
[
"test",
"cases",
"retrieves",
"all",
"six",
"documents",
"indexed",
"above",
"and",
"checks",
"the",
"prec",
"@",
"10",
"calculation",
"where",
"all",
"unlabeled",
"documents",
"are",
"treated",
"as",
"not",
"relevant"
] | [
"public",
"void",
"test",
"rank",
"eval",
"request",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"list",
"<",
"rated",
"request",
">",
"specifications",
"=",
"create",
"test",
"evaluation",
"spec",
"(",
")",
";",
"precision",
"at",
"k",
"metric",
"=",
"new",
"precision",
"at",
"k",
"(",
"1",
",",
"false",
",",
"10",
")",
";",
"rank",
"eval",
"spec",
"spec",
"=",
"new",
"rank",
"eval",
"spec",
"(",
"specifications",
",",
"metric",
")",
";",
"rank",
"eval",
"request",
"rank",
"eval",
"request",
"=",
"new",
"rank",
"eval",
"request",
"(",
"spec",
",",
"new",
"string",
"[",
"]",
"{",
"\"",
"index",
"\"",
",",
"\"",
"index",
"2",
"\"",
"}",
")",
";",
"rank",
"eval",
"response",
"response",
"=",
"execute",
"(",
"rank",
"eval",
"request",
",",
"high",
"level",
"client",
"(",
")",
":",
":",
"rank",
"eval",
",",
"high",
"level",
"client",
"(",
")",
":",
":",
"rank",
"eval",
"async",
")",
";",
"/",
"/",
"the",
"expected",
"prec",
"@",
"for",
"the",
"first",
"query",
"is",
"5",
"/",
"7",
"and",
"the",
"expected",
"prec",
"@",
"for",
"the",
"second",
"is",
"1",
"/",
"7",
",",
"divided",
"by",
"2",
"to",
"get",
"the",
"average",
"double",
"expected",
"precision",
"=",
"(",
"1",
"0",
"/",
"7",
"0",
"+",
"5",
"0",
"/",
"7",
"0",
")",
"/",
"2",
"0",
";",
"assert",
"equals",
"(",
"expected",
"precision",
",",
"response",
"get",
"metric",
"score",
"(",
")",
",",
"double",
"min",
"value",
")",
";",
"map",
"<",
"string",
",",
"eval",
"query",
"quality",
">",
"partial",
"results",
"=",
"response",
"get",
"partial",
"results",
"(",
")",
";",
"assert",
"equals",
"(",
"2",
",",
"partial",
"results",
"size",
"(",
")",
")",
";",
"eval",
"query",
"quality",
"amsterdam",
"query",
"quality",
"=",
"partial",
"results",
"get",
"(",
"\"",
"amsterdam",
"query",
"\"",
")",
";",
"assert",
"equals",
"(",
"2",
",",
"filter",
"unrated",
"documents",
"(",
"amsterdam",
"query",
"quality",
"get",
"hits",
"and",
"ratings",
"(",
")",
")",
"size",
"(",
")",
")",
";",
"list",
"<",
"rated",
"search",
"hit",
">",
"hits",
"and",
"ratings",
"=",
"amsterdam",
"query",
"quality",
"get",
"hits",
"and",
"ratings",
"(",
")",
";",
"assert",
"equals",
"(",
"7",
",",
"hits",
"and",
"ratings",
"size",
"(",
")",
")",
";",
"for",
"(",
"rated",
"search",
"hit",
"hit",
":",
"hits",
"and",
"ratings",
")",
"{",
"string",
"id",
"=",
"hit",
"get",
"search",
"hit",
"(",
")",
"get",
"id",
"(",
")",
";",
"if",
"(",
"id",
"equals",
"(",
"\"",
"berlin",
"\"",
")",
"|",
"|",
"id",
"equals",
"(",
"\"",
"amsterdam",
"5",
"\"",
")",
")",
"{",
"assert",
"false",
"(",
"hit",
"get",
"rating",
"(",
")",
"is",
"present",
"(",
")",
")",
";",
"}",
"else",
"{",
"assert",
"equals",
"(",
"1",
",",
"hit",
"get",
"rating",
"(",
")",
"get",
"as",
"int",
"(",
")",
")",
";",
"}",
"}",
"eval",
"query",
"quality",
"berlin",
"query",
"quality",
"=",
"partial",
"results",
"get",
"(",
"\"",
"berlin",
"query",
"\"",
")",
";",
"assert",
"equals",
"(",
"6",
",",
"filter",
"unrated",
"documents",
"(",
"berlin",
"query",
"quality",
"get",
"hits",
"and",
"ratings",
"(",
")",
")",
"size",
"(",
")",
")",
";",
"hits",
"and",
"ratings",
"=",
"berlin",
"query",
"quality",
"get",
"hits",
"and",
"ratings",
"(",
")",
";",
"assert",
"equals",
"(",
"7",
",",
"hits",
"and",
"ratings",
"size",
"(",
")",
")",
";",
"for",
"(",
"rated",
"search",
"hit",
"hit",
":",
"hits",
"and",
"ratings",
")",
"{",
"string",
"id",
"=",
"hit",
"get",
"search",
"hit",
"(",
")",
"get",
"id",
"(",
")",
";",
"if",
"(",
"id",
"equals",
"(",
"\"",
"berlin",
"\"",
")",
")",
"{",
"assert",
"equals",
"(",
"1",
",",
"hit",
"get",
"rating",
"(",
")",
"get",
"as",
"int",
"(",
")",
")",
";",
"}",
"else",
"{",
"assert",
"false",
"(",
"hit",
"get",
"rating",
"(",
")",
"is",
"present",
"(",
")",
")",
";",
"}",
"}",
"/",
"/",
"now",
"try",
"this",
"when",
"test",
"2",
"is",
"closed",
"close",
"index",
"(",
"\"",
"index",
"2",
"\"",
")",
";",
"rank",
"eval",
"request",
"indices",
"options",
"(",
"indices",
"options",
"from",
"parameters",
"(",
"null",
",",
"\"",
"true",
"\"",
",",
"null",
",",
"\"",
"false",
"\"",
",",
"search",
"request",
"default",
"indices",
"options",
")",
")",
";",
"response",
"=",
"execute",
"(",
"rank",
"eval",
"request",
",",
"high",
"level",
"client",
"(",
")",
":",
":",
"rank",
"eval",
",",
"high",
"level",
"client",
"(",
")",
":",
":",
"rank",
"eval",
"async",
")",
";",
"}"
] |
[
"add",
"the",
"models",
"to",
"this",
"controller",
"can",
"only",
"be",
"called",
"from",
"inside",
"{",
"@",
"link",
"epoxy",
"controller",
"#",
"build",
"models",
"(",
")",
"}"
] | [
"protected",
"void",
"add",
"(",
"@",
"non",
"null",
"epoxy",
"model",
"<",
"?",
">",
"models",
"to",
"add",
")",
"{",
"models",
"being",
"built",
"ensure",
"capacity",
"(",
"models",
"being",
"built",
"size",
"(",
")",
"+",
"models",
"to",
"add",
"length",
")",
";",
"for",
"(",
"epoxy",
"model",
"<",
"?",
">",
"model",
":",
"models",
"to",
"add",
")",
"{",
"add",
"(",
"model",
")",
";",
"}",
"}"
] |
[
"informs",
"the",
"drawable",
"to",
"drop",
"its",
"caches"
] | [
"void",
"drop",
"caches",
"(",
")",
";"
] |
[
"generate",
"a",
"sample",
"of",
"data",
"set",
"which",
"contains",
"fixed",
"size",
"elements",
"note",
":",
"sample",
"with",
"fixed",
"size",
"is",
"not",
"as",
"efficient",
"as",
"sample",
"with",
"fraction",
",",
"use",
"sample",
"with",
"fraction",
"unless",
"you",
"need",
"exact",
"precision"
] | [
"public",
"static",
"<",
"t",
">",
"data",
"set",
"<",
"t",
">",
"sample",
"with",
"size",
"(",
"data",
"set",
"<",
"t",
">",
"input",
",",
"final",
"boolean",
"with",
"replacement",
",",
"final",
"int",
"num",
"samples",
")",
"{",
"return",
"sample",
"with",
"size",
"(",
"input",
",",
"with",
"replacement",
",",
"num",
"samples",
",",
"utils",
"rng",
"next",
"long",
"(",
")",
")",
";",
"}"
] |
[
"abort",
"the",
"batch",
"and",
"complete",
"the",
"future",
"and",
"callbacks"
] | [
"public",
"void",
"abort",
"(",
"runtime",
"exception",
"exception",
")",
"{",
"if",
"(",
"!",
"final",
"state",
"compare",
"and",
"set",
"(",
"null",
",",
"final",
"state",
"aborted",
")",
")",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"batch",
"has",
"already",
"been",
"completed",
"in",
"final",
"state",
"\"",
"+",
"final",
"state",
"get",
"(",
")",
")",
";",
"log",
"trace",
"(",
"\"",
"aborting",
"batch",
"for",
"partition",
"{",
"}",
"\"",
",",
"topic",
"partition",
",",
"exception",
")",
";",
"complete",
"future",
"and",
"fire",
"callbacks",
"(",
"produce",
"response",
"invalid",
"offset",
",",
"record",
"batch",
"no",
"timestamp",
",",
"exception",
")",
";",
"}"
] |
[
"creates",
"a",
"new",
"listenable",
"future",
"-",
"style",
"stub",
"that",
"supports",
"unary",
"calls",
"on",
"the",
"service"
] | [
"public",
"static",
"metrics",
"service",
"future",
"stub",
"new",
"future",
"stub",
"(",
"io",
"grpc",
"channel",
"channel",
")",
"{",
"io",
"grpc",
"stub",
"abstract",
"stub",
"stub",
"factory",
"<",
"metrics",
"service",
"future",
"stub",
">",
"factory",
"=",
"new",
"io",
"grpc",
"stub",
"abstract",
"stub",
"stub",
"factory",
"<",
"metrics",
"service",
"future",
"stub",
">",
"(",
")",
"{",
"@",
"java",
"lang",
"override",
"public",
"metrics",
"service",
"future",
"stub",
"new",
"stub",
"(",
"io",
"grpc",
"channel",
"channel",
",",
"io",
"grpc",
"call",
"options",
"call",
"options",
")",
"{",
"return",
"new",
"metrics",
"service",
"future",
"stub",
"(",
"channel",
",",
"call",
"options",
")",
";",
"}",
"}",
";",
"return",
"metrics",
"service",
"future",
"stub",
"new",
"stub",
"(",
"factory",
",",
"channel",
")",
";",
"}"
] |
[
"sends",
"a",
"new",
"read",
"requests",
",",
"if",
"further",
"requests",
"remain",
"otherwise",
",",
"this",
"method",
"adds",
"the",
"segment",
"directly",
"to",
"the",
"readers",
"return",
"queue"
] | [
"protected",
"void",
"send",
"read",
"request",
"(",
"memory",
"segment",
"seg",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"this",
"num",
"requests",
"remaining",
"!",
"=",
"0",
")",
"{",
"this",
"reader",
"read",
"block",
"(",
"seg",
")",
";",
"if",
"(",
"this",
"num",
"requests",
"remaining",
"!",
"=",
"-",
"1",
")",
"{",
"this",
"num",
"requests",
"remaining",
"-",
"-",
";",
"}",
"}",
"else",
"{",
"/",
"/",
"directly",
"add",
"it",
"to",
"the",
"end",
"of",
"the",
"return",
"queue",
"this",
"free",
"mem",
"add",
"(",
"seg",
")",
";",
"}",
"}"
] |
[
"sets",
"application",
"id"
] | [
"public",
"void",
"set",
"application",
"id",
"(",
"string",
"application",
"id",
")",
"{",
"this",
"application",
"id",
"=",
"application",
"id",
";",
"}"
] |
[
"restarts",
"a",
"node",
"and",
"calls",
"the",
"callback",
"during",
"restart"
] | [
"public",
"synchronized",
"void",
"restart",
"node",
"(",
"string",
"node",
"name",
",",
"restart",
"callback",
"callback",
")",
"throws",
"exception",
"{",
"ensure",
"open",
"(",
")",
";",
"node",
"and",
"client",
"node",
"and",
"client",
"=",
"nodes",
"get",
"(",
"node",
"name",
")",
";",
"if",
"(",
"node",
"and",
"client",
"!",
"=",
"null",
")",
"{",
"restart",
"node",
"(",
"node",
"and",
"client",
",",
"callback",
")",
";",
"}",
"}"
] |
[
"register",
"a",
"bean",
"from",
"the",
"given",
"bean",
"class",
",",
"deriving",
"its",
"metadata",
"from",
"class",
"-",
"declared",
"annotations",
",",
"using",
"the",
"given",
"supplier",
"for",
"obtaining",
"a",
"new",
"instance",
"(",
"possibly",
"declared",
"as",
"a",
"lambda",
"expression",
"or",
"method",
"reference",
")"
] | [
"public",
"<",
"t",
">",
"void",
"register",
"bean",
"(",
"class",
"<",
"t",
">",
"bean",
"class",
",",
"@",
"nullable",
"string",
"name",
",",
"@",
"nullable",
"supplier",
"<",
"t",
">",
"supplier",
")",
"{",
"do",
"register",
"bean",
"(",
"bean",
"class",
",",
"name",
",",
"null",
",",
"supplier",
",",
"null",
")",
";",
"}"
] |
[
"parses",
"a",
"list",
"all",
"my",
"buckets",
"response",
"xml",
"document",
"from",
"an",
"input",
"stream"
] | [
"public",
"list",
"all",
"my",
"buckets",
"handler",
"parse",
"list",
"my",
"buckets",
"response",
"(",
"input",
"stream",
"input",
"stream",
")",
"throws",
"i",
"o",
"exception",
"{",
"list",
"all",
"my",
"buckets",
"handler",
"handler",
"=",
"new",
"list",
"all",
"my",
"buckets",
"handler",
"(",
")",
";",
"parse",
"xml",
"input",
"stream",
"(",
"handler",
",",
"sanitize",
"xml",
"document",
"(",
"handler",
",",
"input",
"stream",
")",
")",
";",
"return",
"handler",
";",
"}"
] |
[
"set",
"the",
"{",
"@",
"code",
"gson",
"}",
"instance",
"to",
"use",
"if",
"not",
"set",
",",
"a",
"default",
"{",
"@",
"link",
"gson",
"#",
"gson",
"(",
")",
"gson",
"}",
"instance",
"will",
"be",
"used",
"setting",
"a",
"custom",
"-",
"configured",
"{",
"@",
"code",
"gson",
"}",
"is",
"one",
"way",
"to",
"take",
"further",
"control",
"of",
"the",
"json",
"serialization",
"process"
] | [
"public",
"void",
"set",
"gson",
"(",
"gson",
"gson",
")",
"{",
"assert",
"not",
"null",
"(",
"gson",
",",
"\"",
"a",
"gson",
"instance",
"is",
"required",
"\"",
")",
";",
"this",
"gson",
"=",
"gson",
";",
"}"
] |
[
"get",
"prefix",
"ns",
"array"
] | [
"public",
"list",
"<",
"integer",
">",
"get",
"prefix",
"ns",
"array",
"(",
")",
"{",
"return",
"prefix",
"ns",
"array",
";",
"}"
] |
[
"performs",
"an",
"authentication",
"management",
"operation",
"this",
"is",
"useful",
"for",
"handling",
"operations",
"like",
"getrenewcancel",
"delegation",
"tokens",
"which",
"are",
"being",
"handled",
"as",
"operations",
"of",
"the",
"service",
"end",
"-",
"point",
"if",
"the",
"method",
"returns",
"<",
"code",
">",
"true",
"<",
"code",
">",
"the",
"request",
"will",
"continue",
"normal",
"processing",
",",
"this",
"means",
"the",
"method",
"has",
"not",
"produced",
"any",
"http",
"response",
"if",
"the",
"method",
"returns",
"<",
"code",
">",
"false",
"<",
"code",
">",
"the",
"request",
"will",
"end",
",",
"this",
"means",
"the",
"method",
"has",
"produced",
"the",
"corresponding",
"http",
"response"
] | [
"public",
"boolean",
"management",
"operation",
"(",
"authentication",
"token",
"token",
",",
"http",
"servlet",
"request",
"request",
",",
"http",
"servlet",
"response",
"response",
")",
"throws",
"i",
"o",
"exception",
",",
"authentication",
"exception",
";"
] |
[
"a",
"helper",
"api",
"for",
"creating",
"an",
"audit",
"log",
"for",
"a",
"failure",
"event",
"this",
"is",
"factored",
"out",
"for",
"testing",
"purpose"
] | [
"static",
"string",
"create",
"failure",
"log",
"(",
"string",
"user",
",",
"string",
"operation",
",",
"string",
"target",
",",
"string",
"description",
",",
"application",
"id",
"app",
"id",
",",
"container",
"id",
"container",
"id",
")",
"{",
"string",
"builder",
"b",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"start",
"(",
"keys",
"user",
",",
"user",
",",
"b",
")",
";",
"add",
"remote",
"i",
"p",
"(",
"b",
")",
";",
"add",
"(",
"keys",
"operation",
",",
"operation",
",",
"b",
")",
";",
"add",
"(",
"keys",
"target",
",",
"target",
",",
"b",
")",
";",
"add",
"(",
"keys",
"result",
",",
"audit",
"constants",
"failure",
",",
"b",
")",
";",
"add",
"(",
"keys",
"description",
",",
"description",
",",
"b",
")",
";",
"if",
"(",
"app",
"id",
"!",
"=",
"null",
")",
"{",
"add",
"(",
"keys",
"appid",
",",
"app",
"id",
"to",
"string",
"(",
")",
",",
"b",
")",
";",
"}",
"if",
"(",
"container",
"id",
"!",
"=",
"null",
")",
"{",
"add",
"(",
"keys",
"containerid",
",",
"container",
"id",
"to",
"string",
"(",
")",
",",
"b",
")",
";",
"}",
"return",
"b",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"sets",
"current",
"value",
"and",
"notifies",
"all",
"the",
"attached",
"listeners"
] | [
"public",
"void",
"set",
"(",
"t",
"value",
")",
"{",
"if",
"(",
"m",
"value",
"=",
"=",
"value",
"|",
"|",
"(",
"m",
"value",
"!",
"=",
"null",
"&",
"&",
"m",
"value",
"equals",
"(",
"value",
")",
")",
")",
"{",
"return",
";",
"}",
"m",
"value",
"=",
"value",
";",
"for",
"(",
"on",
"value",
"change",
"listener",
"<",
"t",
">",
"listener",
":",
"m",
"listeners",
")",
"{",
"listener",
"on",
"value",
"change",
"(",
"this",
")",
";",
"}",
"}"
] |
[
"returns",
"a",
"list",
"of",
"all",
"comparisons",
"in",
"the",
"model",
",",
"in",
"sorted",
"order",
"by",
"source",
"function",
"name"
] | [
"public",
"list",
"<",
"function",
"comparison",
">",
"get",
"comparisons",
"(",
")",
"{",
"list",
"<",
"function",
"comparison",
">",
"to",
"return",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"to",
"return",
"add",
"all",
"(",
"comparisons",
")",
";",
"collections",
"sort",
"(",
"to",
"return",
")",
";",
"return",
"to",
"return",
";",
"}"
] |
[
"formats",
"a",
"{",
"@",
"code",
"long",
"}",
"as",
"an",
"8",
"-",
"byte",
"unsigned",
"hex",
"value"
] | [
"public",
"static",
"string",
"u",
"8",
"(",
"long",
"v",
")",
"{",
"char",
"[",
"]",
"result",
"=",
"new",
"char",
"[",
"16",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"16",
";",
"i",
"+",
"+",
")",
"{",
"result",
"[",
"15",
"-",
"i",
"]",
"=",
"character",
"for",
"digit",
"(",
"(",
"int",
")",
"v",
"&",
"0x",
"0f",
",",
"16",
")",
";",
"v",
">",
">",
"=",
"4",
";",
"}",
"return",
"new",
"string",
"(",
"result",
")",
";",
"}"
] |
[
"hash",
"-",
"partitions",
"a",
"data",
"set",
"on",
"the",
"specified",
"key",
"fields",
"<",
"b",
">",
"important",
":",
"<",
"b",
">",
"this",
"operation",
"shuffles",
"the",
"whole",
"data",
"set",
"over",
"the",
"network",
"and",
"can",
"take",
"significant",
"amount",
"of",
"time"
] | [
"public",
"partition",
"operator",
"<",
"t",
">",
"partition",
"by",
"hash",
"(",
"int",
"fields",
")",
"{",
"return",
"new",
"partition",
"operator",
"<",
">",
"(",
"this",
",",
"partition",
"method",
"hash",
",",
"new",
"keys",
"expression",
"keys",
"<",
">",
"(",
"fields",
",",
"get",
"type",
"(",
")",
")",
",",
"utils",
"get",
"call",
"location",
"name",
"(",
")",
")",
";",
"}"
] |
[
"creates",
"a",
"source",
"artifact",
"do",
"<",
"b",
">",
"not",
"<",
"b",
">",
"use",
"this",
"unless",
"you",
"have",
"a",
"very",
"good",
"reason",
"to",
"do",
"so",
"and",
"have",
"consulted",
"with",
"someone",
"knowledgeable",
"source",
"artifacts",
"should",
"be",
"only",
"created",
"through",
"{",
"@",
"link",
"com",
"google",
"devtools",
"build",
"lib",
"analysis",
"configuredtargets",
"input",
"file",
"configured",
"target",
"}",
"by",
"{",
"@",
"link",
"configured",
"target",
"factory",
"}",
"this",
"method",
"should",
"only",
"be",
"used",
"when",
"that",
"'",
"s",
"not",
"an",
"option",
"currently",
",",
"the",
"only",
"known",
"use",
"case",
"is",
"the",
"{",
"@",
"code",
"ninja",
"build",
"}",
"rule",
",",
"which",
",",
"if",
"it",
"couldn",
"'",
"t",
"create",
"source",
"artifacts",
",",
"would",
"have",
"to",
"have",
"every",
"source",
"artifact",
"that",
"ninja",
"actions",
"use",
"enumerated",
"in",
"its",
"{",
"@",
"code",
"srcs",
"}",
"attribute",
"if",
"you",
"use",
"this",
"erroneously",
",",
"inconsistencies",
"can",
"occur",
",",
"for",
"example",
",",
"creating",
"a",
"source",
"artifact",
"with",
"the",
"wrong",
"package",
"path",
"entry",
"or",
"in",
"the",
"wrong",
"package"
] | [
"artifact",
"get",
"source",
"artifact",
"for",
"ninja",
"build",
"(",
"path",
"fragment",
"execpath",
",",
"root",
"root",
")",
";"
] |
[
"set",
"whether",
"to",
"look",
"up",
"the",
"jndi",
"object",
"on",
"startup",
"default",
"is",
"\"",
"true",
"\"",
"can",
"be",
"turned",
"off",
"to",
"allow",
"for",
"late",
"availability",
"of",
"the",
"jndi",
"object",
"in",
"this",
"case",
",",
"the",
"jndi",
"object",
"will",
"be",
"fetched",
"on",
"first",
"access"
] | [
"public",
"void",
"set",
"lookup",
"on",
"startup",
"(",
"boolean",
"lookup",
"on",
"startup",
")",
"{",
"this",
"lookup",
"on",
"startup",
"=",
"lookup",
"on",
"startup",
";",
"}"
] |
[
"indicate",
"that",
"message",
"handling",
"is",
"complete",
",",
"allowing",
"for",
"any",
"cleanup",
"or",
"end",
"-",
"of",
"-",
"processing",
"tasks",
"to",
"be",
"performed",
"such",
"as",
"applying",
"header",
"changes",
"made",
"via",
"{",
"@",
"link",
"#",
"get",
"headers",
"(",
")",
"}",
"to",
"the",
"underlying",
"http",
"message",
"(",
"if",
"not",
"applied",
"already",
")",
"this",
"method",
"should",
"be",
"automatically",
"invoked",
"at",
"the",
"end",
"of",
"message",
"processing",
"so",
"typically",
"applications",
"should",
"not",
"have",
"to",
"invoke",
"it",
"if",
"invoked",
"multiple",
"times",
"it",
"should",
"have",
"no",
"side",
"effects"
] | [
"mono",
"<",
"void",
">",
"set",
"complete",
"(",
")",
";"
] |
[
"predicate",
"that",
"indicates",
"that",
"the",
"switch",
"mapping",
"is",
"known",
"to",
"be",
"single",
"-",
"switch",
"the",
"base",
"class",
"returns",
"false",
":",
"it",
"assumes",
"all",
"mappings",
"are",
"multi",
"-",
"rack",
"subclasses",
"may",
"override",
"this",
"with",
"methods",
"that",
"are",
"more",
"aware",
"of",
"their",
"topologies",
"this",
"method",
"is",
"used",
"when",
"parts",
"of",
"hadoop",
"need",
"know",
"whether",
"to",
"apply",
"single",
"rack",
"vs",
"multi",
"-",
"rack",
"policies",
",",
"such",
"as",
"during",
"block",
"placement",
"such",
"algorithms",
"behave",
"differently",
"if",
"they",
"are",
"on",
"multi",
"-",
"switch",
"systems"
] | [
"public",
"boolean",
"is",
"single",
"switch",
"(",
")",
"{",
"return",
"false",
";",
"}"
] |
[
"retrieve",
"the",
"given",
"column",
"as",
"binary",
"stream",
"from",
"the",
"given",
"result",
"set",
"might",
"simply",
"invoke",
"{",
"@",
"code",
"result",
"set",
"get",
"binary",
"stream",
"}",
"or",
"work",
"with",
"{",
"@",
"code",
"result",
"set",
"get",
"blob",
"}",
",",
"depending",
"on",
"the",
"database",
"and",
"driver"
] | [
"input",
"stream",
"get",
"blob",
"as",
"binary",
"stream",
"(",
"result",
"set",
"rs",
",",
"string",
"column",
"name",
")",
"throws",
"s",
"q",
"l",
"exception",
";"
] |
[
"runs",
"the",
"following",
"program",
"the",
"test",
"program",
"defined",
"in",
"{",
"@",
"link",
"#",
"test",
"program",
"(",
"stream",
"execution",
"environment",
")",
"}",
"followed",
"by",
"the",
"checks",
"in",
"{",
"@",
"link",
"#",
"post",
"submit",
"}"
] | [
"public",
"void",
"run",
"checkpointed",
"program",
"(",
")",
"throws",
"exception",
"{",
"try",
"{",
"stream",
"execution",
"environment",
"env",
"=",
"stream",
"execution",
"environment",
"get",
"execution",
"environment",
"(",
")",
";",
"env",
"set",
"parallelism",
"(",
"parallelism",
")",
";",
"env",
"enable",
"checkpointing",
"(",
"500",
")",
";",
"env",
"set",
"restart",
"strategy",
"(",
"restart",
"strategies",
"fixed",
"delay",
"restart",
"(",
"integer",
"max",
"value",
",",
"0l",
")",
")",
";",
"test",
"program",
"(",
"env",
")",
";",
"job",
"graph",
"job",
"graph",
"=",
"env",
"get",
"stream",
"graph",
"(",
")",
"get",
"job",
"graph",
"(",
")",
";",
"try",
"{",
"submit",
"job",
"and",
"wait",
"for",
"result",
"(",
"cluster",
"get",
"cluster",
"client",
"(",
")",
",",
"job",
"graph",
",",
"get",
"class",
"(",
")",
"get",
"class",
"loader",
"(",
")",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"assert",
"assert",
"true",
"(",
"exception",
"utils",
"find",
"throwable",
"(",
"e",
",",
"success",
"exception",
"class",
")",
"is",
"present",
"(",
")",
")",
";",
"}",
"post",
"submit",
"(",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"e",
"print",
"stack",
"trace",
"(",
")",
";",
"assert",
"fail",
"(",
"e",
"get",
"message",
"(",
")",
")",
";",
"}",
"}"
] |
[
"returns",
"the",
"number",
"of",
"entries",
"popped",
"from",
"the",
"stack",
"during",
"the",
"execution",
"of",
"the",
"instruction"
] | [
"public",
"int",
"stack",
"pop",
"count",
"(",
"clazz",
"clazz",
")",
"{",
"return",
"stack",
"pop",
"counts",
"[",
"opcode",
"&",
"0xff",
"]",
";",
"}"
] |
[
"check",
"if",
"the",
"pcode",
"has",
"been",
"determined",
"to",
"be",
"a",
"dead",
"operation"
] | [
"public",
"boolean",
"is",
"dead",
"(",
")",
"{",
"return",
"false",
";",
"}"
] |
[
"ensures",
"that",
"the",
"given",
"object",
"reference",
"is",
"not",
"null",
"upon",
"violation",
",",
"a",
"{",
"@",
"code",
"null",
"pointer",
"exception",
"}",
"with",
"no",
"message",
"is",
"thrown"
] | [
"public",
"static",
"<",
"t",
">",
"t",
"check",
"not",
"null",
"(",
"@",
"nullable",
"t",
"reference",
")",
"{",
"if",
"(",
"reference",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"null",
"pointer",
"exception",
"(",
")",
";",
"}",
"return",
"reference",
";",
"}"
] |
[
"test",
"if",
"{",
"@",
"link",
"block",
"manager",
"#",
"compute",
"invalidate",
"work",
"(",
"int",
")",
"}",
"can",
"schedule",
"invalidate",
"work",
"correctly",
"for",
"both",
"replicas",
"and",
"striped",
"block",
"groups",
",",
"combined"
] | [
"public",
"void",
"test",
"compute",
"invalidate",
"(",
")",
"throws",
"exception",
"{",
"final",
"int",
"block",
"invalidate",
"limit",
"=",
"bm",
"get",
"datanode",
"manager",
"(",
")",
"get",
"block",
"invalidate",
"limit",
"(",
")",
";",
"final",
"random",
"random",
"=",
"new",
"random",
"(",
"system",
"current",
"time",
"millis",
"(",
")",
")",
";",
"namesystem",
"write",
"lock",
"(",
")",
";",
"try",
"{",
"int",
"node",
"count",
"=",
"ec",
"policy",
"get",
"num",
"data",
"units",
"(",
")",
"+",
"ec",
"policy",
"get",
"num",
"parity",
"units",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"node",
"count",
";",
"i",
"+",
"+",
")",
"{",
"for",
"(",
"int",
"j",
"=",
"0",
";",
"j",
"<",
"3",
"*",
"block",
"invalidate",
"limit",
"+",
"1",
";",
"j",
"+",
"+",
")",
"{",
"if",
"(",
"random",
"next",
"boolean",
"(",
")",
")",
"{",
"block",
"striped",
"block",
"=",
"new",
"block",
"(",
"located",
"striped",
"block",
"get",
"block",
"(",
")",
"get",
"block",
"id",
"(",
")",
"+",
"(",
"i",
"*",
"10",
"+",
"j",
")",
",",
"stripes",
"per",
"block",
"*",
"cell",
"size",
",",
"located",
"striped",
"block",
"get",
"block",
"(",
")",
"get",
"generation",
"stamp",
"(",
")",
")",
";",
"bm",
"add",
"to",
"invalidates",
"(",
"striped",
"block",
",",
"nodes",
"[",
"i",
"]",
")",
";",
"}",
"else",
"{",
"block",
"replica",
"=",
"new",
"block",
"(",
"i",
"*",
"(",
"block",
"invalidate",
"limit",
"+",
"1",
")",
"+",
"j",
",",
"0",
",",
"generation",
"stamp",
"last",
"reserved",
"stamp",
")",
";",
"bm",
"add",
"to",
"invalidates",
"(",
"replica",
",",
"nodes",
"[",
"i",
"]",
")",
";",
"}",
"}",
"}",
"verify",
"invalidation",
"work",
"counts",
"(",
"block",
"invalidate",
"limit",
")",
";",
"}",
"finally",
"{",
"namesystem",
"write",
"unlock",
"(",
")",
";",
"}",
"}"
] |
[
"return",
"map",
"of",
"results",
",",
"keyed",
"by",
"decider",
"name"
] | [
"public",
"map",
"<",
"string",
",",
"autoscaling",
"decider",
"result",
">",
"results",
"(",
")",
"{",
"return",
"results",
";",
"}"
] |
[
"removes",
"a",
"key",
"from",
"the",
"hashtable"
] | [
"public",
"boolean",
"remove",
"(",
"short",
"key",
")",
"{",
"if",
"(",
"indexer",
"remove",
"(",
"key",
")",
"<",
"0",
")",
"{",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}"
] |
[
"get",
"string",
"item"
] | [
"public",
"string",
"get",
"string",
"item",
"(",
")",
"{",
"return",
"string",
"item",
";",
"}"
] |
[
"set",
"the",
"storage",
"policy",
"for",
"a",
"given",
"file",
"or",
"directory"
] | [
"public",
"void",
"set",
"storage",
"policy",
"(",
"final",
"path",
"path",
",",
"final",
"string",
"policy",
"name",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"path",
"abs",
"f",
"=",
"fix",
"relative",
"part",
"(",
"path",
")",
";",
"new",
"f",
"s",
"link",
"resolver",
"<",
"void",
">",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"next",
"(",
"final",
"abstract",
"file",
"system",
"fs",
",",
"final",
"path",
"p",
")",
"throws",
"i",
"o",
"exception",
"{",
"fs",
"set",
"storage",
"policy",
"(",
"path",
",",
"policy",
"name",
")",
";",
"return",
"null",
";",
"}",
"}",
"resolve",
"(",
"this",
",",
"abs",
"f",
")",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"prefix",
"ns",
"integer",
"'"
] | [
"public",
"void",
"prefix",
"ns",
"integer",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"prefix",
"ns",
"integer",
"}"
] |
[
"fetches",
"the",
"next",
"available",
"proxy",
"client",
"in",
"the",
"pool",
"each",
"client",
"connection",
"is",
"reserved",
"for",
"a",
"single",
"user",
"and",
"cannot",
"be",
"reused",
"until",
"free"
] | [
"public",
"connection",
"context",
"get",
"connection",
"(",
"user",
"group",
"information",
"ugi",
",",
"string",
"nn",
"address",
",",
"class",
"<",
"?",
">",
"protocol",
")",
"throws",
"i",
"o",
"exception",
"{",
"/",
"/",
"check",
"if",
"the",
"manager",
"is",
"shutdown",
"if",
"(",
"!",
"this",
"running",
")",
"{",
"log",
"error",
"(",
"\"",
"cannot",
"get",
"a",
"connection",
"to",
"{",
"}",
"because",
"the",
"manager",
"isn",
"'",
"t",
"running",
"\"",
",",
"nn",
"address",
")",
";",
"return",
"null",
";",
"}",
"/",
"/",
"try",
"to",
"get",
"the",
"pool",
"if",
"created",
"connection",
"pool",
"id",
"connection",
"id",
"=",
"new",
"connection",
"pool",
"id",
"(",
"ugi",
",",
"nn",
"address",
",",
"protocol",
")",
";",
"connection",
"pool",
"pool",
"=",
"null",
";",
"read",
"lock",
"lock",
"(",
")",
";",
"try",
"{",
"pool",
"=",
"this",
"pools",
"get",
"(",
"connection",
"id",
")",
";",
"}",
"finally",
"{",
"read",
"lock",
"unlock",
"(",
")",
";",
"}",
"/",
"/",
"create",
"the",
"pool",
"if",
"not",
"created",
"before",
"if",
"(",
"pool",
"=",
"=",
"null",
")",
"{",
"write",
"lock",
"lock",
"(",
")",
";",
"try",
"{",
"pool",
"=",
"this",
"pools",
"get",
"(",
"connection",
"id",
")",
";",
"if",
"(",
"pool",
"=",
"=",
"null",
")",
"{",
"pool",
"=",
"new",
"connection",
"pool",
"(",
"this",
"conf",
",",
"nn",
"address",
",",
"ugi",
",",
"this",
"min",
"size",
",",
"this",
"max",
"size",
",",
"this",
"min",
"active",
"ratio",
",",
"protocol",
")",
";",
"this",
"pools",
"put",
"(",
"connection",
"id",
",",
"pool",
")",
";",
"}",
"}",
"finally",
"{",
"write",
"lock",
"unlock",
"(",
")",
";",
"}",
"}",
"connection",
"context",
"conn",
"=",
"pool",
"get",
"connection",
"(",
")",
";",
"/",
"/",
"add",
"a",
"new",
"connection",
"to",
"the",
"pool",
"if",
"it",
"wasn",
"'",
"t",
"usable",
"if",
"(",
"conn",
"=",
"=",
"null",
"|",
"|",
"!",
"conn",
"is",
"usable",
"(",
")",
")",
"{",
"if",
"(",
"!",
"this",
"creator",
"queue",
"offer",
"(",
"pool",
")",
")",
"{",
"log",
"error",
"(",
"\"",
"cannot",
"add",
"more",
"than",
"{",
"}",
"connections",
"at",
"the",
"same",
"time",
"\"",
",",
"this",
"creator",
"queue",
"max",
"size",
")",
";",
"}",
"}",
"if",
"(",
"conn",
"!",
"=",
"null",
"&",
"&",
"conn",
"is",
"closed",
"(",
")",
")",
"{",
"log",
"error",
"(",
"\"",
"we",
"got",
"a",
"closed",
"connection",
"from",
"{",
"}",
"\"",
",",
"pool",
")",
";",
"conn",
"=",
"null",
";",
"}",
"return",
"conn",
";",
"}"
] |
[
"get",
"global",
"quota",
"for",
"the",
"federation",
"path"
] | [
"quota",
"usage",
"get",
"global",
"quota",
"(",
"string",
"path",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"!",
"router",
"is",
"quota",
"enabled",
"(",
")",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"the",
"quota",
"system",
"is",
"disabled",
"in",
"router",
"\"",
")",
";",
"}",
"long",
"n",
"quota",
"=",
"hdfs",
"constants",
"quota",
"reset",
";",
"long",
"s",
"quota",
"=",
"hdfs",
"constants",
"quota",
"reset",
";",
"long",
"[",
"]",
"type",
"quota",
"=",
"new",
"long",
"[",
"storage",
"type",
"values",
"(",
")",
"length",
"]",
";",
"each",
"by",
"storage",
"type",
"(",
"t",
"-",
">",
"type",
"quota",
"[",
"t",
"ordinal",
"(",
")",
"]",
"=",
"hdfs",
"constants",
"quota",
"reset",
")",
";",
"router",
"quota",
"manager",
"manager",
"=",
"this",
"router",
"get",
"quota",
"manager",
"(",
")",
";",
"tree",
"map",
"<",
"string",
",",
"router",
"quota",
"usage",
">",
"pts",
"=",
"manager",
"get",
"parents",
"containing",
"quota",
"(",
"path",
")",
";",
"entry",
"<",
"string",
",",
"router",
"quota",
"usage",
">",
"entry",
"=",
"pts",
"last",
"entry",
"(",
")",
";",
"while",
"(",
"entry",
"!",
"=",
"null",
"&",
"&",
"(",
"n",
"quota",
"=",
"=",
"hdfs",
"constants",
"quota",
"reset",
"|",
"|",
"s",
"quota",
"=",
"=",
"hdfs",
"constants",
"quota",
"reset",
"|",
"|",
"or",
"by",
"storage",
"type",
"(",
"t",
"-",
">",
"type",
"quota",
"[",
"t",
"ordinal",
"(",
")",
"]",
"=",
"=",
"hdfs",
"constants",
"quota",
"reset",
")",
")",
")",
"{",
"string",
"ppath",
"=",
"entry",
"get",
"key",
"(",
")",
";",
"quota",
"usage",
"quota",
"=",
"entry",
"get",
"value",
"(",
")",
";",
"if",
"(",
"n",
"quota",
"=",
"=",
"hdfs",
"constants",
"quota",
"reset",
")",
"{",
"n",
"quota",
"=",
"quota",
"get",
"quota",
"(",
")",
";",
"}",
"if",
"(",
"s",
"quota",
"=",
"=",
"hdfs",
"constants",
"quota",
"reset",
")",
"{",
"s",
"quota",
"=",
"quota",
"get",
"space",
"quota",
"(",
")",
";",
"}",
"each",
"by",
"storage",
"type",
"(",
"t",
"-",
">",
"{",
"if",
"(",
"type",
"quota",
"[",
"t",
"ordinal",
"(",
")",
"]",
"=",
"=",
"hdfs",
"constants",
"quota",
"reset",
")",
"{",
"type",
"quota",
"[",
"t",
"ordinal",
"(",
")",
"]",
"=",
"quota",
"get",
"type",
"quota",
"(",
"t",
")",
";",
"}",
"}",
")",
";",
"entry",
"=",
"pts",
"lower",
"entry",
"(",
"ppath",
")",
";",
"}",
"return",
"new",
"quota",
"usage",
"builder",
"(",
")",
"quota",
"(",
"n",
"quota",
")",
"space",
"quota",
"(",
"s",
"quota",
")",
"type",
"quota",
"(",
"type",
"quota",
")",
"build",
"(",
")",
";",
"}"
] |
[
"get",
"the",
"auto",
"offset",
"reset",
"strategy",
"in",
"case",
"the",
"initialized",
"offsets",
"falls",
"out",
"of",
"the",
"range",
"the",
"offset",
"strategy",
"is",
"only",
"used",
"when",
"the",
"offset",
"initializer",
"is",
"used",
"to",
"initialize",
"the",
"starting",
"offsets",
"and",
"the",
"starting",
"offsets",
"is",
"out",
"of",
"range"
] | [
"offset",
"reset",
"strategy",
"get",
"auto",
"offset",
"reset",
"strategy",
"(",
")",
";"
] |
[
"returns",
"the",
"start",
"time",
"of",
"the",
"specified",
"chunk"
] | [
"public",
"long",
"get",
"start",
"time",
"us",
"(",
"int",
"chunk",
"index",
")",
"{",
"return",
"chunk",
"start",
"times",
"us",
"[",
"chunk",
"index",
"]",
";",
"}"
] |
[
"positions",
"the",
"given",
"input",
"stream",
"to",
"the",
"beginning",
"of",
"the",
"exif",
"data",
"in",
"the",
"jpeg",
"app1",
"block"
] | [
"private",
"static",
"int",
"move",
"to",
"a",
"p",
"p",
"1",
"e",
"x",
"i",
"f",
"(",
"input",
"stream",
"is",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"move",
"to",
"marker",
"(",
"is",
",",
"marker",
"app1",
")",
")",
"{",
"/",
"/",
"read",
"block",
"length",
"/",
"/",
"subtract",
"2",
"as",
"length",
"contain",
"size",
"field",
"we",
"just",
"read",
"int",
"length",
"=",
"stream",
"processor",
"read",
"packed",
"int",
"(",
"is",
",",
"2",
",",
"false",
")",
"-",
"2",
";",
"if",
"(",
"length",
">",
"6",
")",
"{",
"int",
"magic",
"=",
"stream",
"processor",
"read",
"packed",
"int",
"(",
"is",
",",
"4",
",",
"false",
")",
";",
"length",
"-",
"=",
"4",
";",
"int",
"zero",
"=",
"stream",
"processor",
"read",
"packed",
"int",
"(",
"is",
",",
"2",
",",
"false",
")",
";",
"length",
"-",
"=",
"2",
";",
"if",
"(",
"magic",
"=",
"=",
"app1",
"exif",
"magic",
"&",
"&",
"zero",
"=",
"=",
"0",
")",
"{",
"/",
"/",
"jeita",
"cp",
"-",
"3451",
"exif",
"version",
"2",
"2",
"return",
"length",
";",
"}",
"}",
"}",
"return",
"0",
";",
"}"
] |
[
"set",
"the",
"filter",
"to",
"be",
"applied",
"on",
"the",
"image"
] | [
"public",
"void",
"set",
"filter",
"(",
"g",
"p",
"u",
"image",
"filter",
"filter",
")",
"{",
"this",
"filter",
"=",
"filter",
";",
"gpu",
"image",
"set",
"filter",
"(",
"filter",
")",
";",
"request",
"render",
"(",
")",
";",
"}"
] |
[
"add",
"a",
"sequence",
"variable",
"that",
"expands",
"{",
"@",
"code",
"name",
"}",
"to",
"{",
"@",
"code",
"values",
"}",
"accepts",
"values",
"as",
"immutable",
"set",
"as",
"immutable",
"list",
"has",
"smaller",
"memory",
"footprint",
",",
"we",
"copy",
"the",
"values",
"into",
"a",
"new",
"list"
] | [
"public",
"builder",
"add",
"string",
"sequence",
"variable",
"(",
"string",
"name",
",",
"immutable",
"set",
"<",
"string",
">",
"values",
")",
"{",
"check",
"variable",
"not",
"present",
"already",
"(",
"name",
")",
";",
"preconditions",
"check",
"not",
"null",
"(",
"values",
",",
"\"",
"cannot",
"set",
"null",
"as",
"a",
"value",
"for",
"variable",
"'",
"%",
"s",
"'",
"\"",
",",
"name",
")",
";",
"immutable",
"list",
"builder",
"<",
"string",
">",
"builder",
"=",
"immutable",
"list",
"builder",
"(",
")",
";",
"builder",
"add",
"all",
"(",
"values",
")",
";",
"variables",
"map",
"put",
"(",
"name",
",",
"new",
"string",
"sequence",
"(",
"builder",
"build",
"(",
")",
")",
")",
";",
"return",
"this",
";",
"}"
] |
[
"initialize",
"the",
"state",
"storage"
] | [
"public",
"void",
"service",
"init",
"(",
"configuration",
"conf",
")",
"throws",
"i",
"o",
"exception",
"{",
"init",
"storage",
"(",
"conf",
")",
";",
"}"
] |
[
"encode",
"the",
"given",
"masked",
"long",
"into",
"a",
"pattern",
"block",
"as",
"specified",
"by",
"a",
"given",
"context",
"field"
] | [
"public",
"static",
"assembly",
"pattern",
"block",
"from",
"context",
"field",
"(",
"context",
"field",
"cf",
",",
"masked",
"long",
"val",
")",
"{",
"int",
"size",
"=",
"cf",
"get",
"byte",
"end",
"(",
")",
"-",
"cf",
"get",
"byte",
"start",
"(",
")",
"+",
"1",
";",
"val",
"=",
"val",
"mask",
"(",
"cf",
"max",
"value",
"(",
")",
")",
";",
"try",
"{",
"val",
"=",
"val",
"inv",
"shift",
"right",
"logical",
"(",
"cf",
"get",
"shift",
"(",
")",
")",
";",
"}",
"catch",
"(",
"solver",
"exception",
"e",
")",
"{",
"throw",
"new",
"assertion",
"error",
"(",
"e",
")",
";",
"}",
"/",
"/",
"context",
"does",
"not",
"have",
"variable",
"endianness",
"byte",
"[",
"]",
"mask",
"=",
"new",
"byte",
"[",
"size",
"]",
";",
"byte",
"[",
"]",
"vals",
"=",
"new",
"byte",
"[",
"size",
"]",
";",
"long",
"lmsk",
"=",
"val",
"get",
"mask",
"(",
")",
";",
"long",
"lval",
"=",
"val",
"long",
"value",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"size",
"-",
"1",
";",
"i",
">",
"=",
"0",
";",
"i",
"-",
"-",
")",
"{",
"mask",
"[",
"i",
"]",
"=",
"(",
"byte",
")",
"(",
"lmsk",
"&",
"0xff",
")",
";",
"vals",
"[",
"i",
"]",
"=",
"(",
"byte",
")",
"(",
"lval",
"&",
"0xff",
")",
";",
"lmsk",
">",
">",
"=",
"8",
";",
"lval",
">",
">",
"=",
"8",
";",
"}",
"return",
"new",
"assembly",
"pattern",
"block",
"(",
"cf",
"get",
"byte",
"start",
"(",
")",
",",
"mask",
",",
"vals",
")",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"bool",
"item",
"'"
] | [
"public",
"void",
"bool",
"item",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"bool",
"item",
"}"
] |
[
"returns",
"a",
"writer",
"which",
"can",
"be",
"used",
"to",
"write",
"to",
"the",
"terminal",
"directly",
"using",
"standard",
"error"
] | [
"public",
"print",
"writer",
"get",
"error",
"writer",
"(",
")",
"{",
"return",
"error",
"writer",
";",
"}"
] |
[
"notifies",
"the",
"listener",
"that",
"the",
"given",
"stream",
"has",
"transitioned",
"from",
"{",
"@",
"code",
"open",
"}",
"to",
"{",
"@",
"code",
"half",
"closed",
"}",
"this",
"method",
"will",
"not",
"be",
"called",
"until",
"a",
"state",
"transition",
"occurs",
"from",
"when",
"{",
"@",
"link",
"#",
"on",
"stream",
"active",
"(",
"http",
"2",
"stream",
")",
"}",
"was",
"called",
"the",
"stream",
"can",
"be",
"inspected",
"to",
"determine",
"which",
"side",
"is",
"{",
"@",
"code",
"half",
"closed",
"}",
"if",
"a",
"{",
"@",
"link",
"runtime",
"exception",
"}",
"is",
"thrown",
"it",
"will",
"be",
"logged",
"and",
"not",
"propagated",
"throwing",
"from",
"this",
"method",
"is",
"not",
"supported",
"and",
"is",
"considered",
"a",
"programming",
"error"
] | [
"void",
"on",
"stream",
"half",
"closed",
"(",
"http",
"2",
"stream",
"stream",
")",
";"
] |
[
"used",
"for",
"delegation",
"token",
"related",
"functionality",
"must",
"delegate",
"to",
"underlying",
"file",
"system"
] | [
"protected",
"uri",
"get",
"canonical",
"uri",
"(",
")",
"{",
"return",
"fs",
"get",
"canonical",
"uri",
"(",
")",
";",
"}"
] |
[
"sets",
"the",
"offset",
"for",
"results",
"returned",
"by",
"this",
"query",
"{",
"@",
"link",
"org",
"greenrobot",
"greendao",
"query",
"query",
"builder",
"#",
"offset",
"(",
"int",
")",
"}",
"must",
"have",
"been",
"called",
"on",
"the",
"query",
"builder",
"that",
"created",
"this",
"query",
"object"
] | [
"public",
"void",
"set",
"offset",
"(",
"int",
"offset",
")",
"{",
"check",
"thread",
"(",
")",
";",
"if",
"(",
"offset",
"position",
"=",
"=",
"-",
"1",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"offset",
"must",
"be",
"set",
"with",
"query",
"builder",
"before",
"it",
"can",
"be",
"used",
"here",
"\"",
")",
";",
"}",
"parameters",
"[",
"offset",
"position",
"]",
"=",
"integer",
"to",
"string",
"(",
"offset",
")",
";",
"}"
] |
[
"get",
"integer",
"item"
] | [
"public",
"integer",
"get",
"integer",
"item",
"(",
")",
"{",
"return",
"integer",
"item",
";",
"}"
] |
[
"\\",
"sum",
"i",
"func",
"(",
"x",
"1",
"i",
",",
"x",
"2",
"i",
")"
] | [
"public",
"static",
"double",
"apply",
"sum",
"(",
"dense",
"vector",
"x",
"1",
",",
"dense",
"vector",
"x",
"2",
",",
"bi",
"function",
"<",
"double",
",",
"double",
",",
"double",
">",
"func",
")",
"{",
"assert",
"x",
"1",
"size",
"(",
")",
"=",
"=",
"x",
"2",
"size",
"(",
")",
":",
"\"",
"x",
"1",
"and",
"x",
"2",
"size",
"mismatched",
"\"",
";",
"double",
"[",
"]",
"x",
"1data",
"=",
"x",
"1",
"get",
"data",
"(",
")",
";",
"double",
"[",
"]",
"x",
"2data",
"=",
"x",
"2",
"get",
"data",
"(",
")",
";",
"double",
"s",
"=",
"0",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"x",
"1data",
"length",
";",
"i",
"+",
"+",
")",
"{",
"s",
"+",
"=",
"func",
"apply",
"(",
"x",
"1data",
"[",
"i",
"]",
",",
"x",
"2data",
"[",
"i",
"]",
")",
";",
"}",
"return",
"s",
";",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.