docstring_tokens
list | code_tokens
list |
|---|---|
[
"{",
"@",
"inherit",
"doc",
"}"
] |
[
"protected",
"int",
"compare",
"to",
"0",
"(",
"offsetted",
"item",
"other",
")",
"{",
"type",
"list",
"this",
"list",
"=",
"this",
"list",
";",
"type",
"list",
"other",
"list",
"=",
"(",
"(",
"type",
"list",
"item",
")",
"other",
")",
"list",
";",
"return",
"std",
"type",
"list",
"compare",
"contents",
"(",
"this",
"list",
",",
"other",
"list",
")",
";",
"}"
] |
[
"verify",
"valid",
"ssl",
"configuration",
"and",
"connection"
] |
[
"public",
"void",
"test",
"valid",
"ssl",
"connection",
"(",
")",
"throws",
"exception",
"{",
"test",
"valid",
"ssl",
"connection",
"(",
"create",
"ssl",
"config",
"(",
")",
")",
";",
"}"
] |
[
"stop",
"the",
"service",
"this",
"method",
"is",
"invoked",
"on",
"the",
"execution",
"thread",
"by",
"default",
"this",
"method",
"does",
"nothing"
] |
[
"protected",
"void",
"shut",
"down",
"(",
")",
"throws",
"exception",
"{",
"}"
] |
[
"puts",
"the",
"given",
"long",
"value",
"in",
"the",
"long",
"array",
"at",
"the",
"given",
"index"
] |
[
"public",
"void",
"put",
"(",
"int",
"index",
",",
"long",
"value",
")",
"{",
"if",
"(",
"value",
"=",
"=",
"0",
")",
"{",
"remove",
"(",
"index",
")",
";",
"return",
";",
"}",
"if",
"(",
"index",
">",
"=",
"longs",
"length",
")",
"{",
"adjust",
"array",
"(",
"math",
"max",
"(",
"index",
"+",
"1",
",",
"longs",
"length",
"*",
"2",
")",
")",
";",
"}",
"longs",
"[",
"index",
"]",
"=",
"value",
";",
"if",
"(",
"index",
">",
"last",
"non",
"zero",
"index",
")",
"{",
"last",
"non",
"zero",
"index",
"=",
"index",
";",
"}",
"}"
] |
[
"private",
"method",
"used",
"by",
"several",
"methods",
"(",
"{",
"@",
"link",
"#",
"get",
"all",
"used",
"schemas",
"(",
"open",
"a",
"p",
"i",
")",
"}",
",",
"{",
"@",
"link",
"#",
"get",
"unused",
"schemas",
"(",
"open",
"a",
"p",
"i",
")",
"}",
",",
"{",
"@",
"link",
"#",
"get",
"schemas",
"used",
"only",
"in",
"form",
"param",
"(",
"open",
"a",
"p",
"i",
")",
"}",
",",
")",
"to",
"traverse",
"all",
"paths",
"of",
"an",
"open",
"a",
"p",
"i",
"instance",
"and",
"call",
"the",
"visitor",
"functional",
"interface",
"when",
"a",
"schema",
"is",
"found"
] |
[
"private",
"static",
"void",
"visit",
"open",
"a",
"p",
"i",
"(",
"open",
"a",
"p",
"i",
"open",
"a",
"p",
"i",
",",
"open",
"a",
"p",
"i",
"schema",
"visitor",
"visitor",
")",
"{",
"map",
"<",
"string",
",",
"path",
"item",
">",
"paths",
"=",
"open",
"a",
"p",
"i",
"get",
"paths",
"(",
")",
";",
"list",
"<",
"string",
">",
"visited",
"schemas",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"if",
"(",
"paths",
"!",
"=",
"null",
")",
"{",
"for",
"(",
"path",
"item",
"path",
":",
"paths",
"values",
"(",
")",
")",
"{",
"visit",
"path",
"item",
"(",
"path",
",",
"open",
"a",
"p",
"i",
",",
"visitor",
",",
"visited",
"schemas",
")",
";",
"}",
"}",
"}"
] |
[
"sets",
"the",
"flags",
"corresponding",
"to",
"the",
"edges",
"of",
"the",
"component",
"that",
"are",
"visible",
"afterwards",
",",
"it",
"checks",
"if",
"the",
"component",
"has",
"entered",
"the",
"full",
"impression",
"visible",
"range",
"and",
",",
"if",
"so",
",",
"it",
"sets",
"the",
"appropriate",
"flag"
] |
[
"public",
"void",
"set",
"visible",
"edges",
"(",
"rect",
"component",
"bounds",
",",
"rect",
"component",
"visible",
"bounds",
")",
"{",
"if",
"(",
"component",
"bounds",
"top",
"=",
"=",
"component",
"visible",
"bounds",
"top",
")",
"{",
"m",
"flags",
"|",
"=",
"flag",
"top",
"edge",
"visible",
";",
"}",
"if",
"(",
"component",
"bounds",
"bottom",
"=",
"=",
"component",
"visible",
"bounds",
"bottom",
")",
"{",
"m",
"flags",
"|",
"=",
"flag",
"bottom",
"edge",
"visible",
";",
"}",
"if",
"(",
"component",
"bounds",
"left",
"=",
"=",
"component",
"visible",
"bounds",
"left",
")",
"{",
"m",
"flags",
"|",
"=",
"flag",
"left",
"edge",
"visible",
";",
"}",
"if",
"(",
"component",
"bounds",
"right",
"=",
"=",
"component",
"visible",
"bounds",
"right",
")",
"{",
"m",
"flags",
"|",
"=",
"flag",
"right",
"edge",
"visible",
";",
"}",
"}"
] |
[
"<",
"code",
">",
"repeated",
"aapt",
"pb",
"styled",
"string",
"span",
"span",
"=",
"2",
";",
"<",
"code",
">"
] |
[
"private",
"void",
"add",
"span",
"(",
"com",
"android",
"aapt",
"resources",
"styled",
"string",
"span",
"value",
")",
"{",
"if",
"(",
"value",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"null",
"pointer",
"exception",
"(",
")",
";",
"}",
"ensure",
"span",
"is",
"mutable",
"(",
")",
";",
"span",
"add",
"(",
"value",
")",
";",
"}"
] |
[
"returns",
"the",
"configured",
"targetaspect",
"for",
"this",
"value"
] |
[
"provider",
"collection",
"get",
"configured",
"object",
"(",
")",
";"
] |
[
"set",
"the",
"http",
"invoker",
"request",
"executor",
"implementation",
"to",
"use",
"for",
"executing",
"remote",
"invocations",
"default",
"is",
"{",
"@",
"link",
"simple",
"http",
"invoker",
"request",
"executor",
"}",
"alternatively",
",",
"consider",
"using",
"{",
"@",
"link",
"http",
"components",
"http",
"invoker",
"request",
"executor",
"}",
"for",
"more",
"sophisticated",
"needs"
] |
[
"public",
"void",
"set",
"http",
"invoker",
"request",
"executor",
"(",
"http",
"invoker",
"request",
"executor",
"http",
"invoker",
"request",
"executor",
")",
"{",
"this",
"http",
"invoker",
"request",
"executor",
"=",
"http",
"invoker",
"request",
"executor",
";",
"}"
] |
[
"adds",
"a",
"number",
"of",
"connections",
"for",
"one",
"or",
"more",
"types",
"each",
"type",
"can",
"only",
"be",
"added",
"once"
] |
[
"public",
"builder",
"add",
"connections",
"(",
"int",
"num",
"connections",
",",
"transport",
"request",
"options",
"type",
"types",
")",
"{",
"if",
"(",
"types",
"=",
"=",
"null",
"|",
"|",
"types",
"length",
"=",
"=",
"0",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"types",
"must",
"not",
"be",
"null",
"\"",
")",
";",
"}",
"for",
"(",
"transport",
"request",
"options",
"type",
"type",
":",
"types",
")",
"{",
"if",
"(",
"added",
"types",
"contains",
"(",
"type",
")",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"type",
"[",
"\"",
"+",
"type",
"+",
"\"",
"]",
"is",
"already",
"registered",
"\"",
")",
";",
"}",
"}",
"added",
"types",
"add",
"all",
"(",
"arrays",
"as",
"list",
"(",
"types",
")",
")",
";",
"handles",
"add",
"(",
"new",
"connection",
"type",
"handle",
"(",
"this",
"num",
"connections",
",",
"num",
"connections",
",",
"enum",
"set",
"copy",
"of",
"(",
"arrays",
"as",
"list",
"(",
"types",
")",
")",
")",
")",
";",
"this",
"num",
"connections",
"+",
"=",
"num",
"connections",
";",
"return",
"this",
";",
"}"
] |
[
"whether",
"to",
"update",
"the",
"'",
"content",
"-",
"length",
"'",
"header",
"of",
"the",
"response",
"when",
"set",
"to",
"{",
"@",
"code",
"true",
"}",
",",
"the",
"response",
"is",
"buffered",
"in",
"order",
"to",
"determine",
"the",
"content",
"length",
"and",
"set",
"the",
"'",
"content",
"-",
"length",
"'",
"header",
"of",
"the",
"response",
"the",
"default",
"setting",
"is",
"{",
"@",
"code",
"false",
"}"
] |
[
"public",
"void",
"set",
"update",
"content",
"length",
"(",
"boolean",
"update",
"content",
"length",
")",
"{",
"this",
"update",
"content",
"length",
"=",
"update",
"content",
"length",
";",
"}"
] |
[
"specify",
"an",
"existing",
"file",
",",
"but",
"ips",
"in",
"wrong",
"format",
"test",
"for",
"inclusion",
"should",
"be",
"true",
"as",
"if",
"the",
"feature",
"is",
"turned",
"off"
] |
[
"public",
"void",
"test",
"for",
"bad",
"f",
"ile",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"string",
"[",
"]",
"ips",
"=",
"{",
"\"",
"10",
"221",
"102",
"/",
"23",
"\"",
"}",
";",
"create",
"file",
"with",
"entries",
"(",
"\"",
"ips",
"txt",
"\"",
",",
"ips",
")",
";",
"try",
"{",
"new",
"file",
"based",
"i",
"p",
"list",
"(",
"\"",
"ips",
"txt",
"\"",
")",
";",
"fail",
"(",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"/",
"/",
"expects",
"exception",
"}",
"}"
] |
[
"test",
"the",
"property",
"'",
"pattern",
"with",
"digits",
"'"
] |
[
"public",
"void",
"pattern",
"with",
"digits",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"pattern",
"with",
"digits",
"}"
] |
[
"returns",
"the",
"<",
"a",
"href",
"=",
"\"",
"http",
":",
"en",
"wikipedia",
"orgwiki",
"arithmetic",
"mean",
"\"",
">",
"arithmetic",
"mean",
"of",
"the",
"values",
"the",
"count",
"must",
"be",
"non",
"-",
"zero",
"the",
"definition",
"of",
"the",
"mean",
"is",
"the",
"same",
"as",
"{",
"@",
"link",
"stats",
"#",
"mean",
"}"
] |
[
"public",
"static",
"double",
"mean",
"of",
"(",
"iterable",
"<",
"?",
"extends",
"number",
">",
"values",
")",
"{",
"return",
"mean",
"of",
"(",
"values",
"iterator",
"(",
")",
")",
";",
"}"
] |
[
"add",
"a",
"{",
"@",
"link",
"open",
"ssl",
"engine",
"}",
"to",
"this",
"{",
"@",
"link",
"open",
"ssl",
"engine",
"map",
"}"
] |
[
"void",
"add",
"(",
"reference",
"counted",
"open",
"ssl",
"engine",
"engine",
")",
";"
] |
[
"get",
"the",
"managed",
"memory",
"needed"
] |
[
"public",
"memory",
"size",
"get",
"managed",
"memory",
"(",
")",
"{",
"throw",
"unsupported",
"operation",
"execption",
"if",
"unknown",
"(",
")",
";",
"return",
"managed",
"memory",
";",
"}"
] |
[
"set",
"the",
"path",
"pattern"
] |
[
"public",
"glob",
"builder",
"with",
"path",
"pattern",
"(",
"path",
"pattern",
")",
"{",
"path",
"pattern",
"=",
"pattern",
";",
"return",
"this",
";",
"}"
] |
[
"test",
"to",
"verify",
"that",
"server",
"is",
"able",
"to",
"start",
"with",
"invalid",
"credentials",
"if",
"the",
"configuration",
"is",
"set",
"to",
"quorum",
"auth",
"server",
"require",
"sasl",
"=",
"false",
"quorum",
"will",
"talk",
"each",
"other",
"even",
"if",
"the",
"authentication",
"is",
"not",
"succeeded"
] |
[
"public",
"void",
"test",
"sasl",
"not",
"required",
"with",
"invalid",
"credentials",
"(",
")",
"throws",
"exception",
"{",
"map",
"<",
"string",
",",
"string",
">",
"auth",
"configs",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"auth",
"configs",
"put",
"(",
"quorum",
"auth",
"quorum",
"learner",
"sasl",
"login",
"context",
",",
"\"",
"quorum",
"learner",
"invalid",
"\"",
")",
";",
"auth",
"configs",
"put",
"(",
"quorum",
"auth",
"quorum",
"sasl",
"auth",
"enabled",
",",
"\"",
"false",
"\"",
")",
";",
"auth",
"configs",
"put",
"(",
"quorum",
"auth",
"quorum",
"server",
"sasl",
"auth",
"required",
",",
"\"",
"false",
"\"",
")",
";",
"string",
"connect",
"str",
"=",
"start",
"quorum",
"(",
"3",
",",
"auth",
"configs",
",",
"3",
")",
";",
"countdown",
"watcher",
"watcher",
"=",
"new",
"countdown",
"watcher",
"(",
")",
";",
"zoo",
"keeper",
"zk",
"=",
"new",
"zoo",
"keeper",
"(",
"connect",
"str",
",",
"client",
"base",
"connection",
"timeout",
",",
"watcher",
")",
";",
"watcher",
"wait",
"for",
"connected",
"(",
"client",
"base",
"connection",
"timeout",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"10",
";",
"i",
"+",
"+",
")",
"{",
"zk",
"create",
"(",
"\"",
"/",
"\"",
"+",
"i",
",",
"new",
"byte",
"[",
"0",
"]",
",",
"ids",
"open",
"acl",
"unsafe",
",",
"create",
"mode",
"persistent",
")",
";",
"}",
"zk",
"close",
"(",
")",
";",
"}"
] |
[
"gets",
"the",
"total",
"number",
"of",
"int",
"values",
"in",
"this",
"range"
] |
[
"public",
"long",
"get",
"num",
"values",
"(",
")",
"{",
"iterator",
"<",
"range",
">",
"it",
"=",
"set",
"iterator",
"(",
")",
";",
"long",
"n",
"=",
"0",
";",
"while",
"(",
"it",
"has",
"next",
"(",
")",
")",
"{",
"range",
"r",
"=",
"it",
"next",
"(",
")",
";",
"n",
"+",
"=",
"r",
"size",
"(",
")",
";",
"}",
"return",
"n",
";",
"}"
] |
[
"build",
"a",
"circle"
] |
[
"public",
"static",
"void",
"build",
"(",
"mesh",
"part",
"builder",
"builder",
",",
"float",
"radius",
",",
"int",
"divisions",
",",
"final",
"vector",
"3",
"center",
",",
"final",
"vector",
"3",
"normal",
",",
"final",
"vector",
"3",
"tangent",
",",
"final",
"vector",
"3",
"binormal",
")",
"{",
"build",
"(",
"builder",
",",
"radius",
",",
"divisions",
",",
"center",
"x",
",",
"center",
"y",
",",
"center",
"z",
",",
"normal",
"x",
",",
"normal",
"y",
",",
"normal",
"z",
",",
"tangent",
"x",
",",
"tangent",
"y",
",",
"tangent",
"z",
",",
"binormal",
"x",
",",
"binormal",
"y",
",",
"binormal",
"z",
")",
";",
"}"
] |
[
"obtain",
"an",
"initialized",
"shared",
"connection"
] |
[
"protected",
"connection",
"get",
"connection",
"(",
")",
"throws",
"j",
"m",
"s",
"exception",
"{",
"synchronized",
"(",
"this",
"connection",
"monitor",
")",
"{",
"if",
"(",
"this",
"connection",
"=",
"=",
"null",
")",
"{",
"init",
"connection",
"(",
")",
";",
"}",
"return",
"this",
"connection",
";",
"}",
"}"
] |
[
"total",
"number",
"of",
"available",
"sockets",
"between",
"the",
"router",
"and",
"n",
"ns"
] |
[
"public",
"int",
"get",
"num",
"active",
"connections",
"(",
")",
"{",
"return",
"this",
"connection",
"manager",
"get",
"num",
"active",
"connections",
"(",
")",
";",
"}"
] |
[
"called",
"when",
"this",
"{",
"@",
"link",
"section",
"}",
"is",
"not",
"in",
"use",
"anymore",
"to",
"release",
"its",
"resources"
] |
[
"void",
"release",
"(",
")",
"{",
"/",
"/",
"todo",
"release",
"list",
"into",
"a",
"pool",
"t",
"1",
"1",
"9",
"5",
"3",
"2",
"9",
"6",
"}"
] |
[
"returns",
"the",
"currently",
"displayed",
"structure",
"description"
] |
[
"public",
"string",
"get",
"description",
"(",
")",
"{",
"return",
"description",
"text",
"field",
"get",
"text",
"(",
")",
"trim",
"(",
")",
";",
"}"
] |
[
"check",
"to",
"see",
"if",
"the",
"property",
"is",
"assigned",
"to",
"this",
"service",
"and",
"is",
"defined",
"with",
"a",
"value"
] |
[
"public",
"boolean",
"is",
"assigned",
"to",
"(",
"final",
"registered",
"service",
"service",
")",
"{",
"return",
"is",
"assigned",
"to",
"(",
"service",
",",
"s",
"-",
">",
"true",
")",
";",
"}"
] |
[
"creates",
"a",
"fresh",
"entry",
"with",
"the",
"specified",
"object",
"at",
"the",
"specified",
"position",
"in",
"the",
"entry",
"arrays"
] |
[
"void",
"insert",
"entry",
"(",
"int",
"entry",
"index",
",",
"@",
"nullable",
"decl",
"e",
"object",
",",
"int",
"hash",
",",
"int",
"mask",
")",
"{",
"this",
"entries",
"[",
"entry",
"index",
"]",
"=",
"compact",
"hashing",
"mask",
"combine",
"(",
"hash",
",",
"unset",
",",
"mask",
")",
";",
"this",
"elements",
"[",
"entry",
"index",
"]",
"=",
"object",
";",
"}"
] |
[
"adds",
"{",
"@",
"link",
"required",
"config",
"fragments",
"provider",
"}",
"if",
"{",
"@",
"link",
"core",
"options",
"#",
"include",
"required",
"config",
"fragments",
"provider",
"}",
"isn",
"'",
"t",
"{",
"@",
"link",
"core",
"options",
"include",
"config",
"fragments",
"enum",
"#",
"off",
"}",
"see",
"{",
"@",
"link",
"com",
"google",
"devtools",
"build",
"lib",
"analysis",
"config",
"required",
"fragments",
"util",
"}",
"for",
"a",
"description",
"of",
"the",
"meaning",
"of",
"this",
"provider",
"'",
"s",
"content",
"that",
"class",
"contains",
"methods",
"that",
"populate",
"the",
"results",
"of",
"{",
"@",
"link",
"rule",
"context",
"#",
"get",
"required",
"config",
"fragments",
"}",
"and",
"{",
"@",
"link",
"#",
"aspect",
"impl",
"specific",
"required",
"config",
"fragments",
"}"
] |
[
"private",
"void",
"maybe",
"add",
"required",
"config",
"fragments",
"provider",
"(",
")",
"{",
"if",
"(",
"rule",
"context",
"should",
"include",
"required",
"config",
"fragments",
"provider",
"(",
")",
")",
"{",
"add",
"provider",
"(",
"new",
"required",
"config",
"fragments",
"provider",
"(",
"immutable",
"set",
"<",
"string",
">",
"builder",
"(",
")",
"add",
"all",
"(",
"rule",
"context",
"get",
"required",
"config",
"fragments",
"(",
")",
")",
"add",
"all",
"(",
"aspect",
"impl",
"specific",
"required",
"config",
"fragments",
")",
"build",
"(",
")",
")",
")",
";",
"}",
"}"
] |
[
"returns",
"a",
"json",
"adapter",
"equal",
"to",
"this",
",",
"but",
"is",
"lenient",
"when",
"reading",
"and",
"writing"
] |
[
"public",
"final",
"json",
"adapter",
"<",
"t",
">",
"lenient",
"(",
")",
"{",
"final",
"json",
"adapter",
"<",
"t",
">",
"delegate",
"=",
"this",
";",
"return",
"new",
"json",
"adapter",
"<",
"t",
">",
"(",
")",
"{",
"@",
"override",
"public",
"@",
"nullable",
"t",
"from",
"json",
"(",
"json",
"reader",
"reader",
")",
"throws",
"i",
"o",
"exception",
"{",
"boolean",
"lenient",
"=",
"reader",
"is",
"lenient",
"(",
")",
";",
"reader",
"set",
"lenient",
"(",
"true",
")",
";",
"try",
"{",
"return",
"delegate",
"from",
"json",
"(",
"reader",
")",
";",
"}",
"finally",
"{",
"reader",
"set",
"lenient",
"(",
"lenient",
")",
";",
"}",
"}",
"@",
"override",
"public",
"void",
"to",
"json",
"(",
"json",
"writer",
"writer",
",",
"@",
"nullable",
"t",
"value",
")",
"throws",
"i",
"o",
"exception",
"{",
"boolean",
"lenient",
"=",
"writer",
"is",
"lenient",
"(",
")",
";",
"writer",
"set",
"lenient",
"(",
"true",
")",
";",
"try",
"{",
"delegate",
"to",
"json",
"(",
"writer",
",",
"value",
")",
";",
"}",
"finally",
"{",
"writer",
"set",
"lenient",
"(",
"lenient",
")",
";",
"}",
"}",
"@",
"override",
"boolean",
"is",
"lenient",
"(",
")",
"{",
"return",
"true",
";",
"}",
"@",
"override",
"public",
"string",
"to",
"string",
"(",
")",
"{",
"return",
"delegate",
"+",
"\"",
"lenient",
"(",
")",
"\"",
";",
"}",
"}",
";",
"}"
] |
[
"regression",
"test",
":",
"child",
"value",
"that",
"has",
"been",
"deleted",
"since",
"it",
"and",
"its",
"parent",
"were",
"marked",
"dirty",
"no",
"longer",
"knows",
"it",
"has",
"a",
"reverse",
"dep",
"on",
"its",
"parent",
"start",
"with",
":",
"top",
"0",
"top",
"1",
"0",
"0",
"0",
"\\",
"|",
"leaf",
"then",
"fail",
"to",
"build",
"leaf",
"now",
"the",
"entry",
"for",
"leaf",
"should",
"have",
"no",
"\"",
"memory",
"\"",
"that",
"it",
"was",
"ever",
"depended",
"on",
"by",
"tops",
"now",
"build",
"tops",
",",
"but",
"fail",
"again"
] |
[
"public",
"void",
"many",
"dirty",
"values",
"clear",
"children",
"on",
"second",
"fail",
"(",
")",
"throws",
"exception",
"{",
"sky",
"key",
"leaf",
"key",
"=",
"graph",
"tester",
"non",
"hermetic",
"key",
"(",
"\"",
"leaf",
"\"",
")",
";",
"tester",
"set",
"(",
"leaf",
"key",
",",
"new",
"string",
"value",
"(",
"\"",
"leafy",
"\"",
")",
")",
";",
"sky",
"key",
"last",
"key",
"=",
"graph",
"tester",
"to",
"sky",
"key",
"(",
"\"",
"last",
"\"",
")",
";",
"tester",
"set",
"(",
"last",
"key",
",",
"new",
"string",
"value",
"(",
"\"",
"last",
"\"",
")",
")",
";",
"final",
"list",
"<",
"sky",
"key",
">",
"tops",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"/",
"/",
"request",
"far",
"more",
"top",
"-",
"level",
"values",
"than",
"there",
"are",
"threads",
",",
"so",
"some",
"of",
"them",
"will",
"block",
"until",
"/",
"/",
"the",
"leaf",
"child",
"is",
"enqueued",
"for",
"processing",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"10000",
";",
"i",
"+",
"+",
")",
"{",
"sky",
"key",
"top",
"key",
"=",
"graph",
"tester",
"to",
"sky",
"key",
"(",
"\"",
"top",
"\"",
"+",
"i",
")",
";",
"tester",
"get",
"or",
"create",
"(",
"top",
"key",
")",
"add",
"dependency",
"(",
"leaf",
"key",
")",
"add",
"dependency",
"(",
"last",
"key",
")",
"set",
"computed",
"value",
"(",
"concatenate",
")",
";",
"tops",
"add",
"(",
"top",
"key",
")",
";",
"}",
"tester",
"eval",
"(",
"/",
"*",
"keep",
"going",
"=",
"*",
"/",
"false",
",",
"tops",
"to",
"array",
"(",
"new",
"sky",
"key",
"[",
"0",
"]",
")",
")",
";",
"fail",
"build",
"and",
"remove",
"value",
"(",
"leaf",
"key",
")",
";",
"/",
"/",
"request",
"the",
"tops",
"since",
"leaf",
"was",
"deleted",
"from",
"the",
"graph",
"last",
"build",
",",
"it",
"no",
"longer",
"knows",
"that",
"/",
"/",
"its",
"parents",
"depend",
"on",
"it",
"when",
"leaf",
"throws",
",",
"at",
"least",
"one",
"of",
"its",
"parents",
"(",
"hopefully",
")",
"will",
"not",
"/",
"/",
"have",
"re",
"-",
"informed",
"leaf",
"that",
"the",
"parent",
"depends",
"on",
"it",
",",
"exposing",
"the",
"bug",
",",
"since",
"the",
"parent",
"/",
"/",
"should",
"then",
"not",
"try",
"to",
"clean",
"the",
"reverse",
"dep",
"from",
"leaf",
"tester",
"set",
"(",
"leaf",
"key",
",",
"null",
")",
";",
"/",
"/",
"evaluator",
"will",
"think",
"leaf",
"was",
"interrupted",
"because",
"it",
"threw",
",",
"so",
"it",
"will",
"be",
"cleaned",
"from",
"graph",
"tester",
"get",
"or",
"create",
"(",
"leaf",
"key",
",",
"/",
"*",
"mark",
"as",
"modified",
"=",
"*",
"/",
"true",
")",
"set",
"builder",
"(",
"interrupt",
"builder",
")",
";",
"tester",
"invalidate",
"(",
")",
";",
"assert",
"throws",
"(",
"interrupted",
"exception",
"class",
",",
"(",
")",
"-",
">",
"tester",
"eval",
"(",
"/",
"*",
"keep",
"going",
"=",
"*",
"/",
"false",
",",
"tops",
"to",
"array",
"(",
"new",
"sky",
"key",
"[",
"0",
"]",
")",
")",
")",
";",
"}"
] |
[
"filters",
"this",
"object",
",",
"assuming",
"it",
"contains",
"the",
"resources",
"of",
"the",
"current",
"target",
"if",
"this",
"object",
"contains",
"the",
"resources",
"from",
"a",
"dependency",
"of",
"this",
"target",
",",
"use",
"{",
"@",
"link",
"#",
"maybe",
"filter",
"(",
"rule",
"error",
"consumer",
",",
"resource",
"filter",
",",
"boolean",
")",
"}",
"instead"
] |
[
"public",
"android",
"resources",
"filter",
"local",
"resources",
"(",
"rule",
"error",
"consumer",
"error",
"consumer",
",",
"resource",
"filter",
"resource",
"filter",
")",
"throws",
"rule",
"error",
"exception",
"{",
"optional",
"<",
"?",
"extends",
"android",
"resources",
">",
"filtered",
"=",
"maybe",
"filter",
"(",
"error",
"consumer",
",",
"resource",
"filter",
",",
"/",
"*",
"is",
"dependency",
"=",
"*",
"/",
"false",
")",
";",
"return",
"filtered",
"is",
"present",
"(",
")",
"?",
"filtered",
"get",
"(",
")",
":",
"this",
";",
"}"
] |
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
] |
[
"private",
"string",
"to",
"indented",
"string",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
] |
[
"whether",
"this",
"component",
"will",
"populate",
"any",
"accessibility",
"nodes",
"or",
"events",
"that",
"are",
"passed",
"to",
"it"
] |
[
"protected",
"boolean",
"implements",
"accessibility",
"(",
")",
"{",
"return",
"false",
";",
"}"
] |
[
"returns",
"the",
"total",
"number",
"of",
"die",
"records",
"in",
"the",
"entire",
"program"
] |
[
"public",
"int",
"get",
"total",
"d",
"i",
"e",
"count",
"(",
")",
"{",
"return",
"total",
"d",
"i",
"e",
"count",
";",
"}"
] |
[
"gets",
"the",
"original",
"bytecode",
"address"
] |
[
"public",
"int",
"get",
"address",
"(",
")",
"{",
"return",
"address",
";",
"}"
] |
[
"called",
"once",
"a",
"new",
"{",
"@",
"link",
"channel",
"}",
"is",
"created",
"in",
"the",
"{",
"@",
"link",
"channel",
"pool",
"}",
"this",
"method",
"will",
"be",
"called",
"by",
"the",
"{",
"@",
"link",
"event",
"loop",
"}",
"of",
"the",
"{",
"@",
"link",
"channel",
"}"
] |
[
"void",
"channel",
"created",
"(",
"channel",
"ch",
")",
"throws",
"exception",
";"
] |
[
"find",
"all",
"elements",
"within",
"the",
"current",
"context",
"using",
"the",
"given",
"mechanism"
] |
[
"list",
"<",
"web",
"element",
">",
"find",
"elements",
"(",
"by",
"by",
")",
";"
] |
[
"a",
"list",
"of",
"alternate",
"names",
"to",
"verify",
"the",
"subject",
"identity",
"in",
"the",
"certificate",
"presented",
"by",
"the",
"client",
"<",
"code",
">",
"repeated",
"string",
"subject",
"alt",
"names",
"=",
"6",
";",
"<",
"code",
">"
] |
[
"public",
"java",
"lang",
"string",
"get",
"subject",
"alt",
"names",
"(",
"int",
"index",
")",
"{",
"return",
"subject",
"alt",
"names",
"get",
"(",
"index",
")",
";",
"}"
] |
[
"assigns",
"a",
"single",
"split",
"when",
"assigning",
"multiple",
"splits",
",",
"it",
"is",
"more",
"efficient",
"to",
"assign",
"all",
"of",
"them",
"in",
"a",
"single",
"call",
"to",
"the",
"{",
"@",
"link",
"#",
"assign",
"splits",
"(",
"splits",
"assignment",
")",
"}",
"method"
] |
[
"default",
"void",
"assign",
"split",
"(",
"split",
"t",
"split",
",",
"int",
"subtask",
")",
"{",
"assign",
"splits",
"(",
"new",
"splits",
"assignment",
"<",
">",
"(",
"split",
",",
"subtask",
")",
")",
";",
"}"
] |
[
"creates",
"a",
"zip",
"archive",
"from",
"all",
"found",
"r",
"class",
"(",
"and",
"inner",
"class",
")",
"files"
] |
[
"public",
"static",
"void",
"create",
"class",
"jar",
"(",
"path",
"generated",
"classes",
"root",
",",
"path",
"class",
"jar",
",",
"@",
"nullable",
"string",
"target",
"label",
",",
"@",
"nullable",
"string",
"injecting",
"rule",
"kind",
")",
"{",
"try",
"{",
"files",
"create",
"directories",
"(",
"class",
"jar",
"get",
"parent",
"(",
")",
")",
";",
"try",
"(",
"final",
"zip",
"builder",
"zip",
"=",
"zip",
"builder",
"create",
"for",
"(",
"class",
"jar",
")",
")",
"{",
"class",
"jar",
"building",
"visitor",
"visitor",
"=",
"new",
"class",
"jar",
"building",
"visitor",
"(",
"zip",
",",
"generated",
"classes",
"root",
")",
";",
"files",
"walk",
"file",
"tree",
"(",
"generated",
"classes",
"root",
",",
"visitor",
")",
";",
"visitor",
"write",
"manifest",
"content",
"(",
"target",
"label",
",",
"injecting",
"rule",
"kind",
")",
";",
"visitor",
"write",
"entries",
"(",
")",
";",
"}",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"e",
")",
";",
"}",
"}"
] |
[
"test",
"the",
"property",
"'",
"id",
"'"
] |
[
"public",
"void",
"id",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"id",
"}"
] |
[
"sets",
"up",
"the",
"support",
"for",
"building",
"obj",
"c",
"any",
"partial",
"toolchain",
"line",
"will",
"be",
"merged",
"into",
"every",
"toolchain",
"stanza",
"in",
"the",
"crosstool",
"loaded",
"from",
"file"
] |
[
"public",
"static",
"void",
"setup",
"(",
"mock",
"tools",
"config",
"config",
")",
"throws",
"i",
"o",
"exception",
"{",
"for",
"(",
"string",
"tool",
":",
"immutable",
"set",
"of",
"(",
"\"",
"objc",
"dummy",
"mm",
"\"",
",",
"\"",
"gcov",
"\"",
",",
"\"",
"realpath",
"\"",
",",
"\"",
"testrunner",
"\"",
",",
"\"",
"xcrunwrapper",
"sh",
"\"",
",",
"\"",
"mcov",
"\"",
",",
"\"",
"libtool",
"\"",
")",
")",
"{",
"config",
"create",
"(",
"test",
"constants",
"tools",
"repository",
"scratch",
"+",
"\"",
"tools",
"/",
"objc",
"/",
"\"",
"+",
"tool",
")",
";",
"}",
"config",
"create",
"(",
"test",
"constants",
"tools",
"repository",
"scratch",
"+",
"\"",
"tools",
"/",
"objc",
"/",
"build",
"\"",
",",
"\"",
"package",
"(",
"default",
"visibility",
"=",
"[",
"'",
"/",
"/",
"visibility",
":",
"public",
"'",
"]",
")",
"\"",
",",
"\"",
"exports",
"files",
"(",
"glob",
"(",
"[",
"'",
"*",
"*",
"'",
"]",
")",
")",
"\"",
",",
"\"",
"filegroup",
"(",
"name",
"=",
"'",
"default",
"provisioning",
"profile",
"'",
",",
"srcs",
"=",
"[",
"'",
"foo",
"mobileprovision",
"'",
"]",
")",
"\"",
",",
"\"",
"filegroup",
"(",
"name",
"=",
"'",
"compile",
"protos",
"'",
",",
"srcs",
"=",
"[",
"'",
"compile",
"protos",
"py",
"'",
"]",
")",
"\"",
",",
"\"",
"filegroup",
"(",
"name",
"=",
"'",
"protobuf",
"compiler",
"wrapper",
"'",
",",
"srcs",
"=",
"[",
"'",
"protobuf",
"compiler",
"wrapper",
"sh",
"'",
"]",
")",
"\"",
",",
"\"",
"filegroup",
"(",
"name",
"=",
"'",
"protobuf",
"compiler",
"'",
",",
"srcs",
"=",
"[",
"'",
"protobuf",
"compiler",
"helper",
"py",
"'",
"]",
")",
"\"",
",",
"\"",
"filegroup",
"(",
"\"",
",",
"\"",
"name",
"=",
"'",
"protobuf",
"compiler",
"support",
"'",
",",
"\"",
",",
"\"",
"srcs",
"=",
"[",
"'",
"proto",
"support",
"'",
",",
"'",
"protobuf",
"compiler",
"helper",
"py",
"'",
"]",
",",
"\"",
",",
"\"",
")",
"\"",
",",
"\"",
"sh",
"binary",
"(",
"name",
"=",
"'",
"xcrunwrapper",
"'",
",",
"srcs",
"=",
"[",
"'",
"xcrunwrapper",
"sh",
"'",
"]",
")",
"\"",
",",
"\"",
"apple",
"binary",
"(",
"name",
"=",
"'",
"xctest",
"appbin",
"'",
",",
"platform",
"type",
"=",
"'",
"ios",
"'",
",",
"deps",
"=",
"[",
"'",
":",
"dummy",
"lib",
"'",
"]",
")",
"\"",
",",
"\"",
"filegroup",
"(",
"name",
"=",
"'",
"xctest",
"infoplist",
"'",
",",
"srcs",
"=",
"[",
"'",
"xctest",
"plist",
"'",
"]",
")",
"\"",
",",
"\"",
"filegroup",
"(",
"name",
"=",
"'",
"j",
"2objc",
"dead",
"code",
"pruner",
"'",
",",
"srcs",
"=",
"[",
"'",
"j",
"2objc",
"dead",
"code",
"pruner",
"py",
"'",
"]",
")",
"\"",
",",
"\"",
"filegroup",
"(",
"\"",
",",
"\"",
"name",
"=",
"'",
"protobuf",
"well",
"known",
"types",
"'",
",",
"\"",
",",
"string",
"format",
"(",
"\"",
"srcs",
"=",
"[",
"'",
"%",
"s",
"/",
"/",
"objcproto",
":",
"well",
"known",
"type",
"proto",
"'",
"]",
",",
"\"",
",",
"test",
"constants",
"tools",
"repository",
")",
",",
"\"",
")",
"\"",
",",
"\"",
"xcode",
"config",
"(",
"name",
"=",
"'",
"host",
"xcodes",
"'",
",",
"\"",
",",
"\"",
"default",
"=",
"'",
":",
"version",
"7",
"3",
"1",
"'",
",",
"\"",
",",
"\"",
"versions",
"=",
"[",
"'",
":",
"version",
"7",
"3",
"1",
"'",
",",
"'",
":",
"version",
"5",
"0",
"'",
",",
"'",
":",
"version",
"7",
"3",
"'",
",",
"'",
":",
"version",
"5",
"8",
"'",
",",
"'",
":",
"version",
"5",
"'",
"]",
")",
"\"",
",",
"\"",
"xcode",
"version",
"(",
"\"",
",",
"\"",
"name",
"=",
"'",
"version",
"7",
"3",
"1",
"'",
",",
"\"",
",",
"\"",
"version",
"=",
"'",
"\"",
"+",
"default",
"xcode",
"version",
"+",
"\"",
"'",
",",
"\"",
",",
"\"",
"default",
"ios",
"sdk",
"version",
"=",
"\\",
"\"",
"\"",
"+",
"default",
"ios",
"sdk",
"version",
"+",
"\"",
"\\",
"\"",
",",
"\"",
",",
"\"",
")",
"\"",
",",
"\"",
"xcode",
"version",
"(",
"\"",
",",
"\"",
"name",
"=",
"'",
"version",
"7",
"3",
"'",
",",
"\"",
",",
"\"",
"version",
"=",
"'",
"7",
"3",
"'",
",",
"\"",
",",
"\"",
")",
"\"",
",",
"\"",
"xcode",
"version",
"(",
"\"",
",",
"\"",
"name",
"=",
"'",
"version",
"5",
"0",
"'",
",",
"\"",
",",
"\"",
"version",
"=",
"'",
"5",
"0",
"'",
",",
"\"",
",",
"\"",
")",
"\"",
",",
"\"",
"xcode",
"version",
"(",
"\"",
",",
"\"",
"name",
"=",
"'",
"version",
"5",
"8",
"'",
",",
"\"",
",",
"\"",
"version",
"=",
"'",
"5",
"8",
"'",
",",
"\"",
",",
"\"",
")",
"\"",
",",
"\"",
"xcode",
"version",
"(",
"\"",
",",
"\"",
"name",
"=",
"'",
"version",
"5",
"'",
",",
"\"",
",",
"\"",
"version",
"=",
"'",
"5",
"'",
",",
"\"",
",",
"\"",
")",
"\"",
",",
"\"",
"objc",
"library",
"(",
"name",
"=",
"'",
"dummy",
"lib",
"'",
",",
"srcs",
"=",
"[",
"'",
"objc",
"dummy",
"mm",
"'",
"]",
")",
"\"",
",",
"\"",
"alias",
"(",
"name",
"=",
"'",
"protobuf",
"lib",
"'",
",",
"actual",
"=",
"'",
"/",
"/",
"objcproto",
":",
"protobuf",
"lib",
"'",
")",
"\"",
")",
";",
"/",
"/",
"if",
"the",
"bazel",
"tools",
"repository",
"is",
"not",
"in",
"the",
"workspace",
",",
"also",
"create",
"a",
"workspace",
"tools",
"/",
"objc",
"/",
"/",
"package",
"with",
"a",
"few",
"lingering",
"dependencies",
"/",
"/",
"todo",
"(",
"b",
"/",
"64537078",
")",
":",
"move",
"these",
"dependencies",
"underneath",
"the",
"tools",
"workspace",
"if",
"(",
"test",
"constants",
"tools",
"repository",
"scratch",
"length",
"(",
")",
">",
"0",
")",
"{",
"config",
"create",
"(",
"\"",
"tools",
"/",
"objc",
"/",
"build",
"\"",
",",
"\"",
"package",
"(",
"default",
"visibility",
"=",
"[",
"'",
"/",
"/",
"visibility",
":",
"public",
"'",
"]",
")",
"\"",
",",
"\"",
"exports",
"files",
"(",
"glob",
"(",
"[",
"'",
"*",
"*",
"'",
"]",
")",
")",
"\"",
",",
"\"",
"apple",
"binary",
"(",
"name",
"=",
"'",
"xctest",
"appbin",
"'",
",",
"platform",
"type",
"=",
"'",
"ios",
"'",
",",
"deps",
"=",
"[",
"'",
":",
"dummy",
"lib",
"'",
"]",
")",
"\"",
",",
"\"",
"filegroup",
"(",
"name",
"=",
"'",
"default",
"provisioning",
"profile",
"'",
",",
"srcs",
"=",
"[",
"'",
"foo",
"mobileprovision",
"'",
"]",
")",
"\"",
",",
"\"",
"filegroup",
"(",
"name",
"=",
"'",
"xctest",
"infoplist",
"'",
",",
"srcs",
"=",
"[",
"'",
"xctest",
"plist",
"'",
"]",
")",
"\"",
")",
";",
"}",
"config",
"create",
"(",
"test",
"constants",
"tools",
"repository",
"scratch",
"+",
"\"",
"tools",
"/",
"objc",
"/",
"foo",
"mobileprovision",
"\"",
",",
"\"",
"no",
"such",
"luck",
"\"",
")",
";",
"config",
"create",
"(",
"test",
"constants",
"tools",
"repository",
"scratch",
"+",
"\"",
"tools",
"/",
"objc",
"/",
"compile",
"protos",
"py",
"\"",
")",
";",
"config",
"create",
"(",
"test",
"constants",
"tools",
"repository",
"scratch",
"+",
"\"",
"tools",
"/",
"objc",
"/",
"xctest",
"plist",
"\"",
")",
";",
"config",
"create",
"(",
"test",
"constants",
"tools",
"repository",
"scratch",
"+",
"\"",
"tools",
"/",
"objc",
"/",
"proto",
"support",
"\"",
")",
";",
"config",
"create",
"(",
"test",
"constants",
"tools",
"repository",
"scratch",
"+",
"\"",
"tools",
"/",
"objc",
"/",
"j",
"2objc",
"dead",
"code",
"pruner",
"py",
"\"",
")",
";",
"setup",
"cc",
"toolchain",
"config",
"(",
"config",
")",
";",
"setup",
"objc",
"proto",
"(",
"config",
")",
";",
"}"
] |
[
"returns",
"the",
"encoding",
"of",
"output",
"audio"
] |
[
"public",
"@",
"c",
"encoding",
"int",
"get",
"encoding",
"(",
")",
"{",
"return",
"encoding",
";",
"}"
] |
[
"return",
"a",
"map",
"of",
"the",
"allocated",
"resources",
"the",
"map",
"key",
"is",
"the",
"resource",
"name",
",",
"and",
"the",
"value",
"is",
"the",
"resource",
"value"
] |
[
"public",
"map",
"<",
"string",
",",
"long",
">",
"get",
"allocated",
"resources",
"(",
")",
"{",
"return",
"collections",
"unmodifiable",
"map",
"(",
"allocated",
"resources",
")",
";",
"}"
] |
[
"if",
"the",
"child",
"node",
"doesn",
"'",
"t",
"exist",
",",
"it",
"is",
"created"
] |
[
"private",
"static",
"node",
"get",
"first",
"child",
"node",
"by",
"name",
"(",
"node",
"parent",
",",
"string",
"child",
")",
"{",
"node",
"list",
"child",
"nodes",
"=",
"parent",
"get",
"child",
"nodes",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"child",
"nodes",
"get",
"length",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"if",
"(",
"child",
"nodes",
"item",
"(",
"i",
")",
"get",
"node",
"name",
"(",
")",
"equals",
"(",
"child",
")",
")",
"{",
"return",
"child",
"nodes",
"item",
"(",
"i",
")",
";",
"}",
"}",
"node",
"new",
"node",
"=",
"parent",
"get",
"owner",
"document",
"(",
")",
"create",
"element",
"(",
"child",
")",
";",
"if",
"(",
"child",
"nodes",
"item",
"(",
"0",
")",
"!",
"=",
"null",
")",
"return",
"parent",
"insert",
"before",
"(",
"new",
"node",
",",
"child",
"nodes",
"item",
"(",
"0",
")",
")",
";",
"else",
"return",
"parent",
"append",
"child",
"(",
"new",
"node",
")",
";",
"}"
] |
[
"returns",
"the",
"intended",
"target",
"platform",
"value",
"based",
"on",
"options",
"defined",
"in",
"this",
"fragment"
] |
[
"public",
"label",
"compute",
"target",
"platform",
"(",
")",
"{",
"/",
"/",
"handle",
"default",
"values",
"for",
"the",
"host",
"and",
"target",
"platform",
"/",
"/",
"todo",
"(",
"https",
":",
"/",
"/",
"github",
"com",
"/",
"bazelbuild",
"/",
"bazel",
"/",
"issues",
"/",
"6849",
")",
":",
"after",
"migration",
",",
"set",
"the",
"defaults",
"/",
"/",
"directly",
"if",
"(",
"!",
"platforms",
"is",
"empty",
"(",
")",
")",
"{",
"return",
"iterables",
"get",
"first",
"(",
"platforms",
",",
"null",
")",
";",
"}",
"else",
"if",
"(",
"auto",
"configure",
"host",
"platform",
")",
"{",
"/",
"/",
"default",
"to",
"the",
"host",
"platform",
",",
"whatever",
"it",
"is",
"return",
"compute",
"host",
"platform",
"(",
")",
";",
"}",
"else",
"{",
"/",
"/",
"use",
"the",
"legacy",
"target",
"platform",
"return",
"target",
"platform",
"fallback",
";",
"}",
"}"
] |
[
"example",
"for",
"testing",
"blocking",
"unary",
"call"
] |
[
"public",
"void",
"get",
"feature",
"(",
")",
"{",
"point",
"request",
"point",
"=",
"point",
"new",
"builder",
"(",
")",
"set",
"latitude",
"(",
"-",
"1",
")",
"set",
"longitude",
"(",
"-",
"1",
")",
"build",
"(",
")",
";",
"point",
"response",
"point",
"=",
"point",
"new",
"builder",
"(",
")",
"set",
"latitude",
"(",
"-",
"123",
")",
"set",
"longitude",
"(",
"-",
"123",
")",
"build",
"(",
")",
";",
"final",
"atomic",
"reference",
"<",
"point",
">",
"point",
"delivered",
"=",
"new",
"atomic",
"reference",
"<",
"point",
">",
"(",
")",
";",
"final",
"feature",
"response",
"feature",
"=",
"feature",
"new",
"builder",
"(",
")",
"set",
"name",
"(",
"\"",
"dummy",
"feature",
"\"",
")",
"set",
"location",
"(",
"response",
"point",
")",
"build",
"(",
")",
";",
"/",
"/",
"implement",
"the",
"fake",
"service",
"route",
"guide",
"impl",
"base",
"get",
"feature",
"impl",
"=",
"new",
"route",
"guide",
"impl",
"base",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"get",
"feature",
"(",
"point",
"point",
",",
"stream",
"observer",
"<",
"feature",
">",
"response",
"observer",
")",
"{",
"point",
"delivered",
"set",
"(",
"point",
")",
";",
"response",
"observer",
"on",
"next",
"(",
"response",
"feature",
")",
";",
"response",
"observer",
"on",
"completed",
"(",
")",
";",
"}",
"}",
";",
"service",
"registry",
"add",
"service",
"(",
"get",
"feature",
"impl",
")",
";",
"client",
"get",
"feature",
"(",
"-",
"1",
",",
"-",
"1",
")",
";",
"assert",
"equals",
"(",
"request",
"point",
",",
"point",
"delivered",
"get",
"(",
")",
")",
";",
"verify",
"(",
"test",
"helper",
")",
"on",
"message",
"(",
"response",
"feature",
")",
";",
"verify",
"(",
"test",
"helper",
",",
"never",
"(",
")",
")",
"on",
"rpc",
"error",
"(",
"any",
"(",
"throwable",
"class",
")",
")",
";",
"}"
] |
[
"test",
"to",
"make",
"sure",
"release",
"1",
"2",
"0",
"support",
"concat"
] |
[
"public",
"void",
"test",
"release",
"1",
"2",
"0",
"(",
")",
"{",
"assert",
"true",
"(",
"name",
"node",
"layout",
"version",
"supports",
"(",
"layout",
"version",
"feature",
"concat",
",",
"feature",
"reserved",
"rel1",
"2",
"0",
"get",
"info",
"(",
")",
"get",
"layout",
"version",
"(",
")",
")",
")",
";",
"}"
] |
[
"gets",
"required",
"scope"
] |
[
"protected",
"abstract",
"string",
"get",
"required",
"scope",
"(",
")",
";"
] |
[
"this",
"method",
"can",
"be",
"used",
"to",
"enable",
"recursive",
"processing",
"of",
"files",
"during",
"<",
"code",
">",
"-",
"import",
"<",
"code",
">",
"or",
"<",
"code",
">",
"-",
"process",
"<",
"code",
">",
"modes",
"in",
"order",
"for",
"recursive",
"processing",
"of",
"files",
"to",
"occur",
",",
"the",
"user",
"must",
"have",
"specified",
"a",
"directory",
"(",
"and",
"not",
"a",
"specific",
"file",
")",
"for",
"the",
"headless",
"analyzer",
"to",
"import",
"or",
"process"
] |
[
"public",
"void",
"enable",
"recursive",
"processing",
"(",
"boolean",
"enabled",
")",
"{",
"this",
"recursive",
"=",
"enabled",
";",
"}"
] |
[
"，",
"\"",
"pool",
"-",
"x",
"-",
"thread",
"-",
"y",
"\""
] |
[
"public",
"static",
"thread",
"factory",
"build",
"thread",
"factory",
"(",
"@",
"not",
"null",
"string",
"thread",
"name",
"prefix",
")",
"{",
"return",
"new",
"thread",
"factory",
"builder",
"(",
")",
"set",
"name",
"format",
"(",
"thread",
"name",
"prefix",
"+",
"\"",
"-",
"%",
"d",
"\"",
")",
"build",
"(",
")",
";",
"}"
] |
[
"the",
"finalize",
"method",
"shuts",
"down",
"the",
"timer",
"this",
"is",
"a",
"fail",
"-",
"safe",
"shutdown",
",",
"in",
"case",
"the",
"original",
"shutdown",
"method",
"was",
"never",
"called",
"this",
"should",
"not",
"be",
"relied",
"upon",
"!",
"it",
"will",
"cause",
"shutdown",
"to",
"happen",
"much",
"later",
"than",
"if",
"manual",
"shutdown",
"is",
"attempted",
",",
"and",
"cause",
"threads",
"to",
"linger",
"for",
"longer",
"than",
"needed"
] |
[
"protected",
"void",
"finalize",
"(",
")",
"throws",
"throwable",
"{",
"super",
"finalize",
"(",
")",
";",
"if",
"(",
"!",
"timer",
"service",
"is",
"terminated",
"(",
")",
")",
"{",
"log",
"info",
"(",
"\"",
"timer",
"service",
"is",
"shutting",
"down",
"\"",
")",
";",
"timer",
"service",
"shutdown",
"service",
"(",
")",
";",
"}",
"cancelables",
"close",
"(",
")",
";",
"}"
] |
[
"get",
"the",
"field",
"{",
"@",
"code",
"attributes",
"}",
"(",
"along",
"with",
"{",
"@",
"code",
"attributes",
"count",
"}",
")"
] |
[
"public",
"attribute",
"list",
"get",
"attributes",
"(",
")",
";"
] |
[
"returns",
"the",
"number",
"of",
"classes",
"that",
"has",
"been",
"visited",
"so",
"far"
] |
[
"public",
"int",
"get",
"count",
"(",
")",
"{",
"return",
"count",
";",
"}"
] |
[
"gets",
"the",
"map",
"phase",
"finish",
"time"
] |
[
"public",
"long",
"get",
"map",
"finish",
"time",
"(",
")",
"{",
"return",
"map",
"finish",
"time",
";",
"}"
] |
[
"sets",
"the",
"text",
"to",
"be",
"displayed",
"on",
"tabs",
"when",
"provider",
"is",
"stacked",
"with",
"other",
"providers"
] |
[
"public",
"void",
"set",
"tab",
"text",
"(",
"string",
"tab",
"text",
")",
"{",
"this",
"tab",
"text",
"=",
"tab",
"text",
";",
"}"
] |
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
] |
[
"private",
"string",
"to",
"indented",
"string",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
] |
[
"specify",
"application",
"context",
"initializers",
"to",
"be",
"applied",
"to",
"the",
"root",
"application",
"context",
"that",
"the",
"{",
"@",
"code",
"context",
"loader",
"listener",
"}",
"is",
"being",
"created",
"with"
] |
[
"protected",
"application",
"context",
"initializer",
"<",
"?",
">",
"[",
"]",
"get",
"root",
"application",
"context",
"initializers",
"(",
")",
"{",
"return",
"null",
";",
"}"
] |
[
"(",
"-",
"d",
")",
"，",
"，"
] |
[
"public",
"static",
"double",
"get",
"double",
"(",
"string",
"property",
"name",
",",
"string",
"env",
"name",
",",
"double",
"default",
"value",
")",
"{",
"check",
"env",
"name",
"(",
"env",
"name",
")",
";",
"double",
"property",
"value",
"=",
"number",
"util",
"to",
"double",
"object",
"(",
"system",
"get",
"property",
"(",
"property",
"name",
")",
",",
"null",
")",
";",
"if",
"(",
"property",
"value",
"!",
"=",
"null",
")",
"{",
"return",
"property",
"value",
";",
"}",
"else",
"{",
"property",
"value",
"=",
"number",
"util",
"to",
"double",
"object",
"(",
"system",
"getenv",
"(",
"env",
"name",
")",
",",
"null",
")",
";",
"return",
"property",
"value",
"!",
"=",
"null",
"?",
"property",
"value",
":",
"default",
"value",
";",
"}",
"}"
] |
[
"creates",
"list",
"of",
"users",
"with",
"given",
"input",
"array",
"<",
"b",
">",
"0",
"<",
"b",
">",
"-",
"successful",
"operation"
] |
[
"public",
"void",
"create",
"users",
"with",
"list",
"input",
"(",
"list",
"<",
"user",
">",
"body",
")",
"throws",
"rest",
"client",
"exception",
"{",
"create",
"users",
"with",
"list",
"input",
"with",
"http",
"info",
"(",
"body",
")",
";",
"}"
] |
[
"sets",
"the",
"path",
"to",
"use",
"for",
"redirecting",
"stdout",
",",
"if",
"any"
] |
[
"public",
"command",
"line",
"builder",
"set",
"stdout",
"path",
"(",
"path",
"stdout",
"path",
")",
"{",
"this",
"stdout",
"path",
"=",
"stdout",
"path",
";",
"return",
"this",
";",
"}"
] |
[
"set",
"whether",
"to",
"lazily",
"initialize",
"handlers",
"only",
"applicable",
"to",
"singleton",
"handlers",
",",
"as",
"prototypes",
"are",
"always",
"lazily",
"initialized",
"default",
"is",
"\"",
"false",
"\"",
",",
"as",
"eager",
"initialization",
"allows",
"for",
"more",
"efficiency",
"through",
"referencing",
"the",
"controller",
"objects",
"directly",
"if",
"you",
"want",
"to",
"allow",
"your",
"controllers",
"to",
"be",
"lazily",
"initialized",
",",
"make",
"them",
"\"",
"lazy",
"-",
"init",
"\"",
"and",
"set",
"this",
"flag",
"to",
"true",
"just",
"making",
"them",
"\"",
"lazy",
"-",
"init",
"\"",
"will",
"not",
"work",
",",
"as",
"they",
"are",
"initialized",
"through",
"the",
"references",
"from",
"the",
"handler",
"mapping",
"in",
"this",
"case"
] |
[
"public",
"void",
"set",
"lazy",
"init",
"handlers",
"(",
"boolean",
"lazy",
"init",
"handlers",
")",
"{",
"this",
"lazy",
"init",
"handlers",
"=",
"lazy",
"init",
"handlers",
";",
"}"
] |
[
"marks",
"this",
"event",
"has",
"being",
"stopped",
"this",
"halts",
"event",
"propagation",
"any",
"other",
"listeners",
"on",
"the",
"{",
"@",
"link",
"#",
"get",
"listener",
"actor",
"(",
")",
"listener",
"actor",
"}",
"are",
"notified",
",",
"but",
"after",
"that",
"no",
"other",
"listeners",
"are",
"notified"
] |
[
"public",
"void",
"stop",
"(",
")",
"{",
"stopped",
"=",
"true",
";",
"}"
] |
[
"tests",
"that",
"config",
"keys",
"must",
"resolve",
"to",
"config",
"setting",
"targets"
] |
[
"public",
"void",
"invalid",
"config",
"key",
"(",
")",
"throws",
"exception",
"{",
"reporter",
"remove",
"handler",
"(",
"fail",
"fast",
"handler",
")",
";",
"/",
"/",
"expect",
"errors",
"scratch",
"file",
"(",
"\"",
"conditions",
"/",
"build",
"\"",
",",
"\"",
"config",
"setting",
"(",
"\"",
",",
"\"",
"name",
"=",
"'",
"a",
"'",
",",
"\"",
",",
"\"",
"values",
"=",
"{",
"'",
"test",
"arg",
"'",
":",
"'",
"a",
"'",
"}",
")",
"\"",
",",
"\"",
"rule",
"with",
"output",
"attr",
"(",
"\"",
",",
"\"",
"name",
"=",
"'",
"b",
"'",
",",
"\"",
",",
"\"",
"out",
"=",
"'",
"b",
"out",
"'",
")",
"\"",
")",
";",
"write",
"hello",
"rules",
"(",
"/",
"*",
"include",
"default",
"condition",
"=",
"*",
"/",
"true",
")",
";",
"assert",
"that",
"(",
"get",
"configured",
"target",
"(",
"\"",
"/",
"/",
"java",
"/",
"hello",
":",
"hello",
"\"",
")",
")",
"is",
"null",
"(",
")",
";",
"assert",
"contains",
"event",
"(",
"\"",
"/",
"/",
"conditions",
":",
"b",
"is",
"not",
"a",
"valid",
"select",
"(",
")",
"condition",
"for",
"/",
"/",
"java",
"/",
"hello",
":",
"hello",
"\"",
")",
";",
"assert",
"does",
"not",
"contain",
"event",
"(",
"\"",
"/",
"/",
"conditions",
":",
"a",
"\"",
")",
";",
"/",
"/",
"this",
"one",
"is",
"legitimate",
"}"
] |
[
"tests",
"that",
"the",
"slot",
"manager",
"ignores",
"slot",
"reports",
"of",
"unknown",
"origin",
"(",
"not",
"registered",
"task",
"managers",
")"
] |
[
"public",
"void",
"test",
"receiving",
"unknown",
"slot",
"report",
"(",
")",
"throws",
"exception",
"{",
"final",
"resource",
"manager",
"id",
"resource",
"manager",
"id",
"=",
"resource",
"manager",
"id",
"generate",
"(",
")",
";",
"final",
"resource",
"actions",
"resource",
"manager",
"actions",
"=",
"new",
"testing",
"resource",
"actions",
"builder",
"(",
")",
"build",
"(",
")",
";",
"final",
"instance",
"i",
"d",
"unknown",
"instance",
"i",
"d",
"=",
"new",
"instance",
"i",
"d",
"(",
")",
";",
"final",
"slot",
"i",
"d",
"unknown",
"slot",
"id",
"=",
"new",
"slot",
"i",
"d",
"(",
"resource",
"i",
"d",
"generate",
"(",
")",
",",
"0",
")",
";",
"final",
"resource",
"profile",
"unknown",
"resource",
"profile",
"=",
"resource",
"profile",
"from",
"resources",
"(",
"1",
"0",
",",
"1",
")",
";",
"final",
"slot",
"status",
"unknown",
"slot",
"status",
"=",
"new",
"slot",
"status",
"(",
"unknown",
"slot",
"id",
",",
"unknown",
"resource",
"profile",
")",
";",
"final",
"slot",
"report",
"unknown",
"slot",
"report",
"=",
"new",
"slot",
"report",
"(",
"unknown",
"slot",
"status",
")",
";",
"try",
"(",
"slot",
"manager",
"slot",
"manager",
"=",
"create",
"slot",
"manager",
"(",
"resource",
"manager",
"id",
",",
"resource",
"manager",
"actions",
")",
")",
"{",
"/",
"/",
"check",
"that",
"we",
"don",
"'",
"t",
"have",
"any",
"slots",
"registered",
"assert",
"true",
"(",
"0",
"=",
"=",
"slot",
"manager",
"get",
"number",
"registered",
"slots",
"(",
")",
")",
";",
"/",
"/",
"this",
"should",
"not",
"update",
"anything",
"since",
"the",
"instance",
"id",
"is",
"not",
"known",
"to",
"the",
"slot",
"/",
"/",
"manager",
"assert",
"false",
"(",
"slot",
"manager",
"report",
"slot",
"status",
"(",
"unknown",
"instance",
"i",
"d",
",",
"unknown",
"slot",
"report",
")",
")",
";",
"assert",
"true",
"(",
"0",
"=",
"=",
"slot",
"manager",
"get",
"number",
"registered",
"slots",
"(",
")",
")",
";",
"}",
"}"
] |
[
"whether",
"this",
"status",
"code",
"is",
"in",
"the",
"http",
"series",
"{",
"@",
"link",
"org",
"springframework",
"http",
"http",
"status",
"series",
"#",
"informational",
"}",
"this",
"is",
"a",
"shortcut",
"for",
"checking",
"the",
"value",
"of",
"{",
"@",
"link",
"#",
"series",
"(",
")",
"}"
] |
[
"public",
"boolean",
"is",
"1xx",
"informational",
"(",
")",
"{",
"return",
"(",
"series",
"(",
")",
"=",
"=",
"series",
"informational",
")",
";",
"}"
] |
[
"returns",
"to",
"sum",
"of",
"all",
"sizes",
"passed",
"to",
"{",
"@",
"link",
"stream",
"tracer",
"#",
"outbound",
"wire",
"size",
"}"
] |
[
"long",
"get",
"outbound",
"wire",
"size",
"(",
")",
";"
] |
[
"test",
"writes",
"a",
"file",
"and",
"closes",
"it",
"block",
"reported",
"is",
"generated",
"with",
"an",
"extra",
"block",
"block",
"report",
"is",
"forced",
"and",
"the",
"check",
"for",
"#",
"of",
"pendingdeletion",
"blocks",
"is",
"performed"
] |
[
"public",
"void",
"block",
"report",
"04",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"string",
"method",
"name",
"=",
"generic",
"test",
"utils",
"get",
"method",
"name",
"(",
")",
";",
"path",
"file",
"path",
"=",
"new",
"path",
"(",
"\"",
"/",
"\"",
"+",
"method",
"name",
"+",
"\"",
"dat",
"\"",
")",
";",
"d",
"f",
"s",
"test",
"util",
"create",
"file",
"(",
"fs",
",",
"file",
"path",
",",
"file",
"size",
",",
"repl",
"factor",
",",
"rand",
"next",
"long",
"(",
")",
")",
";",
"data",
"node",
"dn",
"=",
"cluster",
"get",
"data",
"nodes",
"(",
")",
"get",
"(",
"dn",
"n0",
")",
";",
"/",
"/",
"all",
"blocks",
"belong",
"to",
"the",
"same",
"file",
",",
"hence",
"same",
"bp",
"string",
"pool",
"id",
"=",
"cluster",
"get",
"namesystem",
"(",
")",
"get",
"block",
"pool",
"id",
"(",
")",
";",
"/",
"/",
"create",
"a",
"bogus",
"new",
"block",
"which",
"will",
"not",
"be",
"present",
"on",
"the",
"namenode",
"extended",
"block",
"b",
"=",
"new",
"extended",
"block",
"(",
"pool",
"id",
",",
"rand",
"next",
"long",
"(",
")",
",",
"1024l",
",",
"rand",
"next",
"long",
"(",
")",
")",
";",
"dn",
"get",
"f",
"s",
"dataset",
"(",
")",
"create",
"rbw",
"(",
"storage",
"type",
"default",
",",
"null",
",",
"b",
",",
"false",
")",
";",
"datanode",
"registration",
"dn",
"r",
"=",
"dn",
"get",
"d",
"n",
"registration",
"for",
"b",
"p",
"(",
"pool",
"id",
")",
";",
"storage",
"block",
"report",
"[",
"]",
"reports",
"=",
"get",
"block",
"reports",
"(",
"dn",
",",
"pool",
"id",
",",
"false",
",",
"false",
")",
";",
"send",
"block",
"reports",
"(",
"dn",
"r",
",",
"pool",
"id",
",",
"reports",
")",
";",
"print",
"stats",
"(",
")",
";",
"assert",
"that",
"(",
"\"",
"wrong",
"number",
"of",
"corrupt",
"blocks",
"\"",
",",
"cluster",
"get",
"namesystem",
"(",
")",
"get",
"corrupt",
"replica",
"blocks",
"(",
")",
",",
"is",
"(",
"0l",
")",
")",
";",
"assert",
"that",
"(",
"\"",
"wrong",
"number",
"of",
"pending",
"deletion",
"blocks",
"\"",
",",
"cluster",
"get",
"namesystem",
"(",
")",
"get",
"pending",
"deletion",
"blocks",
"(",
")",
",",
"is",
"(",
"1l",
")",
")",
";",
"}"
] |
[
"runs",
"the",
"given",
"runnable",
"if",
"this",
"is",
"the",
"first",
"call",
"to",
"<",
"code",
">",
"run",
"<",
"code",
">",
",",
"then",
"do",
"the",
"work",
"immediately",
";",
"otherwise",
",",
"buffer",
"the",
"request",
"until",
"the",
"timeout",
"has",
"expired",
"see",
"the",
"header",
"of",
"{",
"@",
"link",
"abstract",
"swing",
"update",
"manager",
"}",
"for",
"details",
"on",
"the",
"update",
"process"
] |
[
"public",
"synchronized",
"void",
"run",
"(",
"runnable",
"r",
")",
"{",
"this",
"next",
"runnable",
"=",
"r",
";",
"update",
"(",
")",
";",
"}"
] |
[
"prints",
"a",
"test",
"summary",
"information",
"for",
"all",
"tests",
"to",
"the",
"terminal"
] |
[
"public",
"void",
"notify",
"(",
"set",
"<",
"test",
"summary",
">",
"summaries",
",",
"int",
"number",
"of",
"executed",
"targets",
")",
"{",
"test",
"result",
"stats",
"stats",
"=",
"new",
"test",
"result",
"stats",
"(",
")",
";",
"stats",
"number",
"of",
"targets",
"=",
"summaries",
"size",
"(",
")",
";",
"stats",
"number",
"of",
"executed",
"targets",
"=",
"number",
"of",
"executed",
"targets",
";",
"execution",
"options",
"execution",
"options",
"=",
"preconditions",
"check",
"not",
"null",
"(",
"options",
"get",
"options",
"(",
"execution",
"options",
"class",
")",
")",
";",
"test",
"output",
"format",
"test",
"output",
"=",
"execution",
"options",
"test",
"output",
";",
"for",
"(",
"test",
"summary",
"summary",
":",
"summaries",
")",
"{",
"if",
"(",
"summary",
"is",
"local",
"action",
"cached",
"(",
")",
"&",
"&",
"test",
"log",
"helper",
"should",
"output",
"test",
"log",
"(",
"test",
"output",
",",
"test",
"result",
"is",
"blaze",
"test",
"status",
"passed",
"(",
"summary",
"get",
"status",
"(",
")",
")",
")",
")",
"{",
"test",
"summary",
"printer",
"print",
"cached",
"output",
"(",
"summary",
",",
"test",
"output",
",",
"printer",
",",
"test",
"log",
"path",
"formatter",
",",
"execution",
"options",
"max",
"test",
"output",
"bytes",
")",
";",
"}",
"}",
"for",
"(",
"test",
"summary",
"summary",
":",
"summaries",
")",
"{",
"if",
"(",
"test",
"result",
"is",
"blaze",
"test",
"status",
"passed",
"(",
"summary",
"get",
"status",
"(",
")",
")",
")",
"{",
"stats",
"pass",
"count",
"+",
"+",
";",
"}",
"else",
"if",
"(",
"summary",
"get",
"status",
"(",
")",
"=",
"=",
"blaze",
"test",
"status",
"no",
"status",
")",
"{",
"stats",
"no",
"status",
"count",
"+",
"+",
";",
"}",
"else",
"if",
"(",
"summary",
"get",
"status",
"(",
")",
"=",
"=",
"blaze",
"test",
"status",
"failed",
"to",
"build",
")",
"{",
"stats",
"failed",
"to",
"build",
"count",
"+",
"+",
";",
"}",
"else",
"if",
"(",
"summary",
"ran",
"remotely",
"(",
")",
")",
"{",
"stats",
"failed",
"remotely",
"count",
"+",
"+",
";",
"}",
"else",
"{",
"stats",
"failed",
"locally",
"count",
"+",
"+",
";",
"}",
"if",
"(",
"summary",
"was",
"unreported",
"wrong",
"size",
"(",
")",
")",
"{",
"stats",
"was",
"unreported",
"wrong",
"size",
"=",
"true",
";",
"}",
"stats",
"total",
"test",
"cases",
"+",
"=",
"summary",
"get",
"total",
"test",
"cases",
"(",
")",
";",
"stats",
"total",
"unknown",
"test",
"cases",
"+",
"=",
"summary",
"get",
"unkown",
"test",
"cases",
"(",
")",
";",
"stats",
"total",
"failed",
"test",
"cases",
"+",
"=",
"summary",
"get",
"failed",
"test",
"cases",
"(",
")",
"size",
"(",
")",
";",
"}",
"stats",
"failed",
"count",
"=",
"summaries",
"size",
"(",
")",
"-",
"stats",
"pass",
"count",
";",
"test",
"summary",
"format",
"test",
"summary",
"format",
"=",
"execution",
"options",
"test",
"summary",
";",
"switch",
"(",
"test",
"summary",
"format",
")",
"{",
"case",
"detailed",
":",
"print",
"summary",
"(",
"summaries",
",",
"/",
"*",
"show",
"all",
"tests",
"=",
"*",
"/",
"false",
",",
"/",
"*",
"show",
"no",
"status",
"tests",
"=",
"*",
"/",
"true",
",",
"/",
"*",
"print",
"failed",
"test",
"cases",
"=",
"*",
"/",
"true",
")",
";",
"break",
";",
"case",
"short",
":",
"print",
"summary",
"(",
"summaries",
",",
"/",
"*",
"show",
"all",
"tests",
"=",
"*",
"/",
"true",
",",
"/",
"*",
"show",
"no",
"status",
"tests",
"=",
"*",
"/",
"false",
",",
"/",
"*",
"print",
"failed",
"test",
"cases",
"=",
"*",
"/",
"false",
")",
";",
"break",
";",
"case",
"terse",
":",
"print",
"summary",
"(",
"summaries",
",",
"/",
"*",
"show",
"all",
"tests",
"=",
"*",
"/",
"false",
",",
"/",
"*",
"show",
"no",
"status",
"tests",
"=",
"*",
"/",
"false",
",",
"/",
"*",
"print",
"failed",
"test",
"cases",
"=",
"*",
"/",
"false",
")",
";",
"break",
";",
"case",
"testcase",
":",
"case",
"none",
":",
"break",
";",
"}",
"print",
"stats",
"(",
"stats",
")",
";",
"}"
] |
[
"return",
"a",
"list",
"of",
"entities",
"that",
"match",
"the",
"given",
"parameters"
] |
[
"public",
"timeline",
"entities",
"get",
"entities",
"(",
"@",
"context",
"http",
"servlet",
"request",
"req",
",",
"@",
"context",
"http",
"servlet",
"response",
"res",
",",
"@",
"path",
"param",
"(",
"\"",
"entity",
"type",
"\"",
")",
"string",
"entity",
"type",
",",
"@",
"query",
"param",
"(",
"\"",
"primary",
"filter",
"\"",
")",
"string",
"primary",
"filter",
",",
"@",
"query",
"param",
"(",
"\"",
"secondary",
"filter",
"\"",
")",
"string",
"secondary",
"filter",
",",
"@",
"query",
"param",
"(",
"\"",
"window",
"start",
"\"",
")",
"string",
"window",
"start",
",",
"@",
"query",
"param",
"(",
"\"",
"window",
"end",
"\"",
")",
"string",
"window",
"end",
",",
"@",
"query",
"param",
"(",
"\"",
"from",
"id",
"\"",
")",
"string",
"from",
"id",
",",
"@",
"query",
"param",
"(",
"\"",
"from",
"ts",
"\"",
")",
"string",
"from",
"ts",
",",
"@",
"query",
"param",
"(",
"\"",
"limit",
"\"",
")",
"string",
"limit",
",",
"@",
"query",
"param",
"(",
"\"",
"fields",
"\"",
")",
"string",
"fields",
")",
"{",
"init",
"(",
"res",
")",
";",
"try",
"{",
"return",
"timeline",
"data",
"manager",
"get",
"entities",
"(",
"parse",
"str",
"(",
"entity",
"type",
")",
",",
"parse",
"pair",
"str",
"(",
"primary",
"filter",
",",
"\"",
":",
"\"",
")",
",",
"parse",
"pairs",
"str",
"(",
"secondary",
"filter",
",",
"\"",
",",
"\"",
",",
"\"",
":",
"\"",
")",
",",
"parse",
"long",
"str",
"(",
"window",
"start",
")",
",",
"parse",
"long",
"str",
"(",
"window",
"end",
")",
",",
"parse",
"str",
"(",
"from",
"id",
")",
",",
"parse",
"long",
"str",
"(",
"from",
"ts",
")",
",",
"parse",
"long",
"str",
"(",
"limit",
")",
",",
"parse",
"fields",
"str",
"(",
"fields",
",",
"\"",
",",
"\"",
")",
",",
"get",
"user",
"(",
"req",
")",
")",
";",
"}",
"catch",
"(",
"number",
"format",
"exception",
"e",
")",
"{",
"throw",
"new",
"bad",
"request",
"exception",
"(",
"\"",
"window",
"start",
",",
"window",
"end",
",",
"from",
"ts",
"or",
"limit",
"is",
"not",
"a",
"numeric",
"value",
":",
"\"",
"+",
"e",
")",
";",
"}",
"catch",
"(",
"illegal",
"argument",
"exception",
"e",
")",
"{",
"throw",
"new",
"bad",
"request",
"exception",
"(",
"\"",
"requested",
"invalid",
"field",
":",
"\"",
"+",
"e",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"log",
"error",
"(",
"\"",
"error",
"getting",
"entities",
"\"",
",",
"e",
")",
";",
"throw",
"new",
"web",
"application",
"exception",
"(",
"e",
",",
"response",
"status",
"internal",
"server",
"error",
")",
";",
"}",
"}"
] |
[
"create",
"new",
"instance",
"of",
"command",
"packet"
] |
[
"public",
"static",
"postgre",
"s",
"q",
"l",
"command",
"packet",
"new",
"instance",
"(",
"final",
"postgre",
"s",
"q",
"l",
"command",
"packet",
"type",
"command",
"packet",
"type",
",",
"final",
"postgre",
"s",
"q",
"l",
"packet",
"payload",
"payload",
",",
"final",
"int",
"connection",
"id",
")",
"throws",
"s",
"q",
"l",
"exception",
"{",
"switch",
"(",
"command",
"packet",
"type",
")",
"{",
"case",
"query",
":",
"return",
"new",
"postgre",
"s",
"q",
"l",
"com",
"query",
"packet",
"(",
"payload",
")",
";",
"case",
"parse",
":",
"return",
"new",
"postgre",
"s",
"q",
"l",
"com",
"parse",
"packet",
"(",
"payload",
")",
";",
"case",
"bind",
":",
"return",
"new",
"postgre",
"s",
"q",
"l",
"com",
"bind",
"packet",
"(",
"payload",
",",
"connection",
"id",
")",
";",
"case",
"describe",
":",
"return",
"new",
"postgre",
"s",
"q",
"l",
"com",
"describe",
"packet",
"(",
"payload",
")",
";",
"case",
"execute",
":",
"return",
"new",
"postgre",
"s",
"q",
"l",
"com",
"execute",
"packet",
"(",
"payload",
")",
";",
"case",
"sync",
":",
"return",
"new",
"postgre",
"s",
"q",
"l",
"com",
"sync",
"packet",
"(",
"payload",
")",
";",
"case",
"terminate",
":",
"return",
"new",
"postgre",
"s",
"q",
"l",
"com",
"termination",
"packet",
"(",
"payload",
")",
";",
"default",
":",
"return",
"new",
"postgre",
"s",
"q",
"l",
"unsupported",
"command",
"packet",
"(",
"command",
"packet",
"type",
"get",
"value",
"(",
")",
")",
";",
"}",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] |
[
"public",
"boolean",
"next",
"(",
"k",
"key",
",",
"v",
"value",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"jc",
"flush",
"(",
"ivalue",
")",
")",
"{",
"writable",
"utils",
"clone",
"into",
"(",
"key",
",",
"jc",
"key",
"(",
")",
")",
";",
"writable",
"utils",
"clone",
"into",
"(",
"value",
",",
"emit",
"(",
"ivalue",
")",
")",
";",
"return",
"true",
";",
"}",
"jc",
"clear",
"(",
")",
";",
"k",
"iterkey",
"=",
"create",
"key",
"(",
")",
";",
"final",
"priority",
"queue",
"<",
"composable",
"record",
"reader",
"<",
"k",
",",
"?",
">",
">",
"q",
"=",
"get",
"record",
"reader",
"queue",
"(",
")",
";",
"while",
"(",
"!",
"q",
"is",
"empty",
"(",
")",
")",
"{",
"fill",
"join",
"collector",
"(",
"iterkey",
")",
";",
"jc",
"reset",
"(",
"iterkey",
")",
";",
"if",
"(",
"jc",
"flush",
"(",
"ivalue",
")",
")",
"{",
"writable",
"utils",
"clone",
"into",
"(",
"key",
",",
"jc",
"key",
"(",
")",
")",
";",
"writable",
"utils",
"clone",
"into",
"(",
"value",
",",
"emit",
"(",
"ivalue",
")",
")",
";",
"return",
"true",
";",
"}",
"jc",
"clear",
"(",
")",
";",
"}",
"return",
"false",
";",
"}"
] |
[
"returns",
"the",
"health",
"check",
"registry"
] |
[
"public",
"health",
"check",
"registry",
"get",
"health",
"check",
"registry",
"(",
")",
"{",
"return",
"health",
"check",
"registry",
";",
"}"
] |
[
"return",
"the",
"time",
"this",
"task",
"spent",
"being",
"run",
"if",
"the",
"task",
"is",
"still",
"running",
"or",
"has",
"not",
"yet",
"been",
"run",
",",
"returns",
"-",
"1"
] |
[
"long",
"get",
"total",
"execution",
"nanos",
"(",
")",
"{",
"if",
"(",
"start",
"time",
"nanos",
"=",
"=",
"-",
"1",
"|",
"|",
"finish",
"time",
"nanos",
"=",
"=",
"-",
"1",
")",
"{",
"/",
"/",
"there",
"must",
"have",
"been",
"an",
"exception",
"thrown",
",",
"the",
"total",
"time",
"is",
"unknown",
"(",
"-",
"1",
")",
"return",
"-",
"1",
";",
"}",
"return",
"math",
"max",
"(",
"finish",
"time",
"nanos",
"-",
"start",
"time",
"nanos",
",",
"1",
")",
";",
"}"
] |
[
"constructs",
"the",
"name",
"under",
"which",
"a",
"metric",
"(",
"or",
"metric",
"result",
")",
"is",
"registered",
"the",
"name",
"is",
"prefixed",
"with",
"evaluation",
"name",
"so",
"that",
"registered",
"names",
"are",
"unique"
] |
[
"public",
"static",
"string",
"registered",
"metric",
"name",
"(",
"parse",
"field",
"evaluation",
"name",
",",
"parse",
"field",
"metric",
"name",
")",
"{",
"return",
"registered",
"metric",
"name",
"(",
"evaluation",
"name",
"get",
"preferred",
"name",
"(",
")",
",",
"metric",
"name",
"get",
"preferred",
"name",
"(",
")",
")",
";",
"}"
] |
[
"returns",
"the",
"remainder",
"of",
"the",
"given",
"particular",
"integer",
"value",
"divided",
"by",
"this",
"integer",
"value"
] |
[
"public",
"integer",
"value",
"remainder",
"of",
"(",
"particular",
"integer",
"value",
"other",
")",
"{",
"return",
"remainder",
"of",
"(",
"(",
"specific",
"integer",
"value",
")",
"other",
")",
";",
"}"
] |
[
"get",
"detail",
"information",
"of",
"specified",
"instance"
] |
[
"public",
"object",
"node",
"detail",
"(",
"http",
"servlet",
"request",
"request",
")",
"throws",
"exception",
"{",
"string",
"namespace",
"id",
"=",
"web",
"utils",
"optional",
"(",
"request",
",",
"common",
"params",
"namespace",
"id",
",",
"constants",
"default",
"namespace",
"id",
")",
";",
"string",
"service",
"name",
"=",
"web",
"utils",
"required",
"(",
"request",
",",
"common",
"params",
"service",
"name",
")",
";",
"naming",
"utils",
"check",
"service",
"name",
"format",
"(",
"service",
"name",
")",
";",
"string",
"cluster",
"=",
"web",
"utils",
"optional",
"(",
"request",
",",
"common",
"params",
"cluster",
"name",
",",
"utils",
"and",
"commons",
"default",
"cluster",
"name",
")",
";",
"string",
"ip",
"=",
"web",
"utils",
"required",
"(",
"request",
",",
"\"",
"ip",
"\"",
")",
";",
"int",
"port",
"=",
"integer",
"parse",
"int",
"(",
"web",
"utils",
"required",
"(",
"request",
",",
"\"",
"port",
"\"",
")",
")",
";",
"service",
"service",
"=",
"service",
"manager",
"get",
"service",
"(",
"namespace",
"id",
",",
"service",
"name",
")",
";",
"if",
"(",
"service",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"nacos",
"exception",
"(",
"nacos",
"exception",
"not",
"found",
",",
"\"",
"no",
"service",
"\"",
"+",
"service",
"name",
"+",
"\"",
"found",
"!",
"\"",
")",
";",
"}",
"list",
"<",
"string",
">",
"clusters",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"clusters",
"add",
"(",
"cluster",
")",
";",
"list",
"<",
"instance",
">",
"ips",
"=",
"service",
"all",
"i",
"ps",
"(",
"clusters",
")",
";",
"if",
"(",
"ips",
"=",
"=",
"null",
"|",
"|",
"ips",
"is",
"empty",
"(",
")",
")",
"{",
"throw",
"new",
"nacos",
"exception",
"(",
"nacos",
"exception",
"not",
"found",
",",
"\"",
"no",
"ips",
"found",
"for",
"cluster",
"\"",
"+",
"cluster",
"+",
"\"",
"in",
"service",
"\"",
"+",
"service",
"name",
")",
";",
"}",
"for",
"(",
"instance",
"instance",
":",
"ips",
")",
"{",
"if",
"(",
"instance",
"get",
"ip",
"(",
")",
"equals",
"(",
"ip",
")",
"&",
"&",
"instance",
"get",
"port",
"(",
")",
"=",
"=",
"port",
")",
"{",
"object",
"node",
"result",
"=",
"jackson",
"utils",
"create",
"empty",
"json",
"node",
"(",
")",
";",
"result",
"put",
"(",
"\"",
"service",
"\"",
",",
"service",
"name",
")",
";",
"result",
"put",
"(",
"\"",
"ip",
"\"",
",",
"ip",
")",
";",
"result",
"put",
"(",
"\"",
"port",
"\"",
",",
"port",
")",
";",
"result",
"put",
"(",
"\"",
"cluster",
"name",
"\"",
",",
"cluster",
")",
";",
"result",
"put",
"(",
"\"",
"weight",
"\"",
",",
"instance",
"get",
"weight",
"(",
")",
")",
";",
"result",
"put",
"(",
"\"",
"healthy",
"\"",
",",
"instance",
"is",
"healthy",
"(",
")",
")",
";",
"result",
"put",
"(",
"\"",
"instance",
"id",
"\"",
",",
"instance",
"get",
"instance",
"id",
"(",
")",
")",
";",
"result",
"set",
"(",
"\"",
"metadata",
"\"",
",",
"jackson",
"utils",
"transfer",
"to",
"json",
"node",
"(",
"instance",
"get",
"metadata",
"(",
")",
")",
")",
";",
"return",
"result",
";",
"}",
"}",
"throw",
"new",
"nacos",
"exception",
"(",
"nacos",
"exception",
"not",
"found",
",",
"\"",
"no",
"matched",
"ip",
"found",
"!",
"\"",
")",
";",
"}"
] |
[
"get",
"a",
"singleton",
"instance",
"of",
"hash",
"function",
"of",
"a",
"type",
"defined",
"in",
"the",
"configuration"
] |
[
"public",
"static",
"hash",
"get",
"instance",
"(",
"configuration",
"conf",
")",
"{",
"int",
"type",
"=",
"get",
"hash",
"type",
"(",
"conf",
")",
";",
"return",
"get",
"instance",
"(",
"type",
")",
";",
"}"
] |
[
"find",
"the",
"fields",
"constant",
"that",
"matches",
"field",
"id",
",",
"throwing",
"an",
"exception",
"if",
"it",
"is",
"not",
"found"
] |
[
"public",
"static",
"fields",
"find",
"by",
"thrift",
"id",
"or",
"throw",
"(",
"int",
"field",
"id",
")",
"{",
"fields",
"fields",
"=",
"find",
"by",
"thrift",
"id",
"(",
"field",
"id",
")",
";",
"if",
"(",
"fields",
"=",
"=",
"null",
")",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"field",
"\"",
"+",
"field",
"id",
"+",
"\"",
"doesn",
"'",
"t",
"exist",
"!",
"\"",
")",
";",
"return",
"fields",
";",
"}"
] |
[
"invokes",
"the",
"{",
"@",
"link",
"org",
"apache",
"flink",
"api",
"java",
"closure",
"cleaner",
"}",
"on",
"the",
"given",
"function",
"if",
"closure",
"cleaning",
"is",
"enabled",
"in",
"the",
"{",
"@",
"link",
"execution",
"config",
"}"
] |
[
"protected",
"<",
"f",
">",
"f",
"clean",
"(",
"f",
"f",
")",
"{",
"return",
"get",
"execution",
"environment",
"(",
")",
"clean",
"(",
"f",
")",
";",
"}"
] |
[
"generate",
"a",
"mapping",
"update",
"for",
"the",
"given",
"root",
"object",
"mapper"
] |
[
"mapping",
"mapping",
"update",
"(",
"root",
"object",
"mapper",
"root",
"object",
"mapper",
")",
"{",
"return",
"new",
"mapping",
"(",
"root",
"object",
"mapper",
",",
"metadata",
"mappers",
",",
"meta",
")",
";",
"}"
] |
[
"non",
"failing",
"v2",
"list",
"object",
"request"
] |
[
"private",
"list",
"objects",
"v",
"2",
"result",
"inner",
"list",
"objects",
"v",
"2",
"(",
"list",
"objects",
"v",
"2",
"request",
"request",
")",
"{",
"log",
"debug",
"(",
"\"",
"prefix",
"{",
"}",
"\"",
",",
"request",
"get",
"prefix",
"(",
")",
")",
";",
"list",
"objects",
"v",
"2",
"result",
"listing",
"=",
"super",
"list",
"objects",
"v",
"2",
"(",
"request",
")",
";",
"listing",
"=",
"filter",
"list",
"objects",
"v",
"2",
"(",
"listing",
")",
";",
"listing",
"=",
"restore",
"list",
"objects",
"v",
"2",
"(",
"request",
",",
"listing",
")",
";",
"return",
"listing",
";",
"}"
] |
[
"returns",
"the",
"width",
"in",
"pixels",
"of",
"the",
"{",
"@",
"link",
"android",
"graphics",
"bitmap",
"bitmaps",
"}"
] |
[
"int",
"get",
"width",
"(",
")",
"{",
"return",
"width",
";",
"}"
] |
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
] |
[
"private",
"string",
"to",
"indented",
"string",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
] |
[
"the",
"persisted",
"global",
"checkpoint",
"for",
"the",
"shard"
] |
[
"long",
"global",
"checkpoint",
"(",
")",
";"
] |
[
"adds",
"a",
"listener",
"that",
"will",
"be",
"notified",
"when",
"the",
"job",
"queue",
"has",
"been",
"drained"
] |
[
"void",
"add",
"on",
"empty",
"queue",
"listener",
"(",
"@",
"non",
"null",
"empty",
"queue",
"listener",
"listener",
")",
"{",
"run",
"on",
"executor",
"(",
"(",
")",
"-",
">",
"{",
"synchronized",
"(",
"empty",
"queue",
"listeners",
")",
"{",
"empty",
"queue",
"listeners",
"add",
"(",
"listener",
")",
";",
"}",
"}",
")",
";",
"}"
] |
[
"returns",
"true",
"if",
"and",
"only",
"if",
"this",
"binary",
"string",
"data",
"contains",
"the",
"specified",
"sequence",
"of",
"bytes",
"values"
] |
[
"public",
"boolean",
"contains",
"(",
"final",
"binary",
"string",
"data",
"s",
")",
"{",
"ensure",
"materialized",
"(",
")",
";",
"s",
"ensure",
"materialized",
"(",
")",
";",
"if",
"(",
"s",
"binary",
"section",
"size",
"in",
"bytes",
"=",
"=",
"0",
")",
"{",
"return",
"true",
";",
"}",
"int",
"find",
"=",
"binary",
"segment",
"utils",
"find",
"(",
"binary",
"section",
"segments",
",",
"binary",
"section",
"offset",
",",
"binary",
"section",
"size",
"in",
"bytes",
",",
"s",
"binary",
"section",
"segments",
",",
"s",
"binary",
"section",
"offset",
",",
"s",
"binary",
"section",
"size",
"in",
"bytes",
")",
";",
"return",
"find",
"!",
"=",
"-",
"1",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] |
[
"public",
"boolean",
"has",
"constant",
"operation",
"(",
"rop",
"opcode",
",",
"register",
"spec",
"source",
"a",
",",
"register",
"spec",
"source",
"b",
")",
"{",
"if",
"(",
"source",
"a",
"get",
"type",
"(",
")",
"!",
"=",
"type",
"int",
")",
"{",
"return",
"false",
";",
"}",
"/",
"/",
"return",
"false",
"if",
"second",
"source",
"isn",
"'",
"t",
"a",
"constant",
"if",
"(",
"!",
"(",
"source",
"b",
"get",
"type",
"bearer",
"(",
")",
"instanceof",
"cst",
"integer",
")",
")",
"{",
"/",
"/",
"except",
"for",
"rsub",
"-",
"int",
"(",
"reverse",
"sub",
")",
"where",
"first",
"source",
"is",
"constant",
"if",
"(",
"source",
"a",
"get",
"type",
"bearer",
"(",
")",
"instanceof",
"cst",
"integer",
"&",
"&",
"opcode",
"get",
"opcode",
"(",
")",
"=",
"=",
"reg",
"ops",
"sub",
")",
"{",
"cst",
"integer",
"cst",
"=",
"(",
"cst",
"integer",
")",
"source",
"a",
"get",
"type",
"bearer",
"(",
")",
";",
"return",
"cst",
"fits",
"in",
"1",
"6",
"bits",
"(",
")",
";",
"}",
"else",
"{",
"return",
"false",
";",
"}",
"}",
"cst",
"integer",
"cst",
"=",
"(",
"cst",
"integer",
")",
"source",
"b",
"get",
"type",
"bearer",
"(",
")",
";",
"switch",
"(",
"opcode",
"get",
"opcode",
"(",
")",
")",
"{",
"/",
"/",
"these",
"have",
"8",
"and",
"16",
"bit",
"cst",
"representations",
"case",
"reg",
"ops",
"rem",
":",
"case",
"reg",
"ops",
"add",
":",
"case",
"reg",
"ops",
"mul",
":",
"case",
"reg",
"ops",
"div",
":",
"case",
"reg",
"ops",
"and",
":",
"case",
"reg",
"ops",
"or",
":",
"case",
"reg",
"ops",
"xor",
":",
"return",
"cst",
"fits",
"in",
"1",
"6",
"bits",
"(",
")",
";",
"/",
"/",
"these",
"only",
"have",
"8",
"bit",
"cst",
"reps",
"case",
"reg",
"ops",
"shl",
":",
"case",
"reg",
"ops",
"shr",
":",
"case",
"reg",
"ops",
"ushr",
":",
"return",
"cst",
"fits",
"in",
"8",
"bits",
"(",
")",
";",
"/",
"/",
"no",
"sub",
"-",
"const",
"insn",
",",
"so",
"check",
"if",
"equivalent",
"add",
"-",
"const",
"fits",
"case",
"reg",
"ops",
"sub",
":",
"cst",
"integer",
"cst",
"2",
"=",
"cst",
"integer",
"make",
"(",
"-",
"cst",
"get",
"value",
"(",
")",
")",
";",
"return",
"cst",
"2",
"fits",
"in",
"1",
"6",
"bits",
"(",
")",
";",
"default",
":",
"return",
"false",
";",
"}",
"}"
] |
[
"we",
"forbid",
"non",
"-",
"ascii",
"characters",
"in",
"outgoing",
"request",
"headers",
",",
"but",
"accept",
"utf",
"-",
"8"
] |
[
"@",
"test",
"public",
"void",
"response",
"header",
"parsing",
"is",
"lenient",
"(",
")",
"throws",
"exception",
"{",
"headers",
"builder",
"headers",
"builder",
"=",
"new",
"headers",
"builder",
"(",
")",
";",
"headers",
"builder",
"add",
"(",
"\"",
"content",
"-",
"length",
"\"",
",",
"\"",
"0",
"\"",
")",
";",
"add",
"header",
"lenient",
"(",
"headers",
"builder",
",",
"\"",
"a",
"\\",
"tb",
":",
"c",
"\\",
"u",
"0",
"0",
"7fd",
"\"",
")",
";",
"add",
"header",
"lenient",
"(",
"headers",
"builder",
",",
"\"",
":",
"ef",
"\"",
")",
";",
"add",
"header",
"lenient",
"(",
"headers",
"builder",
",",
"\"",
"\\",
"ud",
"8",
"3c",
"\\",
"udf",
"6",
"9",
":",
"\\",
"u",
"2",
"6",
"1",
"5",
"\\",
"ufe",
"0f",
"\"",
")",
";",
"headers",
"headers",
"=",
"headers",
"builder",
"build",
"(",
")",
";",
"server",
"enqueue",
"(",
"new",
"mock",
"response",
"(",
")",
"set",
"headers",
"(",
"headers",
")",
")",
";",
"execute",
"synchronously",
"(",
"\"",
"/",
"\"",
")",
"assert",
"header",
"(",
"\"",
"a",
"\\",
"tb",
"\"",
",",
"\"",
"c",
"\\",
"u",
"0",
"0",
"7fd",
"\"",
")",
"assert",
"header",
"(",
"\"",
"\\",
"ud",
"8",
"3c",
"\\",
"udf",
"6",
"9",
"\"",
",",
"\"",
"\\",
"u",
"2",
"6",
"1",
"5",
"\\",
"ufe",
"0f",
"\"",
")",
"assert",
"header",
"(",
"\"",
"\"",
",",
"\"",
"ef",
"\"",
")",
";",
"}"
] |
[
"set",
"the",
"properties",
"lists",
"by",
"the",
"new",
"instances",
"the",
"old",
"instance",
"is",
"discarded"
] |
[
"private",
"void",
"refresh",
"(",
"final",
"host",
"properties",
"host",
"properties",
")",
"{",
"synchronized",
"(",
"this",
")",
"{",
"this",
"host",
"properties",
"=",
"host",
"properties",
";",
"}",
"}"
] |
[
"builds",
"the",
"specified",
"controller"
] |
[
"public",
"abstract",
"drawee",
"controller",
"build",
"(",
")",
"{",
"validate",
"(",
")",
";",
"/",
"/",
"if",
"only",
"a",
"low",
"-",
"res",
"request",
"is",
"specified",
",",
"treat",
"it",
"as",
"a",
"final",
"request",
"if",
"(",
"m",
"image",
"request",
"=",
"=",
"null",
"&",
"&",
"m",
"multi",
"image",
"requests",
"=",
"=",
"null",
"&",
"&",
"m",
"low",
"res",
"image",
"request",
"!",
"=",
"null",
")",
"{",
"m",
"image",
"request",
"=",
"m",
"low",
"res",
"image",
"request",
";",
"m",
"low",
"res",
"image",
"request",
"=",
"null",
";",
"}",
"return",
"build",
"controller",
"(",
")",
";",
"}"
] |
[
"update",
"re",
"-",
"encryption",
"progress",
"(",
"submitted",
")",
"caller",
"should",
"log",
"sync",
"after",
"calling",
"this",
",",
"outside",
"of",
"the",
"fsn",
"lock",
"the",
"reencryption",
"status",
"is",
"updated",
"during",
"set",
"x",
"attrs"
] |
[
"static",
"x",
"attr",
"update",
"reencryption",
"submitted",
"(",
"final",
"f",
"s",
"directory",
"fsd",
",",
"final",
"i",
"nodes",
"in",
"path",
"iip",
",",
"final",
"string",
"ez",
"key",
"version",
"name",
")",
"throws",
"i",
"o",
"exception",
"{",
"assert",
"fsd",
"has",
"write",
"lock",
"(",
")",
";",
"preconditions",
"check",
"not",
"null",
"(",
"ez",
"key",
"version",
"name",
",",
"\"",
"ez",
"key",
"version",
"name",
"is",
"null",
"\"",
")",
";",
"final",
"zone",
"encryption",
"info",
"proto",
"zone",
"proto",
"=",
"get",
"zone",
"encryption",
"info",
"proto",
"(",
"iip",
")",
";",
"preconditions",
"check",
"not",
"null",
"(",
"zone",
"proto",
",",
"\"",
"zone",
"encryption",
"info",
"proto",
"is",
"null",
"\"",
")",
";",
"final",
"reencryption",
"info",
"proto",
"new",
"proto",
"=",
"p",
"b",
"helper",
"client",
"convert",
"(",
"ez",
"key",
"version",
"name",
",",
"time",
"now",
"(",
")",
",",
"false",
",",
"0",
",",
"0",
",",
"null",
",",
"null",
")",
";",
"final",
"zone",
"encryption",
"info",
"proto",
"new",
"zone",
"proto",
"=",
"p",
"b",
"helper",
"client",
"convert",
"(",
"p",
"b",
"helper",
"client",
"convert",
"(",
"zone",
"proto",
"get",
"suite",
"(",
")",
")",
",",
"p",
"b",
"helper",
"client",
"convert",
"(",
"zone",
"proto",
"get",
"crypto",
"protocol",
"version",
"(",
")",
")",
",",
"zone",
"proto",
"get",
"key",
"name",
"(",
")",
",",
"new",
"proto",
")",
";",
"final",
"x",
"attr",
"xattr",
"=",
"x",
"attr",
"helper",
"build",
"x",
"attr",
"(",
"crypto",
"xattr",
"encryption",
"zone",
",",
"new",
"zone",
"proto",
"to",
"byte",
"array",
"(",
")",
")",
";",
"final",
"list",
"<",
"x",
"attr",
">",
"xattrs",
"=",
"lists",
"new",
"array",
"list",
"with",
"capacity",
"(",
"1",
")",
";",
"xattrs",
"add",
"(",
"xattr",
")",
";",
"f",
"s",
"dir",
"x",
"attr",
"op",
"unprotected",
"set",
"x",
"attrs",
"(",
"fsd",
",",
"iip",
",",
"xattrs",
",",
"enum",
"set",
"of",
"(",
"x",
"attr",
"set",
"flag",
"replace",
")",
")",
";",
"return",
"xattr",
";",
"}"
] |
[
"indicate",
"that",
"the",
"test",
"case",
"with",
"the",
"given",
"key",
"has",
"started"
] |
[
"public",
"void",
"test",
"started",
"(",
"description",
"description",
")",
"{",
"test",
"case",
"node",
"test",
"case",
"=",
"get",
"test",
"case",
"(",
"description",
")",
";",
"if",
"(",
"test",
"case",
"!",
"=",
"null",
")",
"{",
"test",
"case",
"started",
"(",
"now",
"(",
")",
")",
";",
"test",
"property",
"runner",
"integration",
"set",
"test",
"case",
"for",
"thread",
"(",
"test",
"case",
")",
";",
"test",
"integrations",
"runner",
"integration",
"set",
"test",
"case",
"for",
"thread",
"(",
"test",
"case",
")",
";",
"}",
"}"
] |
[
"returns",
"the",
"<",
"code",
">",
"no",
"hide",
"left",
"<",
"code",
">",
"setting",
"for",
"horizontal",
"custom",
"sash",
"form"
] |
[
"public",
"boolean",
"is",
"no",
"hide",
"left",
"(",
")",
"{",
"return",
"no",
"hide",
"up",
";",
"}"
] |
[
"tests",
"{",
"@",
"link",
"selection",
"override",
"}",
"'",
"s",
"{",
"@",
"link",
"android",
"os",
"parcelable",
"}",
"implementation"
] |
[
"public",
"void",
"selection",
"override",
"parcelable",
"(",
")",
"{",
"int",
"[",
"]",
"tracks",
"=",
"new",
"int",
"[",
"]",
"{",
"2",
",",
"3",
"}",
";",
"selection",
"override",
"selection",
"override",
"to",
"parcel",
"=",
"new",
"selection",
"override",
"(",
"/",
"*",
"group",
"index",
"=",
"*",
"/",
"1",
",",
"tracks",
")",
";",
"parcel",
"parcel",
"=",
"parcel",
"obtain",
"(",
")",
";",
"selection",
"override",
"to",
"parcel",
"write",
"to",
"parcel",
"(",
"parcel",
",",
"0",
")",
";",
"parcel",
"set",
"data",
"position",
"(",
"0",
")",
";",
"selection",
"override",
"selection",
"override",
"from",
"parcel",
"=",
"selection",
"override",
"creator",
"create",
"from",
"parcel",
"(",
"parcel",
")",
";",
"assert",
"that",
"(",
"selection",
"override",
"from",
"parcel",
")",
"is",
"equal",
"to",
"(",
"selection",
"override",
"to",
"parcel",
")",
";",
"parcel",
"recycle",
"(",
")",
";",
"}"
] |
[
"return",
"the",
"jndi",
"environment",
"to",
"use",
"for",
"jndi",
"lookups"
] |
[
"public",
"properties",
"get",
"jndi",
"environment",
"(",
")",
"{",
"return",
"this",
"jndi",
"template",
"get",
"environment",
"(",
")",
";",
"}"
] |
[
"'",
"native",
"'",
"processing",
"method",
"for",
"direct",
"calls",
"with",
"an",
"arbitrary",
"target",
"instance",
",",
"resolving",
"all",
"of",
"its",
"fields",
"and",
"methods",
"which",
"are",
"annotated",
"with",
"one",
"of",
"the",
"configured",
"'",
"autowired",
"'",
"annotation",
"types"
] |
[
"public",
"void",
"process",
"injection",
"(",
"object",
"bean",
")",
"throws",
"bean",
"creation",
"exception",
"{",
"class",
"<",
"?",
">",
"clazz",
"=",
"bean",
"get",
"class",
"(",
")",
";",
"injection",
"metadata",
"metadata",
"=",
"find",
"autowiring",
"metadata",
"(",
"clazz",
"get",
"name",
"(",
")",
",",
"clazz",
",",
"null",
")",
";",
"try",
"{",
"metadata",
"inject",
"(",
"bean",
",",
"null",
",",
"null",
")",
";",
"}",
"catch",
"(",
"bean",
"creation",
"exception",
"ex",
")",
"{",
"throw",
"ex",
";",
"}",
"catch",
"(",
"throwable",
"ex",
")",
"{",
"throw",
"new",
"bean",
"creation",
"exception",
"(",
"\"",
"injection",
"of",
"autowired",
"dependencies",
"failed",
"for",
"class",
"[",
"\"",
"+",
"clazz",
"+",
"\"",
"]",
"\"",
",",
"ex",
")",
";",
"}",
"}"
] |
[
"the",
"list",
"of",
"outgoing",
"connections",
"from",
"this",
"node",
"to",
"succeeding",
"tasks"
] |
[
"public",
"list",
"<",
"dag",
"connection",
">",
"get",
"outgoing",
"connections",
"(",
")",
"{",
"return",
"this",
"outgoing",
"connections",
";",
"}"
] |
[
"determine",
"whether",
"the",
"given",
"bean",
"property",
"is",
"excluded",
"from",
"dependency",
"checks",
"this",
"implementation",
"excludes",
"properties",
"defined",
"by",
"cglib",
"and",
"properties",
"whose",
"type",
"matches",
"an",
"ignored",
"dependency",
"type",
"or",
"which",
"are",
"defined",
"by",
"an",
"ignored",
"dependency",
"interface"
] |
[
"protected",
"boolean",
"is",
"excluded",
"from",
"dependency",
"check",
"(",
"property",
"descriptor",
"pd",
")",
"{",
"return",
"(",
"autowire",
"utils",
"is",
"excluded",
"from",
"dependency",
"check",
"(",
"pd",
")",
"|",
"|",
"this",
"ignored",
"dependency",
"types",
"contains",
"(",
"pd",
"get",
"property",
"type",
"(",
")",
")",
"|",
"|",
"autowire",
"utils",
"is",
"setter",
"defined",
"in",
"interface",
"(",
"pd",
",",
"this",
"ignored",
"dependency",
"interfaces",
")",
")",
";",
"}"
] |
[
"if",
"we",
"still",
"holding",
"values",
"in",
"a",
"set",
",",
"convert",
"this",
"filter",
"into",
"an",
"approximate",
",",
"cuckoo",
"-",
"backed",
"filter",
"this",
"will",
"create",
"a",
"list",
"of",
"cuckoo",
"filters",
",",
"and",
"null",
"out",
"the",
"set",
"of",
"hashes"
] |
[
"void",
"convert",
"(",
")",
"{",
"if",
"(",
"is",
"set",
"mode",
"=",
"=",
"false",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"cannot",
"convert",
"set",
"backed",
"scaling",
"cuckoo",
"filter",
"to",
"approximate",
"\"",
"+",
"\"",
"when",
"it",
"has",
"already",
"been",
"converted",
"\"",
")",
";",
"}",
"long",
"old",
"size",
"=",
"get",
"size",
"in",
"bytes",
"(",
")",
";",
"filters",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"cuckoo",
"filter",
"t",
"=",
"new",
"cuckoo",
"filter",
"(",
"capacity",
",",
"fpp",
",",
"rng",
")",
";",
"/",
"/",
"cache",
"the",
"chosen",
"num",
"buckets",
"for",
"later",
"use",
"num",
"buckets",
"=",
"t",
"get",
"num",
"buckets",
"(",
")",
";",
"fingerprint",
"mask",
"=",
"t",
"get",
"fingerprint",
"mask",
"(",
")",
";",
"bits",
"per",
"entry",
"=",
"t",
"get",
"bits",
"per",
"entry",
"(",
")",
";",
"hashes",
"for",
"each",
"(",
"t",
":",
":",
"add",
")",
";",
"filters",
"add",
"(",
"t",
")",
";",
"hashes",
"=",
"null",
";",
"is",
"set",
"mode",
"=",
"false",
";",
"breaker",
"accept",
"(",
"-",
"old",
"size",
")",
";",
"/",
"/",
"this",
"zeros",
"out",
"the",
"overhead",
"of",
"the",
"set",
"breaker",
"accept",
"(",
"get",
"size",
"in",
"bytes",
"(",
")",
")",
";",
"/",
"/",
"this",
"adds",
"back",
"in",
"the",
"new",
"overhead",
"of",
"the",
"cuckoo",
"filters",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.