docstring_tokens
list | code_tokens
list |
|---|---|
[
"work",
"around",
"for",
"bug",
"6935026"
] |
[
"public",
"list",
"<",
"string",
">",
"get",
"logger",
"names",
"(",
")",
"{",
"while",
"(",
"true",
")",
"{",
"try",
"{",
"list",
"<",
"string",
">",
"r",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"enumeration",
"<",
"string",
">",
"e",
"=",
"log",
"manager",
"get",
"log",
"manager",
"(",
")",
"get",
"logger",
"names",
"(",
")",
";",
"while",
"(",
"e",
"has",
"more",
"elements",
"(",
")",
")",
"r",
"add",
"(",
"e",
"next",
"element",
"(",
")",
")",
";",
"return",
"r",
";",
"}",
"catch",
"(",
"concurrent",
"modification",
"exception",
"e",
")",
"{",
"/",
"/",
"retry",
"}",
"}",
"}"
] |
[
"workhorse",
"to",
"check",
"and",
"write",
"out",
"compressed",
"datalengths"
] |
[
"void",
"write",
"buffer",
"(",
"data",
"output",
"buffer",
"uncompressed",
"data",
"buffer",
")",
"throws",
"i",
"o",
"exception",
"{",
"deflate",
"filter",
"reset",
"state",
"(",
")",
";",
"buffer",
"reset",
"(",
")",
";",
"deflate",
"out",
"write",
"(",
"uncompressed",
"data",
"buffer",
"get",
"data",
"(",
")",
",",
"0",
",",
"uncompressed",
"data",
"buffer",
"get",
"length",
"(",
")",
")",
";",
"deflate",
"out",
"flush",
"(",
")",
";",
"deflate",
"filter",
"finish",
"(",
")",
";",
"writable",
"utils",
"write",
"v",
"int",
"(",
"out",
",",
"buffer",
"get",
"length",
"(",
")",
")",
";",
"out",
"write",
"(",
"buffer",
"get",
"data",
"(",
")",
",",
"0",
",",
"buffer",
"get",
"length",
"(",
")",
")",
";",
"}"
] |
[
"look",
"up",
"the",
"session",
"factory",
"that",
"this",
"filter",
"should",
"use",
",",
"taking",
"the",
"current",
"http",
"request",
"as",
"argument",
"the",
"default",
"implementation",
"delegates",
"to",
"the",
"{",
"@",
"link",
"#",
"lookup",
"session",
"factory",
"(",
")",
"}",
"variant",
"without",
"arguments"
] |
[
"protected",
"session",
"factory",
"lookup",
"session",
"factory",
"(",
"http",
"servlet",
"request",
"request",
")",
"{",
"return",
"lookup",
"session",
"factory",
"(",
")",
";",
"}"
] |
[
"returns",
"whether",
"this",
"monitor",
"is",
"occupied",
"by",
"any",
"thread",
"this",
"method",
"is",
"designed",
"for",
"use",
"in",
"monitoring",
"of",
"the",
"system",
"state",
",",
"not",
"for",
"synchronization",
"control"
] |
[
"public",
"boolean",
"is",
"occupied",
"(",
")",
"{",
"return",
"lock",
"is",
"locked",
"(",
")",
";",
"}"
] |
[
"get",
"name",
"integer"
] |
[
"public",
"integer",
"get",
"name",
"integer",
"(",
")",
"{",
"return",
"name",
"integer",
";",
"}"
] |
[
"create",
"a",
"new",
"project",
"using",
"a",
"wizard",
"to",
"get",
"the",
"project",
"information"
] |
[
"void",
"new",
"project",
"(",
")",
"{",
"new",
"project",
"panel",
"manager",
"panel",
"manager",
"=",
"new",
"new",
"project",
"panel",
"manager",
"(",
"tool",
")",
";",
"wizard",
"manager",
"wm",
"=",
"new",
"wizard",
"manager",
"(",
"\"",
"new",
"project",
"\"",
",",
"true",
",",
"panel",
"manager",
",",
"new",
"project",
"icon",
")",
";",
"wm",
"show",
"wizard",
"(",
"tool",
"get",
"tool",
"frame",
"(",
")",
")",
";",
"project",
"locator",
"new",
"project",
"locator",
"=",
"panel",
"manager",
"get",
"new",
"project",
"location",
"(",
")",
";",
"repository",
"adapter",
"new",
"repo",
"=",
"panel",
"manager",
"get",
"project",
"repository",
"(",
")",
";",
"if",
"(",
"new",
"project",
"locator",
"=",
"=",
"null",
")",
"{",
"return",
";",
"/",
"/",
"user",
"canceled",
"}",
"project",
"new",
"project",
"=",
"null",
";",
"try",
"{",
"/",
"/",
"if",
"all",
"is",
"well",
"and",
"we",
"already",
"have",
"an",
"active",
"project",
",",
"close",
"it",
"project",
"active",
"project",
"=",
"plugin",
"get",
"active",
"project",
"(",
")",
";",
"if",
"(",
"active",
"project",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"!",
"close",
"project",
"(",
"false",
")",
")",
"{",
"/",
"/",
"false",
"-",
"-",
">",
"not",
"exiting",
"return",
";",
"/",
"/",
"user",
"canceled",
"}",
"}",
"if",
"(",
"new",
"repo",
"!",
"=",
"null",
")",
"{",
"try",
"{",
"if",
"(",
"new",
"repo",
"get",
"server",
"(",
")",
"is",
"connected",
"(",
")",
")",
"{",
"new",
"repo",
"connect",
"(",
")",
";",
"}",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"client",
"util",
"handle",
"exception",
"(",
"new",
"repo",
",",
"e",
",",
"\"",
"repository",
"connection",
"\"",
",",
"tool",
"get",
"tool",
"frame",
"(",
")",
")",
";",
"}",
"}",
"new",
"project",
"=",
"tool",
"get",
"project",
"manager",
"(",
")",
"create",
"project",
"(",
"new",
"project",
"locator",
",",
"new",
"repo",
",",
"true",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"string",
"msg",
"=",
"e",
"get",
"message",
"(",
")",
";",
"if",
"(",
"msg",
"=",
"=",
"null",
")",
"{",
"msg",
"=",
"e",
"to",
"string",
"(",
")",
";",
"}",
"msg",
"show",
"error",
"(",
"this",
",",
"tool",
"get",
"tool",
"frame",
"(",
")",
",",
"\"",
"create",
"project",
"failed",
"\"",
",",
"\"",
"failed",
"to",
"create",
"new",
"project",
"'",
"\"",
"+",
"new",
"project",
"locator",
"get",
"name",
"(",
")",
"+",
"\"",
"'",
":",
"\"",
"+",
"msg",
",",
"e",
")",
";",
"}",
"finally",
"{",
"if",
"(",
"new",
"project",
"=",
"=",
"null",
"&",
"&",
"new",
"repo",
"!",
"=",
"null",
")",
"{",
"new",
"repo",
"disconnect",
"(",
")",
";",
"}",
"}",
"/",
"/",
"make",
"the",
"new",
"project",
"the",
"active",
"one",
"tool",
"set",
"active",
"project",
"(",
"new",
"project",
")",
";",
"/",
"/",
"update",
"our",
"list",
"of",
"recent",
"projects",
"plugin",
"rebuild",
"recent",
"menus",
"(",
")",
";",
"if",
"(",
"new",
"project",
"!",
"=",
"null",
")",
"{",
"open",
"project",
"and",
"notify",
"(",
"new",
"project",
")",
";",
"}",
"}"
] |
[
"allocates",
"some",
"unpooled",
"off",
"-",
"heap",
"memory",
"and",
"creates",
"a",
"new",
"memory",
"segment",
"that",
"represents",
"that",
"memory"
] |
[
"public",
"static",
"memory",
"segment",
"allocate",
"unpooled",
"off",
"heap",
"memory",
"(",
"int",
"size",
")",
"{",
"return",
"allocate",
"unpooled",
"off",
"heap",
"memory",
"(",
"size",
",",
"null",
")",
";",
"}"
] |
[
"set",
"the",
"linear",
"damping",
"of",
"the",
"body"
] |
[
"public",
"void",
"set",
"linear",
"damping",
"(",
"float",
"linear",
"damping",
")",
"{",
"body",
"set",
"linear",
"damping",
"(",
"linear",
"damping",
")",
";",
"}"
] |
[
"utility",
"method",
"to",
"load",
"service",
"json",
"from",
"disk",
"or",
"from",
"yarn",
"examples"
] |
[
"public",
"service",
"load",
"app",
"json",
"from",
"local",
"f",
"s",
"(",
"string",
"file",
"name",
",",
"string",
"service",
"name",
",",
"long",
"lifetime",
",",
"string",
"queue",
")",
"throws",
"i",
"o",
"exception",
",",
"yarn",
"exception",
"{",
"file",
"file",
"=",
"new",
"file",
"(",
"file",
"name",
")",
";",
"if",
"(",
"!",
"file",
"exists",
"(",
")",
"&",
"&",
"file",
"name",
"equals",
"(",
"file",
"get",
"name",
"(",
")",
")",
")",
"{",
"string",
"examples",
"dir",
"str",
"=",
"system",
"getenv",
"(",
"\"",
"yarn",
"service",
"examples",
"dir",
"\"",
")",
";",
"string",
"[",
"]",
"examples",
"dirs",
";",
"if",
"(",
"examples",
"dir",
"str",
"=",
"=",
"null",
")",
"{",
"string",
"yarn",
"home",
"=",
"system",
"getenv",
"(",
"application",
"constants",
"environment",
"hadoop",
"yarn",
"home",
"key",
"(",
")",
")",
";",
"examples",
"dirs",
"=",
"new",
"string",
"[",
"]",
"{",
"yarn",
"home",
"+",
"\"",
"/",
"share",
"/",
"hadoop",
"/",
"yarn",
"/",
"yarn",
"-",
"service",
"-",
"examples",
"\"",
",",
"yarn",
"home",
"+",
"\"",
"/",
"yarn",
"-",
"service",
"-",
"examples",
"\"",
"}",
";",
"}",
"else",
"{",
"examples",
"dirs",
"=",
"string",
"utils",
"split",
"(",
"examples",
"dir",
"str",
",",
"\"",
":",
"\"",
")",
";",
"}",
"for",
"(",
"string",
"dir",
":",
"examples",
"dirs",
")",
"{",
"file",
"=",
"new",
"file",
"(",
"message",
"format",
"format",
"(",
"\"",
"{",
"0",
"}",
"/",
"{",
"1",
"}",
"/",
"{",
"2",
"}",
"json",
"\"",
",",
"dir",
",",
"file",
"name",
",",
"file",
"name",
")",
")",
";",
"if",
"(",
"file",
"exists",
"(",
")",
")",
"{",
"break",
";",
"}",
"/",
"/",
"then",
"look",
"for",
"secondary",
"location",
"file",
"=",
"new",
"file",
"(",
"message",
"format",
"format",
"(",
"\"",
"{",
"0",
"}",
"/",
"{",
"1",
"}",
"json",
"\"",
",",
"dir",
",",
"file",
"name",
")",
")",
";",
"if",
"(",
"file",
"exists",
"(",
")",
")",
"{",
"break",
";",
"}",
"}",
"}",
"if",
"(",
"!",
"file",
"exists",
"(",
")",
")",
"{",
"throw",
"new",
"yarn",
"exception",
"(",
"\"",
"file",
"or",
"example",
"could",
"not",
"be",
"found",
":",
"\"",
"+",
"file",
"name",
")",
";",
"}",
"path",
"file",
"path",
"=",
"new",
"path",
"(",
"file",
"get",
"absolute",
"path",
"(",
")",
")",
";",
"log",
"info",
"(",
"\"",
"loading",
"service",
"definition",
"from",
"local",
"fs",
":",
"\"",
"+",
"file",
"path",
")",
";",
"service",
"service",
"=",
"json",
"ser",
"deser",
"load",
"(",
"file",
"system",
"get",
"local",
"(",
"get",
"config",
"(",
")",
")",
",",
"file",
"path",
")",
";",
"if",
"(",
"!",
"string",
"utils",
"is",
"empty",
"(",
"service",
"name",
")",
")",
"{",
"service",
"set",
"name",
"(",
"service",
"name",
")",
";",
"}",
"if",
"(",
"lifetime",
"!",
"=",
"null",
"&",
"&",
"lifetime",
">",
"0",
")",
"{",
"service",
"set",
"lifetime",
"(",
"lifetime",
")",
";",
"}",
"if",
"(",
"!",
"string",
"utils",
"is",
"empty",
"(",
"queue",
")",
")",
"{",
"service",
"set",
"queue",
"(",
"queue",
")",
";",
"}",
"return",
"service",
";",
"}"
] |
[
"sets",
"the",
"internal",
"state",
"of",
"the",
"view",
"such",
"that",
"the",
"next",
"bytes",
"will",
"be",
"read",
"from",
"the",
"given",
"memory",
"segment",
",",
"starting",
"at",
"the",
"given",
"position",
"the",
"memory",
"segment",
"will",
"provide",
"bytes",
"up",
"to",
"the",
"given",
"limit",
"position"
] |
[
"protected",
"void",
"seek",
"input",
"(",
"memory",
"segment",
"segment",
",",
"int",
"position",
"in",
"segment",
",",
"int",
"limit",
"in",
"segment",
")",
"{",
"this",
"current",
"segment",
"=",
"segment",
";",
"this",
"position",
"in",
"segment",
"=",
"position",
"in",
"segment",
";",
"this",
"limit",
"in",
"segment",
"=",
"limit",
"in",
"segment",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"origin",
"'"
] |
[
"public",
"void",
"origin",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"origin",
"}"
] |
[
"marks",
"up",
"the",
"prelink",
"mach",
"-",
"o",
"headers"
] |
[
"public",
"void",
"markup",
"headers",
"(",
")",
"throws",
"exception",
"{",
"macho",
"prelink",
"program",
"builder",
"this",
"markup",
"headers",
"(",
"header",
",",
"header",
"addr",
")",
";",
"if",
"(",
"!",
"name",
"is",
"empty",
"(",
")",
")",
"{",
"listing",
"set",
"comment",
"(",
"header",
"addr",
",",
"code",
"unit",
"plate",
"comment",
",",
"name",
")",
";",
"}",
"}"
] |
[
"initialises",
"the",
"message",
"formatter"
] |
[
"default",
"public",
"void",
"init",
"(",
"properties",
"props",
")",
"{",
"}"
] |
[
"forces",
"the",
"fixed",
"timestamp",
"for",
"directories",
"to",
"make",
"sure",
"classes",
"jar",
"always",
"get",
"a",
"consistent",
"checksum"
] |
[
"protected",
"void",
"zip",
"dir",
"(",
"resource",
"dir",
",",
"zip",
"output",
"stream",
"z",
"out",
",",
"string",
"v",
"path",
",",
"int",
"mode",
",",
"zip",
"extra",
"field",
"[",
"]",
"extra",
")",
"throws",
"i",
"o",
"exception",
"{",
"/",
"/",
"use",
"wrapped",
"z",
"out",
"instead",
"of",
"z",
"out",
"super",
"zip",
"dir",
"(",
"dir",
",",
"wrapped",
"z",
"out",
",",
"v",
"path",
",",
"mode",
",",
"extra",
")",
";",
"}"
] |
[
"stream",
"is",
"closed",
"this",
"will",
"be",
"called",
"exactly",
"once"
] |
[
"public",
"void",
"stream",
"closed",
"(",
"status",
"status",
")",
"{",
"}"
] |
[
"customizes",
"the",
"aggregated",
"result",
"for",
"example",
",",
"summarizing",
"or",
"making",
"immutable"
] |
[
"protected",
"function",
"<",
"t",
",",
"t",
">",
"finisher",
"(",
")",
"{",
"return",
"function",
"identity",
"(",
")",
";",
"}"
] |
[
"specify",
"the",
"number",
"of",
"seconds",
"to",
"wait",
"until",
"http",
"exchanges",
"have",
"completed",
"when",
"shutting",
"down",
"the",
"http",
"server",
"default",
"is",
"0"
] |
[
"public",
"void",
"set",
"shutdown",
"delay",
"(",
"int",
"shutdown",
"delay",
")",
"{",
"this",
"shutdown",
"delay",
"=",
"shutdown",
"delay",
";",
"}"
] |
[
"convert",
"a",
"string",
"of",
"lines",
"that",
"look",
"like",
":",
"\"",
"68",
"72",
"70",
"63",
"02",
"00",
"00",
"00",
"82",
"00",
"1d",
"6f",
"72",
"67",
"2e",
"61",
"hrpc",
"org",
"a",
"\"",
"into",
"an",
"array",
"of",
"bytes"
] |
[
"private",
"static",
"byte",
"[",
"]",
"hex",
"dump",
"to",
"bytes",
"(",
"string",
"hexdump",
")",
"{",
"final",
"int",
"last",
"hex",
"col",
"=",
"3",
"*",
"16",
";",
"string",
"builder",
"hex",
"string",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"for",
"(",
"string",
"line",
":",
"string",
"utils",
"to",
"upper",
"case",
"(",
"hexdump",
")",
"split",
"(",
"\"",
"\\",
"n",
"\"",
")",
")",
"{",
"hex",
"string",
"append",
"(",
"line",
"substring",
"(",
"0",
",",
"last",
"hex",
"col",
")",
"replace",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
")",
";",
"}",
"return",
"string",
"utils",
"hex",
"string",
"to",
"byte",
"(",
"hex",
"string",
"to",
"string",
"(",
")",
")",
";",
"}"
] |
[
"get",
"the",
"maximum",
"am",
"resource",
"percent",
"per",
"queue",
"setting"
] |
[
"public",
"float",
"get",
"maximum",
"application",
"master",
"resource",
"per",
"queue",
"percent",
"(",
"string",
"queue",
")",
"{",
"return",
"get",
"float",
"(",
"get",
"queue",
"prefix",
"(",
"queue",
")",
"+",
"maximum",
"am",
"resource",
"suffix",
",",
"get",
"maximum",
"application",
"master",
"resource",
"percent",
"(",
")",
")",
";",
"}"
] |
[
"tests",
"that",
"in",
"case",
"of",
"port",
"collision",
",",
"a",
"flink",
"runtime",
"exception",
"is",
"thrown",
"with",
"a",
"specific",
"message"
] |
[
"public",
"void",
"test",
"server",
"initialization",
"failure",
"(",
")",
"throws",
"throwable",
"{",
"/",
"/",
"the",
"expected",
"exception",
"along",
"with",
"the",
"adequate",
"message",
"expected",
"ex",
"expect",
"(",
"flink",
"runtime",
"exception",
"class",
")",
";",
"expected",
"ex",
"expect",
"message",
"(",
"\"",
"unable",
"to",
"start",
"test",
"server",
"2",
"all",
"ports",
"in",
"provided",
"range",
"are",
"occupied",
"\"",
")",
";",
"list",
"<",
"integer",
">",
"port",
"list",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"port",
"list",
"add",
"(",
"7777",
")",
";",
"try",
"(",
"test",
"server",
"server",
"1",
"=",
"new",
"test",
"server",
"(",
"\"",
"test",
"server",
"1",
"\"",
",",
"new",
"disabled",
"kv",
"state",
"request",
"stats",
"(",
")",
",",
"port",
"list",
"iterator",
"(",
")",
")",
")",
"{",
"server",
"1",
"start",
"(",
")",
";",
"try",
"(",
"test",
"server",
"server",
"2",
"=",
"new",
"test",
"server",
"(",
"\"",
"test",
"server",
"2",
"\"",
",",
"new",
"disabled",
"kv",
"state",
"request",
"stats",
"(",
")",
",",
"collections",
"singleton",
"list",
"(",
"server",
"1",
"get",
"server",
"address",
"(",
")",
"get",
"port",
"(",
")",
")",
"iterator",
"(",
")",
")",
")",
"{",
"server",
"2",
"start",
"(",
")",
";",
"}",
"}",
"}"
] |
[
"test",
"verifies",
"that",
"the",
"server",
"is",
"able",
"to",
"redefine",
"if",
"user",
"configured",
"only",
"min",
"session",
"timeout",
"limit"
] |
[
"public",
"void",
"test",
"with",
"only",
"min",
"session",
"timeout",
"(",
")",
"throws",
"exception",
"{",
"client",
"base",
"setup",
"test",
"env",
"(",
")",
";",
"final",
"int",
"client",
"port",
"qp1",
"=",
"port",
"assignment",
"unique",
"(",
")",
";",
"final",
"int",
"client",
"port",
"qp2",
"=",
"port",
"assignment",
"unique",
"(",
")",
";",
"string",
"quorum",
"cfg",
"section",
"=",
"\"",
"server",
"1",
"=",
"127",
"0",
"0",
"1",
":",
"\"",
"+",
"port",
"assignment",
"unique",
"(",
")",
"+",
"\"",
":",
"\"",
"+",
"port",
"assignment",
"unique",
"(",
")",
"+",
"\"",
"\\",
"nserver",
"2",
"=",
"127",
"0",
"0",
"1",
":",
"\"",
"+",
"port",
"assignment",
"unique",
"(",
")",
"+",
"\"",
":",
"\"",
"+",
"port",
"assignment",
"unique",
"(",
")",
";",
"final",
"int",
"min",
"session",
"time",
"out",
"=",
"15000",
";",
"final",
"string",
"configs",
"=",
"\"",
"min",
"session",
"timeout",
"=",
"\"",
"+",
"min",
"session",
"time",
"out",
"+",
"\"",
"\\",
"n",
"\"",
";",
"main",
"thread",
"q",
"1",
"=",
"new",
"main",
"thread",
"(",
"1",
",",
"client",
"port",
"qp1",
",",
"quorum",
"cfg",
"section",
",",
"configs",
")",
";",
"main",
"thread",
"q",
"2",
"=",
"new",
"main",
"thread",
"(",
"2",
",",
"client",
"port",
"qp2",
",",
"quorum",
"cfg",
"section",
",",
"configs",
")",
";",
"q",
"1",
"start",
"(",
")",
";",
"q",
"2",
"start",
"(",
")",
";",
"assert",
"true",
"(",
"client",
"base",
"wait",
"for",
"server",
"up",
"(",
"\"",
"127",
"0",
"0",
"1",
":",
"\"",
"+",
"client",
"port",
"qp1",
",",
"connection",
"timeout",
")",
",",
"\"",
"waiting",
"for",
"server",
"1",
"being",
"up",
"\"",
")",
";",
"assert",
"true",
"(",
"client",
"base",
"wait",
"for",
"server",
"up",
"(",
"\"",
"127",
"0",
"0",
"1",
":",
"\"",
"+",
"client",
"port",
"qp2",
",",
"connection",
"timeout",
")",
",",
"\"",
"waiting",
"for",
"server",
"2",
"being",
"up",
"\"",
")",
";",
"quorum",
"peer",
"quorum",
"peer",
"=",
"q",
"1",
"main",
"quorum",
"peer",
";",
"final",
"int",
"max",
"session",
"time",
"out",
"=",
"quorum",
"peer",
"tick",
"time",
"*",
"20",
";",
"assert",
"equals",
"(",
"min",
"session",
"time",
"out",
",",
"quorum",
"peer",
"get",
"min",
"session",
"timeout",
"(",
")",
",",
"\"",
"minimum",
"session",
"time",
"out",
"is",
"not",
"considered",
"\"",
")",
";",
"assert",
"equals",
"(",
"max",
"session",
"time",
"out",
",",
"quorum",
"peer",
"get",
"max",
"session",
"timeout",
"(",
")",
",",
"\"",
"maximum",
"session",
"time",
"out",
"is",
"wrong",
"\"",
")",
";",
"}"
] |
[
"set",
"up",
"block",
"match",
"deconfliction",
"value",
"match",
"hash",
"this",
"is",
"fed",
"into",
"the",
"n",
"-",
"gram",
"hashes",
"for",
"instructions",
"contained",
"by",
"this",
"block",
"to",
"uniquely",
"associate",
"the",
"n",
"-",
"grams",
"with",
"this",
"block",
"(",
"and",
"the",
"matching",
"block",
"on",
"the",
"other",
"side",
")"
] |
[
"protected",
"void",
"set",
"matched",
"(",
"int",
"index",
")",
"{",
"is",
"matched",
"=",
"true",
";",
"/",
"/",
"mark",
"that",
"this",
"block",
"has",
"been",
"matched",
"/",
"/",
"calculate",
"value",
"to",
"feed",
"into",
"hashes",
"/",
"/",
"achieve",
"better",
"bit",
"diversity",
"within",
"the",
"32",
"-",
"bit",
"value",
"using",
"expanding",
"(",
"not",
"stabilizing",
")",
"transformations",
"/",
"/",
"both",
"addition",
",",
"and",
"multiplication",
"by",
"relatively",
"prime",
"values",
",",
"are",
"still",
"invertible",
"module",
"2",
"^",
"32",
",",
"so",
"/",
"/",
"no",
"information",
"contained",
"in",
"-",
"index",
"-",
"is",
"lost",
"otherwise",
"the",
"exact",
"values",
"don",
"'",
"t",
"matter",
"much",
"match",
"hash",
"=",
"index",
"*",
"7919",
";",
"match",
"hash",
"+",
"=",
"511",
";",
"match",
"hash",
"*",
"=",
"4691",
";",
"}"
] |
[
"gets",
"the",
"type",
"descriptor",
"(",
"rtti",
"0",
")",
"model",
"associated",
"with",
"this",
"rtti",
"4"
] |
[
"public",
"type",
"descriptor",
"model",
"get",
"rtti",
"0",
"model",
"(",
")",
"throws",
"invalid",
"data",
"type",
"exception",
"{",
"check",
"validity",
"(",
")",
";",
"return",
"rtti",
"0",
"model",
";",
"}"
] |
[
"like",
"using",
"(",
")",
"but",
"overrideable",
"by",
"navigable",
"set",
"test",
"suite",
"builder"
] |
[
"sorted",
"set",
"test",
"suite",
"builder",
"<",
"e",
">",
"new",
"builder",
"using",
"(",
"test",
"sorted",
"set",
"generator",
"<",
"e",
">",
"delegate",
",",
"bound",
"to",
",",
"bound",
"from",
")",
"{",
"return",
"using",
"(",
"new",
"sorted",
"set",
"subset",
"test",
"set",
"generator",
"<",
"e",
">",
"(",
"delegate",
",",
"to",
",",
"from",
")",
")",
";",
"}"
] |
[
"does",
"this",
"bean",
"factory",
"contain",
"a",
"bean",
"definition",
"or",
"externally",
"registered",
"singleton",
"instance",
"with",
"the",
"given",
"name",
"?",
"if",
"the",
"given",
"name",
"is",
"an",
"alias",
",",
"it",
"will",
"be",
"translated",
"back",
"to",
"the",
"corresponding",
"canonical",
"bean",
"name",
"if",
"this",
"factory",
"is",
"hierarchical",
",",
"will",
"ask",
"any",
"parent",
"factory",
"if",
"the",
"bean",
"cannot",
"be",
"found",
"in",
"this",
"factory",
"instance",
"if",
"a",
"bean",
"definition",
"or",
"singleton",
"instance",
"matching",
"the",
"given",
"name",
"is",
"found",
",",
"this",
"method",
"will",
"return",
"{",
"@",
"code",
"true",
"}",
"whether",
"the",
"named",
"bean",
"definition",
"is",
"concrete",
"or",
"abstract",
",",
"lazy",
"or",
"eager",
",",
"in",
"scope",
"or",
"not",
"therefore",
",",
"note",
"that",
"a",
"{",
"@",
"code",
"true",
"}",
"return",
"value",
"from",
"this",
"method",
"does",
"not",
"necessarily",
"indicate",
"that",
"{",
"@",
"link",
"#",
"get",
"bean",
"}",
"will",
"be",
"able",
"to",
"obtain",
"an",
"instance",
"for",
"the",
"same",
"name"
] |
[
"boolean",
"contains",
"bean",
"(",
"string",
"name",
")",
";"
] |
[
"sets",
"storage",
"size",
"for",
"the",
"specified",
"key"
] |
[
"public",
"void",
"set",
"storage",
"size",
"(",
"string",
"name",
",",
"double",
"value",
",",
"storage",
"unit",
"unit",
")",
"{",
"set",
"(",
"name",
",",
"value",
"+",
"unit",
"get",
"short",
"name",
"(",
")",
")",
";",
"}"
] |
[
"positive",
"test",
"to",
"check",
"rename",
"succeeds",
"when",
"sticky",
"bit",
"is",
"set",
"on",
"source",
"parent",
"directory",
"and",
"user",
"owns",
"the",
"source",
"directory"
] |
[
"public",
"void",
"test",
"rename",
"with",
"sticky",
"bit",
"positive",
"(",
")",
"throws",
"throwable",
"{",
"path",
"parent",
"src",
"dir",
"=",
"new",
"path",
"(",
"\"",
"/",
"test",
"rename",
"with",
"sticky",
"bit",
"positive",
"src",
"\"",
")",
";",
"path",
"src",
"path",
"=",
"new",
"path",
"(",
"parent",
"src",
"dir",
",",
"\"",
"test",
"1",
"dat",
"\"",
")",
";",
"path",
"parent",
"dst",
"dir",
"=",
"new",
"path",
"(",
"\"",
"/",
"test",
"rename",
"with",
"sticky",
"bit",
"positive",
"dst",
"\"",
")",
";",
"path",
"dst",
"path",
"=",
"new",
"path",
"(",
"parent",
"dst",
"dir",
",",
"\"",
"test",
"2",
"dat",
"\"",
")",
";",
"authorizer",
"add",
"auth",
"rule",
"for",
"owner",
"(",
"\"",
"/",
"\"",
",",
"write",
",",
"true",
")",
";",
"/",
"*",
"to",
"create",
"parent",
"dirs",
"*",
"/",
"authorizer",
"add",
"auth",
"rule",
"for",
"owner",
"(",
"parent",
"src",
"dir",
"to",
"string",
"(",
")",
",",
"write",
",",
"true",
")",
";",
"authorizer",
"add",
"auth",
"rule",
"for",
"owner",
"(",
"parent",
"dst",
"dir",
"to",
"string",
"(",
")",
",",
"write",
",",
"true",
")",
";",
"/",
"*",
"required",
"for",
"asser",
"path",
"exists",
"calls",
"*",
"/",
"fs",
"update",
"wasb",
"authorizer",
"(",
"authorizer",
")",
";",
"try",
"{",
"touch",
"(",
"fs",
",",
"src",
"path",
")",
";",
"assert",
"path",
"exists",
"(",
"fs",
",",
"\"",
"source",
"path",
"does",
"not",
"exist",
"\"",
",",
"src",
"path",
")",
";",
"fs",
"mkdirs",
"(",
"parent",
"dst",
"dir",
")",
";",
"assert",
"is",
"directory",
"(",
"fs",
",",
"parent",
"dst",
"dir",
")",
";",
"/",
"/",
"set",
"stickybit",
"on",
"parent",
"directory",
"fs",
"set",
"permission",
"(",
"parent",
"src",
"dir",
",",
"new",
"fs",
"permission",
"(",
"stickybit",
"permission",
"constant",
")",
")",
";",
"assert",
"rename",
"outcome",
"(",
"fs",
",",
"src",
"path",
",",
"dst",
"path",
",",
"true",
")",
";",
"assert",
"path",
"does",
"not",
"exist",
"(",
"fs",
",",
"\"",
"source",
"path",
"exists",
"\"",
",",
"src",
"path",
")",
";",
"assert",
"path",
"exists",
"(",
"fs",
",",
"\"",
"dest",
"path",
"does",
"not",
"exist",
"\"",
",",
"dst",
"path",
")",
";",
"}",
"finally",
"{",
"recursive",
"delete",
"(",
"parent",
"src",
"dir",
")",
";",
"recursive",
"delete",
"(",
"parent",
"dst",
"dir",
")",
";",
"}",
"}"
] |
[
"determine",
"whether",
"the",
"specified",
"property",
"is",
"writable",
"returns",
"{",
"@",
"code",
"false",
"}",
"if",
"the",
"property",
"doesn",
"'",
"t",
"exist"
] |
[
"boolean",
"is",
"writable",
"property",
"(",
"string",
"property",
"name",
")",
";"
] |
[
"decide",
"whether",
"the",
"progress",
"bar",
"should",
"be",
"redrawn",
"only",
"for",
"the",
"reason",
"that",
"time",
"has",
"passed"
] |
[
"private",
"synchronized",
"boolean",
"time",
"based",
"refresh",
"(",
")",
"{",
"if",
"(",
"!",
"state",
"tracker",
"progress",
"bar",
"time",
"dependent",
"(",
")",
")",
"{",
"return",
"false",
";",
"}",
"long",
"now",
"millis",
"=",
"clock",
"current",
"time",
"millis",
"(",
")",
";",
"long",
"interval",
"millis",
"=",
"cursor",
"control",
"?",
"short",
"refresh",
"millis",
":",
"long",
"refresh",
"millis",
";",
"if",
"(",
"last",
"refresh",
"millis",
"<",
"must",
"refresh",
"after",
"millis",
"&",
"&",
"must",
"refresh",
"after",
"millis",
"<",
"now",
"millis",
"+",
"minimal",
"delay",
"millis",
")",
"{",
"/",
"/",
"within",
"the",
"a",
"smal",
"interval",
"from",
"now",
",",
"an",
"update",
"is",
"scheduled",
"anyway",
",",
"/",
"/",
"so",
"don",
"'",
"t",
"do",
"a",
"time",
"-",
"based",
"update",
"of",
"the",
"progress",
"bar",
"now",
",",
"to",
"avoid",
"/",
"/",
"updates",
"too",
"close",
"to",
"each",
"other",
"return",
"false",
";",
"}",
"return",
"last",
"refresh",
"millis",
"+",
"interval",
"millis",
"<",
"now",
"millis",
";",
"}"
] |
[
"get",
"the",
"acl",
"information",
"for",
"a",
"given",
"file"
] |
[
"public",
"acl",
"status",
"get",
"acl",
"status",
"(",
"path",
"path",
")",
"throws",
"i",
"o",
"exception",
"{",
"map",
"<",
"string",
",",
"string",
">",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"params",
"put",
"(",
"op",
"param",
",",
"operation",
"getaclstatus",
"to",
"string",
"(",
")",
")",
";",
"http",
"u",
"r",
"l",
"connection",
"conn",
"=",
"get",
"connection",
"(",
"operation",
"getaclstatus",
"get",
"method",
"(",
")",
",",
"params",
",",
"path",
",",
"true",
")",
";",
"http",
"exception",
"utils",
"validate",
"response",
"(",
"conn",
",",
"http",
"u",
"r",
"l",
"connection",
"http",
"ok",
")",
";",
"j",
"s",
"o",
"n",
"object",
"json",
"=",
"(",
"j",
"s",
"o",
"n",
"object",
")",
"http",
"f",
"s",
"utils",
"json",
"parse",
"(",
"conn",
")",
";",
"json",
"=",
"(",
"j",
"s",
"o",
"n",
"object",
")",
"json",
"get",
"(",
"acl",
"status",
"json",
")",
";",
"return",
"create",
"acl",
"status",
"(",
"json",
")",
";",
"}"
] |
[
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"a",
"{",
"@",
"link",
"channel",
"option",
"}",
"exists",
"for",
"the",
"given",
"{",
"@",
"code",
"name",
"}"
] |
[
"public",
"static",
"boolean",
"exists",
"(",
"string",
"name",
")",
"{",
"return",
"pool",
"exists",
"(",
"name",
")",
";",
"}"
] |
[
"this",
"method",
"will",
"be",
"removed",
"in",
"a",
"certain",
"version",
"after",
"april",
"5",
",",
"2020",
",",
"so",
"please",
"do",
"not",
"use",
"this",
"method"
] |
[
"public",
"void",
"set",
"offset",
"store",
"(",
"offset",
"store",
"offset",
"store",
")",
"{",
"this",
"offset",
"store",
"=",
"offset",
"store",
";",
"}"
] |
[
"get",
"namespace",
"number"
] |
[
"public",
"big",
"decimal",
"get",
"namespace",
"number",
"(",
")",
"{",
"return",
"namespace",
"number",
";",
"}"
] |
[
"create",
"a",
"new",
"adapter",
"for",
"this",
"enum",
"with",
"a",
"fallback",
"value",
"to",
"use",
"when",
"the",
"json",
"string",
"does",
"not",
"match",
"any",
"of",
"the",
"enum",
"'",
"s",
"constants",
"note",
"that",
"this",
"value",
"will",
"not",
"be",
"used",
"when",
"the",
"json",
"value",
"is",
"null",
",",
"absent",
",",
"or",
"not",
"a",
"string",
"also",
",",
"the",
"string",
"values",
"are",
"case",
"-",
"sensitive",
",",
"and",
"this",
"fallback",
"value",
"will",
"be",
"used",
"even",
"on",
"case",
"mismatches"
] |
[
"public",
"enum",
"json",
"adapter",
"<",
"t",
">",
"with",
"unknown",
"fallback",
"(",
"@",
"nullable",
"t",
"fallback",
"value",
")",
"{",
"return",
"new",
"enum",
"json",
"adapter",
"<",
">",
"(",
"enum",
"type",
",",
"fallback",
"value",
",",
"true",
")",
";",
"}"
] |
[
"called",
"when",
"icy",
"stream",
"metadata",
"has",
"been",
"split",
"from",
"the",
"stream"
] |
[
"void",
"on",
"icy",
"metadata",
"(",
"parsable",
"byte",
"array",
"metadata",
")",
";"
] |
[
"shutdown",
"this",
"uam",
"client",
",",
"without",
"killing",
"the",
"uam",
"in",
"the",
"yarn",
"r",
"m",
"side"
] |
[
"public",
"void",
"shut",
"down",
"connections",
"(",
")",
"{",
"this",
"heartbeat",
"handler",
"shutdown",
"(",
")",
";",
"this",
"rm",
"proxy",
"relayer",
"shutdown",
"(",
")",
";",
"}"
] |
[
"add",
"a",
"new",
"pet",
"to",
"the",
"store"
] |
[
"public",
"api",
"response",
"<",
"void",
">",
"add",
"pet",
"with",
"http",
"info",
"(",
"pet",
"pet",
")",
"throws",
"api",
"exception",
"{",
"object",
"local",
"var",
"post",
"body",
"=",
"pet",
";",
"/",
"/",
"verify",
"the",
"required",
"parameter",
"'",
"pet",
"'",
"is",
"set",
"if",
"(",
"pet",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"api",
"exception",
"(",
"400",
",",
"\"",
"missing",
"the",
"required",
"parameter",
"'",
"pet",
"'",
"when",
"calling",
"add",
"pet",
"\"",
")",
";",
"}",
"/",
"/",
"create",
"path",
"and",
"map",
"variables",
"string",
"local",
"var",
"path",
"=",
"\"",
"/",
"pet",
"\"",
";",
"/",
"/",
"query",
"params",
"list",
"<",
"pair",
">",
"local",
"var",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
"pair",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"header",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"cookie",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"object",
">",
"local",
"var",
"form",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"object",
">",
"(",
")",
";",
"final",
"string",
"[",
"]",
"local",
"var",
"accepts",
"=",
"{",
"}",
";",
"final",
"string",
"local",
"var",
"accept",
"=",
"api",
"client",
"select",
"header",
"accept",
"(",
"local",
"var",
"accepts",
")",
";",
"final",
"string",
"[",
"]",
"local",
"var",
"content",
"types",
"=",
"{",
"\"",
"application",
"/",
"json",
"\"",
",",
"\"",
"application",
"/",
"xml",
"\"",
"}",
";",
"final",
"string",
"local",
"var",
"content",
"type",
"=",
"api",
"client",
"select",
"header",
"content",
"type",
"(",
"local",
"var",
"content",
"types",
")",
";",
"string",
"[",
"]",
"local",
"var",
"auth",
"names",
"=",
"new",
"string",
"[",
"]",
"{",
"\"",
"http",
"signature",
"test",
"\"",
",",
"\"",
"petstore",
"auth",
"\"",
"}",
";",
"return",
"api",
"client",
"invoke",
"a",
"p",
"i",
"(",
"\"",
"pet",
"api",
"add",
"pet",
"\"",
",",
"local",
"var",
"path",
",",
"\"",
"post",
"\"",
",",
"local",
"var",
"query",
"params",
",",
"local",
"var",
"post",
"body",
",",
"local",
"var",
"header",
"params",
",",
"local",
"var",
"cookie",
"params",
",",
"local",
"var",
"form",
"params",
",",
"local",
"var",
"accept",
",",
"local",
"var",
"content",
"type",
",",
"local",
"var",
"auth",
"names",
",",
"null",
",",
"false",
")",
";",
"}"
] |
[
"returns",
"a",
"future",
"that",
"yields",
"either",
"an",
"exception",
",",
"or",
"the",
"full",
"set",
"of",
"consumer",
"group",
"listings",
"in",
"the",
"event",
"of",
"a",
"failure",
",",
"the",
"future",
"yields",
"nothing",
"but",
"the",
"first",
"exception",
"which",
"occurred"
] |
[
"public",
"kafka",
"future",
"<",
"collection",
"<",
"consumer",
"group",
"listing",
">",
">",
"all",
"(",
")",
"{",
"return",
"all",
";",
"}"
] |
[
"cleanup",
"operation",
"once",
"container",
"is",
"completed",
"-",
"deletes",
"cgroup"
] |
[
"public",
"list",
"<",
"privileged",
"operation",
">",
"post",
"complete",
"(",
"container",
"id",
"container",
"id",
")",
"throws",
"resource",
"handler",
"exception",
"{",
"log",
"info",
"(",
"\"",
"post",
"complete",
"for",
"container",
":",
"\"",
"+",
"container",
"id",
"to",
"string",
"(",
")",
")",
";",
"c",
"groups",
"handler",
"delete",
"c",
"group",
"(",
"c",
"groups",
"handler",
"c",
"group",
"controller",
"net",
"cls",
",",
"container",
"id",
"to",
"string",
"(",
")",
")",
";",
"return",
"null",
";",
"}"
] |
[
"displays",
"the",
"conflict",
"resolution",
"panel",
"for",
"a",
"single",
"tag",
"id",
"at",
"the",
"specified",
"address"
] |
[
"private",
"void",
"show",
"merge",
"panel",
"(",
"final",
"listing",
"merge",
"panel",
"listing",
"panel",
",",
"final",
"address",
"addr",
",",
"long",
"tag",
"i",
"d",
",",
"task",
"monitor",
"monitor",
")",
"{",
"this",
"current",
"address",
"=",
"addr",
";",
"this",
"current",
"monitor",
"=",
"monitor",
";",
"try",
"{",
"final",
"change",
"listener",
"change",
"listener",
"=",
"new",
"change",
"listener",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"state",
"changed",
"(",
"change",
"event",
"e",
")",
"{",
"/",
"/",
"if",
"choice",
"has",
"already",
"been",
"set",
",",
"then",
"just",
"use",
"that",
"option",
"and",
"don",
"'",
"t",
"/",
"/",
"prompt",
"the",
"user",
"conflict",
"option",
"=",
"conflict",
"panel",
"get",
"selected",
"options",
"(",
")",
";",
"if",
"(",
"conflict",
"option",
"=",
"=",
"ask",
"user",
")",
"{",
"if",
"(",
"merge",
"manager",
"!",
"=",
"null",
")",
"{",
"merge",
"manager",
"set",
"apply",
"enabled",
"(",
"false",
")",
";",
"try",
"{",
"merge",
"conflicting",
"tag",
"(",
"addr",
",",
"keep",
"latest",
",",
"current",
"monitor",
")",
";",
"}",
"catch",
"(",
"cancelled",
"exception",
"ce",
")",
"{",
"/",
"/",
"no",
"need",
"to",
"do",
"anything",
"}",
"}",
"return",
";",
"}",
"if",
"(",
"merge",
"manager",
"!",
"=",
"null",
")",
"{",
"merge",
"manager",
"clear",
"status",
"text",
"(",
")",
";",
"}",
"try",
"{",
"merge",
"conflicting",
"tag",
"(",
"addr",
",",
"conflict",
"option",
",",
"current",
"monitor",
")",
";",
"}",
"catch",
"(",
"cancelled",
"exception",
"ce",
")",
"{",
"/",
"/",
"no",
"need",
"to",
"do",
"anything",
"}",
"if",
"(",
"merge",
"manager",
"!",
"=",
"null",
")",
"{",
"merge",
"manager",
"set",
"apply",
"enabled",
"(",
"true",
")",
";",
"}",
"}",
"}",
";",
"swing",
"utilities",
"invoke",
"and",
"wait",
"(",
"new",
"runnable",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"run",
"(",
")",
"{",
"setup",
"conflicts",
"panel",
"(",
"listing",
"panel",
",",
"function",
"tag",
"listing",
"merger",
"this",
"current",
"address",
",",
"tag",
"i",
"d",
",",
"change",
"listener",
")",
";",
"listing",
"panel",
"set",
"bottom",
"component",
"(",
"conflict",
"panel",
")",
";",
"}",
"}",
")",
";",
"swing",
"utilities",
"invoke",
"later",
"(",
"new",
"runnable",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"run",
"(",
")",
"{",
"address",
"address",
"to",
"show",
"=",
"function",
"tag",
"listing",
"merger",
"this",
"current",
"address",
";",
"listing",
"panel",
"clear",
"all",
"backgrounds",
"(",
")",
";",
"if",
"(",
"address",
"to",
"show",
"!",
"=",
"null",
")",
"{",
"listing",
"panel",
"paint",
"all",
"backgrounds",
"(",
"get",
"code",
"unit",
"address",
"set",
"(",
"address",
"to",
"show",
")",
")",
";",
"listing",
"panel",
"go",
"to",
"(",
"address",
"to",
"show",
")",
";",
"}",
"}",
"}",
")",
";",
"}",
"catch",
"(",
"interrupted",
"exception",
"|",
"invocation",
"target",
"exception",
"e",
")",
"{",
"msg",
"show",
"error",
"(",
"this",
",",
"null",
",",
"\"",
"merge",
"error",
"\"",
",",
"\"",
"error",
"displaying",
"merge",
"panel",
"\"",
",",
"e",
")",
";",
"return",
";",
"}",
"if",
"(",
"merge",
"manager",
"!",
"=",
"null",
")",
"{",
"merge",
"manager",
"set",
"apply",
"enabled",
"(",
"false",
")",
";",
"merge",
"manager",
"show",
"listing",
"merge",
"panel",
"(",
"current",
"address",
")",
";",
"}",
"}"
] |
[
"calculate",
"the",
"available",
"space",
"of",
"the",
"filesystem",
",",
"excluding",
"space",
"reserved",
"for",
"non",
"-",
"hdfs",
"and",
"space",
"reserved",
"for",
"rbw"
] |
[
"public",
"long",
"get",
"available",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"long",
"remaining",
"=",
"get",
"capacity",
"(",
")",
"-",
"get",
"dfs",
"used",
"(",
")",
"-",
"get",
"reserved",
"for",
"replicas",
"(",
")",
";",
"long",
"available",
"=",
"usage",
"get",
"available",
"(",
")",
"-",
"get",
"remaining",
"reserved",
"(",
")",
"-",
"get",
"reserved",
"for",
"replicas",
"(",
")",
";",
"if",
"(",
"remaining",
">",
"available",
")",
"{",
"remaining",
"=",
"available",
";",
"}",
"return",
"math",
"max",
"(",
"remaining",
",",
"0l",
")",
";",
"}"
] |
[
"prioritizes",
"an",
"already",
"existing",
"element",
"note",
"that",
"this",
"method",
"assumes",
"identity",
"{",
"@",
"impl",
"note",
"since",
"this",
"method",
"removes",
"the",
"element",
"and",
"reinserts",
"it",
"in",
"a",
"priority",
"position",
"in",
"general",
",",
"some",
"optimizations",
"for",
"special",
"cases",
"are",
"used",
"}"
] |
[
"public",
"void",
"prioritize",
"(",
"t",
"element",
")",
"{",
"final",
"iterator",
"<",
"t",
">",
"iterator",
"=",
"deque",
"iterator",
"(",
")",
";",
"/",
"/",
"already",
"prioritized",
"?",
"then",
",",
"do",
"not",
"reorder",
"elements",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"num",
"priority",
"elements",
"&",
"&",
"iterator",
"has",
"next",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"if",
"(",
"iterator",
"next",
"(",
")",
"=",
"=",
"element",
")",
"{",
"return",
";",
"}",
"}",
"/",
"/",
"if",
"the",
"next",
"non",
"-",
"priority",
"element",
"is",
"the",
"given",
"element",
",",
"we",
"can",
"simply",
"include",
"it",
"in",
"the",
"/",
"/",
"priority",
"section",
"if",
"(",
"iterator",
"has",
"next",
"(",
")",
"&",
"&",
"iterator",
"next",
"(",
")",
"=",
"=",
"element",
")",
"{",
"num",
"priority",
"elements",
"+",
"+",
";",
"return",
";",
"}",
"/",
"/",
"remove",
"the",
"given",
"element",
"while",
"(",
"iterator",
"has",
"next",
"(",
")",
")",
"{",
"if",
"(",
"iterator",
"next",
"(",
")",
"=",
"=",
"element",
")",
"{",
"iterator",
"remove",
"(",
")",
";",
"break",
";",
"}",
"}",
"add",
"priority",
"element",
"(",
"element",
")",
";",
"}"
] |
[
"returns",
"the",
"external",
"file",
"attributes",
"of",
"the",
"entry"
] |
[
"public",
"int",
"get",
"external",
"attributes",
"(",
")",
"{",
"return",
"external",
"attributes",
";",
"}"
] |
[
"set",
"the",
"crosstool",
"inputs",
"required",
"for",
"the",
"action"
] |
[
"public",
"cpp",
"link",
"action",
"builder",
"set",
"linker",
"files",
"(",
"nested",
"set",
"<",
"artifact",
">",
"linker",
"files",
")",
"{",
"this",
"linker",
"files",
"=",
"linker",
"files",
";",
"return",
"this",
";",
"}"
] |
[
"sets",
"the",
"{",
"@",
"link",
"overview",
"color",
"component",
"}",
"that",
"will",
"be",
"displaying",
"the",
"colors",
"for",
"this",
"service"
] |
[
"public",
"void",
"set",
"overview",
"component",
"(",
"overview",
"color",
"component",
"component",
")",
";"
] |
[
"process",
"an",
"i",
"node"
] |
[
"private",
"void",
"process",
"i",
"node",
"(",
"data",
"input",
"stream",
"in",
",",
"image",
"visitor",
"v",
",",
"boolean",
"skip",
"blocks",
",",
"string",
"parent",
"name",
",",
"boolean",
"is",
"snapshot",
"copy",
")",
"throws",
"i",
"o",
"exception",
"{",
"boolean",
"support",
"snapshot",
"=",
"name",
"node",
"layout",
"version",
"supports",
"(",
"feature",
"snapshot",
",",
"image",
"version",
")",
";",
"boolean",
"support",
"inode",
"id",
"=",
"name",
"node",
"layout",
"version",
"supports",
"(",
"feature",
"add",
"inode",
"id",
",",
"image",
"version",
")",
";",
"v",
"visit",
"enclosing",
"element",
"(",
"image",
"element",
"inode",
")",
";",
"final",
"string",
"path",
"name",
"=",
"read",
"i",
"node",
"path",
"(",
"in",
",",
"parent",
"name",
")",
";",
"v",
"visit",
"(",
"image",
"element",
"inode",
"path",
",",
"path",
"name",
")",
";",
"long",
"inode",
"id",
"=",
"hdfs",
"constants",
"grandfather",
"inode",
"id",
";",
"if",
"(",
"support",
"inode",
"id",
")",
"{",
"inode",
"id",
"=",
"in",
"read",
"long",
"(",
")",
";",
"v",
"visit",
"(",
"image",
"element",
"inode",
"id",
",",
"inode",
"id",
")",
";",
"}",
"v",
"visit",
"(",
"image",
"element",
"replication",
",",
"in",
"read",
"short",
"(",
")",
")",
";",
"v",
"visit",
"(",
"image",
"element",
"modification",
"time",
",",
"format",
"date",
"(",
"in",
"read",
"long",
"(",
")",
")",
")",
";",
"if",
"(",
"name",
"node",
"layout",
"version",
"supports",
"(",
"feature",
"file",
"access",
"time",
",",
"image",
"version",
")",
")",
"v",
"visit",
"(",
"image",
"element",
"access",
"time",
",",
"format",
"date",
"(",
"in",
"read",
"long",
"(",
")",
")",
")",
";",
"v",
"visit",
"(",
"image",
"element",
"block",
"size",
",",
"in",
"read",
"long",
"(",
")",
")",
";",
"int",
"num",
"blocks",
"=",
"in",
"read",
"int",
"(",
")",
";",
"process",
"blocks",
"(",
"in",
",",
"v",
",",
"num",
"blocks",
",",
"skip",
"blocks",
")",
";",
"if",
"(",
"num",
"blocks",
">",
"=",
"0",
")",
"{",
"/",
"/",
"file",
"if",
"(",
"support",
"snapshot",
")",
"{",
"/",
"/",
"make",
"sure",
"subtree",
"map",
"only",
"contains",
"entry",
"for",
"directory",
"subtree",
"map",
"remove",
"(",
"inode",
"id",
")",
";",
"/",
"/",
"process",
"file",
"diffs",
"process",
"file",
"diff",
"list",
"(",
"in",
",",
"v",
",",
"parent",
"name",
")",
";",
"if",
"(",
"is",
"snapshot",
"copy",
")",
"{",
"boolean",
"under",
"construction",
"=",
"in",
"read",
"boolean",
"(",
")",
";",
"if",
"(",
"under",
"construction",
")",
"{",
"v",
"visit",
"(",
"image",
"element",
"client",
"name",
",",
"f",
"s",
"image",
"serialization",
"read",
"string",
"(",
"in",
")",
")",
";",
"v",
"visit",
"(",
"image",
"element",
"client",
"machine",
",",
"f",
"s",
"image",
"serialization",
"read",
"string",
"(",
"in",
")",
")",
";",
"}",
"}",
"}",
"process",
"permission",
"(",
"in",
",",
"v",
")",
";",
"}",
"else",
"if",
"(",
"num",
"blocks",
"=",
"=",
"-",
"1",
")",
"{",
"/",
"/",
"directory",
"if",
"(",
"support",
"snapshot",
"&",
"&",
"support",
"inode",
"id",
")",
"{",
"dir",
"node",
"map",
"put",
"(",
"inode",
"id",
",",
"path",
"name",
")",
";",
"}",
"v",
"visit",
"(",
"image",
"element",
"ns",
"quota",
",",
"in",
"read",
"long",
"(",
")",
")",
";",
"if",
"(",
"name",
"node",
"layout",
"version",
"supports",
"(",
"feature",
"diskspace",
"quota",
",",
"image",
"version",
")",
")",
"{",
"v",
"visit",
"(",
"image",
"element",
"ds",
"quota",
",",
"in",
"read",
"long",
"(",
")",
")",
";",
"}",
"if",
"(",
"support",
"snapshot",
")",
"{",
"boolean",
"snapshottable",
"=",
"in",
"read",
"boolean",
"(",
")",
";",
"if",
"(",
"!",
"snapshottable",
")",
"{",
"boolean",
"with",
"snapshot",
"=",
"in",
"read",
"boolean",
"(",
")",
";",
"v",
"visit",
"(",
"image",
"element",
"is",
"withsnapshot",
"dir",
",",
"boolean",
"to",
"string",
"(",
"with",
"snapshot",
")",
")",
";",
"}",
"else",
"{",
"v",
"visit",
"(",
"image",
"element",
"is",
"snapshottable",
"dir",
",",
"boolean",
"to",
"string",
"(",
"snapshottable",
")",
")",
";",
"}",
"}",
"process",
"permission",
"(",
"in",
",",
"v",
")",
";",
"}",
"else",
"if",
"(",
"num",
"blocks",
"=",
"=",
"-",
"2",
")",
"{",
"v",
"visit",
"(",
"image",
"element",
"symlink",
",",
"text",
"read",
"string",
"(",
"in",
")",
")",
";",
"process",
"permission",
"(",
"in",
",",
"v",
")",
";",
"}",
"else",
"if",
"(",
"num",
"blocks",
"=",
"=",
"-",
"3",
")",
"{",
"/",
"/",
"reference",
"node",
"final",
"boolean",
"is",
"with",
"name",
"=",
"in",
"read",
"boolean",
"(",
")",
";",
"int",
"snapshot",
"id",
"=",
"in",
"read",
"int",
"(",
")",
";",
"if",
"(",
"is",
"with",
"name",
")",
"{",
"v",
"visit",
"(",
"image",
"element",
"snapshot",
"last",
"snapshot",
"id",
",",
"snapshot",
"id",
")",
";",
"}",
"else",
"{",
"v",
"visit",
"(",
"image",
"element",
"snapshot",
"dst",
"snapshot",
"id",
",",
"snapshot",
"id",
")",
";",
"}",
"final",
"boolean",
"first",
"referred",
"=",
"in",
"read",
"boolean",
"(",
")",
";",
"if",
"(",
"first",
"referred",
")",
"{",
"/",
"/",
"if",
"a",
"subtree",
"is",
"linked",
"by",
"multiple",
"\"",
"parents",
"\"",
",",
"the",
"corresponding",
"dir",
"/",
"/",
"must",
"be",
"referred",
"by",
"a",
"reference",
"node",
"we",
"put",
"the",
"reference",
"node",
"into",
"/",
"/",
"the",
"subtree",
"map",
"here",
"and",
"let",
"its",
"value",
"be",
"false",
"when",
"we",
"later",
"visit",
"/",
"/",
"the",
"subtree",
"for",
"the",
"first",
"time",
",",
"we",
"change",
"the",
"value",
"to",
"true",
"subtree",
"map",
"put",
"(",
"inode",
"id",
",",
"false",
")",
";",
"v",
"visit",
"enclosing",
"element",
"(",
"image",
"element",
"snapshot",
"ref",
"inode",
")",
";",
"process",
"i",
"node",
"(",
"in",
",",
"v",
",",
"skip",
"blocks",
",",
"parent",
"name",
",",
"is",
"snapshot",
"copy",
")",
";",
"v",
"leave",
"enclosing",
"element",
"(",
")",
";",
"/",
"/",
"referred",
"inode",
"}",
"else",
"{",
"v",
"visit",
"(",
"image",
"element",
"snapshot",
"ref",
"inode",
"id",
",",
"in",
"read",
"long",
"(",
")",
")",
";",
"}",
"}",
"v",
"leave",
"enclosing",
"element",
"(",
")",
";",
"/",
"/",
"i",
"node",
"}"
] |
[
"for",
"j",
"unit",
"testing",
"only",
",",
"set",
"the",
"option",
"for",
"resolving",
"a",
"conflict"
] |
[
"void",
"set",
"conflict",
"resolution",
"(",
"int",
"option",
")",
"{",
"conflict",
"option",
"=",
"option",
";",
"}"
] |
[
"returns",
"an",
"integer",
"value",
"with",
"value",
"1",
",",
"0",
",",
"or",
"-",
"1",
",",
"if",
"this",
"float",
"value",
"is",
"less",
"than",
",",
"equal",
"to",
",",
"or",
"greater",
"than",
"the",
"given",
"specific",
"float",
"value",
",",
"respectively"
] |
[
"public",
"final",
"integer",
"value",
"compare",
"reverse",
"(",
"specific",
"float",
"value",
"other",
")",
"{",
"return",
"compare",
"(",
"other",
")",
"negate",
"(",
")",
";",
"}"
] |
[
"determine",
"if",
"a",
"header",
"{",
"@",
"code",
"name",
"}",
"{",
"@",
"code",
"value",
"}",
"pair",
"should",
"be",
"treated",
"as",
"<",
"a",
"href",
"=",
"\"",
"https",
":",
"tools",
"ietf",
"orghtmlrfc",
"7",
"5",
"4",
"1",
"#",
"section",
"-",
"7",
"1",
"3",
"\"",
">",
"sensitive"
] |
[
"boolean",
"is",
"sensitive",
"(",
"char",
"sequence",
"name",
",",
"char",
"sequence",
"value",
")",
";"
] |
[
"schema",
"of",
"type",
"array",
"requires",
"a",
"schema",
"for",
"the",
"values",
",",
"but",
"connect",
"has",
"no",
"union",
"or",
"\"",
"any",
"\"",
"schema",
"type",
"therefore",
",",
"we",
"can",
"'",
"t",
"represent",
"this"
] |
[
"public",
"void",
"should",
"fail",
"to",
"convert",
"to",
"list",
"from",
"string",
"with",
"non",
"common",
"element",
"type",
"and",
"blank",
"element",
"(",
")",
"{",
"assert",
"throws",
"(",
"data",
"exception",
"class",
",",
"(",
")",
"-",
">",
"values",
"convert",
"to",
"list",
"(",
"schema",
"string",
"schema",
",",
"\"",
"[",
"1",
",",
"2",
",",
"3",
",",
"\\",
"\"",
"four",
"\\",
"\"",
",",
",",
",",
"]",
"\"",
")",
")",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] |
[
"public",
"builder",
"<",
"k",
",",
"v",
">",
"put",
"all",
"(",
"iterable",
"<",
"?",
"extends",
"entry",
"<",
"?",
"extends",
"k",
",",
"?",
"extends",
"v",
">",
">",
"entries",
")",
"{",
"super",
"put",
"all",
"(",
"entries",
")",
";",
"return",
"this",
";",
"}"
] |
[
"gets",
"change",
"type"
] |
[
"public",
"configuration",
"change",
"type",
"get",
"change",
"type",
"(",
")",
"{",
"return",
"change",
"type",
";",
"}"
] |
[
"returns",
"the",
"indices",
"to",
"freeze"
] |
[
"public",
"string",
"[",
"]",
"get",
"indices",
"(",
")",
"{",
"return",
"indices",
";",
"}"
] |
[
"sometimes",
"build",
"a",
"replication",
"task",
"for",
"tracking",
"the",
"phase",
"of",
"the",
"transport",
"replication",
"action",
"since",
"transport",
"replication",
"action",
"has",
"to",
"work",
"if",
"the",
"task",
"as",
"null",
"just",
"as",
"well",
"as",
"if",
"it",
"is",
"supplied",
"this",
"returns",
"null",
"half",
"the",
"time"
] |
[
"private",
"replication",
"task",
"maybe",
"task",
"(",
")",
"{",
"return",
"random",
"(",
")",
"next",
"boolean",
"(",
")",
"?",
"new",
"replication",
"task",
"(",
"0",
",",
"null",
",",
"null",
",",
"null",
",",
"null",
",",
"null",
")",
":",
"null",
";",
"}"
] |
[
"this",
"is",
"where",
"we",
"go",
"through",
"the",
"new",
"layout",
"state",
"and",
"compare",
"it",
"to",
"the",
"previous",
"one",
"if",
"we",
"find",
"we",
"do",
"a",
"couple",
"of",
"things",
":",
"-",
"loop",
"trough",
"the",
"disappearing",
"tree",
"making",
"sure",
"it",
"is",
"mounted",
"(",
"we",
"mounted",
"if",
"it",
"'",
"s",
"not",
")",
"-",
"add",
"all",
"the",
"items",
"to",
"a",
"set",
"to",
"be",
"able",
"to",
"hook",
"the",
"unmount",
"delegate",
"-",
"move",
"the",
"disappearing",
"mount",
"item",
"to",
"the",
"root",
"host",
"-",
"finally",
"map",
"the",
"disappearing",
"mount",
"item",
"to",
"the",
"transition",
"id"
] |
[
"private",
"static",
"void",
"extract",
"disappearing",
"items",
"(",
"extension",
"state",
"<",
"transitions",
"extension",
"state",
">",
"extension",
"state",
",",
"transitions",
"extension",
"input",
"new",
"transitions",
"extension",
"input",
")",
"{",
"int",
"mount",
"item",
"count",
"=",
"get",
"mount",
"target",
"(",
"extension",
"state",
")",
"get",
"render",
"unit",
"count",
"(",
")",
";",
"final",
"transitions",
"extension",
"state",
"state",
"=",
"extension",
"state",
"get",
"state",
"(",
")",
";",
"if",
"(",
"state",
"m",
"last",
"transitions",
"extension",
"input",
"=",
"=",
"null",
"|",
"|",
"mount",
"item",
"count",
"=",
"=",
"0",
")",
"{",
"return",
";",
"}",
"for",
"(",
"int",
"i",
"=",
"1",
";",
"i",
"<",
"mount",
"item",
"count",
";",
"i",
"+",
"+",
")",
"{",
"if",
"(",
"is",
"item",
"disappearing",
"(",
"state",
",",
"new",
"transitions",
"extension",
"input",
",",
"i",
")",
")",
"{",
"final",
"int",
"last",
"descendant",
"index",
"=",
"find",
"last",
"descendant",
"index",
"(",
"state",
"m",
"last",
"transitions",
"extension",
"input",
",",
"i",
")",
";",
"/",
"/",
"go",
"though",
"disappearing",
"subtree",
"mount",
"anything",
"that",
"'",
"s",
"not",
"mounted",
"(",
"without",
"acquiring",
"/",
"/",
"reference",
")",
"for",
"(",
"int",
"j",
"=",
"i",
";",
"j",
"<",
"=",
"last",
"descendant",
"index",
";",
"j",
"+",
"+",
")",
"{",
"if",
"(",
"get",
"mount",
"target",
"(",
"extension",
"state",
")",
"get",
"mount",
"item",
"at",
"(",
"j",
")",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"we",
"need",
"to",
"release",
"any",
"mount",
"reference",
"to",
"this",
"because",
"we",
"need",
"to",
"force",
"mount",
"here",
"final",
"long",
"id",
"=",
"state",
"m",
"last",
"transitions",
"extension",
"input",
"get",
"mountable",
"output",
"at",
"(",
"j",
")",
"get",
"render",
"unit",
"(",
")",
"get",
"id",
"(",
")",
";",
"if",
"(",
"extension",
"state",
"owns",
"reference",
"(",
"id",
")",
")",
"{",
"extension",
"state",
"release",
"mount",
"reference",
"(",
"id",
",",
"false",
")",
";",
"}",
"extension",
"state",
"acquire",
"mount",
"reference",
"(",
"id",
",",
"true",
")",
";",
"/",
"/",
"here",
"we",
"have",
"to",
"release",
"the",
"ref",
"count",
"without",
"mounting",
"extension",
"state",
"release",
"mount",
"reference",
"(",
"id",
",",
"false",
")",
";",
"}",
"final",
"render",
"unit",
"render",
"unit",
"=",
"get",
"mount",
"target",
"(",
"extension",
"state",
")",
"get",
"mount",
"item",
"at",
"(",
"j",
")",
"get",
"render",
"tree",
"node",
"(",
")",
"get",
"render",
"unit",
"(",
")",
";",
"state",
"m",
"locked",
"disappearing",
"mountitems",
"put",
"(",
"render",
"unit",
",",
"state",
"m",
"last",
"transitions",
"extension",
"input",
"get",
"animatable",
"item",
"(",
"render",
"unit",
")",
")",
";",
"}",
"/",
"/",
"reference",
"to",
"the",
"root",
"of",
"the",
"disappearing",
"subtree",
"final",
"mount",
"item",
"disappearing",
"item",
"=",
"get",
"mount",
"target",
"(",
"extension",
"state",
")",
"get",
"mount",
"item",
"at",
"(",
"i",
")",
";",
"if",
"(",
"disappearing",
"item",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"the",
"root",
"of",
"the",
"disappearing",
"subtree",
"should",
"not",
"be",
"null",
",",
"\"",
"+",
"\"",
"acquire",
"mount",
"reference",
"on",
"this",
"index",
"should",
"be",
"called",
"before",
"this",
"index",
":",
"\"",
"+",
"i",
")",
";",
"}",
"/",
"/",
"moving",
"item",
"to",
"the",
"root",
"if",
"needed",
"remount",
"host",
"to",
"root",
"if",
"needed",
"(",
"extension",
"state",
",",
"i",
",",
"disappearing",
"item",
")",
";",
"map",
"disappearing",
"item",
"with",
"transition",
"id",
"(",
"state",
",",
"disappearing",
"item",
")",
";",
"final",
"long",
"id",
"=",
"disappearing",
"item",
"get",
"render",
"tree",
"node",
"(",
")",
"get",
"render",
"unit",
"(",
")",
"get",
"id",
"(",
")",
";",
"get",
"mount",
"target",
"(",
"extension",
"state",
")",
"notify",
"unmount",
"(",
"id",
")",
";",
"i",
"=",
"last",
"descendant",
"index",
";",
"}",
"}",
"}"
] |
[
"function",
"to",
"translate",
"a",
"point",
"given",
"in",
"screen",
"coordinates",
"to",
"world",
"space",
"it",
"'",
"s",
"the",
"same",
"as",
"glu",
"glu",
"un",
"project",
"but",
"does",
"not",
"rely",
"on",
"open",
"g",
"l",
"the",
"viewport",
"is",
"assumed",
"to",
"span",
"the",
"whole",
"screen",
"and",
"is",
"fetched",
"from",
"{",
"@",
"link",
"graphics",
"#",
"get",
"width",
"(",
")",
"}",
"and",
"{",
"@",
"link",
"graphics",
"#",
"get",
"height",
"(",
")",
"}",
"the",
"x",
"-",
"and",
"y",
"-",
"coordinate",
"of",
"vec",
"are",
"assumed",
"to",
"be",
"in",
"screen",
"coordinates",
"(",
"origin",
"is",
"the",
"top",
"left",
"corner",
",",
"y",
"pointing",
"down",
",",
"x",
"pointing",
"to",
"the",
"right",
")",
"as",
"reported",
"by",
"the",
"touch",
"methods",
"in",
"{",
"@",
"link",
"input",
"}",
"a",
"z",
"-",
"coordinate",
"of",
"0",
"will",
"return",
"a",
"point",
"on",
"the",
"near",
"plane",
",",
"a",
"z",
"-",
"coordinate",
"of",
"1",
"will",
"return",
"a",
"point",
"on",
"the",
"far",
"plane"
] |
[
"public",
"vector",
"3",
"unproject",
"(",
"vector",
"3",
"screen",
"coords",
")",
"{",
"unproject",
"(",
"screen",
"coords",
",",
"0",
",",
"0",
",",
"gdx",
"graphics",
"get",
"width",
"(",
")",
",",
"gdx",
"graphics",
"get",
"height",
"(",
")",
")",
";",
"return",
"screen",
"coords",
";",
"}"
] |
[
"if",
"more",
"access",
"units",
"should",
"be",
"added",
"to",
"the",
"batch",
"buffer"
] |
[
"public",
"boolean",
"is",
"full",
"(",
")",
"{",
"return",
"access",
"unit",
"count",
">",
"=",
"max",
"access",
"unit",
"count",
"|",
"|",
"(",
"data",
"!",
"=",
"null",
"&",
"&",
"data",
"position",
"(",
")",
">",
"=",
"batch",
"size",
"bytes",
")",
"|",
"|",
"has",
"pending",
"access",
"unit",
";",
"}"
] |
[
"replace",
"any",
"bean",
"names",
"used",
"as",
"keys",
"in",
"the",
"{",
"@",
"code",
"notification",
"listener",
"}",
"mappings",
"with",
"their",
"corresponding",
"{",
"@",
"code",
"object",
"name",
"}",
"values"
] |
[
"private",
"void",
"replace",
"notification",
"listener",
"bean",
"name",
"keys",
"if",
"necessary",
"(",
"string",
"bean",
"name",
",",
"object",
"name",
"object",
"name",
")",
"{",
"if",
"(",
"this",
"notification",
"listeners",
"!",
"=",
"null",
")",
"{",
"for",
"(",
"notification",
"listener",
"bean",
"notification",
"listener",
":",
"this",
"notification",
"listeners",
")",
"{",
"notification",
"listener",
"replace",
"object",
"name",
"(",
"bean",
"name",
",",
"object",
"name",
")",
";",
"}",
"}",
"}"
] |
[
"the",
"strictness",
",",
"especially",
"\"",
"strict",
"stubs",
"\"",
"(",
"{",
"@",
"link",
"strictness",
"#",
"strict",
"stubs",
"}",
")",
"helps",
"debugging",
"and",
"keeping",
"tests",
"clean",
"it",
"'",
"s",
"a",
"new",
"feature",
"introduced",
"in",
"mockito",
"2",
"3",
"other",
"levels",
"of",
"strictness",
"-",
"\"",
"warn",
"\"",
"-",
"(",
"{",
"@",
"link",
"strictness",
"#",
"warn",
"}",
")",
"and",
"\"",
"lenient",
"\"",
"(",
"{",
"@",
"link",
"mockito",
"rule",
"#",
"silent",
"(",
")",
"}",
")",
"strictness",
"were",
"already",
"present",
"in",
"mockito",
"2",
"1",
"0",
"version",
"2",
"3",
"0",
"introduces",
"\"",
"strict",
"stubs",
"\"",
"(",
"{",
"@",
"link",
"strictness",
"#",
"strict",
"stubs",
"}",
")",
"<",
"pre",
"class",
"=",
"\"",
"code",
"\"",
">",
"<",
"code",
"class",
"=",
"\"",
"java",
"\"",
">",
"public",
"class",
"example",
"test",
"{",
"&",
"#",
"064",
";",
"rule",
"public",
"mockito",
"rule",
"rule",
"=",
"mockito",
"j",
"unit",
"rule",
"(",
")",
"strictness",
"(",
"strictness",
"strict",
"stubs",
")",
";",
"}",
"<",
"code",
">",
"see",
"javadoc",
"for",
"{",
"@",
"link",
"strictness",
"}",
"to",
"learn",
"how",
"strictness",
"influences",
"the",
"behavior",
"of",
"the",
"j",
"unit",
"rule",
"see",
"{",
"@",
"link",
"strictness",
"#",
"strict",
"stubs",
"}",
"to",
"learn",
"why",
"is",
"it",
"recommended",
"to",
"use",
"\"",
"strict",
"stubbing",
"\"",
"it",
"is",
"possible",
"to",
"tweak",
"the",
"strictness",
"per",
"test",
"method",
"why",
"would",
"you",
"need",
"it",
"?",
"see",
"the",
"use",
"cases",
"in",
"javadoc",
"for",
"{",
"@",
"link",
"potential",
"stubbing",
"problem",
"}",
"class",
"in",
"order",
"to",
"tweak",
"strictness",
"per",
"stubbing",
"see",
"{",
"@",
"link",
"mockito",
"#",
"lenient",
"(",
")",
"}",
",",
"per",
"mock",
"see",
"{",
"@",
"link",
"mock",
"settings",
"#",
"lenient",
"(",
")",
"}",
"<",
"pre",
"class",
"=",
"\"",
"code",
"\"",
">",
"<",
"code",
"class",
"=",
"\"",
"java",
"\"",
">",
"public",
"class",
"example",
"test",
"{",
"&",
"#",
"064",
";",
"rule",
"public",
"mockito",
"rule",
"rule",
"=",
"mockito",
"j",
"unit",
"rule",
"(",
")",
"strictness",
"(",
"strictness",
"strict",
"stubs",
")",
";",
"&",
"#",
"064",
";",
"test",
"public",
"void",
"example",
"test",
"(",
")",
"{",
"change",
"the",
"strictness",
"level",
"only",
"for",
"this",
"test",
"method",
"useful",
"for",
"edge",
"cases",
"(",
"see",
"javadoc",
"for",
"potential",
"stubbing",
"problem",
"class",
")",
"mockito",
"strictness",
"(",
"strictness",
"lenient",
")",
";",
"remaining",
"test",
"code",
"}",
"}",
"<",
"code",
">",
"\"",
"strict",
"stubs",
"\"",
"are",
"planned",
"to",
"be",
"the",
"default",
"for",
"mockito",
"v",
"3",
"we",
"are",
"very",
"eager",
"to",
"hear",
"feedback",
"about",
"\"",
"strict",
"stubbing",
"\"",
"feature",
",",
"let",
"us",
"know",
"by",
"commenting",
"on",
"git",
"hub",
"<",
"a",
"href",
"=",
"\"",
"https",
":",
"github",
"commockitomockitoissues",
"7",
"6",
"9",
"\"",
">",
"issue",
"769",
"strict",
"stubbing",
"is",
"an",
"attempt",
"to",
"improve",
"testability",
"and",
"productivity",
"with",
"mockito",
"tell",
"us",
"what",
"you",
"think",
"!"
] |
[
"mockito",
"rule",
"strictness",
"(",
"strictness",
"strictness",
")",
";"
] |
[
"gets",
"a",
"property",
"from",
"the",
"configuration",
"the",
"default",
"value",
"will",
"return",
"if",
"the",
"configuration",
"doesn",
"'",
"t",
"contain",
"the",
"mapping",
"for",
"the",
"specified",
"key"
] |
[
"default",
"object",
"get",
"property",
"(",
"string",
"key",
",",
"object",
"default",
"value",
")",
"{",
"object",
"value",
"=",
"get",
"internal",
"property",
"(",
"key",
")",
";",
"return",
"value",
"!",
"=",
"null",
"?",
"value",
":",
"default",
"value",
";",
"}"
] |
[
"specify",
"the",
"property",
"path",
"to",
"apply",
"to",
"the",
"target"
] |
[
"public",
"void",
"set",
"property",
"path",
"(",
"string",
"property",
"path",
")",
"{",
"this",
"property",
"path",
"=",
"string",
"utils",
"trim",
"all",
"whitespace",
"(",
"property",
"path",
")",
";",
"}"
] |
[
"rebase",
"the",
"task",
"spec",
"time",
"so",
"that",
"it",
"is",
"not",
"earlier",
"than",
"the",
"current",
"time",
"this",
"is",
"only",
"needed",
"for",
"tasks",
"passed",
"in",
"with",
"-",
"-",
"exec",
"normally",
",",
"the",
"controller",
"rebases",
"the",
"task",
"spec",
"time"
] |
[
"task",
"spec",
"rebase",
"task",
"spec",
"time",
"(",
"task",
"spec",
"spec",
")",
"throws",
"exception",
"{",
"object",
"node",
"node",
"=",
"json",
"util",
"json",
"serde",
"value",
"to",
"tree",
"(",
"spec",
")",
";",
"node",
"set",
"(",
"\"",
"start",
"ms",
"\"",
",",
"new",
"long",
"node",
"(",
"math",
"max",
"(",
"time",
"milliseconds",
"(",
")",
",",
"spec",
"start",
"ms",
"(",
")",
")",
")",
")",
";",
"return",
"json",
"util",
"json",
"serde",
"tree",
"to",
"value",
"(",
"node",
",",
"task",
"spec",
"class",
")",
";",
"}"
] |
[
"sets",
"the",
"semantic",
"properties",
"for",
"the",
"user",
"-",
"defined",
"function",
"(",
"udf",
")",
"the",
"semantic",
"properties",
"define",
"how",
"fields",
"of",
"tuples",
"and",
"other",
"objects",
"are",
"modified",
"or",
"preserved",
"through",
"this",
"udf",
"the",
"configured",
"properties",
"can",
"be",
"retrieved",
"via",
"{",
"@",
"link",
"udf",
"operator",
"#",
"get",
"semantic",
"properties",
"(",
")",
"}"
] |
[
"public",
"void",
"set",
"semantic",
"properties",
"(",
"single",
"input",
"semantic",
"properties",
"properties",
")",
"{",
"this",
"udf",
"semantics",
"=",
"properties",
";",
"this",
"analyzed",
"udf",
"semantics",
"=",
"false",
";",
"}"
] |
[
"tests",
"that",
"the",
"{",
"@",
"link",
"zoo",
"keeper",
"ha",
"services",
"}",
"cleans",
"up",
"all",
"paths",
"if",
"it",
"is",
"closed",
"via",
"{",
"@",
"link",
"zoo",
"keeper",
"ha",
"services",
"#",
"close",
"and",
"cleanup",
"all",
"data",
"(",
")",
"}"
] |
[
"public",
"void",
"test",
"simple",
"close",
"and",
"cleanup",
"all",
"data",
"(",
")",
"throws",
"exception",
"{",
"final",
"configuration",
"configuration",
"=",
"create",
"configuration",
"(",
"\"",
"/",
"foo",
"/",
"bar",
"/",
"flink",
"\"",
")",
";",
"final",
"testing",
"blob",
"store",
"service",
"blob",
"store",
"service",
"=",
"new",
"testing",
"blob",
"store",
"service",
"(",
")",
";",
"final",
"list",
"<",
"string",
">",
"initial",
"children",
"=",
"client",
"get",
"children",
"(",
")",
"for",
"path",
"(",
"\"",
"/",
"\"",
")",
";",
"run",
"cleanup",
"test",
"(",
"configuration",
",",
"blob",
"store",
"service",
",",
"zoo",
"keeper",
"ha",
"services",
":",
":",
"close",
"and",
"cleanup",
"all",
"data",
")",
";",
"assert",
"that",
"(",
"blob",
"store",
"service",
"is",
"closed",
"and",
"cleaned",
"up",
"all",
"data",
"(",
")",
",",
"is",
"(",
"true",
")",
")",
";",
"final",
"list",
"<",
"string",
">",
"children",
"=",
"client",
"get",
"children",
"(",
")",
"for",
"path",
"(",
"\"",
"/",
"\"",
")",
";",
"assert",
"that",
"(",
"children",
",",
"is",
"(",
"equal",
"to",
"(",
"initial",
"children",
")",
")",
")",
";",
"}"
] |
[
"a",
"signal",
"used",
"when",
"installing",
"actions",
"some",
"actions",
"are",
"only",
"added",
"to",
"a",
"given",
"window",
"if",
"there",
"is",
"a",
"provider",
"in",
"that",
"window",
"that",
"can",
"work",
"with",
"that",
"action",
"providers",
"can",
"return",
"a",
"context",
"class",
"from",
"this",
"method",
"to",
"control",
"whether",
"dependent",
"actions",
"get",
"added",
"most",
"providers",
"return",
"null",
"for",
"this",
"method",
",",
"which",
"means",
"they",
"will",
"not",
"have",
"any",
"dependent",
"actions",
"added",
"to",
"windows",
"other",
"than",
"the",
"primary",
"application",
"window"
] |
[
"public",
"class",
"<",
"?",
">",
"get",
"context",
"type",
"(",
")",
"{",
"return",
"context",
"type",
";",
"}"
] |
[
"the",
"date",
"that",
"hadoop",
"was",
"compiled"
] |
[
"public",
"static",
"string",
"get",
"date",
"(",
")",
"{",
"return",
"common",
"version",
"info",
"get",
"date",
"(",
")",
";",
"}"
] |
[
"write",
"the",
"token",
"only",
"works",
"if",
"valid"
] |
[
"public",
"void",
"write",
"(",
"data",
"output",
"out",
")",
"throws",
"i",
"o",
"exception",
"{",
"validate",
"(",
"\"",
"writing",
"\"",
"+",
"this",
"+",
"\"",
":",
"\"",
",",
"credential",
"type",
"required",
"any",
"including",
"empty",
")",
";",
"text",
"write",
"string",
"(",
"out",
",",
"access",
"key",
")",
";",
"text",
"write",
"string",
"(",
"out",
",",
"secret",
"key",
")",
";",
"text",
"write",
"string",
"(",
"out",
",",
"session",
"token",
")",
";",
"text",
"write",
"string",
"(",
"out",
",",
"role",
"a",
"r",
"n",
")",
";",
"out",
"write",
"long",
"(",
"expiration",
")",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] |
[
"public",
"string",
"[",
"]",
"get",
"locations",
"(",
")",
"{",
"return",
"empty",
";",
"}"
] |
[
"append",
"a",
"record",
"at",
"the",
"next",
"sequential",
"offset"
] |
[
"public",
"void",
"append",
"(",
"record",
"record",
")",
"{",
"append",
"with",
"offset",
"(",
"record",
"offset",
"(",
")",
",",
"is",
"control",
"batch",
",",
"record",
"timestamp",
"(",
")",
",",
"record",
"key",
"(",
")",
",",
"record",
"value",
"(",
")",
",",
"record",
"headers",
"(",
")",
")",
";",
"}"
] |
[
"a",
"not",
"efficient",
"calculation",
"of",
"the",
"fibonacci",
"sequence"
] |
[
"public",
"static",
"long",
"fib",
"(",
"int",
"n",
")",
"{",
"if",
"(",
"n",
"<",
"2",
")",
"{",
"return",
"n",
";",
"}",
"else",
"{",
"return",
"fib",
"(",
"n",
"-",
"1",
")",
"+",
"fib",
"(",
"n",
"-",
"2",
")",
";",
"}",
"}"
] |
[
"test",
"the",
"property",
"'",
"just",
"symbol",
"'"
] |
[
"public",
"void",
"just",
"symbol",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"just",
"symbol",
"}"
] |
[
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"and",
"only",
"if",
"the",
"specified",
"message",
"can",
"be",
"decoded",
"by",
"this",
"codec"
] |
[
"public",
"boolean",
"accept",
"inbound",
"message",
"(",
"object",
"msg",
")",
"throws",
"exception",
"{",
"return",
"inbound",
"msg",
"matcher",
"match",
"(",
"msg",
")",
";",
"}"
] |
[
"the",
"template",
"source",
"definition"
] |
[
"public",
"put",
"index",
"template",
"request",
"source",
"(",
"byte",
"[",
"]",
"source",
",",
"x",
"content",
"type",
"x",
"content",
"type",
")",
"{",
"return",
"source",
"(",
"source",
",",
"0",
",",
"source",
"length",
",",
"x",
"content",
"type",
")",
";",
"}"
] |
[
"the",
"time",
"in",
"days",
"that",
"model",
"snapshots",
"are",
"retained",
"for",
"the",
"job",
"updates",
"the",
"{",
"@",
"link",
"job",
"#",
"model",
"snapshot",
"retention",
"days",
"}",
"setting"
] |
[
"public",
"builder",
"set",
"model",
"snapshot",
"retention",
"days",
"(",
"long",
"model",
"snapshot",
"retention",
"days",
")",
"{",
"this",
"model",
"snapshot",
"retention",
"days",
"=",
"model",
"snapshot",
"retention",
"days",
";",
"return",
"this",
";",
"}"
] |
[
"show",
"the",
"default",
"merge",
"panel",
"the",
"default",
"merge",
"panel",
"now",
"shows",
"the",
"status",
"of",
"each",
"phase",
"of",
"the",
"merge",
"and",
"also",
"the",
"progress",
"in",
"the",
"current",
"phase"
] |
[
"public",
"void",
"show",
"default",
"merge",
"panel",
"(",
"final",
"string",
"description",
")",
"{",
"show",
"component",
"(",
"null",
",",
"null",
",",
"null",
")",
";",
"swing",
"utilities",
"invoke",
"later",
"(",
"(",
")",
"-",
">",
"merge",
"plugin",
"update",
"merge",
"description",
"(",
"description",
")",
")",
";",
"}"
] |
[
"if",
"false",
",",
"the",
"actor",
"will",
"not",
"be",
"drawn",
"and",
"will",
"not",
"receive",
"touch",
"events",
"default",
"is",
"true"
] |
[
"public",
"void",
"set",
"visible",
"(",
"boolean",
"visible",
")",
"{",
"this",
"visible",
"=",
"visible",
";",
"}"
] |
[
"talks",
"to",
"the",
"http",
"interface",
"to",
"get",
"the",
"json",
"output",
"of",
"a",
"status",
"command",
"on",
"the",
"given",
"file"
] |
[
"private",
"string",
"get",
"status",
"(",
"string",
"filename",
",",
"string",
"command",
")",
"throws",
"exception",
"{",
"long",
"old",
"ops",
"stat",
"=",
"metrics",
"getter",
"get",
"or",
"default",
"(",
"command",
",",
"default",
"entry",
"metric",
"getter",
")",
"call",
"(",
")",
";",
"string",
"user",
"=",
"hadoop",
"users",
"conf",
"test",
"helper",
"get",
"hadoop",
"users",
"(",
")",
"[",
"0",
"]",
";",
"/",
"/",
"remove",
"leading",
"/",
"from",
"filename",
"if",
"(",
"filename",
"char",
"at",
"(",
"0",
")",
"=",
"=",
"'",
"/",
"'",
")",
"{",
"filename",
"=",
"filename",
"substring",
"(",
"1",
")",
";",
"}",
"string",
"path",
"ops",
"=",
"message",
"format",
"format",
"(",
"\"",
"/",
"webhdfs",
"/",
"v",
"1",
"/",
"{",
"0",
"}",
"?",
"user",
"name",
"=",
"{",
"1",
"}",
"&",
"op",
"=",
"{",
"2",
"}",
"\"",
",",
"filename",
",",
"user",
",",
"command",
")",
";",
"url",
"url",
"=",
"new",
"url",
"(",
"test",
"jetty",
"helper",
"get",
"jetty",
"u",
"r",
"l",
"(",
")",
",",
"path",
"ops",
")",
";",
"http",
"u",
"r",
"l",
"connection",
"conn",
"=",
"(",
"http",
"u",
"r",
"l",
"connection",
")",
"url",
"open",
"connection",
"(",
")",
";",
"conn",
"connect",
"(",
")",
";",
"assert",
"assert",
"equals",
"(",
"http",
"u",
"r",
"l",
"connection",
"http",
"ok",
",",
"conn",
"get",
"response",
"code",
"(",
")",
")",
";",
"buffered",
"reader",
"reader",
"=",
"new",
"buffered",
"reader",
"(",
"new",
"input",
"stream",
"reader",
"(",
"conn",
"get",
"input",
"stream",
"(",
")",
")",
")",
";",
"long",
"ops",
"stat",
"=",
"metrics",
"getter",
"get",
"or",
"default",
"(",
"command",
",",
"default",
"exit",
"metric",
"getter",
")",
"call",
"(",
")",
";",
"assert",
"assert",
"equals",
"(",
"old",
"ops",
"stat",
"+",
"1l",
",",
"ops",
"stat",
")",
";",
"return",
"reader",
"read",
"line",
"(",
")",
";",
"}"
] |
[
"gets",
"all",
"server",
"sockets",
"that",
"exist",
"in",
"the",
"process"
] |
[
"public",
"void",
"get",
"server",
"sockets",
"(",
"io",
"grpc",
"channelz",
"v",
"1",
"get",
"server",
"sockets",
"request",
"request",
",",
"io",
"grpc",
"stub",
"stream",
"observer",
"<",
"io",
"grpc",
"channelz",
"v",
"1",
"get",
"server",
"sockets",
"response",
">",
"response",
"observer",
")",
"{",
"io",
"grpc",
"stub",
"client",
"calls",
"async",
"unary",
"call",
"(",
"get",
"channel",
"(",
")",
"new",
"call",
"(",
"get",
"get",
"server",
"sockets",
"method",
"(",
")",
",",
"get",
"call",
"options",
"(",
")",
")",
",",
"request",
",",
"response",
"observer",
")",
";",
"}"
] |
[
"returns",
"<",
"code",
">",
"true",
"<",
"code",
">",
"if",
"this",
"setting",
"has",
"a",
"node",
"scope",
",",
"otherwise",
"<",
"code",
">",
"false",
"<",
"code",
">"
] |
[
"public",
"boolean",
"has",
"node",
"scope",
"(",
")",
"{",
"return",
"properties",
"contains",
"(",
"property",
"node",
"scope",
")",
";",
"}"
] |
[
"sets",
"{",
"@",
"link",
"intermediate",
"artifacts",
"}",
"for",
"deriving",
"artifact",
"paths"
] |
[
"public",
"builder",
"set",
"intermediate",
"artifacts",
"(",
"intermediate",
"artifacts",
"intermediate",
"artifacts",
")",
"{",
"this",
"intermediate",
"artifacts",
"=",
"intermediate",
"artifacts",
";",
"return",
"this",
";",
"}"
] |
[
"unlike",
"web",
"socket",
"where",
"sub",
"-",
"protocol",
"negotiation",
"is",
"part",
"of",
"the",
"initial",
"handshake",
",",
"in",
"http",
"transports",
"the",
"same",
"negotiation",
"must",
"be",
"emulated",
"and",
"the",
"selected",
"protocol",
"set",
"through",
"this",
"setter"
] |
[
"public",
"void",
"set",
"accepted",
"protocol",
"(",
"@",
"nullable",
"string",
"protocol",
")",
"{",
"this",
"accepted",
"protocol",
"=",
"protocol",
";",
"}"
] |
[
"the",
"reason",
"for",
"canceling",
"the",
"task"
] |
[
"public",
"string",
"get",
"reason",
"(",
")",
"{",
"return",
"reason",
";",
"}"
] |
[
"describes",
"the",
"table",
"source"
] |
[
"default",
"string",
"explain",
"source",
"(",
")",
"{",
"return",
"table",
"connector",
"utils",
"generate",
"runtime",
"name",
"(",
"get",
"class",
"(",
")",
",",
"get",
"table",
"schema",
"(",
")",
"get",
"field",
"names",
"(",
")",
")",
";",
"}"
] |
[
"show",
"fragment",
"then",
"hide",
"other",
"fragment"
] |
[
"public",
"static",
"void",
"show",
"hide",
"(",
"@",
"non",
"null",
"final",
"fragment",
"show",
",",
"@",
"non",
"null",
"final",
"fragment",
"hide",
")",
"{",
"show",
"hide",
"(",
"show",
",",
"arrays",
"as",
"list",
"(",
"hide",
")",
")",
";",
"}"
] |
[
"returns",
"the",
"bridge",
"method",
"for",
"writing",
"an",
"instance",
"field",
",",
"identified",
"by",
"(",
"putfield",
")",
"instruction"
] |
[
"public",
"final",
"method",
"key",
"bridge",
"of",
"instance",
"write",
"(",
")",
"{",
"return",
"method",
"key",
"create",
"(",
"owner",
"(",
")",
",",
"name",
"with",
"suffix",
"(",
"\"",
"bridge",
"setter",
"\"",
")",
",",
"type",
"get",
"method",
"descriptor",
"(",
"get",
"field",
"type",
"(",
")",
",",
"type",
"get",
"object",
"type",
"(",
"owner",
"name",
"(",
")",
")",
",",
"get",
"field",
"type",
"(",
")",
")",
")",
";",
"}"
] |
[
"intercept",
"the",
"execution",
"of",
"a",
"handler",
"called",
"after",
"handler",
"mapping",
"determined",
"an",
"appropriate",
"handler",
"object",
",",
"but",
"before",
"handler",
"adapter",
"invokes",
"the",
"handler",
"dispatcher",
"servlet",
"processes",
"a",
"handler",
"in",
"an",
"execution",
"chain",
",",
"consisting",
"of",
"any",
"number",
"of",
"interceptors",
",",
"with",
"the",
"handler",
"itself",
"at",
"the",
"end",
"with",
"this",
"method",
",",
"each",
"interceptor",
"can",
"decide",
"to",
"abort",
"the",
"execution",
"chain",
",",
"typically",
"sending",
"an",
"http",
"error",
"or",
"writing",
"a",
"custom",
"response",
"note",
":",
"special",
"considerations",
"apply",
"for",
"asynchronous",
"request",
"processing",
"for",
"more",
"details",
"see",
"{",
"@",
"link",
"org",
"springframework",
"web",
"servlet",
"async",
"handler",
"interceptor",
"}",
"the",
"default",
"implementation",
"returns",
"{",
"@",
"code",
"true",
"}"
] |
[
"default",
"boolean",
"pre",
"handle",
"(",
"http",
"servlet",
"request",
"request",
",",
"http",
"servlet",
"response",
"response",
",",
"object",
"handler",
")",
"throws",
"exception",
"{",
"return",
"true",
";",
"}"
] |
[
"get",
"how",
"many",
"bytes",
"can",
"be",
"written",
"until",
"{",
"@",
"link",
"#",
"is",
"writable",
"(",
")",
"}",
"returns",
"{",
"@",
"code",
"false",
"}",
"this",
"quantity",
"will",
"always",
"be",
"non",
"-",
"negative",
"if",
"{",
"@",
"link",
"#",
"is",
"writable",
"(",
")",
"}",
"is",
"{",
"@",
"code",
"false",
"}",
"then",
"0"
] |
[
"long",
"bytes",
"before",
"unwritable",
"(",
")",
";"
] |
[
"add",
"{",
"@",
"link",
"binding",
"result",
"}",
"attributes",
"to",
"the",
"model",
"for",
"attributes",
"that",
"require",
"it"
] |
[
"private",
"void",
"update",
"binding",
"result",
"(",
"native",
"web",
"request",
"request",
",",
"model",
"map",
"model",
")",
"throws",
"exception",
"{",
"list",
"<",
"string",
">",
"key",
"names",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"model",
"key",
"set",
"(",
")",
")",
";",
"for",
"(",
"string",
"name",
":",
"key",
"names",
")",
"{",
"object",
"value",
"=",
"model",
"get",
"(",
"name",
")",
";",
"if",
"(",
"value",
"!",
"=",
"null",
"&",
"&",
"is",
"binding",
"candidate",
"(",
"name",
",",
"value",
")",
")",
"{",
"string",
"binding",
"result",
"key",
"=",
"binding",
"result",
"model",
"key",
"prefix",
"+",
"name",
";",
"if",
"(",
"!",
"model",
"contains",
"attribute",
"(",
"binding",
"result",
"key",
")",
")",
"{",
"web",
"data",
"binder",
"data",
"binder",
"=",
"this",
"data",
"binder",
"factory",
"create",
"binder",
"(",
"request",
",",
"value",
",",
"name",
")",
";",
"model",
"put",
"(",
"binding",
"result",
"key",
",",
"data",
"binder",
"get",
"binding",
"result",
"(",
")",
")",
";",
"}",
"}",
"}",
"}"
] |
[
"returns",
"a",
"fixed",
"-",
"size",
"list",
"backed",
"by",
"the",
"specified",
"array",
",",
"similar",
"to",
"{",
"@",
"link",
"arrays",
"#",
"as",
"list",
"(",
"object",
"[",
"]",
")",
"}",
"the",
"list",
"supports",
"{",
"@",
"link",
"list",
"#",
"set",
"(",
"int",
",",
"object",
")",
"}",
",",
"but",
"any",
"attempt",
"to",
"set",
"a",
"value",
"to",
"{",
"@",
"code",
"null",
"}",
"will",
"result",
"in",
"a",
"{",
"@",
"link",
"null",
"pointer",
"exception",
"}",
"the",
"returned",
"list",
"maintains",
"the",
"values",
",",
"but",
"not",
"the",
"identities",
",",
"of",
"{",
"@",
"code",
"double",
"}",
"objects",
"written",
"to",
"or",
"read",
"from",
"it",
"for",
"example",
",",
"whether",
"{",
"@",
"code",
"list",
"get",
"(",
"0",
")",
"=",
"=",
"list",
"get",
"(",
"0",
")",
"}",
"is",
"true",
"for",
"the",
"returned",
"list",
"is",
"unspecified",
"the",
"returned",
"list",
"may",
"have",
"unexpected",
"behavior",
"if",
"it",
"contains",
"{",
"@",
"code",
"na",
"n",
"}",
",",
"or",
"if",
"{",
"@",
"code",
"na",
"n",
"}",
"is",
"used",
"as",
"a",
"parameter",
"to",
"any",
"of",
"its",
"methods",
"<",
"b",
">",
"note",
":",
"<",
"b",
">",
"when",
"possible",
",",
"you",
"should",
"represent",
"your",
"data",
"as",
"an",
"{",
"@",
"link",
"immutable",
"double",
"array",
"}",
"instead",
",",
"which",
"has",
"an",
"{",
"@",
"link",
"immutable",
"double",
"array",
"#",
"as",
"list",
"as",
"list",
"}",
"view"
] |
[
"public",
"static",
"list",
"<",
"double",
">",
"as",
"list",
"(",
"double",
"backing",
"array",
")",
"{",
"if",
"(",
"backing",
"array",
"length",
"=",
"=",
"0",
")",
"{",
"return",
"collections",
"empty",
"list",
"(",
")",
";",
"}",
"return",
"new",
"double",
"array",
"as",
"list",
"(",
"backing",
"array",
")",
";",
"}"
] |
[
"set",
"the",
"{",
"@",
"code",
"name",
"}",
"to",
"{",
"@",
"code",
"value",
"}",
"this",
"will",
"remove",
"all",
"previous",
"values",
"associated",
"with",
"{",
"@",
"code",
"name",
"}"
] |
[
"public",
"abstract",
"http",
"headers",
"set",
"int",
"(",
"char",
"sequence",
"name",
",",
"int",
"value",
")",
";"
] |
[
"get",
"the",
"node",
"by",
"the",
"node",
"id",
"(",
"or",
"null",
"if",
"the",
"node",
"is",
"not",
"online",
"or",
"does",
"not",
"exist",
")"
] |
[
"public",
"node",
"node",
"by",
"id",
"(",
"int",
"id",
")",
"{",
"return",
"this",
"nodes",
"by",
"id",
"get",
"(",
"id",
")",
";",
"}"
] |
[
"tests",
"that",
"connections",
"can",
"'",
"t",
"be",
"made",
"if",
"server",
"uses",
"t",
"l",
"sv",
"1",
"2",
"with",
"custom",
"cipher",
"suite",
"and",
"client",
"uses",
"t",
"l",
"sv",
"1",
"3"
] |
[
"public",
"void",
"test",
"ciphers",
"suite",
"fail",
"for",
"server",
"tls",
"1",
"2",
"client",
"tls",
"1",
"3",
"(",
")",
"throws",
"exception",
"{",
"assume",
"true",
"(",
"java",
"is",
"java11",
"compatible",
")",
";",
"string",
"tls",
"1",
"2",
"cipher",
"suite",
"=",
"\"",
"tls",
"ecdhe",
"rsa",
"with",
"aes",
"256",
"gcm",
"sha384",
"\"",
";",
"string",
"tls",
"1",
"3",
"cipher",
"suite",
"=",
"\"",
"tls",
"aes",
"128",
"gcm",
"sha256",
"\"",
";",
"ssl",
"server",
"configs",
"put",
"(",
"ssl",
"configs",
"ssl",
"protocol",
"config",
",",
"\"",
"t",
"l",
"sv",
"1",
"2",
"\"",
")",
";",
"ssl",
"server",
"configs",
"put",
"(",
"ssl",
"configs",
"ssl",
"enabled",
"protocols",
"config",
",",
"collections",
"singleton",
"list",
"(",
"\"",
"t",
"l",
"sv",
"1",
"2",
"\"",
")",
")",
";",
"ssl",
"server",
"configs",
"put",
"(",
"ssl",
"configs",
"ssl",
"cipher",
"suites",
"config",
",",
"collections",
"singleton",
"list",
"(",
"tls",
"1",
"2",
"cipher",
"suite",
")",
")",
";",
"server",
"=",
"network",
"test",
"utils",
"create",
"echo",
"server",
"(",
"listener",
"name",
"for",
"security",
"protocol",
"(",
"security",
"protocol",
"ssl",
")",
",",
"security",
"protocol",
"ssl",
",",
"new",
"test",
"security",
"config",
"(",
"ssl",
"server",
"configs",
")",
",",
"null",
",",
"time",
")",
";",
"ssl",
"client",
"configs",
"put",
"(",
"ssl",
"configs",
"ssl",
"protocol",
"config",
",",
"\"",
"t",
"l",
"sv",
"1",
"3",
"\"",
")",
";",
"ssl",
"client",
"configs",
"put",
"(",
"ssl",
"configs",
"ssl",
"cipher",
"suites",
"config",
",",
"collections",
"singleton",
"list",
"(",
"tls",
"1",
"3",
"cipher",
"suite",
")",
")",
";",
"check",
"authentiation",
"failed",
"(",
")",
";",
"}"
] |
[
"return",
"a",
"{",
"@",
"link",
"murmur",
"hash",
"3",
"values",
"}",
"instance",
"that",
"computes",
"hashes",
"on",
"the",
"fly",
"for",
"each",
"double",
"value"
] |
[
"public",
"static",
"murmur",
"hash",
"3",
"values",
"hash",
"(",
"sorted",
"numeric",
"double",
"values",
"values",
")",
"{",
"return",
"new",
"double",
"(",
"values",
")",
";",
"}"
] |
[
"sets",
"the",
"work",
"item"
] |
[
"public",
"void",
"set",
"work",
"item",
"(",
"disk",
"balancer",
"work",
"item",
"work",
"item",
")",
"{",
"this",
"work",
"item",
"=",
"work",
"item",
";",
"}"
] |
[
"sets",
"an",
"explicit",
"smoothing",
"model",
"used",
"for",
"this",
"suggester",
"the",
"default",
"is",
"{",
"@",
"link",
"stupid",
"backoff",
"}"
] |
[
"public",
"phrase",
"suggestion",
"builder",
"smoothing",
"model",
"(",
"smoothing",
"model",
"model",
")",
"{",
"this",
"model",
"=",
"model",
";",
"return",
"this",
";",
"}"
] |
[
"flag",
"to",
"define",
"if",
"constructors",
"should",
"be",
"generated"
] |
[
"public",
"void",
"set",
"constructors",
"(",
"boolean",
"constructors",
")",
"{",
"this",
"constructors",
"=",
"constructors",
";",
"}"
] |
[
"provide",
"a",
"string",
"representation",
"of",
"this",
"{",
"@",
"code",
"merged",
"test",
"property",
"sources",
"}",
"instance"
] |
[
"public",
"string",
"to",
"string",
"(",
")",
"{",
"return",
"new",
"to",
"string",
"creator",
"(",
"this",
")",
"append",
"(",
"\"",
"locations",
"\"",
",",
"arrays",
"to",
"string",
"(",
"this",
"locations",
")",
")",
"append",
"(",
"\"",
"properties",
"\"",
",",
"arrays",
"to",
"string",
"(",
"this",
"properties",
")",
")",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"get",
"the",
"time",
"elapsed",
"for",
"downstream",
"ack",
"rtt",
"in",
"nanoseconds"
] |
[
"public",
"long",
"get",
"downstream",
"ack",
"time",
"nanos",
"(",
")",
"{",
"return",
"proto",
"get",
"downstream",
"ack",
"time",
"nanos",
"(",
")",
";",
"}"
] |
[
"this",
"field",
"consists",
"of",
"4",
"1",
"-",
"bit",
"flags",
"and",
"a",
"4",
"-",
"bit",
"tdata",
"alignment"
] |
[
"public",
"byte",
"get",
"flags",
"(",
")",
"{",
"return",
"o",
"flags",
";",
"}"
] |
[
"define",
"a",
"constant",
"value",
"where",
"disappear",
"animations",
"should",
"end",
"at"
] |
[
"public",
"transition",
"units",
"builder",
"disappear",
"to",
"(",
"float",
"value",
")",
"{",
"return",
"disappear",
"to",
"(",
"new",
"float",
"value",
"(",
"value",
")",
")",
";",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.