docstring_tokens
list | code_tokens
list |
---|---|
[
"returns",
"an",
"{",
"@",
"code",
"unsigned",
"long",
"}",
"holding",
"the",
"value",
"of",
"the",
"specified",
"{",
"@",
"code",
"string",
"}",
",",
"parsed",
"as",
"an",
"unsigned",
"{",
"@",
"code",
"long",
"}",
"value",
"in",
"the",
"specified",
"radix"
] |
[
"public",
"static",
"unsigned",
"long",
"value",
"of",
"(",
"string",
"string",
",",
"int",
"radix",
")",
"{",
"return",
"from",
"long",
"bits",
"(",
"unsigned",
"longs",
"parse",
"unsigned",
"long",
"(",
"string",
",",
"radix",
")",
")",
";",
"}"
] |
[
"copies",
"an",
"iterable",
"'",
"s",
"elements",
"into",
"an",
"array"
] |
[
"public",
"static",
"<",
"t",
">",
"t",
"[",
"]",
"to",
"array",
"(",
"iterable",
"<",
"?",
"extends",
"t",
">",
"iterable",
",",
"class",
"<",
"t",
">",
"type",
")",
"{",
"return",
"to",
"array",
"(",
"iterable",
",",
"object",
"arrays",
"new",
"array",
"(",
"type",
",",
"0",
")",
")",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] |
[
"public",
"boolean",
"next",
"(",
")",
"throws",
"s",
"q",
"l",
"exception",
"{",
"return",
"(",
"counter",
">",
"100000",
")",
";",
"}"
] |
[
"returns",
"an",
"address",
"range",
"iterator",
"over",
"all",
"occupied",
"ranges",
"whose",
"from",
"address",
"falls",
"within",
"the",
"range",
"start",
"addr",
"to",
"end",
"addr"
] |
[
"public",
"address",
"range",
"iterator",
"get",
"address",
"ranges",
"(",
"address",
"start",
"addr",
",",
"address",
"end",
"addr",
")",
"{",
"return",
"new",
"range",
"iterator",
"(",
"start",
"addr",
",",
"end",
"addr",
")",
";",
"}"
] |
[
"guaranteed",
"to",
"throw",
"an",
"exception",
"and",
"leave",
"the",
"map",
"unmodified"
] |
[
"public",
"final",
"v",
"put",
"(",
"k",
"k",
",",
"v",
"v",
")",
"{",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
")",
";",
"}"
] |
[
"deep",
"comparison",
"of",
"array",
"of",
"<",
"code",
">",
"float",
"<",
"code",
">",
"length",
"and",
"all",
"values",
"are",
"compared",
"the",
"method",
"{",
"@",
"link",
"#",
"append",
"(",
"float",
",",
"float",
")",
"}",
"is",
"used"
] |
[
"public",
"equals",
"builder",
"append",
"(",
"float",
"[",
"]",
"lhs",
",",
"float",
"[",
"]",
"rhs",
")",
"{",
"if",
"(",
"!",
"is",
"equals",
")",
"{",
"return",
"this",
";",
"}",
"if",
"(",
"lhs",
"=",
"=",
"rhs",
")",
"{",
"return",
"this",
";",
"}",
"if",
"(",
"lhs",
"=",
"=",
"null",
"|",
"|",
"rhs",
"=",
"=",
"null",
")",
"{",
"this",
"set",
"equals",
"(",
"false",
")",
";",
"return",
"this",
";",
"}",
"if",
"(",
"lhs",
"length",
"!",
"=",
"rhs",
"length",
")",
"{",
"this",
"set",
"equals",
"(",
"false",
")",
";",
"return",
"this",
";",
"}",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"lhs",
"length",
"&",
"&",
"is",
"equals",
";",
"+",
"+",
"i",
")",
"{",
"append",
"(",
"lhs",
"[",
"i",
"]",
",",
"rhs",
"[",
"i",
"]",
")",
";",
"}",
"return",
"this",
";",
"}"
] |
[
"retrieve",
"the",
"amount",
"of",
"the",
"total",
"items",
"in",
"the",
"urv",
"for",
"display",
"that",
"will",
"be",
"including",
"all",
"data",
"items",
"as",
"well",
"as",
"the",
"decorative",
"items"
] |
[
"public",
"int",
"get",
"item",
"count",
"(",
")",
"{",
"return",
"get",
"adapter",
"item",
"count",
"(",
")",
"+",
"total",
"additional",
"items",
"(",
")",
";",
"}"
] |
[
"process",
"a",
"{",
"@",
"link",
"stream",
"record",
"}",
"from",
"the",
"right",
"stream",
"whenever",
"a",
"{",
"@",
"link",
"stream",
"record",
"}",
"arrives",
"at",
"the",
"right",
"stream",
",",
"it",
"will",
"get",
"added",
"to",
"the",
"right",
"buffer",
"possible",
"join",
"candidates",
"for",
"that",
"element",
"will",
"be",
"looked",
"up",
"from",
"the",
"left",
"buffer",
"and",
"if",
"the",
"pair",
"lies",
"within",
"the",
"user",
"defined",
"boundaries",
",",
"it",
"gets",
"passed",
"to",
"the",
"{",
"@",
"link",
"process",
"join",
"function",
"}"
] |
[
"public",
"void",
"process",
"element",
"2",
"(",
"stream",
"record",
"<",
"t2",
">",
"record",
")",
"throws",
"exception",
"{",
"process",
"element",
"(",
"record",
",",
"right",
"buffer",
",",
"left",
"buffer",
",",
"-",
"upper",
"bound",
",",
"-",
"lower",
"bound",
",",
"false",
")",
";",
"}"
] |
[
"updates",
"this",
"hasher",
"with",
"the",
"given",
"bytes"
] |
[
"protected",
"void",
"update",
"(",
"byte",
"[",
"]",
"b",
")",
"{",
"update",
"(",
"b",
",",
"0",
",",
"b",
"length",
")",
";",
"}"
] |
[
"deletes",
"a",
"pet",
"<",
"b",
">",
"200",
"<",
"b",
">",
"-",
"successful",
"operation",
"<",
"b",
">",
"400",
"<",
"b",
">",
"-",
"invalid",
"pet",
"value"
] |
[
"public",
"void",
"delete",
"pet",
"(",
"long",
"pet",
"id",
",",
"map",
"<",
"string",
",",
"object",
">",
"params",
")",
"throws",
"i",
"o",
"exception",
"{",
"delete",
"pet",
"for",
"http",
"response",
"(",
"pet",
"id",
",",
"params",
")",
";",
"}"
] |
[
"retrieves",
"the",
"value",
"in",
"queue",
"without",
"removing",
"it",
"indexing",
"is",
"from",
"the",
"front",
"to",
"back",
",",
"zero",
"based",
"therefore",
"get",
"(",
"0",
")",
"is",
"the",
"same",
"as",
"{",
"@",
"link",
"#",
"first",
"(",
")",
"}"
] |
[
"public",
"long",
"get",
"(",
"int",
"index",
")",
"{",
"if",
"(",
"index",
"<",
"0",
")",
"throw",
"new",
"index",
"out",
"of",
"bounds",
"exception",
"(",
"\"",
"index",
"can",
"'",
"t",
"be",
"<",
"0",
":",
"\"",
"+",
"index",
")",
";",
"if",
"(",
"index",
">",
"=",
"size",
")",
"throw",
"new",
"index",
"out",
"of",
"bounds",
"exception",
"(",
"\"",
"index",
"can",
"'",
"t",
"be",
">",
"=",
"size",
":",
"\"",
"+",
"index",
"+",
"\"",
">",
"=",
"\"",
"+",
"size",
")",
";",
"final",
"long",
"[",
"]",
"values",
"=",
"this",
"values",
";",
"int",
"i",
"=",
"head",
"+",
"index",
";",
"if",
"(",
"i",
">",
"=",
"values",
"length",
")",
"{",
"i",
"-",
"=",
"values",
"length",
";",
"}",
"return",
"values",
"[",
"i",
"]",
";",
"}"
] |
[
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"the",
"bounds",
"of",
"{",
"@",
"code",
"other",
"}",
"do",
"not",
"extend",
"outside",
"the",
"bounds",
"of",
"this",
"range",
"examples",
":",
"{",
"@",
"code",
"[",
"3",
"6",
"]",
"}",
"encloses",
"{",
"@",
"code",
"[",
"4",
"5",
"]",
"}",
"{",
"@",
"code",
"(",
"3",
"6",
")",
"}",
"encloses",
"{",
"@",
"code",
"(",
"3",
"6",
")",
"}",
"{",
"@",
"code",
"[",
"3",
"6",
"]",
"}",
"encloses",
"{",
"@",
"code",
"[",
"4",
"4",
")",
"}",
"(",
"even",
"though",
"the",
"latter",
"is",
"empty",
")",
"{",
"@",
"code",
"(",
"3",
"6",
"]",
"}",
"does",
"not",
"enclose",
"{",
"@",
"code",
"[",
"3",
"6",
"]",
"}",
"{",
"@",
"code",
"[",
"4",
"5",
"]",
"}",
"does",
"not",
"enclose",
"{",
"@",
"code",
"(",
"3",
"6",
")",
"}",
"(",
"even",
"though",
"it",
"contains",
"every",
"value",
"contained",
"by",
"the",
"latter",
"range",
")",
"{",
"@",
"code",
"[",
"3",
"6",
"]",
"}",
"does",
"not",
"enclose",
"{",
"@",
"code",
"(",
"1",
"1",
"]",
"}",
"(",
"even",
"though",
"it",
"contains",
"every",
"value",
"contained",
"by",
"the",
"latter",
"range",
")",
"note",
"that",
"if",
"{",
"@",
"code",
"a",
"encloses",
"(",
"b",
")",
"}",
",",
"then",
"{",
"@",
"code",
"b",
"contains",
"(",
"v",
")",
"}",
"implies",
"{",
"@",
"code",
"a",
"contains",
"(",
"v",
")",
"}",
",",
"but",
"as",
"the",
"last",
"two",
"examples",
"illustrate",
",",
"the",
"converse",
"is",
"not",
"always",
"true",
"being",
"reflexive",
",",
"antisymmetric",
"and",
"transitive",
",",
"the",
"{",
"@",
"code",
"encloses",
"}",
"relation",
"defines",
"a",
"partial",
"order",
"over",
"ranges",
"there",
"exists",
"a",
"unique",
"{",
"@",
"linkplain",
"range",
"#",
"all",
"maximal",
"}",
"range",
"according",
"to",
"this",
"relation",
",",
"and",
"also",
"numerous",
"{",
"@",
"linkplain",
"#",
"is",
"empty",
"minimal",
"}",
"ranges",
"enclosure",
"also",
"implies",
"{",
"@",
"linkplain",
"#",
"is",
"connected",
"connectedness",
"}"
] |
[
"public",
"boolean",
"encloses",
"(",
"range",
"<",
"c",
">",
"other",
")",
"{",
"return",
"lower",
"bound",
"compare",
"to",
"(",
"other",
"lower",
"bound",
")",
"<",
"=",
"0",
"&",
"&",
"upper",
"bound",
"compare",
"to",
"(",
"other",
"upper",
"bound",
")",
">",
"=",
"0",
";",
"}"
] |
[
"creates",
"a",
"user",
"account",
"requires",
"{",
"@",
"link",
"jenkins",
"#",
"administer",
"}"
] |
[
"public",
"user",
"create",
"account",
"by",
"admin",
"(",
"stapler",
"request",
"req",
",",
"stapler",
"response",
"rsp",
",",
"string",
"add",
"user",
"view",
",",
"string",
"success",
"view",
")",
"throws",
"i",
"o",
"exception",
",",
"servlet",
"exception",
"{",
"check",
"permission",
"(",
"jenkins",
"administer",
")",
";",
"user",
"u",
"=",
"create",
"account",
"(",
"req",
",",
"rsp",
",",
"false",
",",
"add",
"user",
"view",
")",
";",
"if",
"(",
"u",
"!",
"=",
"null",
"&",
"&",
"success",
"view",
"!",
"=",
"null",
")",
"{",
"rsp",
"send",
"redirect",
"(",
"success",
"view",
")",
";",
"}",
"return",
"u",
";",
"}"
] |
[
"deletes",
"the",
"file",
"underlying",
"the",
"given",
"channel",
"if",
"the",
"channel",
"is",
"still",
"open",
",",
"this",
"call",
"may",
"fail"
] |
[
"public",
"static",
"void",
"delete",
"channel",
"(",
"id",
"channel",
")",
"{",
"if",
"(",
"channel",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"channel",
"get",
"path",
"file",
"(",
")",
"exists",
"(",
")",
"&",
"&",
"!",
"channel",
"get",
"path",
"file",
"(",
")",
"delete",
"(",
")",
")",
"{",
"log",
"warn",
"(",
"\"",
"i",
"o",
"manager",
"failed",
"to",
"delete",
"temporary",
"file",
"{",
"}",
"\"",
",",
"channel",
"get",
"path",
"(",
")",
")",
";",
"}",
"}",
"}"
] |
[
"verify",
"that",
"current",
"user",
"is",
"the",
"checkout",
"user",
"for",
"this",
"file"
] |
[
"private",
"void",
"verify",
"repo",
"user",
"(",
"string",
"case",
"name",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"versioned",
"file",
"system",
"instanceof",
"local",
"file",
"system",
")",
"{",
"return",
";",
"/",
"/",
"rely",
"on",
"local",
"project",
"ownership",
"}",
"string",
"repo",
"user",
"name",
"=",
"versioned",
"file",
"system",
"get",
"user",
"name",
"(",
")",
";",
"if",
"(",
"repo",
"user",
"name",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"file",
"\"",
"+",
"case",
"name",
"+",
"\"",
"not",
"permitted",
"(",
"not",
"connected",
")",
"\"",
")",
";",
"}",
"item",
"checkout",
"status",
"checkout",
"status",
"=",
"get",
"checkout",
"status",
"(",
")",
";",
"if",
"(",
"checkout",
"status",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"file",
"not",
"checked",
"out",
"\"",
")",
";",
"}",
"string",
"checkout",
"user",
"name",
"=",
"checkout",
"status",
"get",
"user",
"(",
")",
";",
"if",
"(",
"!",
"repo",
"user",
"name",
"equals",
"(",
"checkout",
"user",
"name",
")",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"file",
"\"",
"+",
"case",
"name",
"+",
"\"",
"not",
"permitted",
"-",
"checkout",
"user",
"'",
"\"",
"+",
"checkout",
"user",
"name",
"+",
"\"",
"'",
"differs",
"from",
"repository",
"user",
"'",
"\"",
"+",
"repo",
"user",
"name",
"+",
"\"",
"'",
"\"",
")",
";",
"}",
"}"
] |
[
"equivalent",
"to",
"calling",
":",
"actions",
"click",
"(",
"element",
")",
"send",
"keys",
"(",
"keys",
"to",
"send",
")",
"this",
"method",
"is",
"different",
"from",
"{",
"@",
"link",
"web",
"element",
"#",
"send",
"keys",
"(",
"char",
"sequence",
")",
"}",
"-",
"see",
"{",
"@",
"link",
"#",
"send",
"keys",
"(",
"char",
"sequence",
")",
"}",
"for",
"details",
"how"
] |
[
"public",
"actions",
"send",
"keys",
"(",
"web",
"element",
"target",
",",
"char",
"sequence",
"keys",
")",
"{",
"if",
"(",
"is",
"building",
"actions",
"(",
")",
")",
"{",
"action",
"add",
"action",
"(",
"new",
"send",
"keys",
"action",
"(",
"json",
"keyboard",
",",
"json",
"mouse",
",",
"(",
"locatable",
")",
"target",
",",
"keys",
")",
")",
";",
"}",
"return",
"focus",
"in",
"ticks",
"(",
"target",
")",
"send",
"keys",
"in",
"ticks",
"(",
"keys",
")",
";",
"}"
] |
[
"tests",
"to",
"ensure",
"each",
"of",
"the",
"block",
"replication",
"parameters",
"can",
"be",
"passed",
"updated",
"successfully"
] |
[
"public",
"void",
"test",
"params",
"can",
"be",
"reconfigured",
"(",
")",
"throws",
"reconfiguration",
"exception",
"{",
"assert",
"equals",
"(",
"8",
",",
"bm",
"get",
"max",
"replication",
"streams",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"10",
",",
"bm",
"get",
"replication",
"streams",
"hard",
"limit",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"12",
",",
"bm",
"get",
"blocks",
"repl",
"work",
"multiplier",
"(",
")",
")",
";",
"cluster",
"get",
"name",
"node",
"(",
")",
"reconfigure",
"property",
"impl",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"namenode",
"replication",
"max",
"streams",
"key",
",",
"\"",
"20",
"\"",
")",
";",
"cluster",
"get",
"name",
"node",
"(",
")",
"reconfigure",
"property",
"impl",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"namenode",
"replication",
"streams",
"hard",
"limit",
"key",
",",
"\"",
"22",
"\"",
")",
";",
"cluster",
"get",
"name",
"node",
"(",
")",
"reconfigure",
"property",
"impl",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"namenode",
"replication",
"work",
"multiplier",
"per",
"iteration",
",",
"\"",
"24",
"\"",
")",
";",
"assert",
"equals",
"(",
"20",
",",
"bm",
"get",
"max",
"replication",
"streams",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"22",
",",
"bm",
"get",
"replication",
"streams",
"hard",
"limit",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"24",
",",
"bm",
"get",
"blocks",
"repl",
"work",
"multiplier",
"(",
")",
")",
";",
"}"
] |
[
"closes",
"the",
"stream"
] |
[
"public",
"void",
"close",
"(",
")",
"{",
"try",
"{",
"super",
"close",
"(",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"ioe",
")",
"{",
"/",
"/",
"does",
"not",
"happen",
"throwables",
"propagate",
"(",
"ioe",
")",
";",
"}",
"}"
] |
[
"gets",
"failure",
"view"
] |
[
"public",
"view",
"get",
"failure",
"view",
"(",
"final",
"class",
"type",
")",
"{",
"return",
"get",
"view",
"(",
"type",
"get",
"simple",
"name",
"(",
")",
")",
"get",
"value",
"(",
")",
";",
"}"
] |
[
"server",
"key",
"computed",
"from",
"the",
"client",
"password",
"using",
"the",
"scram",
"algorithm"
] |
[
"public",
"byte",
"[",
"]",
"server",
"key",
"(",
")",
"{",
"return",
"server",
"key",
";",
"}"
] |
[
"the",
"specification",
"of",
"this",
"method",
"matches",
"that",
"of",
"{",
"@",
"link",
"file",
"context",
"#",
"rename",
"snapshot",
"(",
"path",
",",
"string",
",",
"string",
")",
"}"
] |
[
"public",
"void",
"rename",
"snapshot",
"(",
"final",
"path",
"path",
",",
"final",
"string",
"snapshot",
"old",
"name",
",",
"final",
"string",
"snapshot",
"new",
"name",
")",
"throws",
"i",
"o",
"exception",
"{",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
"get",
"class",
"(",
")",
"get",
"simple",
"name",
"(",
")",
"+",
"\"",
"doesn",
"'",
"t",
"support",
"rename",
"snapshot",
"\"",
")",
";",
"}"
] |
[
"returns",
"the",
"currently",
"set",
"task",
"monitor"
] |
[
"public",
"task",
"monitor",
"get",
"task",
"monitor",
"(",
")",
"{",
"return",
"monitor",
";",
"}"
] |
[
"create",
"the",
"main",
"panel"
] |
[
"private",
"j",
"panel",
"create",
"panel",
"(",
"string",
"prompt",
")",
"{",
"j",
"panel",
"panel",
"=",
"new",
"j",
"panel",
"(",
"new",
"border",
"layout",
"(",
")",
")",
";",
"panel",
"set",
"border",
"(",
"border",
"factory",
"create",
"empty",
"border",
"(",
"10",
",",
"10",
",",
"10",
",",
"10",
")",
")",
";",
"label",
"=",
"new",
"g",
"d",
"label",
"(",
"prompt",
")",
";",
"number",
"input",
"field",
"=",
"new",
"integer",
"text",
"field",
"(",
"12",
")",
";",
"number",
"input",
"field",
"add",
"change",
"listener",
"(",
"e",
"-",
">",
"update",
"o",
"k",
"button",
"enablement",
"(",
")",
")",
";",
"/",
"/",
"actually",
"assemble",
"the",
"parts",
"into",
"a",
"status",
"panel",
"panel",
"add",
"(",
"label",
",",
"border",
"layout",
"west",
")",
";",
"panel",
"add",
"(",
"number",
"input",
"field",
"get",
"component",
"(",
")",
",",
"border",
"layout",
"center",
")",
";",
"return",
"panel",
";",
"}"
] |
[
"get",
"the",
"total",
"number",
"of",
"job",
"submissions",
"in",
"the",
"cluster"
] |
[
"public",
"int",
"get",
"total",
"job",
"submissions",
"(",
")",
"{",
"return",
"total",
"job",
"submissions",
";",
"}"
] |
[
"method",
":",
"string",
"mod",
"operator",
",",
"return",
"0",
"~",
"(",
"mod",
"-",
"1",
")"
] |
[
"public",
"static",
"int",
"string",
"mod",
"(",
"string",
"string",
",",
"int",
"mod",
")",
"{",
"int",
"hash",
"code",
"=",
"0",
";",
"if",
"(",
"string",
"!",
"=",
"null",
")",
"{",
"hash",
"code",
"=",
"string",
"hash",
"code",
"(",
")",
";",
"if",
"(",
"hash",
"code",
"<",
"0",
")",
"{",
"hash",
"code",
"=",
"math",
"abs",
"(",
"hash",
"code",
")",
";",
"hash",
"code",
"=",
"hash",
"code",
"<",
"0",
"?",
"0",
":",
"hash",
"code",
";",
"}",
"}",
"return",
"hash",
"code",
"%",
"(",
"mod",
">",
"0",
"?",
"mod",
":",
"1",
")",
";",
"}"
] |
[
"return",
"true",
"if",
"the",
"given",
"character",
"is",
"mapped",
"to",
"a",
"supported",
"entity",
"reference"
] |
[
"public",
"boolean",
"is",
"mapped",
"to",
"reference",
"(",
"char",
"character",
",",
"string",
"encoding",
")",
"{",
"return",
"(",
"convert",
"to",
"reference",
"(",
"character",
",",
"encoding",
")",
"!",
"=",
"null",
")",
";",
"}"
] |
[
"patch",
"a",
"configuration",
"to",
"declare",
"this",
"the",
"dt",
"provider",
"for",
"a",
"filesystem",
"built",
"off",
"the",
"given",
"configuration",
"the",
"abfs",
"filesystem",
"still",
"needs",
"to",
"come",
"up",
"with",
"security",
"enabled"
] |
[
"public",
"static",
"configuration",
"use",
"classic",
"d",
"t",
"manager",
"(",
"configuration",
"conf",
")",
"{",
"conf",
"set",
"boolean",
"(",
"fs",
"azure",
"enable",
"delegation",
"token",
",",
"true",
")",
";",
"conf",
"set",
"(",
"fs",
"azure",
"delegation",
"token",
"provider",
"type",
",",
"classic",
"delegation",
"token",
"manager",
"name",
")",
";",
"return",
"conf",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"array",
"array",
"of",
"model",
"'"
] |
[
"public",
"void",
"array",
"array",
"of",
"model",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"array",
"array",
"of",
"model",
"}"
] |
[
"bytes",
"to",
"parcelable"
] |
[
"public",
"static",
"<",
"t",
">",
"t",
"bytes",
"2",
"parcelable",
"(",
"final",
"byte",
"[",
"]",
"bytes",
",",
"final",
"parcelable",
"creator",
"<",
"t",
">",
"creator",
")",
"{",
"if",
"(",
"bytes",
"=",
"=",
"null",
")",
"return",
"null",
";",
"parcel",
"parcel",
"=",
"parcel",
"obtain",
"(",
")",
";",
"parcel",
"unmarshall",
"(",
"bytes",
",",
"0",
",",
"bytes",
"length",
")",
";",
"parcel",
"set",
"data",
"position",
"(",
"0",
")",
";",
"t",
"result",
"=",
"creator",
"create",
"from",
"parcel",
"(",
"parcel",
")",
";",
"parcel",
"recycle",
"(",
")",
";",
"return",
"result",
";",
"}"
] |
[
"adds",
"a",
"sort",
"builder"
] |
[
"public",
"search",
"source",
"builder",
"sort",
"(",
"sort",
"builder",
"<",
"?",
">",
"sort",
")",
"{",
"if",
"(",
"sorts",
"=",
"=",
"null",
")",
"{",
"sorts",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"}",
"sorts",
"add",
"(",
"sort",
")",
";",
"return",
"this",
";",
"}"
] |
[
"sets",
"the",
"increment",
"applied",
"to",
"the",
"ticker",
"whenever",
"it",
"is",
"queried",
"the",
"default",
"behavior",
"is",
"to",
"auto",
"increment",
"by",
"zero",
"i",
"e",
":",
"the",
"ticker",
"is",
"left",
"unchanged",
"when",
"queried"
] |
[
"public",
"fake",
"ticker",
"set",
"auto",
"increment",
"step",
"(",
"java",
"time",
"duration",
"auto",
"increment",
"step",
")",
"{",
"return",
"set",
"auto",
"increment",
"step",
"(",
"auto",
"increment",
"step",
"to",
"nanos",
"(",
")",
",",
"time",
"unit",
"nanoseconds",
")",
";",
"}"
] |
[
"returns",
"the",
"count",
"of",
"{",
"@",
"code",
"node",
"}",
"'",
"s",
"incoming",
"edges",
"(",
"equal",
"to",
"{",
"@",
"code",
"predecessors",
"(",
"node",
")",
"size",
"(",
")",
"}",
")",
"in",
"a",
"directed",
"graph",
"in",
"an",
"undirected",
"graph",
",",
"returns",
"the",
"{",
"@",
"link",
"#",
"degree",
"(",
"object",
")",
"}",
"if",
"the",
"count",
"is",
"greater",
"than",
"{",
"@",
"code",
"integer",
"max",
"value",
"}",
",",
"returns",
"{",
"@",
"code",
"integer",
"max",
"value",
"}"
] |
[
"int",
"in",
"degree",
"(",
"n",
"node",
")",
";"
] |
[
"execute",
"post",
"http",
"response"
] |
[
"public",
"static",
"http",
"response",
"execute",
"post",
"(",
"final",
"string",
"url",
",",
"final",
"string",
"entity",
",",
"final",
"map",
"<",
"string",
",",
"object",
">",
"parameters",
")",
"{",
"return",
"execute",
"post",
"(",
"url",
",",
"null",
",",
"null",
",",
"entity",
",",
"parameters",
")",
";",
"}"
] |
[
"emits",
"random",
"words",
"sequence",
"of",
"desired",
"size",
"note",
"that",
"the",
"desired",
"output",
"size",
"is",
"passed",
"as",
"the",
"value",
"parameter",
"to",
"this",
"map"
] |
[
"public",
"void",
"map",
"(",
"null",
"writable",
"key",
",",
"long",
"writable",
"value",
",",
"context",
"context",
")",
"throws",
"i",
"o",
"exception",
",",
"interrupted",
"exception",
"{",
"/",
"/",
"todo",
"control",
"the",
"extra",
"data",
"written",
"/",
"/",
"todo",
"should",
"the",
"key",
"\\",
"tvalue",
"\\",
"n",
"be",
"considered",
"for",
"measuring",
"size",
"?",
"/",
"/",
"can",
"counters",
"like",
"bytes",
"written",
"be",
"used",
"?",
"what",
"will",
"be",
"the",
"value",
"of",
"/",
"/",
"such",
"counters",
"in",
"local",
"job",
"runner",
"?",
"for",
"(",
"long",
"bytes",
"=",
"value",
"get",
"(",
")",
";",
"bytes",
">",
"0",
";",
")",
"{",
"string",
"random",
"key",
"=",
"rtg",
"get",
"random",
"word",
"(",
")",
";",
"string",
"random",
"value",
"=",
"rtg",
"get",
"random",
"word",
"(",
")",
";",
"context",
"write",
"(",
"new",
"text",
"(",
"random",
"key",
")",
",",
"new",
"text",
"(",
"random",
"value",
")",
")",
";",
"bytes",
"-",
"=",
"(",
"random",
"value",
"get",
"bytes",
"(",
"charset",
"u",
"t",
"f",
"8",
")",
"length",
"+",
"random",
"key",
"get",
"bytes",
"(",
"charset",
"u",
"t",
"f",
"8",
")",
"length",
")",
";",
"}",
"}"
] |
[
"connect",
"to",
"the",
"server",
"over",
"web",
"socket"
] |
[
"mono",
"<",
"r",
"socket",
"requester",
">",
"connect",
"web",
"socket",
"(",
"uri",
"uri",
")",
";"
] |
[
"convert",
"byte",
"array",
"containing",
"srid",
"+",
"wkb",
"geometry",
"into",
"geometry",
"object"
] |
[
"public",
"geometry",
"from",
"w",
"k",
"b",
"(",
"byte",
"[",
"]",
"bytes",
")",
"{",
"if",
"(",
"bytes",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"try",
"(",
"byte",
"array",
"input",
"stream",
"input",
"stream",
"=",
"new",
"byte",
"array",
"input",
"stream",
"(",
"bytes",
")",
")",
"{",
"/",
"/",
"read",
"srid",
"byte",
"[",
"]",
"srid",
"bytes",
"=",
"new",
"byte",
"[",
"4",
"]",
";",
"input",
"stream",
"read",
"(",
"srid",
"bytes",
")",
";",
"int",
"srid",
"=",
"byte",
"order",
"values",
"get",
"int",
"(",
"srid",
"bytes",
",",
"byte",
"order",
")",
";",
"/",
"/",
"prepare",
"geometry",
"factory",
"geometry",
"factory",
"geometry",
"factory",
"=",
"new",
"geometry",
"factory",
"(",
"precision",
"model",
",",
"srid",
",",
"coordinate",
"sequence",
"factory",
")",
";",
"/",
"/",
"read",
"geometry",
"w",
"k",
"b",
"reader",
"wkb",
"reader",
"=",
"new",
"w",
"k",
"b",
"reader",
"(",
"geometry",
"factory",
")",
";",
"geometry",
"geometry",
"=",
"wkb",
"reader",
"read",
"(",
"new",
"input",
"stream",
"in",
"stream",
"(",
"input",
"stream",
")",
")",
";",
"return",
"geometry",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"|",
"parse",
"exception",
"e",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"e",
")",
";",
"}",
"}"
] |
[
"constructs",
"a",
"list",
"item",
"with",
"instances",
"of",
"this",
"class",
"representing",
"the",
"contents",
"of",
"the",
"given",
"array",
"of",
"sections",
",",
"adding",
"it",
"to",
"the",
"given",
"map",
"section"
] |
[
"public",
"static",
"void",
"add",
"map",
"(",
"section",
"[",
"]",
"sections",
",",
"mixed",
"item",
"section",
"map",
"section",
")",
"{",
"if",
"(",
"sections",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"null",
"pointer",
"exception",
"(",
"\"",
"sections",
"=",
"=",
"null",
"\"",
")",
";",
"}",
"if",
"(",
"map",
"section",
"items",
"(",
")",
"size",
"(",
")",
"!",
"=",
"0",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"map",
"section",
"items",
"(",
")",
"size",
"(",
")",
"!",
"=",
"0",
"\"",
")",
";",
"}",
"array",
"list",
"<",
"map",
"item",
">",
"items",
"=",
"new",
"array",
"list",
"<",
"map",
"item",
">",
"(",
"50",
")",
";",
"for",
"(",
"section",
"section",
":",
"sections",
")",
"{",
"item",
"type",
"current",
"type",
"=",
"null",
";",
"item",
"first",
"item",
"=",
"null",
";",
"item",
"last",
"item",
"=",
"null",
";",
"int",
"count",
"=",
"0",
";",
"for",
"(",
"item",
"item",
":",
"section",
"items",
"(",
")",
")",
"{",
"item",
"type",
"type",
"=",
"item",
"item",
"type",
"(",
")",
";",
"if",
"(",
"type",
"!",
"=",
"current",
"type",
")",
"{",
"if",
"(",
"count",
"!",
"=",
"0",
")",
"{",
"items",
"add",
"(",
"new",
"map",
"item",
"(",
"current",
"type",
",",
"section",
",",
"first",
"item",
",",
"last",
"item",
",",
"count",
")",
")",
";",
"}",
"current",
"type",
"=",
"type",
";",
"first",
"item",
"=",
"item",
";",
"count",
"=",
"0",
";",
"}",
"last",
"item",
"=",
"item",
";",
"count",
"+",
"+",
";",
"}",
"if",
"(",
"count",
"!",
"=",
"0",
")",
"{",
"/",
"/",
"add",
"a",
"map",
"item",
"for",
"the",
"final",
"items",
"in",
"the",
"section",
"items",
"add",
"(",
"new",
"map",
"item",
"(",
"current",
"type",
",",
"section",
",",
"first",
"item",
",",
"last",
"item",
",",
"count",
")",
")",
";",
"}",
"else",
"if",
"(",
"section",
"=",
"=",
"map",
"section",
")",
"{",
"/",
"/",
"add",
"a",
"map",
"item",
"for",
"the",
"self",
"-",
"referential",
"section",
"items",
"add",
"(",
"new",
"map",
"item",
"(",
"map",
"section",
")",
")",
";",
"}",
"}",
"map",
"section",
"add",
"(",
"new",
"uniform",
"list",
"item",
"<",
"map",
"item",
">",
"(",
"item",
"type",
"type",
"map",
"list",
",",
"items",
")",
")",
";",
"}"
] |
[
"validate",
"that",
"the",
"settings",
"that",
"are",
"required",
"to",
"be",
"identical",
"between",
"the",
"leader",
"and",
"follower",
"index",
"are",
"in",
"fact",
"equal"
] |
[
"private",
"static",
"void",
"validate",
"settings",
"(",
"final",
"settings",
"leader",
"index",
"settings",
",",
"final",
"settings",
"follower",
"index",
"settings",
")",
"{",
"/",
"/",
"make",
"a",
"copy",
",",
"remove",
"settings",
"that",
"are",
"allowed",
"to",
"be",
"different",
",",
"and",
"then",
"compare",
"if",
"the",
"settings",
"are",
"equal",
"final",
"settings",
"leader",
"settings",
"=",
"filter",
"(",
"leader",
"index",
"settings",
")",
";",
"final",
"settings",
"follower",
"settings",
"=",
"filter",
"(",
"follower",
"index",
"settings",
")",
";",
"if",
"(",
"leader",
"settings",
"equals",
"(",
"follower",
"settings",
")",
"=",
"=",
"false",
")",
"{",
"final",
"string",
"message",
"=",
"string",
"format",
"(",
"locale",
"root",
",",
"\"",
"the",
"leader",
"index",
"settings",
"[",
"%",
"s",
"]",
"and",
"follower",
"index",
"settings",
"[",
"%",
"s",
"]",
"must",
"be",
"identical",
"\"",
",",
"leader",
"settings",
",",
"follower",
"settings",
")",
";",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"message",
")",
";",
"}",
"}"
] |
[
"copies",
"num",
"floats",
"floats",
"from",
"src",
"starting",
"at",
"offset",
"to",
"dst",
"dst",
"is",
"assumed",
"to",
"be",
"a",
"direct",
"{",
"@",
"link",
"buffer",
"}",
"the",
"method",
"will",
"crash",
"if",
"that",
"is",
"not",
"the",
"case",
"the",
"position",
"and",
"limit",
"of",
"the",
"buffer",
"are",
"ignored",
",",
"the",
"copy",
"is",
"placed",
"at",
"position",
"0",
"in",
"the",
"buffer",
"after",
"the",
"copying",
"process",
"the",
"position",
"of",
"the",
"buffer",
"is",
"set",
"to",
"0",
"and",
"its",
"limit",
"is",
"set",
"to",
"num",
"floats",
"4",
"if",
"it",
"is",
"a",
"byte",
"buffer",
"and",
"num",
"floats",
"if",
"it",
"is",
"a",
"float",
"buffer",
"in",
"case",
"the",
"buffer",
"is",
"neither",
"a",
"byte",
"buffer",
"nor",
"a",
"float",
"buffer",
"the",
"limit",
"is",
"not",
"set",
"this",
"is",
"an",
"expert",
"method",
",",
"use",
"at",
"your",
"own",
"risk"
] |
[
"public",
"static",
"void",
"copy",
"(",
"float",
"[",
"]",
"src",
",",
"buffer",
"dst",
",",
"int",
"num",
"floats",
",",
"int",
"offset",
")",
"{",
"float",
"buffer",
"float",
"buffer",
"=",
"as",
"float",
"buffer",
"(",
"dst",
")",
";",
"float",
"buffer",
"clear",
"(",
")",
";",
"dst",
"position",
"(",
"0",
")",
";",
"float",
"buffer",
"put",
"(",
"src",
",",
"offset",
",",
"num",
"floats",
")",
";",
"dst",
"position",
"(",
"0",
")",
";",
"if",
"(",
"dst",
"instanceof",
"byte",
"buffer",
")",
"dst",
"limit",
"(",
"num",
"floats",
"<",
"<",
"2",
")",
";",
"else",
"dst",
"limit",
"(",
"num",
"floats",
")",
";",
"}"
] |
[
"delete",
"fake",
":",
"fake",
"endpoint",
"to",
"test",
"group",
"parameters",
"(",
"optional",
")",
"fake",
"endpoint",
"to",
"test",
"group",
"parameters",
"(",
"optional",
")"
] |
[
"default",
"response",
"entity",
"<",
"void",
">",
"test",
"group",
"parameters",
"(",
"@",
"not",
"null",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"required",
"string",
"in",
"group",
"parameters",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"valid",
"@",
"request",
"param",
"(",
"value",
"=",
"\"",
"required",
"string",
"group",
"\"",
",",
"required",
"=",
"true",
")",
"integer",
"required",
"string",
"group",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"required",
"boolean",
"in",
"group",
"parameters",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"request",
"header",
"(",
"value",
"=",
"\"",
"required",
"boolean",
"group",
"\"",
",",
"required",
"=",
"true",
")",
"boolean",
"required",
"boolean",
"group",
",",
"@",
"not",
"null",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"required",
"integer",
"in",
"group",
"parameters",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"valid",
"@",
"request",
"param",
"(",
"value",
"=",
"\"",
"required",
"int",
"6",
"4",
"group",
"\"",
",",
"required",
"=",
"true",
")",
"long",
"required",
"int",
"6",
"4",
"group",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"string",
"in",
"group",
"parameters",
"\"",
")",
"@",
"valid",
"@",
"request",
"param",
"(",
"value",
"=",
"\"",
"string",
"group",
"\"",
",",
"required",
"=",
"false",
")",
"integer",
"string",
"group",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"boolean",
"in",
"group",
"parameters",
"\"",
")",
"@",
"request",
"header",
"(",
"value",
"=",
"\"",
"boolean",
"group",
"\"",
",",
"required",
"=",
"false",
")",
"boolean",
"boolean",
"group",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"integer",
"in",
"group",
"parameters",
"\"",
")",
"@",
"valid",
"@",
"request",
"param",
"(",
"value",
"=",
"\"",
"int",
"6",
"4",
"group",
"\"",
",",
"required",
"=",
"false",
")",
"long",
"int",
"6",
"4",
"group",
")",
"{",
"return",
"new",
"response",
"entity",
"<",
">",
"(",
"http",
"status",
"not",
"implemented",
")",
";",
"}"
] |
[
"provides",
"access",
"to",
"the",
"{",
"@",
"code",
"close",
"status",
"}",
"with",
"which",
"the",
"session",
"is",
"closed",
"either",
"locally",
"or",
"remotely",
",",
"or",
"completes",
"empty",
"if",
"the",
"session",
"ended",
"without",
"a",
"status"
] |
[
"mono",
"<",
"close",
"status",
">",
"close",
"status",
"(",
")",
";",
"/",
"/",
"web",
"socket",
"message",
"factory",
"methods"
] |
[
"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",
")",
";",
"}"
] |
[
"a",
"map",
"of",
"document",
"matchers",
"allowing",
"callers",
"to",
"selectively",
"use",
"only",
"some",
"of",
"the",
"documents",
"in",
"a",
"yaml",
"resource",
"in",
"yaml",
"documents",
"are",
"separated",
"by",
"{",
"@",
"code",
"-",
"-",
"-",
"}",
"lines",
",",
"and",
"each",
"document",
"is",
"converted",
"to",
"properties",
"before",
"the",
"match",
"is",
"made",
"e",
"g",
"<",
"pre",
"class",
"=",
"\"",
"code",
"\"",
">",
"environment",
":",
"dev",
"url",
":",
"https",
":",
"dev",
"bar",
"com",
"name",
":",
"developer",
"setup",
"-",
"-",
"-",
"environment",
":",
"prod",
"url",
":",
"https",
":",
"foo",
"bar",
"com",
"name",
":",
"my",
"cool",
"app",
"when",
"mapped",
"with",
"<",
"pre",
"class",
"=",
"\"",
"code",
"\"",
">",
"set",
"document",
"matchers",
"(",
"properties",
"-",
">",
"(",
"\"",
"prod",
"\"",
"equals",
"(",
"properties",
"get",
"property",
"(",
"\"",
"environment",
"\"",
")",
")",
"?",
"match",
"status",
"found",
":",
"match",
"status",
"not",
"found",
")",
")",
";",
"would",
"end",
"up",
"as",
"<",
"pre",
"class",
"=",
"\"",
"code",
"\"",
">",
"environment",
"=",
"prod",
"url",
"=",
"https",
":",
"foo",
"bar",
"com",
"name",
"=",
"my",
"cool",
"app"
] |
[
"public",
"void",
"set",
"document",
"matchers",
"(",
"document",
"matcher",
"matchers",
")",
"{",
"this",
"document",
"matchers",
"=",
"arrays",
"as",
"list",
"(",
"matchers",
")",
";",
"}"
] |
[
"set",
"the",
"user",
"'",
"s",
"chronology",
"(",
"calendar",
"system",
")"
] |
[
"public",
"void",
"set",
"chronology",
"(",
"@",
"nullable",
"chronology",
"chronology",
")",
"{",
"this",
"chronology",
"=",
"chronology",
";",
"}"
] |
[
"get",
"prefix",
"integer"
] |
[
"public",
"integer",
"get",
"prefix",
"integer",
"(",
")",
"{",
"return",
"prefix",
"integer",
";",
"}"
] |
[
"retrieve",
"the",
"value",
"this",
"method",
"returns",
"the",
"value",
"if",
"it",
"has",
"been",
"set",
"via",
"{",
"@",
"link",
"#",
"set",
"(",
"object",
")",
"}",
",",
"throws",
"an",
"{",
"@",
"link",
"java",
"util",
"concurrent",
"execution",
"exception",
"}",
"if",
"an",
"exception",
"has",
"been",
"set",
"via",
"{",
"@",
"link",
"#",
"set",
"exception",
"(",
"throwable",
")",
"}",
",",
"or",
"throws",
"a",
"{",
"@",
"link",
"java",
"util",
"concurrent",
"cancellation",
"exception",
"}",
"if",
"the",
"future",
"has",
"been",
"cancelled"
] |
[
"public",
"t",
"get",
"(",
")",
"throws",
"interrupted",
"exception",
",",
"execution",
"exception",
"{",
"return",
"this",
"settable",
"task",
"get",
"(",
")",
";",
"}"
] |
[
"helper",
"for",
"{",
"@",
"link",
"#",
"encode",
"output",
"}",
",",
"which",
"writes",
"out",
"the",
"given",
"size",
"value",
",",
"annotating",
"it",
"as",
"well",
"(",
"if",
"annotations",
"are",
"enabled",
")"
] |
[
"private",
"static",
"void",
"encode",
"size",
"(",
"dex",
"file",
"file",
",",
"annotated",
"output",
"out",
",",
"string",
"label",
",",
"int",
"size",
")",
"{",
"if",
"(",
"out",
"annotates",
"(",
")",
")",
"{",
"out",
"annotate",
"(",
"string",
"format",
"(",
"\"",
"%",
"-",
"2",
"1s",
"%",
"0",
"8x",
"\"",
",",
"label",
"+",
"\"",
"size",
":",
"\"",
",",
"size",
")",
")",
";",
"}",
"out",
"write",
"uleb",
"1",
"2",
"8",
"(",
"size",
")",
";",
"}"
] |
[
"return",
"the",
"specific",
"message",
"source",
"that",
"resolves",
"messages",
"with",
"respect",
"to",
"this",
"theme"
] |
[
"message",
"source",
"get",
"message",
"source",
"(",
")",
";"
] |
[
"get",
"one",
"byte",
"from",
"memory",
"at",
"the",
"current",
"position",
"plus",
"offset"
] |
[
"public",
"byte",
"get",
"byte",
"(",
"int",
"offset",
")",
"throws",
"memory",
"access",
"exception",
"{",
"/",
"/",
"check",
"external",
"to",
"code",
"units",
"owned",
"bytes",
"if",
"(",
"offset",
"<",
"0",
"|",
"|",
"offset",
">",
"=",
"bytes",
"length",
")",
"{",
"if",
"(",
"program",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"memory",
"access",
"exception",
"(",
"\"",
"pseduo",
"code",
"unit",
"has",
"null",
"program",
"-",
"memory",
"request",
"out",
"of",
"range",
"\"",
")",
";",
"}",
"memory",
"memory",
"=",
"program",
"get",
"memory",
"(",
")",
";",
"try",
"{",
"return",
"memory",
"get",
"byte",
"(",
"address",
"add",
"(",
"offset",
")",
")",
";",
"}",
"catch",
"(",
"address",
"out",
"of",
"bounds",
"exception",
"e",
")",
"{",
"throw",
"new",
"memory",
"access",
"exception",
"(",
"e",
"get",
"message",
"(",
")",
")",
";",
"}",
"}",
"synchronized",
"(",
"this",
")",
"{",
"refresh",
"if",
"needed",
"(",
")",
";",
"return",
"bytes",
"[",
"offset",
"]",
";",
"}",
"}"
] |
[
"validate",
"that",
"the",
"notification",
"times",
"out",
"after",
"reaching",
"mapreduce",
"job",
"end",
"-",
"notification",
"timeout"
] |
[
"public",
"void",
"test",
"notification",
"timeout",
"(",
")",
"throws",
"interrupted",
"exception",
"{",
"configuration",
"conf",
"=",
"new",
"configuration",
"(",
")",
";",
"/",
"/",
"reduce",
"the",
"timeout",
"to",
"1",
"second",
"conf",
"set",
"int",
"(",
"\"",
"mapreduce",
"job",
"end",
"-",
"notification",
"timeout",
"\"",
",",
"1000",
")",
";",
"job",
"status",
"job",
"status",
"=",
"create",
"test",
"job",
"status",
"(",
"\"",
"job",
"20130313155005308",
"0001",
"\"",
",",
"job",
"status",
"succeeded",
")",
";",
"job",
"conf",
"job",
"conf",
"=",
"create",
"test",
"job",
"conf",
"(",
"conf",
",",
"0",
",",
"base",
"url",
"+",
"\"",
"delay",
"\"",
")",
";",
"long",
"start",
"time",
"=",
"system",
"current",
"time",
"millis",
"(",
")",
";",
"job",
"end",
"notifier",
"local",
"runner",
"notification",
"(",
"job",
"conf",
",",
"job",
"status",
")",
";",
"long",
"elapsed",
"time",
"=",
"system",
"current",
"time",
"millis",
"(",
")",
"-",
"start",
"time",
";",
"/",
"/",
"validate",
"params",
"assert",
"equals",
"(",
"1",
",",
"delay",
"servlet",
"called",
"times",
")",
";",
"/",
"/",
"make",
"sure",
"we",
"timed",
"out",
"with",
"time",
"slightly",
"above",
"1",
"second",
"/",
"/",
"(",
"default",
"timeout",
"is",
"in",
"terms",
"of",
"minutes",
",",
"so",
"we",
"'",
"ll",
"catch",
"the",
"problem",
")",
"assert",
"true",
"(",
"elapsed",
"time",
"<",
"2000",
")",
";",
"}"
] |
[
"sets",
"optional",
"minimum",
"should",
"match",
"value",
"to",
"apply",
"to",
"the",
"query"
] |
[
"public",
"match",
"bool",
"prefix",
"query",
"builder",
"minimum",
"should",
"match",
"(",
"string",
"minimum",
"should",
"match",
")",
"{",
"this",
"minimum",
"should",
"match",
"=",
"minimum",
"should",
"match",
";",
"return",
"this",
";",
"}"
] |
[
"the",
"name",
"of",
"the",
"resource",
"(",
"in",
"the",
"form",
"package",
":",
"typename",
")",
"<",
"code",
">",
"optional",
"string",
"resource",
"name",
"=",
"1",
";",
"<",
"code",
">"
] |
[
"public",
"string",
"get",
"resource",
"name",
"(",
")",
"{",
"return",
"instance",
"get",
"resource",
"name",
"(",
")",
";",
"}"
] |
[
"sets",
"the",
"origin",
"in",
"relation",
"to",
"the",
"sprite",
"'",
"s",
"position",
"for",
"scaling",
"and",
"rotation"
] |
[
"public",
"void",
"set",
"origin",
"(",
"float",
"origin",
"x",
",",
"float",
"origin",
"y",
")",
"{",
"this",
"origin",
"x",
"=",
"origin",
"x",
";",
"this",
"origin",
"y",
"=",
"origin",
"y",
";",
"dirty",
"=",
"true",
";",
"}"
] |
[
"whether",
"to",
"propagate",
"the",
"query",
"parameters",
"of",
"the",
"current",
"request",
"through",
"to",
"the",
"target",
"redirect",
"url",
"default",
"is",
"{",
"@",
"code",
"false",
"}"
] |
[
"public",
"redirect",
"view",
"controller",
"registration",
"set",
"keep",
"query",
"params",
"(",
"boolean",
"propagate",
")",
"{",
"this",
"redirect",
"view",
"set",
"propagate",
"query",
"params",
"(",
"propagate",
")",
";",
"return",
"this",
";",
"}"
] |
[
"adds",
"a",
"number",
"of",
"occurrences",
"of",
"the",
"specified",
"element",
"to",
"this",
"multiset"
] |
[
"public",
"int",
"add",
"(",
"e",
"element",
",",
"int",
"occurrences",
")",
"{",
"check",
"not",
"null",
"(",
"element",
")",
";",
"if",
"(",
"occurrences",
"=",
"=",
"0",
")",
"{",
"return",
"count",
"(",
"element",
")",
";",
"}",
"collect",
"preconditions",
"check",
"positive",
"(",
"occurrences",
",",
"\"",
"occurences",
"\"",
")",
";",
"while",
"(",
"true",
")",
"{",
"atomic",
"integer",
"existing",
"counter",
"=",
"maps",
"safe",
"get",
"(",
"count",
"map",
",",
"element",
")",
";",
"if",
"(",
"existing",
"counter",
"=",
"=",
"null",
")",
"{",
"existing",
"counter",
"=",
"count",
"map",
"put",
"if",
"absent",
"(",
"element",
",",
"new",
"atomic",
"integer",
"(",
"occurrences",
")",
")",
";",
"if",
"(",
"existing",
"counter",
"=",
"=",
"null",
")",
"{",
"return",
"0",
";",
"}",
"/",
"/",
"existing",
"counter",
"!",
"=",
"null",
":",
"fall",
"through",
"to",
"operate",
"against",
"the",
"existing",
"atomic",
"integer",
"}",
"while",
"(",
"true",
")",
"{",
"int",
"old",
"value",
"=",
"existing",
"counter",
"get",
"(",
")",
";",
"if",
"(",
"old",
"value",
"!",
"=",
"0",
")",
"{",
"try",
"{",
"int",
"new",
"value",
"=",
"int",
"math",
"checked",
"add",
"(",
"old",
"value",
",",
"occurrences",
")",
";",
"if",
"(",
"existing",
"counter",
"compare",
"and",
"set",
"(",
"old",
"value",
",",
"new",
"value",
")",
")",
"{",
"/",
"/",
"new",
"value",
"can",
"'",
"t",
"=",
"=",
"0",
",",
"so",
"no",
"need",
"to",
"check",
"&",
"remove",
"return",
"old",
"value",
";",
"}",
"}",
"catch",
"(",
"arithmetic",
"exception",
"overflow",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"overflow",
"adding",
"\"",
"+",
"occurrences",
"+",
"\"",
"occurrences",
"to",
"a",
"count",
"of",
"\"",
"+",
"old",
"value",
")",
";",
"}",
"}",
"else",
"{",
"/",
"/",
"in",
"the",
"case",
"of",
"a",
"concurrent",
"remove",
",",
"we",
"might",
"observe",
"a",
"zero",
"value",
",",
"which",
"means",
"another",
"/",
"/",
"thread",
"is",
"about",
"to",
"remove",
"(",
"element",
",",
"existing",
"counter",
")",
"from",
"the",
"map",
"rather",
"than",
"wait",
",",
"/",
"/",
"we",
"can",
"just",
"do",
"that",
"work",
"here",
"atomic",
"integer",
"new",
"counter",
"=",
"new",
"atomic",
"integer",
"(",
"occurrences",
")",
";",
"if",
"(",
"(",
"count",
"map",
"put",
"if",
"absent",
"(",
"element",
",",
"new",
"counter",
")",
"=",
"=",
"null",
")",
"|",
"|",
"count",
"map",
"replace",
"(",
"element",
",",
"existing",
"counter",
",",
"new",
"counter",
")",
")",
"{",
"return",
"0",
";",
"}",
"break",
";",
"}",
"}",
"/",
"/",
"if",
"we",
"'",
"re",
"still",
"here",
",",
"there",
"was",
"a",
"race",
",",
"so",
"just",
"try",
"again",
"}",
"}"
] |
[
"blocks",
"until",
"the",
"event",
"becomes",
"the",
"signaled",
"state",
"this",
"method",
"blocks",
"infinitely",
"until",
"a",
"value",
"is",
"offered"
] |
[
"public",
"void",
"block",
"(",
")",
"throws",
"interrupted",
"exception",
"{",
"synchronized",
"(",
"lock",
")",
"{",
"while",
"(",
"!",
"signaled",
")",
"lock",
"wait",
"(",
")",
";",
"}",
"}"
] |
[
"generates",
"a",
"certificate",
"signing",
"request"
] |
[
"static",
"p",
"k",
"c",
"s",
"1",
"0",
"certification",
"request",
"generate",
"c",
"s",
"r",
"(",
"key",
"pair",
"key",
"pair",
",",
"x",
"5",
"0",
"0",
"principal",
"principal",
",",
"general",
"names",
"san",
"list",
")",
"throws",
"i",
"o",
"exception",
",",
"operator",
"creation",
"exception",
"{",
"objects",
"require",
"non",
"null",
"(",
"key",
"pair",
",",
"\"",
"key",
"-",
"pair",
"must",
"not",
"be",
"null",
"\"",
")",
";",
"objects",
"require",
"non",
"null",
"(",
"key",
"pair",
"get",
"public",
"(",
")",
",",
"\"",
"public",
"-",
"key",
"must",
"not",
"be",
"null",
"\"",
")",
";",
"objects",
"require",
"non",
"null",
"(",
"principal",
",",
"\"",
"principal",
"must",
"not",
"be",
"null",
"\"",
")",
";",
"jca",
"p",
"k",
"c",
"s",
"1",
"0",
"certification",
"request",
"builder",
"builder",
"=",
"new",
"jca",
"p",
"k",
"c",
"s",
"1",
"0",
"certification",
"request",
"builder",
"(",
"principal",
",",
"key",
"pair",
"get",
"public",
"(",
")",
")",
";",
"if",
"(",
"san",
"list",
"!",
"=",
"null",
")",
"{",
"extensions",
"generator",
"ext",
"gen",
"=",
"new",
"extensions",
"generator",
"(",
")",
";",
"ext",
"gen",
"add",
"extension",
"(",
"extension",
"subject",
"alternative",
"name",
",",
"false",
",",
"san",
"list",
")",
";",
"builder",
"add",
"attribute",
"(",
"p",
"k",
"c",
"s",
"object",
"identifiers",
"pkcs",
"9",
"at",
"extension",
"request",
",",
"ext",
"gen",
"generate",
"(",
")",
")",
";",
"}",
"return",
"builder",
"build",
"(",
"new",
"jca",
"content",
"signer",
"builder",
"(",
"\"",
"s",
"h",
"a",
"2",
"5",
"6with",
"r",
"s",
"a",
"\"",
")",
"set",
"provider",
"(",
"cert",
"gen",
"utils",
"bc",
"prov",
")",
"build",
"(",
"key",
"pair",
"get",
"private",
"(",
")",
")",
")",
";",
"}"
] |
[
"find",
"purchase",
"order",
"by",
"id",
"for",
"valid",
"response",
"try",
"integer",
"i",
"ds",
"with",
"value",
"&",
"lt",
";",
"&",
"#",
"x",
"3",
"d",
";",
"5",
"or",
"&",
"gt",
";",
"10",
"other",
"values",
"will",
"generated",
"exceptions",
"<",
"b",
">",
"200",
"<",
"b",
">",
"-",
"successful",
"operation",
"<",
"b",
">",
"400",
"<",
"b",
">",
"-",
"invalid",
"id",
"supplied",
"<",
"b",
">",
"404",
"<",
"b",
">",
"-",
"order",
"not",
"found"
] |
[
"public",
"order",
"get",
"order",
"by",
"id",
"(",
"long",
"order",
"id",
")",
"throws",
"i",
"o",
"exception",
"{",
"http",
"response",
"response",
"=",
"get",
"order",
"by",
"id",
"for",
"http",
"response",
"(",
"order",
"id",
")",
";",
"type",
"reference",
"<",
"order",
">",
"type",
"ref",
"=",
"new",
"type",
"reference",
"<",
"order",
">",
"(",
")",
"{",
"}",
";",
"return",
"api",
"client",
"get",
"object",
"mapper",
"(",
")",
"read",
"value",
"(",
"response",
"get",
"content",
"(",
")",
",",
"type",
"ref",
")",
";",
"}"
] |
[
"gets",
"accounts",
"by",
"user",
"name"
] |
[
"public",
"stream",
"<",
"dynamo",
"db",
"web",
"authn",
"credential",
"registration",
">",
"get",
"accounts",
"by",
"(",
"final",
"string",
"username",
")",
"{",
"return",
"get",
"records",
"by",
"keys",
"(",
"dynamo",
"db",
"query",
"builder",
"builder",
"(",
")",
"operator",
"(",
"comparison",
"operator",
"eq",
")",
"attribute",
"value",
"(",
"list",
"of",
"(",
"attribute",
"value",
"builder",
"(",
")",
"s",
"(",
"username",
")",
"build",
"(",
")",
")",
")",
"key",
"(",
"column",
"names",
"principal",
"get",
"column",
"name",
"(",
")",
")",
"build",
"(",
")",
")",
";",
"}"
] |
[
"invoked",
"when",
"a",
"bundle",
"is",
"added",
"to",
"{",
"@",
"link",
"bundle",
"host",
"}"
] |
[
"default",
"void",
"bundle",
"added",
"(",
"ghidra",
"bundle",
"bundle",
")",
"{",
"/",
"/",
"}"
] |
[
"set",
"directories",
"that",
"cannot",
"be",
"removed",
"unless",
"empty",
",",
"even",
"by",
"an",
"administrator"
] |
[
"string",
"set",
"protected",
"directories",
"(",
"string",
"protected",
"dirs",
"string",
")",
"{",
"if",
"(",
"protected",
"dirs",
"string",
"=",
"=",
"null",
")",
"{",
"protected",
"directories",
"=",
"new",
"tree",
"set",
"<",
">",
"(",
")",
";",
"}",
"else",
"{",
"protected",
"directories",
"=",
"parse",
"protected",
"directories",
"(",
"protected",
"dirs",
"string",
")",
";",
"}",
"return",
"joiner",
"on",
"(",
"\"",
",",
"\"",
")",
"skip",
"nulls",
"(",
")",
"join",
"(",
"protected",
"directories",
")",
";",
"}"
] |
[
"returns",
"the",
"average",
"time",
"spent",
"loading",
"new",
"values",
"this",
"is",
"defined",
"as",
"{",
"@",
"code",
"total",
"load",
"time",
"(",
"load",
"success",
"count",
"+",
"load",
"exception",
"count",
")",
"}",
"<",
"b",
">",
"note",
":",
"<",
"b",
">",
"the",
"values",
"of",
"the",
"metrics",
"are",
"undefined",
"in",
"case",
"of",
"overflow",
"(",
"though",
"it",
"is",
"guaranteed",
"not",
"to",
"throw",
"an",
"exception",
")",
"if",
"you",
"require",
"specific",
"handling",
",",
"we",
"recommend",
"implementing",
"your",
"own",
"stats",
"collector"
] |
[
"public",
"double",
"average",
"load",
"penalty",
"(",
")",
"{",
"long",
"total",
"load",
"count",
"=",
"saturated",
"add",
"(",
"load",
"success",
"count",
",",
"load",
"exception",
"count",
")",
";",
"return",
"(",
"total",
"load",
"count",
"=",
"=",
"0",
")",
"?",
"0",
"0",
":",
"(",
"double",
")",
"total",
"load",
"time",
"/",
"total",
"load",
"count",
";",
"}"
] |
[
"a",
"timeout",
"to",
"wait",
"if",
"the",
"index",
"operation",
"can",
"'",
"t",
"be",
"performed",
"immediately",
"defaults",
"to",
"{",
"@",
"code",
"1m",
"}"
] |
[
"public",
"final",
"request",
"timeout",
"(",
"time",
"value",
"timeout",
")",
"{",
"this",
"timeout",
"=",
"timeout",
";",
"return",
"(",
"request",
")",
"this",
";",
"}"
] |
[
"get",
"name",
"number"
] |
[
"public",
"big",
"decimal",
"get",
"name",
"number",
"(",
")",
"{",
"return",
"name",
"number",
";",
"}"
] |
[
"@",
"t",
"c",
"description",
":",
"nacos",
"open",
"a",
"p",
"i",
",",
",",
"utf",
"-",
"8",
"@",
"test",
"step",
":",
"1",
"2",
"@",
"expect",
"result",
":"
] |
[
"public",
"void",
"nacos",
"open",
"a",
"p",
"i",
"search",
"config",
"2",
"(",
")",
"{",
"http",
"rest",
"result",
"<",
"string",
">",
"result",
"=",
"null",
";",
"try",
"{",
"final",
"string",
"content",
"=",
"\"",
"\"",
";",
"boolean",
"ret",
"=",
"iconfig",
"publish",
"config",
"(",
"data",
"id",
",",
"group",
",",
"content",
")",
";",
"assert",
"assert",
"true",
"(",
"ret",
")",
";",
"thread",
"sleep",
"(",
"time",
"out",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"params",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"params",
"put",
"(",
"\"",
"data",
"id",
"\"",
",",
"data",
"id",
")",
";",
"params",
"put",
"(",
"\"",
"group",
"\"",
",",
"group",
")",
";",
"params",
"put",
"(",
"\"",
"page",
"no",
"\"",
",",
"\"",
"1",
"\"",
")",
";",
"params",
"put",
"(",
"\"",
"page",
"size",
"\"",
",",
"\"",
"10",
"\"",
")",
";",
"params",
"put",
"(",
"\"",
"search",
"\"",
",",
"\"",
"accurate",
"\"",
")",
";",
"result",
"=",
"agent",
"http",
"get",
"(",
"config",
"controller",
"path",
"+",
"\"",
"/",
"\"",
",",
"null",
",",
"params",
",",
"agent",
"get",
"encode",
"(",
")",
",",
"time",
"out",
")",
";",
"assert",
"assert",
"equals",
"(",
"http",
"u",
"r",
"l",
"connection",
"http",
"ok",
",",
"result",
"get",
"code",
"(",
")",
")",
";",
"assert",
"assert",
"equals",
"(",
"1",
",",
"jackson",
"utils",
"to",
"obj",
"(",
"result",
"get",
"data",
"(",
")",
")",
"get",
"(",
"\"",
"total",
"count",
"\"",
")",
"int",
"value",
"(",
")",
")",
";",
"assert",
"assert",
"equals",
"(",
"content",
",",
"jackson",
"utils",
"to",
"obj",
"(",
"result",
"get",
"data",
"(",
")",
")",
"get",
"(",
"\"",
"page",
"items",
"\"",
")",
"get",
"(",
"0",
")",
"get",
"(",
"\"",
"content",
"\"",
")",
"text",
"value",
"(",
")",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"assert",
"fail",
"(",
")",
";",
"}",
"}"
] |
[
"get",
"the",
"number",
"of",
"streams",
"to",
"merge",
"at",
"once"
] |
[
"public",
"int",
"get",
"factor",
"(",
")",
"{",
"return",
"factor",
";",
"}"
] |
[
"sets",
"the",
"function",
"calling",
"convention",
"for",
"example",
",",
"\"",
"cdecl",
"\""
] |
[
"public",
"void",
"set",
"calling",
"convention",
"(",
"string",
"calling",
"convention",
")",
"{",
"this",
"calling",
"convention",
"=",
"calling",
"convention",
";",
"}"
] |
[
"appends",
"the",
"string",
"representation",
"of",
"the",
"specified",
"{",
"@",
"code",
"float",
"}",
"value",
"the",
"{",
"@",
"code",
"float",
"}",
"value",
"is",
"converted",
"to",
"a",
"string",
"according",
"to",
"the",
"rule",
"defined",
"by",
"{",
"@",
"link",
"string",
"#",
"value",
"of",
"(",
"float",
")",
"}"
] |
[
"public",
"string",
"builder",
"append",
"(",
"float",
"f",
")",
"{",
"append",
"0",
"(",
"float",
"to",
"string",
"(",
"f",
")",
")",
";",
"return",
"this",
";",
"}"
] |
[
"animates",
"the",
"drawing",
"rendering",
"of",
"the",
"chart",
"on",
"both",
"x",
"-",
"and",
"y",
"-",
"axis",
"with",
"the",
"specified",
"animation",
"time",
"if",
"animate",
"(",
")",
"is",
"called",
",",
"no",
"further",
"calling",
"of",
"invalidate",
"(",
")",
"is",
"necessary",
"to",
"refresh",
"the",
"chart",
"animations",
"only",
"work",
"for",
"api",
"level",
"11",
"(",
"android",
"3",
"0",
"x",
")",
"and",
"higher"
] |
[
"public",
"void",
"animate",
"x",
"y",
"(",
"int",
"duration",
"millis",
"x",
",",
"int",
"duration",
"millis",
"y",
")",
"{",
"m",
"animator",
"animate",
"x",
"y",
"(",
"duration",
"millis",
"x",
",",
"duration",
"millis",
"y",
")",
";",
"}"
] |
[
"verify",
"that",
"if",
"a",
"given",
"watcher",
"doesn",
"'",
"t",
"exist",
",",
"the",
"server",
"properly",
"returns",
"an",
"error",
"code",
"for",
"it",
"in",
"our",
"java",
"client",
"implementation",
",",
"we",
"check",
"that",
"a",
"given",
"watch",
"exists",
"at",
"two",
"points",
":",
"1",
")",
"before",
"submitting",
"the",
"remove",
"watches",
"request",
"2",
")",
"after",
"a",
"successful",
"server",
"response",
",",
"when",
"the",
"watcher",
"needs",
"to",
"be",
"removed",
"since",
"this",
"can",
"be",
"racy",
"(",
"i",
"e",
"a",
"watch",
"can",
"fire",
"while",
"a",
"remove",
"watches",
"request",
"is",
"in",
"-",
"flight",
")",
",",
"we",
"need",
"to",
"verify",
"that",
"the",
"watch",
"was",
"actually",
"removed",
"(",
"i",
"e",
"from",
"z",
"k",
"database",
"and",
"data",
"tree",
")",
"and",
"return",
"nowatcher",
"if",
"needed",
"also",
",",
"other",
"implementations",
"might",
"not",
"do",
"a",
"client",
"side",
"check",
"before",
"submitting",
"a",
"remove",
"watches",
"request",
"if",
"we",
"don",
"'",
"t",
"do",
"a",
"server",
"side",
"check",
",",
"we",
"would",
"just",
"return",
"zok",
"even",
"if",
"no",
"watch",
"was",
"removed"
] |
[
"public",
"void",
"test",
"no",
"watcher",
"server",
"exception",
"(",
"boolean",
"use",
"async",
")",
"throws",
"interrupted",
"exception",
",",
"i",
"o",
"exception",
",",
"timeout",
"exception",
"{",
"countdown",
"watcher",
"watcher",
"=",
"new",
"countdown",
"watcher",
"(",
")",
";",
"zoo",
"keeper",
"zk",
"=",
"spy",
"(",
"new",
"zoo",
"keeper",
"(",
"host",
"port",
",",
"connection",
"timeout",
",",
"watcher",
")",
")",
";",
"my",
"watch",
"manager",
"watch",
"manager",
"=",
"new",
"my",
"watch",
"manager",
"(",
"false",
",",
"watcher",
")",
";",
"do",
"return",
"(",
"watch",
"manager",
")",
"when",
"(",
"zk",
")",
"get",
"watch",
"manager",
"(",
")",
";",
"boolean",
"nw",
"=",
"false",
";",
"watcher",
"wait",
"for",
"connected",
"(",
"connection",
"timeout",
")",
";",
"try",
"{",
"zk",
"remove",
"watches",
"(",
"\"",
"/",
"nowatchhere",
"\"",
",",
"watcher",
",",
"watcher",
"type",
"data",
",",
"false",
")",
";",
"}",
"catch",
"(",
"keeper",
"exception",
"nwe",
")",
"{",
"if",
"(",
"nwe",
"code",
"(",
")",
"int",
"value",
"(",
")",
"=",
"=",
"code",
"nowatcher",
"int",
"value",
"(",
")",
")",
"{",
"nw",
"=",
"true",
";",
"}",
"}",
"assert",
"that",
"(",
"\"",
"server",
"didn",
"'",
"t",
"return",
"nowatcher",
"\"",
",",
"watch",
"manager",
"last",
"return",
"code",
",",
"is",
"(",
"code",
"nowatcher",
"int",
"value",
"(",
")",
")",
")",
";",
"assert",
"that",
"(",
"\"",
"no",
"watcher",
"exception",
"didn",
"'",
"t",
"happen",
"\"",
",",
"nw",
",",
"is",
"(",
"true",
")",
")",
";",
"}"
] |
[
"this",
"implementation",
"comes",
"at",
"a",
"relatively",
"high",
"cost",
"per",
"invocation",
"it",
"should",
"not",
"be",
"called",
"repeatedly",
"when",
"it",
"is",
"clear",
"that",
"the",
"value",
"did",
"not",
"change",
"currently",
"this",
"is",
"only",
"truly",
"used",
"to",
"realize",
"certain",
"higher",
"-",
"level",
"tests"
] |
[
"public",
"int",
"size",
"(",
")",
"{",
"if",
"(",
"all",
"elements",
"in",
"cache",
")",
"{",
"return",
"ordered",
"cache",
"size",
"(",
")",
";",
"}",
"else",
"{",
"int",
"count",
"=",
"0",
";",
"try",
"(",
"final",
"rocks",
"bytes",
"iterator",
"iterator",
"=",
"ordered",
"bytes",
"iterator",
"(",
")",
")",
"{",
"while",
"(",
"iterator",
"has",
"next",
"(",
")",
")",
"{",
"iterator",
"next",
"(",
")",
";",
"+",
"+",
"count",
";",
"}",
"}",
"return",
"count",
";",
"}",
"}"
] |
[
"removes",
"all",
"key",
"-",
"value",
"mappings",
"from",
"this",
"sparse",
"array"
] |
[
"public",
"void",
"clear",
"(",
")",
"{",
"int",
"n",
"=",
"m",
"size",
";",
"object",
"[",
"]",
"values",
"=",
"m",
"values",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"n",
";",
"i",
"+",
"+",
")",
"{",
"values",
"[",
"i",
"]",
"=",
"null",
";",
"}",
"m",
"size",
"=",
"0",
";",
"m",
"garbage",
"=",
"false",
";",
"}"
] |
[
"called",
"after",
"{",
"@",
"link",
"application",
"listener",
"}",
"create",
"and",
"resize",
",",
"but",
"before",
"the",
"game",
"loop",
"iteration"
] |
[
"protected",
"void",
"start",
"(",
")",
"{",
"}"
] |
[
"helper",
"method",
"to",
"configure",
"the",
"usernamepassword",
"for",
"basic",
"auth",
"or",
"password",
"oauth"
] |
[
"public",
"api",
"client",
"set",
"credentials",
"(",
"string",
"username",
",",
"string",
"password",
")",
"{",
"for",
"(",
"interceptor",
"api",
"authorization",
":",
"api",
"authorizations",
"values",
"(",
")",
")",
"{",
"if",
"(",
"api",
"authorization",
"instanceof",
"http",
"basic",
"auth",
")",
"{",
"http",
"basic",
"auth",
"basic",
"auth",
"=",
"(",
"http",
"basic",
"auth",
")",
"api",
"authorization",
";",
"basic",
"auth",
"set",
"credentials",
"(",
"username",
",",
"password",
")",
";",
"return",
"this",
";",
"}",
"if",
"(",
"api",
"authorization",
"instanceof",
"o",
"auth",
")",
"{",
"o",
"auth",
"oauth",
"=",
"(",
"o",
"auth",
")",
"api",
"authorization",
";",
"oauth",
"get",
"token",
"request",
"builder",
"(",
")",
"set",
"username",
"(",
"username",
")",
"set",
"password",
"(",
"password",
")",
";",
"return",
"this",
";",
"}",
"}",
"return",
"this",
";",
"}"
] |
[
"sets",
"word",
"to",
"be",
"encoded"
] |
[
"void",
"set",
"word",
"(",
"string",
"in",
")",
"{",
"m",
"in",
"word",
"=",
"in",
"to",
"upper",
"case",
"(",
")",
";",
";",
"m",
"length",
"=",
"m",
"in",
"word",
"length",
"(",
")",
";",
"}"
] |
[
"test",
"for",
"a",
"bug",
"encountered",
"during",
"development",
"of",
"hadoop",
"-",
"8163",
":",
"ensure",
"base",
"node",
"(",
")",
"should",
"throw",
"an",
"exception",
"if",
"it",
"has",
"to",
"retry",
"more",
"than",
"3",
"times",
"to",
"create",
"any",
"part",
"of",
"the",
"path"
] |
[
"public",
"void",
"test",
"ensure",
"base",
"node",
"fails",
"(",
")",
"throws",
"exception",
"{",
"mockito",
"do",
"throw",
"(",
"new",
"keeper",
"exception",
"connection",
"loss",
"exception",
"(",
")",
")",
"when",
"(",
"mock",
"z",
"k",
")",
"create",
"(",
"mockito",
"eq",
"(",
"zk",
"parent",
"name",
")",
",",
"mockito",
"<",
"byte",
"[",
"]",
">",
"any",
"(",
")",
",",
"mockito",
"eq",
"(",
"ids",
"open",
"acl",
"unsafe",
")",
",",
"mockito",
"eq",
"(",
"create",
"mode",
"persistent",
")",
")",
";",
"try",
"{",
"elector",
"ensure",
"parent",
"z",
"node",
"(",
")",
";",
"assert",
"fail",
"(",
"\"",
"did",
"not",
"throw",
"!",
"\"",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"ioe",
")",
"{",
"if",
"(",
"!",
"(",
"ioe",
"get",
"cause",
"(",
")",
"instanceof",
"keeper",
"exception",
"connection",
"loss",
"exception",
")",
")",
"{",
"throw",
"ioe",
";",
"}",
"}",
"/",
"/",
"should",
"have",
"tried",
"three",
"times",
"mockito",
"verify",
"(",
"mock",
"z",
"k",
",",
"mockito",
"times",
"(",
"3",
")",
")",
"create",
"(",
"mockito",
"eq",
"(",
"zk",
"parent",
"name",
")",
",",
"mockito",
"<",
"byte",
"[",
"]",
">",
"any",
"(",
")",
",",
"mockito",
"eq",
"(",
"ids",
"open",
"acl",
"unsafe",
")",
",",
"mockito",
"eq",
"(",
"create",
"mode",
"persistent",
")",
")",
";",
"}"
] |
[
"post",
"pet",
":",
"add",
"a",
"new",
"pet",
"to",
"the",
"store"
] |
[
"default",
"response",
"entity",
"<",
"void",
">",
"add",
"pet",
"(",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"pet",
"object",
"that",
"needs",
"to",
"be",
"added",
"to",
"the",
"store",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"valid",
"@",
"request",
"body",
"pet",
"body",
")",
"{",
"return",
"get",
"delegate",
"(",
")",
"add",
"pet",
"(",
"body",
")",
";",
"}"
] |
[
"returns",
"the",
"last",
"key",
"in",
"this",
"set"
] |
[
"public",
"short",
"get",
"last",
"(",
")",
"{",
"if",
"(",
"root",
"=",
"=",
"null",
")",
"{",
"return",
"-",
"1",
";",
"}",
"r",
"b",
"node",
"node",
"=",
"root",
";",
"while",
"(",
"node",
"right",
"!",
"=",
"null",
")",
"{",
"node",
"=",
"node",
"right",
";",
"}",
"return",
"node",
"key",
";",
"}"
] |
[
"return",
"a",
"map",
"of",
"object",
"file",
"artifacts",
"to",
"associated",
"l",
"t",
"o",
"backend",
"artifacts",
"objects",
"generated",
"when",
"lto",
"backend",
"actions",
"are",
"to",
"be",
"shared",
"among",
"different",
"targets",
"using",
"this",
"library",
"this",
"is",
"the",
"case",
"when",
"we",
"opt",
"not",
"to",
"perform",
"the",
"lto",
"indexing",
"step",
",",
"such",
"as",
"when",
"building",
"tests",
"with",
"static",
"linking",
"thin",
"l",
"t",
"o",
"is",
"otherwise",
"too",
"expensive",
"when",
"statically",
"linking",
"tests",
",",
"due",
"to",
"the",
"number",
"of",
"lto",
"backends",
"that",
"can",
"be",
"generated",
"for",
"a",
"single",
"blaze",
"test",
"invocation"
] |
[
"immutable",
"map",
"<",
"artifact",
",",
"lto",
"backend",
"artifacts",
">",
"get",
"shared",
"non",
"lto",
"backends",
"(",
")",
";"
] |
[
"a",
"function",
"equivalent",
"to",
"the",
"method",
"reference",
"{",
"@",
"code",
"object",
":",
":",
"to",
"string",
"}",
",",
"for",
"users",
"not",
"yet",
"using",
"java",
"8",
"the",
"function",
"simply",
"invokes",
"{",
"@",
"code",
"to",
"string",
"}",
"on",
"its",
"argument",
"and",
"returns",
"the",
"result",
"it",
"throws",
"a",
"{",
"@",
"link",
"null",
"pointer",
"exception",
"}",
"on",
"null",
"input",
"<",
"b",
">",
"warning",
":",
"<",
"b",
">",
"the",
"returned",
"function",
"may",
"not",
"be",
"consistent",
"with",
"equals",
"(",
"as",
"documented",
"at",
"{",
"@",
"link",
"function",
"#",
"apply",
"}",
")",
"for",
"example",
",",
"this",
"function",
"yields",
"different",
"results",
"for",
"the",
"two",
"equal",
"instances",
"{",
"@",
"code",
"immutable",
"set",
"of",
"(",
"1",
",",
"2",
")",
"}",
"and",
"{",
"@",
"code",
"immutable",
"set",
"of",
"(",
"2",
",",
"1",
")",
"}",
"<",
"b",
">",
"warning",
":",
"<",
"b",
">",
"as",
"with",
"all",
"function",
"types",
"in",
"this",
"package",
",",
"avoid",
"depending",
"on",
"the",
"specific",
"{",
"@",
"code",
"equals",
"}",
",",
"{",
"@",
"code",
"hash",
"code",
"}",
"or",
"{",
"@",
"code",
"to",
"string",
"}",
"behavior",
"of",
"the",
"returned",
"function",
"a",
"future",
"migration",
"to",
"{",
"@",
"code",
"java",
"util",
"function",
"}",
"will",
"not",
"preserve",
"this",
"behavior",
"<",
"b",
">",
"for",
"java",
"8",
"users",
":",
"<",
"b",
">",
"use",
"the",
"method",
"reference",
"{",
"@",
"code",
"object",
":",
":",
"to",
"string",
"}",
"instead",
"in",
"the",
"future",
",",
"when",
"this",
"class",
"requires",
"java",
"8",
",",
"this",
"method",
"will",
"be",
"deprecated",
"see",
"{",
"@",
"link",
"function",
"}",
"for",
"more",
"important",
"information",
"about",
"the",
"java",
"8",
"transition"
] |
[
"public",
"static",
"function",
"<",
"object",
",",
"string",
">",
"to",
"string",
"function",
"(",
")",
"{",
"return",
"to",
"string",
"function",
"instance",
";",
"}"
] |
[
"subclasses",
"must",
"call",
"this",
"method",
"after",
"finishing",
"character",
"processing",
",",
"in",
"order",
"to",
"ensure",
"that",
"any",
"unterminated",
"line",
"in",
"the",
"buffer",
"is",
"passed",
"to",
"{",
"@",
"link",
"#",
"handle",
"line",
"}"
] |
[
"protected",
"void",
"finish",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"saw",
"return",
"|",
"|",
"line",
"length",
"(",
")",
">",
"0",
")",
"{",
"finish",
"line",
"(",
"false",
")",
";",
"}",
"}"
] |
[
"check",
"if",
"identity",
"is",
"allowed",
"to",
"drop",
"the",
"specified",
"schema",
"in",
"this",
"catalog"
] |
[
"default",
"void",
"check",
"can",
"drop",
"schema",
"(",
"connector",
"transaction",
"handle",
"transaction",
"handle",
",",
"connector",
"identity",
"identity",
",",
"access",
"control",
"context",
"context",
",",
"string",
"schema",
"name",
")",
"{",
"deny",
"drop",
"schema",
"(",
"schema",
"name",
")",
";",
"}"
] |
[
"moves",
"current",
"position",
"until",
"after",
"the",
"next",
"end",
"of",
"string",
"marker"
] |
[
"public",
"void",
"skip",
"next",
"string",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"offset",
">",
"=",
"b",
"length",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"tried",
"to",
"read",
"nonexistent",
"string",
"from",
"byte",
"array",
"\"",
")",
";",
"}",
"while",
"(",
"offset",
"<",
"b",
"length",
"&",
"&",
"b",
"[",
"offset",
"]",
"!",
"=",
"0x",
"0",
")",
"{",
"+",
"+",
"offset",
";",
"}",
"+",
"+",
"offset",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"category",
"'"
] |
[
"public",
"void",
"category",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"category",
"}"
] |
[
"verify",
"the",
"support",
"for",
"decommissioning",
"a",
"datanode",
"that",
"is",
"already",
"dead",
"under",
"this",
"scenario",
"the",
"datanode",
"should",
"immediately",
"be",
"marked",
"as",
"decommissioned"
] |
[
"public",
"void",
"test",
"decommission",
"dead",
"d",
"n",
"(",
")",
"throws",
"exception",
"{",
"logger",
"log",
"=",
"logger",
"get",
"logger",
"(",
"datanode",
"admin",
"manager",
"class",
")",
";",
"log",
"set",
"level",
"(",
"level",
"debug",
")",
";",
"datanode",
"i",
"d",
"dn",
"i",
"d",
"=",
"cluster",
"get",
"data",
"nodes",
"(",
")",
"get",
"(",
"0",
")",
"get",
"datanode",
"id",
"(",
")",
";",
"string",
"dn",
"name",
"=",
"dn",
"i",
"d",
"get",
"xfer",
"addr",
"(",
")",
";",
"data",
"node",
"properties",
"stopped",
"d",
"n",
"=",
"cluster",
"stop",
"data",
"node",
"(",
"0",
")",
";",
"d",
"f",
"s",
"test",
"util",
"wait",
"for",
"datanode",
"state",
"(",
"cluster",
",",
"dn",
"i",
"d",
"get",
"datanode",
"uuid",
"(",
")",
",",
"false",
",",
"30000",
")",
";",
"f",
"s",
"namesystem",
"fsn",
"=",
"cluster",
"get",
"namesystem",
"(",
")",
";",
"final",
"datanode",
"manager",
"dm",
"=",
"fsn",
"get",
"block",
"manager",
"(",
")",
"get",
"datanode",
"manager",
"(",
")",
";",
"datanode",
"descriptor",
"dn",
"descriptor",
"=",
"dm",
"get",
"datanode",
"(",
"dn",
"i",
"d",
")",
";",
"decommission",
"node",
"(",
"dn",
"name",
")",
";",
"dm",
"refresh",
"nodes",
"(",
"conf",
")",
";",
"block",
"manager",
"test",
"util",
"recheck",
"decommission",
"state",
"(",
"dm",
")",
";",
"/",
"/",
"block",
"until",
"the",
"admin",
"'",
"s",
"monitor",
"updates",
"the",
"number",
"of",
"tracked",
"nodes",
"wait",
"for",
"decommissioned",
"nodes",
"(",
"dm",
"get",
"datanode",
"admin",
"manager",
"(",
")",
",",
"0",
")",
";",
"assert",
"true",
"(",
"dn",
"descriptor",
"is",
"decommissioned",
"(",
")",
")",
";",
"/",
"/",
"add",
"the",
"node",
"back",
"cluster",
"restart",
"data",
"node",
"(",
"stopped",
"d",
"n",
",",
"true",
")",
";",
"cluster",
"wait",
"active",
"(",
")",
";",
"/",
"/",
"call",
"refresh",
"nodes",
"on",
"f",
"s",
"namesystem",
"with",
"empty",
"exclude",
"file",
"to",
"remove",
"the",
"/",
"/",
"datanode",
"from",
"decommissioning",
"list",
"and",
"make",
"it",
"available",
"again",
"hosts",
"file",
"writer",
"init",
"exclude",
"host",
"(",
"\"",
"\"",
")",
";",
"dm",
"refresh",
"nodes",
"(",
"conf",
")",
";",
"}"
] |
[
"create",
"user",
"this",
"can",
"only",
"be",
"done",
"by",
"the",
"logged",
"in",
"user"
] |
[
"public",
"void",
"create",
"user",
"(",
"user",
"user",
")",
"throws",
"api",
"exception",
"{",
"object",
"local",
"var",
"post",
"body",
"=",
"user",
";",
"/",
"/",
"verify",
"the",
"required",
"parameter",
"'",
"user",
"'",
"is",
"set",
"if",
"(",
"user",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"api",
"exception",
"(",
"400",
",",
"\"",
"missing",
"the",
"required",
"parameter",
"'",
"user",
"'",
"when",
"calling",
"create",
"user",
"\"",
")",
";",
"}",
"/",
"/",
"create",
"path",
"and",
"map",
"variables",
"string",
"local",
"var",
"path",
"=",
"\"",
"/",
"user",
"\"",
"replace",
"all",
"(",
"\"",
"\\",
"\\",
"{",
"format",
"\\",
"\\",
"}",
"\"",
",",
"\"",
"json",
"\"",
")",
";",
"/",
"/",
"query",
"params",
"list",
"<",
"pair",
">",
"local",
"var",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
"pair",
">",
"(",
")",
";",
"/",
"/",
"header",
"params",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"header",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"/",
"/",
"form",
"params",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"form",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"string",
"[",
"]",
"local",
"var",
"content",
"types",
"=",
"{",
"}",
";",
"string",
"local",
"var",
"content",
"type",
"=",
"local",
"var",
"content",
"types",
"length",
">",
"0",
"?",
"local",
"var",
"content",
"types",
"[",
"0",
"]",
":",
"\"",
"application",
"/",
"json",
"\"",
";",
"if",
"(",
"local",
"var",
"content",
"type",
"starts",
"with",
"(",
"\"",
"multipart",
"/",
"form",
"-",
"data",
"\"",
")",
")",
"{",
"/",
"/",
"file",
"uploading",
"multipart",
"entity",
"builder",
"local",
"var",
"builder",
"=",
"multipart",
"entity",
"builder",
"create",
"(",
")",
";",
"local",
"var",
"post",
"body",
"=",
"local",
"var",
"builder",
"build",
"(",
")",
";",
"}",
"else",
"{",
"/",
"/",
"normal",
"form",
"params",
"}",
"try",
"{",
"string",
"local",
"var",
"response",
"=",
"api",
"invoker",
"invoke",
"a",
"p",
"i",
"(",
"base",
"path",
",",
"local",
"var",
"path",
",",
"\"",
"post",
"\"",
",",
"local",
"var",
"query",
"params",
",",
"local",
"var",
"post",
"body",
",",
"local",
"var",
"header",
"params",
",",
"local",
"var",
"form",
"params",
",",
"local",
"var",
"content",
"type",
")",
";",
"if",
"(",
"local",
"var",
"response",
"!",
"=",
"null",
")",
"{",
"return",
";",
"}",
"else",
"{",
"return",
";",
"}",
"}",
"catch",
"(",
"api",
"exception",
"ex",
")",
"{",
"throw",
"ex",
";",
"}",
"}"
] |
[
"gets",
"the",
"appropriate",
"ghidra",
"application",
"layout",
"for",
"this",
"headless",
"analyzer",
"the",
"headless",
"analyzer",
"can",
"be",
"used",
"in",
"both",
"\"",
"normal",
"\"",
"mode",
"and",
"single",
"jar",
"mode",
",",
"so",
"we",
"need",
"to",
"use",
"the",
"appropriate",
"layout",
"for",
"either",
"case"
] |
[
"private",
"static",
"ghidra",
"application",
"layout",
"get",
"application",
"layout",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"ghidra",
"application",
"layout",
"layout",
";",
"try",
"{",
"layout",
"=",
"new",
"ghidra",
"application",
"layout",
"(",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"layout",
"=",
"new",
"ghidra",
"jar",
"application",
"layout",
"(",
")",
";",
"}",
"return",
"layout",
";",
"}"
] |
[
"return",
"the",
"covariances",
"as",
"a",
"map",
"-",
"not",
"public",
",",
"used",
"for",
"get",
"property",
"(",
")"
] |
[
"protected",
"map",
"<",
"string",
",",
"hash",
"map",
"<",
"string",
",",
"double",
">",
">",
"get",
"covariances",
"(",
")",
"{",
"return",
"collections",
"unmodifiable",
"map",
"(",
"results",
"covariances",
")",
";",
"}"
] |
[
"removes",
"a",
"listener",
"of",
"video",
"events"
] |
[
"void",
"remove",
"video",
"listener",
"(",
"video",
"listener",
"listener",
")",
";"
] |
[
"model",
"tests",
"for",
"mixed",
"properties",
"and",
"additional",
"properties",
"class"
] |
[
"public",
"void",
"test",
"mixed",
"properties",
"and",
"additional",
"properties",
"class",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"mixed",
"properties",
"and",
"additional",
"properties",
"class",
"}"
] |
[
"is",
"the",
"last",
"block",
"completed",
"?"
] |
[
"public",
"boolean",
"is",
"last",
"block",
"complete",
"(",
")",
"{",
"return",
"is",
"last",
"block",
"complete",
";",
"}"
] |
[
"return",
"headers",
"associated",
"with",
"the",
"exception",
"that",
"should",
"be",
"added",
"to",
"the",
"error",
"response",
",",
"e",
"g",
"\"",
"allow",
"\"",
",",
"\"",
"accept",
"\"",
",",
"etc",
"the",
"default",
"implementation",
"in",
"this",
"class",
"returns",
"an",
"empty",
"map"
] |
[
"public",
"map",
"<",
"string",
",",
"string",
">",
"get",
"headers",
"(",
")",
"{",
"return",
"collections",
"empty",
"map",
"(",
")",
";",
"}"
] |
[
"removes",
"all",
"data",
"sets",
"(",
"and",
"thereby",
"entries",
")",
"from",
"the",
"chart",
"does",
"not",
"set",
"the",
"data",
"object",
"to",
"null",
"also",
"refreshes",
"the",
"chart",
"by",
"calling",
"invalidate",
"(",
")"
] |
[
"public",
"void",
"clear",
"values",
"(",
")",
"{",
"m",
"data",
"clear",
"values",
"(",
")",
";",
"invalidate",
"(",
")",
";",
"}"
] |
[
"get",
"the",
"namenode",
"resolver",
"for",
"a",
"subcluster"
] |
[
"public",
"active",
"namenode",
"resolver",
"get",
"namenode",
"resolver",
"(",
")",
"{",
"return",
"this",
"namenode",
"resolver",
";",
"}"
] |
[
"mappings",
"specified",
"on",
"this",
"search",
"request",
"that",
"override",
"built",
"in",
"mappings"
] |
[
"public",
"map",
"<",
"string",
",",
"object",
">",
"runtime",
"mappings",
"(",
")",
"{",
"return",
"collections",
"unmodifiable",
"map",
"(",
"runtime",
"mappings",
")",
";",
"}"
] |
[
"assert",
"that",
"a",
"map",
"contains",
"entries",
";",
"that",
"is",
",",
"it",
"must",
"not",
"be",
"{",
"@",
"code",
"null",
"}",
"and",
"must",
"contain",
"at",
"least",
"one",
"entry"
] |
[
"public",
"static",
"void",
"not",
"empty",
"(",
"@",
"nullable",
"map",
"<",
"?",
",",
"?",
">",
"map",
")",
"{",
"not",
"empty",
"(",
"map",
",",
"\"",
"[",
"assertion",
"failed",
"]",
"-",
"this",
"map",
"must",
"not",
"be",
"empty",
";",
"it",
"must",
"contain",
"at",
"least",
"one",
"entry",
"\"",
")",
";",
"}"
] |
[
"releases",
"the",
"component",
"listener"
] |
[
"public",
"void",
"release",
"(",
")",
"{",
"released",
"=",
"true",
";",
"player",
"handler",
"remove",
"callbacks",
"and",
"messages",
"(",
"null",
")",
";",
"}"
] |
[
"returns",
"true",
"if",
"the",
"specified",
"offset",
"is",
"a",
"valid",
"offset",
"for",
"this",
"string",
"table"
] |
[
"public",
"boolean",
"is",
"valid",
"(",
"long",
"offset",
")",
"{",
"return",
"(",
"offset",
">",
"=",
"0",
")",
"&",
"&",
"(",
"offset",
"<",
"bytes",
"length",
")",
";",
"}"
] |
[
"only",
"valid",
"if",
"the",
"image",
"format",
"is",
"jpeg"
] |
[
"public",
"int",
"get",
"sample",
"size",
"(",
")",
"{",
"return",
"m",
"sample",
"size",
";",
"}"
] |
[
"adds",
"a",
"new",
"pair",
"of",
"attribute",
"-",
"value"
] |
[
"public",
"builder",
"add",
"attribute",
"(",
"string",
"name",
",",
"string",
"value",
")",
"{",
"attributes",
"put",
"(",
"name",
",",
"value",
")",
";",
"return",
"this",
";",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.