docstring_tokens
list | code_tokens
list |
|---|---|
[
"performs",
"the",
"actual",
"autodetection",
"process",
",",
"delegating",
"to",
"an",
"{",
"@",
"code",
"autodetect",
"callback",
"}",
"instance",
"to",
"vote",
"on",
"the",
"inclusion",
"of",
"a",
"given",
"bean"
]
| [
"private",
"void",
"autodetect",
"(",
"map",
"<",
"string",
",",
"object",
">",
"beans",
",",
"autodetect",
"callback",
"callback",
")",
"{",
"assert",
"state",
"(",
"this",
"bean",
"factory",
"!",
"=",
"null",
",",
"\"",
"no",
"bean",
"factory",
"set",
"\"",
")",
";",
"set",
"<",
"string",
">",
"bean",
"names",
"=",
"new",
"linked",
"hash",
"set",
"<",
">",
"(",
"this",
"bean",
"factory",
"get",
"bean",
"definition",
"count",
"(",
")",
")",
";",
"collections",
"add",
"all",
"(",
"bean",
"names",
",",
"this",
"bean",
"factory",
"get",
"bean",
"definition",
"names",
"(",
")",
")",
";",
"if",
"(",
"this",
"bean",
"factory",
"instanceof",
"configurable",
"bean",
"factory",
")",
"{",
"collections",
"add",
"all",
"(",
"bean",
"names",
",",
"(",
"(",
"configurable",
"bean",
"factory",
")",
"this",
"bean",
"factory",
")",
"get",
"singleton",
"names",
"(",
")",
")",
";",
"}",
"for",
"(",
"string",
"bean",
"name",
":",
"bean",
"names",
")",
"{",
"if",
"(",
"!",
"is",
"excluded",
"(",
"bean",
"name",
")",
"&",
"&",
"!",
"is",
"bean",
"definition",
"abstract",
"(",
"this",
"bean",
"factory",
",",
"bean",
"name",
")",
")",
"{",
"try",
"{",
"class",
"<",
"?",
">",
"bean",
"class",
"=",
"this",
"bean",
"factory",
"get",
"type",
"(",
"bean",
"name",
")",
";",
"if",
"(",
"bean",
"class",
"!",
"=",
"null",
"&",
"&",
"callback",
"include",
"(",
"bean",
"class",
",",
"bean",
"name",
")",
")",
"{",
"boolean",
"lazy",
"init",
"=",
"is",
"bean",
"definition",
"lazy",
"init",
"(",
"this",
"bean",
"factory",
",",
"bean",
"name",
")",
";",
"object",
"bean",
"instance",
"=",
"null",
";",
"if",
"(",
"!",
"lazy",
"init",
")",
"{",
"bean",
"instance",
"=",
"this",
"bean",
"factory",
"get",
"bean",
"(",
"bean",
"name",
")",
";",
"if",
"(",
"!",
"bean",
"class",
"is",
"instance",
"(",
"bean",
"instance",
")",
")",
"{",
"continue",
";",
"}",
"}",
"if",
"(",
"!",
"scoped",
"proxy",
"utils",
"is",
"scoped",
"target",
"(",
"bean",
"name",
")",
"&",
"&",
"!",
"beans",
"contains",
"value",
"(",
"bean",
"name",
")",
"&",
"&",
"(",
"bean",
"instance",
"=",
"=",
"null",
"|",
"|",
"!",
"collection",
"utils",
"contains",
"instance",
"(",
"beans",
"values",
"(",
")",
",",
"bean",
"instance",
")",
")",
")",
"{",
"/",
"/",
"not",
"already",
"registered",
"for",
"jmx",
"exposure",
"beans",
"put",
"(",
"bean",
"name",
",",
"(",
"bean",
"instance",
"!",
"=",
"null",
"?",
"bean",
"instance",
":",
"bean",
"name",
")",
")",
";",
"if",
"(",
"logger",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"logger",
"debug",
"(",
"\"",
"bean",
"with",
"name",
"'",
"\"",
"+",
"bean",
"name",
"+",
"\"",
"'",
"has",
"been",
"autodetected",
"for",
"jmx",
"exposure",
"\"",
")",
";",
"}",
"}",
"else",
"{",
"if",
"(",
"logger",
"is",
"trace",
"enabled",
"(",
")",
")",
"{",
"logger",
"trace",
"(",
"\"",
"bean",
"with",
"name",
"'",
"\"",
"+",
"bean",
"name",
"+",
"\"",
"'",
"is",
"already",
"registered",
"for",
"jmx",
"exposure",
"\"",
")",
";",
"}",
"}",
"}",
"}",
"catch",
"(",
"cannot",
"load",
"bean",
"class",
"exception",
"ex",
")",
"{",
"if",
"(",
"this",
"allow",
"eager",
"init",
")",
"{",
"throw",
"ex",
";",
"}",
"/",
"/",
"otherwise",
"ignore",
"beans",
"where",
"the",
"class",
"is",
"not",
"resolvable",
"}",
"}",
"}",
"}"
]
|
[
"the",
"interface",
"used",
"by",
"client",
"to",
"get",
"node",
"to",
"attributes",
"mappings",
"in",
"existing",
"cluster"
]
| [
"get",
"nodes",
"to",
"attributes",
"response",
"get",
"nodes",
"to",
"attributes",
"(",
"get",
"nodes",
"to",
"attributes",
"request",
"request",
")",
"throws",
"yarn",
"exception",
",",
"i",
"o",
"exception",
";"
]
|
[
"tear",
"down",
"the",
"cluster"
]
| [
"public",
"static",
"void",
"teardown",
"cluster",
"(",
")",
"throws",
"exception",
"{",
"service",
"operations",
"stop",
"quietly",
"(",
"log",
",",
"cluster",
")",
";",
"}"
]
|
[
"locates",
"a",
"file",
"resource",
"by",
"the",
"given",
"name"
]
| [
"public",
"static",
"file",
"get",
"resource",
"file",
"(",
"string",
"filename",
")",
"{",
"url",
"url",
"=",
"get",
"resource",
"(",
"filename",
")",
";",
"if",
"(",
"url",
"=",
"=",
"null",
"|",
"|",
"!",
"\"",
"file",
"\"",
"equals",
"(",
"url",
"get",
"protocol",
"(",
")",
")",
")",
"{",
"return",
"null",
";",
"}",
"try",
"{",
"uri",
"uri",
"=",
"new",
"uri",
"(",
"url",
"to",
"external",
"form",
"(",
")",
")",
";",
"return",
"new",
"file",
"(",
"uri",
")",
";",
"}",
"catch",
"(",
"u",
"r",
"i",
"syntax",
"exception",
"e",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"can",
"not",
"find",
"resource",
"\"",
"+",
"filename",
")",
";",
"}",
"}"
]
|
[
"a",
"timestamp",
"that",
"may",
"be",
"used",
"to",
"obtain",
"wall",
"time",
",",
"but",
"is",
"not",
"guaranteed",
"to",
"be",
"monotonic",
"<",
"b",
">",
"warning",
":",
"<",
"b",
">",
"the",
"returned",
"timestamp",
"is",
"not",
"guaranteed",
"to",
"be",
"monotonic",
",",
"and",
"it",
"may",
"appear",
"to",
"go",
"back",
"in",
"time",
"in",
"certain",
"cases",
"(",
"e",
"g",
"daylight",
"saving",
"time",
")"
]
| [
"abstract",
"instant",
"wall",
"time",
"(",
")",
";"
]
|
[
"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",
"\"",
")",
";",
"}"
]
|
[
"sets",
"the",
"type",
"of",
"the",
"text",
"query"
]
| [
"public",
"multi",
"match",
"query",
"builder",
"type",
"(",
"object",
"type",
")",
"{",
"if",
"(",
"type",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"[",
"\"",
"+",
"name",
"+",
"\"",
"]",
"requires",
"type",
"to",
"be",
"non",
"-",
"null",
"\"",
")",
";",
"}",
"this",
"type",
"=",
"type",
"parse",
"(",
"type",
"to",
"string",
"(",
")",
"to",
"lower",
"case",
"(",
"locale",
"root",
")",
",",
"logging",
"deprecation",
"handler",
"instance",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"show",
"that",
"bootstrapping",
"will",
"fail",
"on",
"a",
"given",
"name",
"node",
"if",
"its",
"directories",
"already",
"exist",
"its",
"not",
"run",
"across",
"all",
"the",
"nn",
"because",
"its",
"testing",
"the",
"state",
"local",
"on",
"each",
"node"
]
| [
"public",
"void",
"test",
"standby",
"dirs",
"already",
"exist",
"(",
")",
"throws",
"exception",
"{",
"/",
"/",
"should",
"not",
"pass",
"since",
"standby",
"dirs",
"exist",
",",
"force",
"not",
"given",
"int",
"rc",
"=",
"bootstrap",
"standby",
"run",
"(",
"new",
"string",
"[",
"]",
"{",
"\"",
"-",
"non",
"interactive",
"\"",
"}",
",",
"cluster",
"get",
"configuration",
"(",
"1",
")",
")",
";",
"assert",
"equals",
"(",
"bootstrap",
"standby",
"err",
"code",
"already",
"formatted",
",",
"rc",
")",
";",
"/",
"/",
"should",
"pass",
"with",
"-",
"force",
"assert",
"equals",
"(",
"0",
",",
"force",
"bootstrap",
"(",
"1",
")",
")",
";",
"}"
]
|
[
"get",
"my",
"number"
]
| [
"public",
"big",
"decimal",
"get",
"my",
"number",
"(",
")",
"{",
"return",
"my",
"number",
";",
"}"
]
|
[
"same",
"as",
"{",
"@",
"link",
"#",
"collect",
"bucket",
"(",
"leaf",
"bucket",
"collector",
",",
"int",
",",
"long",
")",
"}",
",",
"but",
"doesn",
"'",
"t",
"check",
"if",
"the",
"doc",
"counts",
"needs",
"to",
"be",
"re",
"-",
"sized"
]
| [
"public",
"final",
"void",
"collect",
"existing",
"bucket",
"(",
"leaf",
"bucket",
"collector",
"sub",
"collector",
",",
"int",
"doc",
",",
"long",
"bucket",
"ord",
")",
"throws",
"i",
"o",
"exception",
"{",
"int",
"doc",
"count",
"=",
"doc",
"count",
"provider",
"get",
"doc",
"count",
"(",
"doc",
")",
";",
"if",
"(",
"doc",
"counts",
"increment",
"(",
"bucket",
"ord",
",",
"doc",
"count",
")",
"=",
"=",
"doc",
"count",
")",
"{",
"/",
"/",
"we",
"calculate",
"the",
"final",
"number",
"of",
"buckets",
"only",
"during",
"the",
"reduce",
"phase",
"but",
"we",
"still",
"need",
"to",
"/",
"/",
"trigger",
"bucket",
"consumer",
"from",
"time",
"to",
"time",
"in",
"order",
"to",
"give",
"it",
"a",
"chance",
"to",
"check",
"available",
"memory",
"and",
"break",
"/",
"/",
"the",
"execution",
"if",
"we",
"are",
"running",
"out",
"to",
"achieve",
"that",
"we",
"are",
"passing",
"0",
"as",
"a",
"bucket",
"count",
"multi",
"bucket",
"consumer",
"accept",
"(",
"0",
")",
";",
"}",
"sub",
"collector",
"collect",
"(",
"doc",
",",
"bucket",
"ord",
")",
";",
"}"
]
|
[
"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",
"\"",
")",
";",
"}"
]
|
[
"<",
"code",
">",
"optional",
"string",
"prefix",
"=",
"1",
";",
"<",
"code",
">"
]
| [
"public",
"builder",
"set",
"prefix",
"bytes",
"(",
"com",
"google",
"protobuf",
"byte",
"string",
"value",
")",
"{",
"copy",
"on",
"write",
"(",
")",
";",
"instance",
"set",
"prefix",
"bytes",
"(",
"value",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"returns",
"the",
"language",
"used"
]
| [
"public",
"string",
"get",
"language",
"(",
")",
"{",
"return",
"language",
"to",
"string",
"(",
")",
";",
"}"
]
|
[
"assert",
"that",
"the",
"data",
"read",
"matches",
"the",
"dataset",
"at",
"the",
"given",
"offset",
"this",
"helps",
"verify",
"that",
"the",
"seek",
"process",
"is",
"moving",
"the",
"read",
"pointer",
"to",
"the",
"correct",
"location",
"in",
"the",
"file"
]
| [
"private",
"void",
"assert",
"dataset",
"equals",
"(",
"final",
"int",
"read",
"offset",
",",
"final",
"string",
"operation",
",",
"final",
"byte",
"[",
"]",
"data",
",",
"int",
"length",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"length",
";",
"i",
"+",
"+",
")",
"{",
"int",
"o",
"=",
"read",
"offset",
"+",
"i",
";",
"assert",
"equals",
"(",
"operation",
"+",
"\"",
"with",
"seek",
"policy",
"\"",
"+",
"seek",
"policy",
"+",
"\"",
"and",
"read",
"offset",
"\"",
"+",
"read",
"offset",
"+",
"\"",
":",
"data",
"[",
"\"",
"+",
"i",
"+",
"\"",
"]",
"!",
"=",
"dataset",
"[",
"\"",
"+",
"o",
"+",
"\"",
"]",
"\"",
",",
"dataset",
"[",
"o",
"]",
",",
"data",
"[",
"i",
"]",
")",
";",
"}",
"}"
]
|
[
"identical",
"to",
"{",
"@",
"link",
"platform",
"dependent",
"0",
"#",
"hash",
"code",
"ascii",
"sanitize",
"(",
"int",
")",
"}",
"but",
"for",
"{",
"@",
"link",
"char",
"sequence",
"}"
]
| [
"private",
"static",
"int",
"hash",
"code",
"ascii",
"sanitize",
"int",
"(",
"char",
"sequence",
"value",
",",
"int",
"offset",
")",
"{",
"if",
"(",
"big",
"endian",
"native",
"order",
")",
"{",
"/",
"/",
"mimic",
"a",
"unsafe",
"get",
"int",
"call",
"on",
"a",
"big",
"endian",
"machine",
"return",
"(",
"value",
"char",
"at",
"(",
"offset",
"+",
"3",
")",
"&",
"0x",
"1f",
")",
"|",
"(",
"value",
"char",
"at",
"(",
"offset",
"+",
"2",
")",
"&",
"0x",
"1f",
")",
"<",
"<",
"8",
"|",
"(",
"value",
"char",
"at",
"(",
"offset",
"+",
"1",
")",
"&",
"0x",
"1f",
")",
"<",
"<",
"16",
"|",
"(",
"value",
"char",
"at",
"(",
"offset",
")",
"&",
"0x",
"1f",
")",
"<",
"<",
"24",
";",
"}",
"return",
"(",
"value",
"char",
"at",
"(",
"offset",
"+",
"3",
")",
"&",
"0x",
"1f",
")",
"<",
"<",
"24",
"|",
"(",
"value",
"char",
"at",
"(",
"offset",
"+",
"2",
")",
"&",
"0x",
"1f",
")",
"<",
"<",
"16",
"|",
"(",
"value",
"char",
"at",
"(",
"offset",
"+",
"1",
")",
"&",
"0x",
"1f",
")",
"<",
"<",
"8",
"|",
"(",
"value",
"char",
"at",
"(",
"offset",
")",
"&",
"0x",
"1f",
")",
";",
"}"
]
|
[
"in",
"the",
"run",
"method",
"the",
"thief",
"repeatedly",
"tries",
"to",
"take",
"a",
"bean",
"until",
"none",
"are",
"left"
]
| [
"public",
"void",
"run",
"(",
")",
"{",
"var",
"beans",
"=",
"0",
";",
"while",
"(",
"jar",
"take",
"bean",
"(",
")",
")",
"{",
"beans",
"=",
"beans",
"+",
"1",
";",
"logger",
"info",
"(",
"\"",
"{",
"}",
"took",
"a",
"bean",
"\"",
",",
"name",
")",
";",
"}",
"logger",
"info",
"(",
"\"",
"{",
"}",
"took",
"{",
"}",
"beans",
"\"",
",",
"name",
",",
"beans",
")",
";",
"}"
]
|
[
"check",
"if",
"lottery",
"ticket",
"has",
"won"
]
| [
"public",
"lottery",
"ticket",
"check",
"result",
"check",
"ticket",
"for",
"prize",
"(",
"lottery",
"ticket",
"id",
"id",
",",
"lottery",
"numbers",
"winning",
"numbers",
")",
"{",
"return",
"lottery",
"utils",
"check",
"ticket",
"for",
"prize",
"(",
"repository",
",",
"id",
",",
"winning",
"numbers",
")",
";",
"}"
]
|
[
"returns",
"an",
"unmodifiable",
"view",
"of",
"the",
"specified",
"table",
"this",
"method",
"allows",
"modules",
"to",
"provide",
"users",
"with",
"\"",
"read",
"-",
"only",
"\"",
"access",
"to",
"internal",
"tables",
"query",
"operations",
"on",
"the",
"returned",
"table",
"\"",
"read",
"through",
"\"",
"to",
"the",
"specified",
"table",
",",
"and",
"attempts",
"to",
"modify",
"the",
"returned",
"table",
",",
"whether",
"direct",
"or",
"via",
"its",
"collection",
"views",
",",
"result",
"in",
"an",
"{",
"@",
"code",
"unsupported",
"operation",
"exception",
"}",
"the",
"returned",
"table",
"will",
"be",
"serializable",
"if",
"the",
"specified",
"table",
"is",
"serializable",
"consider",
"using",
"an",
"{",
"@",
"link",
"immutable",
"table",
"}",
",",
"which",
"is",
"guaranteed",
"never",
"to",
"change"
]
| [
"public",
"static",
"<",
"r",
",",
"c",
",",
"v",
">",
"table",
"<",
"r",
",",
"c",
",",
"v",
">",
"unmodifiable",
"table",
"(",
"table",
"<",
"?",
"extends",
"r",
",",
"?",
"extends",
"c",
",",
"?",
"extends",
"v",
">",
"table",
")",
"{",
"return",
"new",
"unmodifiable",
"table",
"<",
">",
"(",
"table",
")",
";",
"}"
]
|
[
"attempts",
"to",
"cancel",
"the",
"currently",
"running",
"fetcher",
"this",
"will",
"be",
"called",
"on",
"the",
"main",
"thread",
"and",
"should",
"complete",
"quickly"
]
| [
"void",
"cancel",
"(",
")",
";"
]
|
[
"creates",
"a",
"fresh",
"single",
"subject"
]
| [
"public",
"static",
"<",
"t",
">",
"single",
"subject",
"<",
"t",
">",
"create",
"(",
")",
"{",
"return",
"new",
"single",
"subject",
"<",
">",
"(",
")",
";",
"}"
]
|
[
"fires",
"the",
"latch",
"code",
"that",
"is",
"blocked",
"on",
"{",
"@",
"link",
"#",
"await",
"(",
")",
"}",
"will",
"now",
"return"
]
| [
"public",
"void",
"trigger",
"(",
")",
"{",
"synchronized",
"(",
"lock",
")",
"{",
"triggered",
"=",
"true",
";",
"lock",
"notify",
"all",
"(",
")",
";",
"}",
"}"
]
|
[
"guaranteed",
"to",
"throw",
"an",
"exception",
"and",
"leave",
"the",
"multimap",
"unmodified"
]
| [
"public",
"immutable",
"collection",
"<",
"v",
">",
"remove",
"all",
"(",
"object",
"key",
")",
"{",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
")",
";",
"}"
]
|
[
"rethrows",
"the",
"throwable",
"if",
"it",
"is",
"a",
"fatal",
"exception",
"or",
"calls",
"{",
"@",
"link",
"#",
"on",
"error",
"(",
"throwable",
")",
"}"
]
| [
"protected",
"final",
"void",
"fail",
"(",
"throwable",
"t",
")",
"{",
"exceptions",
"throw",
"if",
"fatal",
"(",
"t",
")",
";",
"upstream",
"cancel",
"(",
")",
";",
"on",
"error",
"(",
"t",
")",
";",
"}"
]
|
[
"checks",
"if",
"the",
"validation",
"is",
"successful"
]
| [
"public",
"validator",
"<",
"t",
">",
"validate",
"(",
"predicate",
"<",
"t",
">",
"validation",
",",
"string",
"message",
")",
"{",
"if",
"(",
"!",
"validation",
"test",
"(",
"obj",
")",
")",
"{",
"exceptions",
"add",
"(",
"new",
"illegal",
"state",
"exception",
"(",
"message",
")",
")",
";",
"}",
"return",
"this",
";",
"}"
]
|
[
"customize",
"the",
"supplied",
"{",
"@",
"link",
"groovy",
"object",
"}",
"for",
"example",
",",
"this",
"can",
"be",
"used",
"to",
"set",
"a",
"custom",
"metaclass",
"to",
"handle",
"missing",
"methods"
]
| [
"void",
"customize",
"(",
"groovy",
"object",
"goo",
")",
";"
]
|
[
"an",
"index",
"into",
"the",
"symbol",
"table",
"indicating",
"the",
"defined",
"external",
"symbols",
"to",
"which",
"this",
"entry",
"refers"
]
| [
"public",
"int",
"get",
"symbol",
"index",
"(",
")",
"{",
"return",
"symbol",
"index",
";",
"}"
]
|
[
"test",
"for",
"the",
"case",
"when",
"the",
"following",
"submit",
"application",
"and",
"administer",
"queue",
"a",
"c",
"ls",
"are",
"defined",
":",
"root",
":",
"(",
"all",
")",
"d",
":",
"(",
"none",
")",
"d1",
":",
"(",
"all",
")",
"expected",
"result",
":",
"access",
"to",
"d",
"will",
"be",
"permitted",
"from",
"the",
"root",
"queue",
",",
"so",
"the",
"user",
"will",
"be",
"able",
"to",
"access",
"queues",
"root",
",",
"d",
"and",
"d1"
]
| [
"public",
"void",
"test",
"queue",
"acl",
"restricted",
"d",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"update",
"config",
"with",
"d",
"and",
"d",
"1",
"queues",
"(",
"all",
"acl",
",",
"none",
"acl",
",",
"all",
"acl",
")",
";",
"check",
"access",
"(",
"true",
",",
"true",
",",
"true",
")",
";",
"}"
]
|
[
"returns",
"true",
"if",
"this",
"cache",
"entry",
"is",
"corrupted",
"and",
"should",
"be",
"ignored"
]
| [
"public",
"boolean",
"is",
"corrupted",
"(",
")",
"{",
"return",
"this",
"=",
"=",
"corrupted",
";",
"}"
]
|
[
"sets",
"the",
"progress",
"to",
"the",
"specified",
"frame",
"if",
"the",
"composition",
"isn",
"'",
"t",
"set",
"yet",
",",
"the",
"progress",
"will",
"be",
"set",
"to",
"the",
"frame",
"when",
"it",
"is"
]
| [
"public",
"void",
"set",
"frame",
"(",
"int",
"frame",
")",
"{",
"lottie",
"drawable",
"set",
"frame",
"(",
"frame",
")",
";",
"}"
]
|
[
"returns",
"an",
"unmodifiable",
"map",
"of",
"the",
"index",
"names",
"to",
"{",
"@",
"link",
"index",
"id",
"}",
"in",
"the",
"repository"
]
| [
"public",
"map",
"<",
"string",
",",
"index",
"id",
">",
"get",
"indices",
"(",
")",
"{",
"return",
"indices",
";",
"}"
]
|
[
"test",
"that",
"a",
"union",
"can",
"'",
"t",
"contain",
"another",
"union",
"that",
"contains",
"it"
]
| [
"public",
"void",
"test",
"cyclic",
"dependency",
"problem",
"4",
"(",
")",
"{",
"union",
"another",
"union",
"=",
"create",
"union",
"(",
"\"",
"another",
"union",
"\"",
")",
";",
"another",
"union",
"add",
"(",
"union",
")",
";",
"try",
"{",
"union",
"add",
"(",
"another",
"union",
")",
";",
"assert",
"fail",
"(",
"\"",
"shouldn",
"'",
"t",
"be",
"able",
"to",
"add",
"another",
"union",
",",
"which",
"contains",
"this",
"union",
",",
"to",
"this",
"union",
"\"",
")",
";",
"}",
"catch",
"(",
"illegal",
"argument",
"exception",
"e",
")",
"{",
"/",
"/",
"should",
"get",
"an",
"exception",
"from",
"adding",
"the",
"union",
"to",
"itself",
"}",
"try",
"{",
"union",
"insert",
"(",
"0",
",",
"another",
"union",
")",
";",
"assert",
"fail",
"(",
"\"",
"shouldn",
"'",
"t",
"be",
"able",
"to",
"insert",
"another",
"union",
",",
"which",
"contains",
"this",
"union",
",",
"to",
"this",
"union",
"\"",
")",
";",
"}",
"catch",
"(",
"illegal",
"argument",
"exception",
"e",
")",
"{",
"/",
"/",
"should",
"get",
"an",
"exception",
"from",
"inserting",
"the",
"union",
"to",
"itself",
"}",
"}"
]
|
[
"sets",
"a",
"custom",
"partitioner",
"for",
"the",
"co",
"group",
"operation",
"the",
"partitioner",
"will",
"be",
"called",
"on",
"the",
"join",
"keys",
"to",
"determine",
"the",
"partition",
"a",
"key",
"should",
"be",
"assigned",
"to",
"the",
"partitioner",
"is",
"evaluated",
"on",
"both",
"inputs",
"in",
"the",
"same",
"way",
"note",
":",
"a",
"custom",
"partitioner",
"can",
"only",
"be",
"used",
"with",
"single",
"-",
"field",
"co",
"group",
"keys",
",",
"not",
"with",
"composite",
"co",
"group",
"keys"
]
| [
"public",
"co",
"group",
"operator",
"<",
"i1",
",",
"i2",
",",
"out",
">",
"with",
"partitioner",
"(",
"partitioner",
"<",
"?",
">",
"partitioner",
")",
"{",
"if",
"(",
"partitioner",
"!",
"=",
"null",
")",
"{",
"keys",
"1",
"validate",
"custom",
"partitioner",
"(",
"partitioner",
",",
"null",
")",
";",
"keys",
"2",
"validate",
"custom",
"partitioner",
"(",
"partitioner",
",",
"null",
")",
";",
"}",
"this",
"custom",
"partitioner",
"=",
"get",
"input",
"1",
"(",
")",
"clean",
"(",
"partitioner",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"return",
"the",
"address",
"size",
"of",
"the",
"os",
"4",
"(",
"for",
"32",
"bits",
"systems",
")",
"and",
"8",
"(",
"for",
"64",
"bits",
"systems",
")"
]
| [
"public",
"static",
"int",
"address",
"size",
"(",
")",
"{",
"return",
"address",
"size",
";",
"}"
]
|
[
"creates",
"a",
"string",
"with",
"the",
"indicated",
"number",
"of",
"html",
"space",
"characters",
"(",
"<",
"code",
">",
"&",
"#",
"x",
"2",
"6",
";",
"nbsp",
";",
"<",
"code",
">",
")"
]
| [
"public",
"static",
"string",
"spaces",
"(",
"int",
"num",
")",
"{",
"string",
"builder",
"buf",
"=",
"new",
"string",
"builder",
"(",
"html",
"space",
"length",
"(",
")",
"*",
"num",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"num",
";",
"i",
"+",
"+",
")",
"{",
"buf",
"append",
"(",
"html",
"space",
")",
";",
"}",
"return",
"buf",
"to",
"string",
"(",
")",
";",
"}"
]
|
[
"sets",
"the",
"results",
"from",
"the",
"dialog",
"only",
"if",
"choice",
"is",
"true",
"<",
"p",
">",
"in",
"other",
"words",
",",
"if",
"the",
"user",
"selects",
"the",
"check",
"box",
",",
"then",
"the",
"result",
"will",
"be",
"saved",
"the",
",",
"whenever",
"the",
"dialog",
"is",
"\"",
"shown",
"\"",
",",
"if",
"there",
"is",
"a",
"saved",
"result",
",",
"it",
"will",
"be",
"returned",
"instead",
"of",
"actually",
"showing",
"the",
"dialog"
]
| [
"public",
"void",
"remember",
"result",
"(",
"int",
"choice",
")",
"{",
"this",
"has",
"remembered",
"result",
"=",
"true",
";",
"this",
"remembered",
"result",
"=",
"choice",
";",
"}"
]
|
[
"returns",
"a",
"{",
"@",
"code",
"top",
"k",
"selector",
"}",
"that",
"collects",
"the",
"lowest",
"{",
"@",
"code",
"k",
"}",
"elements",
"added",
"to",
"it",
",",
"relative",
"to",
"the",
"specified",
"comparator",
",",
"and",
"returns",
"them",
"via",
"{",
"@",
"link",
"#",
"top",
"k",
"}",
"in",
"ascending",
"order"
]
| [
"public",
"static",
"<",
"t",
">",
"top",
"k",
"selector",
"<",
"t",
">",
"least",
"(",
"int",
"k",
",",
"comparator",
"<",
"?",
"super",
"t",
">",
"comparator",
")",
"{",
"return",
"new",
"top",
"k",
"selector",
"<",
"t",
">",
"(",
"comparator",
",",
"k",
")",
";",
"}"
]
|
[
"sets",
"the",
"default",
"background",
"color"
]
| [
"public",
"void",
"set",
"background",
"color",
"(",
"color",
"c",
")",
"{",
"background",
"color",
"model",
"set",
"default",
"background",
"color",
"(",
"c",
")",
";",
"paint",
"context",
"set",
"default",
"background",
"color",
"(",
"c",
")",
";",
"}"
]
|
[
"handler",
"for",
"a",
"goaway",
"being",
"received",
"fails",
"any",
"streams",
"created",
"after",
"the",
"last",
"known",
"stream",
"may",
"only",
"be",
"called",
"during",
"a",
"read"
]
| [
"private",
"void",
"going",
"away",
"(",
"long",
"error",
"code",
",",
"byte",
"[",
"]",
"debug",
"data",
")",
"{",
"status",
"final",
"status",
"=",
"status",
"from",
"h",
"2",
"error",
"(",
"status",
"code",
"unavailable",
",",
"\"",
"goaway",
"shut",
"down",
"transport",
"\"",
",",
"error",
"code",
",",
"debug",
"data",
")",
";",
"lifecycle",
"manager",
"notify",
"graceful",
"shutdown",
"(",
"final",
"status",
")",
";",
"abrupt",
"go",
"away",
"status",
"=",
"status",
"from",
"h",
"2",
"error",
"(",
"status",
"code",
"unavailable",
",",
"\"",
"abrupt",
"goaway",
"closed",
"unsent",
"stream",
"\"",
",",
"error",
"code",
",",
"debug",
"data",
")",
";",
"/",
"/",
"while",
"this",
"should",
"be",
"unavailable",
",",
"netty",
"uses",
"the",
"wrong",
"stream",
"id",
"in",
"the",
"goaway",
"when",
"it",
"/",
"/",
"fails",
"streams",
"due",
"to",
"hpack",
"failures",
"(",
"e",
"g",
",",
"header",
"list",
"too",
"large",
")",
"to",
"be",
"more",
"conservative",
",",
"/",
"/",
"we",
"assume",
"any",
"sent",
"streams",
"may",
"be",
"related",
"to",
"the",
"goaway",
"this",
"should",
"rarely",
"impact",
"users",
"/",
"/",
"since",
"the",
"main",
"time",
"servers",
"should",
"use",
"abrupt",
"g",
"o",
"a",
"w",
"a",
"ys",
"is",
"if",
"there",
"is",
"a",
"protocol",
"error",
",",
"and",
"if",
"/",
"/",
"there",
"wasn",
"'",
"t",
"a",
"protocol",
"error",
"the",
"error",
"code",
"was",
"probably",
"no",
"error",
"which",
"is",
"mapped",
"to",
"/",
"/",
"unavailable",
"https",
":",
"/",
"/",
"github",
"com",
"/",
"netty",
"/",
"netty",
"/",
"issues",
"/",
"10670",
"final",
"status",
"abrupt",
"go",
"away",
"status",
"conservative",
"=",
"status",
"from",
"h",
"2",
"error",
"(",
"null",
",",
"\"",
"abrupt",
"goaway",
"closed",
"sent",
"stream",
"\"",
",",
"error",
"code",
",",
"debug",
"data",
")",
";",
"/",
"/",
"try",
"to",
"allocate",
"as",
"many",
"in",
"-",
"flight",
"streams",
"as",
"possible",
",",
"to",
"reduce",
"race",
"window",
"of",
"/",
"/",
"https",
":",
"/",
"/",
"github",
"com",
"/",
"grpc",
"/",
"grpc",
"-",
"java",
"/",
"issues",
"/",
"2562",
"to",
"be",
"of",
"any",
"help",
",",
"the",
"server",
"has",
"to",
"/",
"/",
"gracefully",
"shut",
"down",
"the",
"connection",
"with",
"two",
"g",
"o",
"a",
"w",
"a",
"ys",
"g",
"r",
"p",
"c",
"servers",
"generally",
"send",
"a",
"ping",
"/",
"/",
"after",
"the",
"first",
"goaway",
",",
"so",
"they",
"can",
"very",
"precisely",
"detect",
"when",
"the",
"goaway",
"has",
"been",
"/",
"/",
"processed",
"and",
"thus",
"this",
"processing",
"must",
"be",
"in",
"-",
"line",
"before",
"processing",
"additional",
"reads",
"/",
"/",
"this",
"can",
"cause",
"reentrancy",
",",
"but",
"should",
"be",
"minor",
"since",
"it",
"is",
"normal",
"to",
"handle",
"writes",
"in",
"/",
"/",
"response",
"to",
"a",
"read",
"also",
",",
"the",
"call",
"stack",
"is",
"rather",
"shallow",
"at",
"this",
"point",
"client",
"write",
"queue",
"drain",
"now",
"(",
")",
";",
"if",
"(",
"lifecycle",
"manager",
"notify",
"shutdown",
"(",
"final",
"status",
")",
")",
"{",
"/",
"/",
"this",
"is",
"for",
"the",
"only",
"r",
"p",
"cs",
"that",
"are",
"actually",
"covered",
"by",
"the",
"goaway",
"error",
"code",
"all",
"other",
"/",
"/",
"r",
"p",
"cs",
"were",
"not",
"observed",
"by",
"the",
"remote",
"and",
"so",
"should",
"be",
"unavailable",
"channel",
"inactive",
"reason",
"=",
"status",
"from",
"h",
"2",
"error",
"(",
"null",
",",
"\"",
"connection",
"closed",
"after",
"goaway",
"\"",
",",
"error",
"code",
",",
"debug",
"data",
")",
";",
"}",
"final",
"int",
"last",
"known",
"stream",
"=",
"connection",
"(",
")",
"local",
"(",
")",
"last",
"stream",
"known",
"by",
"peer",
"(",
")",
";",
"try",
"{",
"connection",
"(",
")",
"for",
"each",
"active",
"stream",
"(",
"new",
"http",
"2",
"stream",
"visitor",
"(",
")",
"{",
"@",
"override",
"public",
"boolean",
"visit",
"(",
"http",
"2",
"stream",
"stream",
")",
"throws",
"http",
"2",
"exception",
"{",
"if",
"(",
"stream",
"id",
"(",
")",
">",
"last",
"known",
"stream",
")",
"{",
"netty",
"client",
"stream",
"transport",
"state",
"client",
"stream",
"=",
"client",
"stream",
"(",
"stream",
")",
";",
"if",
"(",
"client",
"stream",
"!",
"=",
"null",
")",
"{",
"/",
"/",
"rpc",
"progress",
"should",
"be",
"refused",
",",
"but",
"are",
"being",
"conservative",
"see",
"comment",
"for",
"/",
"/",
"abrupt",
"go",
"away",
"status",
"conservative",
"this",
"does",
"reduce",
"our",
"ability",
"to",
"perform",
"transparent",
"/",
"/",
"retries",
",",
"but",
"our",
"main",
"goal",
"of",
"transporent",
"retries",
"is",
"to",
"resolve",
"the",
"local",
"race",
"we",
"/",
"/",
"still",
"hope",
"/",
"expect",
"servers",
"to",
"use",
"the",
"graceful",
"double",
"-",
"goaway",
"when",
"closing",
"/",
"/",
"connections",
"client",
"stream",
"transport",
"report",
"status",
"(",
"abrupt",
"go",
"away",
"status",
"conservative",
",",
"rpc",
"progress",
"processed",
",",
"false",
",",
"new",
"metadata",
"(",
")",
")",
";",
"}",
"stream",
"close",
"(",
")",
";",
"}",
"return",
"true",
";",
"}",
"}",
")",
";",
"}",
"catch",
"(",
"http",
"2",
"exception",
"e",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"e",
")",
";",
"}",
"}"
]
|
[
"commits",
"this",
"edit",
"so",
"it",
"is",
"visible",
"to",
"readers",
"this",
"releases",
"the",
"edit",
"lock",
"so",
"another",
"edit",
"may",
"be",
"started",
"on",
"the",
"same",
"key"
]
| [
"public",
"void",
"commit",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"has",
"errors",
")",
"{",
"complete",
"edit",
"(",
"this",
",",
"false",
")",
";",
"remove",
"(",
"entry",
"key",
")",
";",
"/",
"/",
"the",
"previous",
"entry",
"is",
"stale",
"}",
"else",
"{",
"complete",
"edit",
"(",
"this",
",",
"true",
")",
";",
"}",
"committed",
"=",
"true",
";",
"}"
]
|
[
"gets",
"the",
"serializer",
"for",
"the",
"keys",
"in",
"the",
"state"
]
| [
"public",
"type",
"serializer",
"<",
"uk",
">",
"get",
"key",
"serializer",
"(",
")",
"{",
"final",
"type",
"serializer",
"<",
"map",
"<",
"uk",
",",
"uv",
">",
">",
"raw",
"serializer",
"=",
"get",
"serializer",
"(",
")",
";",
"if",
"(",
"!",
"(",
"raw",
"serializer",
"instanceof",
"map",
"serializer",
")",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"unexpected",
"serializer",
"type",
"\"",
")",
";",
"}",
"return",
"(",
"(",
"map",
"serializer",
"<",
"uk",
",",
"uv",
">",
")",
"raw",
"serializer",
")",
"get",
"key",
"serializer",
"(",
")",
";",
"}"
]
|
[
"this",
"test",
"verifies",
"that",
"the",
"timestamp",
"extractor",
"forwards",
"long",
"max",
"value",
"watermarks",
"same",
"test",
"as",
"before",
",",
"but",
"using",
"a",
"different",
"timestamp",
"extractor"
]
| [
"public",
"void",
"test",
"timestamp",
"extractor",
"with",
"long",
"max",
"watermark",
"from",
"source",
"2",
"(",
")",
"throws",
"exception",
"{",
"final",
"int",
"num",
"elements",
"=",
"10",
";",
"stream",
"execution",
"environment",
"env",
"=",
"stream",
"execution",
"environment",
"get",
"execution",
"environment",
"(",
")",
";",
"env",
"get",
"config",
"(",
")",
"set",
"auto",
"watermark",
"interval",
"(",
"10",
")",
";",
"env",
"set",
"parallelism",
"(",
"2",
")",
";",
"data",
"stream",
"<",
"integer",
">",
"source",
"1",
"=",
"env",
"add",
"source",
"(",
"new",
"source",
"function",
"<",
"integer",
">",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"run",
"(",
"source",
"context",
"<",
"integer",
">",
"ctx",
")",
"throws",
"exception",
"{",
"int",
"index",
"=",
"1",
";",
"while",
"(",
"index",
"<",
"=",
"num",
"elements",
")",
"{",
"ctx",
"collect",
"with",
"timestamp",
"(",
"index",
",",
"index",
")",
";",
"ctx",
"collect",
"with",
"timestamp",
"(",
"index",
"-",
"1",
",",
"index",
"-",
"1",
")",
";",
"index",
"+",
"+",
";",
"ctx",
"emit",
"watermark",
"(",
"new",
"watermark",
"(",
"index",
"-",
"2",
")",
")",
";",
"}",
"/",
"/",
"emit",
"the",
"final",
"long",
"max",
"value",
"watermark",
",",
"do",
"it",
"twice",
"and",
"verify",
"/",
"/",
"that",
"/",
"/",
"we",
"only",
"see",
"one",
"in",
"the",
"result",
"ctx",
"emit",
"watermark",
"(",
"new",
"watermark",
"(",
"long",
"max",
"value",
")",
")",
";",
"ctx",
"emit",
"watermark",
"(",
"new",
"watermark",
"(",
"long",
"max",
"value",
")",
")",
";",
"}",
"@",
"override",
"public",
"void",
"cancel",
"(",
")",
"{",
"}",
"}",
")",
";",
"source",
"1",
"assign",
"timestamps",
"and",
"watermarks",
"(",
"new",
"assigner",
"with",
"periodic",
"watermarks",
"<",
"integer",
">",
"(",
")",
"{",
"@",
"override",
"public",
"long",
"extract",
"timestamp",
"(",
"integer",
"element",
",",
"long",
"current",
"timestamp",
")",
"{",
"return",
"element",
";",
"}",
"@",
"override",
"public",
"watermark",
"get",
"current",
"watermark",
"(",
")",
"{",
"return",
"null",
";",
"}",
"}",
")",
"transform",
"(",
"\"",
"watermark",
"check",
"\"",
",",
"basic",
"type",
"info",
"int",
"type",
"info",
",",
"new",
"custom",
"operator",
"(",
"true",
")",
")",
";",
"env",
"execute",
"(",
")",
";",
"assert",
"assert",
"true",
"(",
"custom",
"operator",
"final",
"watermarks",
"[",
"0",
"]",
"size",
"(",
")",
"=",
"=",
"1",
")",
";",
"assert",
"assert",
"true",
"(",
"custom",
"operator",
"final",
"watermarks",
"[",
"0",
"]",
"get",
"(",
"0",
")",
"get",
"timestamp",
"(",
")",
"=",
"=",
"long",
"max",
"value",
")",
";",
"}"
]
|
[
"applies",
"this",
"function",
"to",
"two",
"inputs",
",",
"or",
"throws",
"an",
"exception",
"if",
"unable",
"to",
"do",
"so",
"any",
"objects",
"that",
"are",
"passed",
"to",
"{",
"@",
"link",
"deferred",
"closer",
"#",
"eventually",
"close",
"(",
"closeable",
",",
"executor",
")",
"closer",
"eventually",
"close",
"(",
")",
"}",
"will",
"be",
"closed",
"when",
"the",
"{",
"@",
"link",
"closing",
"future",
"}",
"pipeline",
"is",
"done",
"(",
"but",
"not",
"before",
"this",
"method",
"completes",
")",
",",
"even",
"if",
"this",
"method",
"throws",
"or",
"the",
"pipeline",
"is",
"cancelled"
]
| [
"u",
"apply",
"(",
"deferred",
"closer",
"closer",
",",
"@",
"nullable",
"decl",
"v1",
"value",
"1",
",",
"@",
"nullable",
"decl",
"v2",
"value",
"2",
")",
"throws",
"exception",
";"
]
|
[
"sorts",
"the",
"specified",
"range",
"of",
"elements",
"using",
"the",
"specified",
"swapper",
"and",
"according",
"to",
"the",
"order",
"induced",
"by",
"the",
"specified",
"comparator",
"using",
"quick",
"sort",
"<",
"p",
">",
"the",
"sorting",
"algorithm",
"is",
"a",
"tuned",
"quick",
"sort",
"adapted",
"from",
"jon",
"l",
"bentley",
"and",
"m",
"douglas",
"mc",
"ilroy",
",",
"&",
"ldquo",
";",
"engineering",
"a",
"sort",
"function",
"&",
"rdquo",
";",
",",
"software",
":",
"practice",
"and",
"experience",
",",
"23",
"(",
"11",
")",
",",
"pages",
"1249",
"&",
"minus",
";",
"1265",
",",
"1993"
]
| [
"private",
"void",
"quick",
"sort",
"(",
"pages",
"index",
"pages",
"index",
",",
"int",
"from",
",",
"int",
"to",
")",
"{",
"int",
"len",
"=",
"to",
"-",
"from",
";",
"/",
"/",
"insertion",
"sort",
"on",
"smallest",
"arrays",
"if",
"(",
"len",
"<",
"small",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"from",
";",
"i",
"<",
"to",
";",
"i",
"+",
"+",
")",
"{",
"for",
"(",
"int",
"j",
"=",
"i",
";",
"j",
">",
"from",
"&",
"&",
"(",
"comparator",
"compare",
"to",
"(",
"pages",
"index",
",",
"j",
"-",
"1",
",",
"j",
")",
">",
"0",
")",
";",
"j",
"-",
"-",
")",
"{",
"pages",
"index",
"swap",
"(",
"j",
",",
"j",
"-",
"1",
")",
";",
"}",
"}",
"return",
";",
"}",
"/",
"/",
"choose",
"a",
"partition",
"element",
",",
"v",
"int",
"m",
"=",
"from",
"+",
"len",
"/",
"2",
";",
"/",
"/",
"small",
"arrays",
",",
"middle",
"element",
"if",
"(",
"len",
">",
"small",
")",
"{",
"int",
"l",
"=",
"from",
";",
"int",
"n",
"=",
"to",
"-",
"1",
";",
"if",
"(",
"len",
">",
"medium",
")",
"{",
"/",
"/",
"big",
"arrays",
",",
"pseudomedian",
"of",
"9",
"int",
"s",
"=",
"len",
"/",
"8",
";",
"l",
"=",
"median",
"3",
"(",
"pages",
"index",
",",
"l",
",",
"l",
"+",
"s",
",",
"l",
"+",
"2",
"*",
"s",
")",
";",
"m",
"=",
"median",
"3",
"(",
"pages",
"index",
",",
"m",
"-",
"s",
",",
"m",
",",
"m",
"+",
"s",
")",
";",
"n",
"=",
"median",
"3",
"(",
"pages",
"index",
",",
"n",
"-",
"2",
"*",
"s",
",",
"n",
"-",
"s",
",",
"n",
")",
";",
"}",
"m",
"=",
"median",
"3",
"(",
"pages",
"index",
",",
"l",
",",
"m",
",",
"n",
")",
";",
"/",
"/",
"mid",
"-",
"size",
",",
"med",
"of",
"3",
"}",
"/",
"/",
"int",
"v",
"=",
"x",
"[",
"m",
"]",
";",
"int",
"a",
"=",
"from",
";",
"int",
"b",
"=",
"a",
";",
"int",
"c",
"=",
"to",
"-",
"1",
";",
"/",
"/",
"establish",
"invariant",
":",
"v",
"*",
"(",
"<",
"v",
")",
"*",
"(",
">",
"v",
")",
"*",
"v",
"*",
"int",
"d",
"=",
"c",
";",
"while",
"(",
"true",
")",
"{",
"int",
"comparison",
";",
"while",
"(",
"b",
"<",
"=",
"c",
"&",
"&",
"(",
"(",
"comparison",
"=",
"comparator",
"compare",
"to",
"(",
"pages",
"index",
",",
"b",
",",
"m",
")",
")",
"<",
"=",
"0",
")",
")",
"{",
"if",
"(",
"comparison",
"=",
"=",
"0",
")",
"{",
"if",
"(",
"a",
"=",
"=",
"m",
")",
"{",
"m",
"=",
"b",
";",
"/",
"/",
"moving",
"target",
";",
"delta",
"to",
"jdk",
"!",
"!",
"!",
"}",
"else",
"if",
"(",
"b",
"=",
"=",
"m",
")",
"{",
"m",
"=",
"a",
";",
"/",
"/",
"moving",
"target",
";",
"delta",
"to",
"jdk",
"!",
"!",
"!",
"}",
"pages",
"index",
"swap",
"(",
"a",
"+",
"+",
",",
"b",
")",
";",
"}",
"b",
"+",
"+",
";",
"}",
"while",
"(",
"c",
">",
"=",
"b",
"&",
"&",
"(",
"(",
"comparison",
"=",
"comparator",
"compare",
"to",
"(",
"pages",
"index",
",",
"c",
",",
"m",
")",
")",
">",
"=",
"0",
")",
")",
"{",
"if",
"(",
"comparison",
"=",
"=",
"0",
")",
"{",
"if",
"(",
"c",
"=",
"=",
"m",
")",
"{",
"m",
"=",
"d",
";",
"/",
"/",
"moving",
"target",
";",
"delta",
"to",
"jdk",
"!",
"!",
"!",
"}",
"else",
"if",
"(",
"d",
"=",
"=",
"m",
")",
"{",
"m",
"=",
"c",
";",
"/",
"/",
"moving",
"target",
";",
"delta",
"to",
"jdk",
"!",
"!",
"!",
"}",
"pages",
"index",
"swap",
"(",
"c",
",",
"d",
"-",
"-",
")",
";",
"}",
"c",
"-",
"-",
";",
"}",
"if",
"(",
"b",
">",
"c",
")",
"{",
"break",
";",
"}",
"if",
"(",
"b",
"=",
"=",
"m",
")",
"{",
"m",
"=",
"d",
";",
"/",
"/",
"moving",
"target",
";",
"delta",
"to",
"jdk",
"!",
"!",
"!",
"}",
"else",
"if",
"(",
"c",
"=",
"=",
"m",
")",
"{",
"m",
"=",
"c",
";",
"/",
"/",
"moving",
"target",
";",
"delta",
"to",
"jdk",
"!",
"!",
"!",
"}",
"pages",
"index",
"swap",
"(",
"b",
"+",
"+",
",",
"c",
"-",
"-",
")",
";",
"}",
"/",
"/",
"swap",
"partition",
"elements",
"back",
"to",
"middle",
"int",
"s",
";",
"int",
"n",
"=",
"to",
";",
"s",
"=",
"math",
"min",
"(",
"a",
"-",
"from",
",",
"b",
"-",
"a",
")",
";",
"vector",
"swap",
"(",
"pages",
"index",
",",
"from",
",",
"b",
"-",
"s",
",",
"s",
")",
";",
"s",
"=",
"math",
"min",
"(",
"d",
"-",
"c",
",",
"n",
"-",
"d",
"-",
"1",
")",
";",
"vector",
"swap",
"(",
"pages",
"index",
",",
"b",
",",
"n",
"-",
"s",
",",
"s",
")",
";",
"/",
"/",
"recursively",
"sort",
"non",
"-",
"partition",
"-",
"elements",
"if",
"(",
"(",
"s",
"=",
"b",
"-",
"a",
")",
">",
"1",
")",
"{",
"quick",
"sort",
"(",
"pages",
"index",
",",
"from",
",",
"from",
"+",
"s",
")",
";",
"}",
"if",
"(",
"(",
"s",
"=",
"d",
"-",
"c",
")",
">",
"1",
")",
"{",
"quick",
"sort",
"(",
"pages",
"index",
",",
"n",
"-",
"s",
",",
"n",
")",
";",
"}",
"}"
]
|
[
"ensures",
"the",
"cluster",
"is",
"healthy",
"after",
"the",
"disruption"
]
| [
"public",
"void",
"ensure",
"healthy",
"(",
"internal",
"test",
"cluster",
"cluster",
")",
"{",
"assert",
"active",
"disruption",
"=",
"=",
"false",
";",
"ensure",
"node",
"count",
"(",
"cluster",
")",
";",
"ensure",
"fully",
"connected",
"cluster",
"(",
"cluster",
")",
";",
"}"
]
|
[
"returns",
"the",
"current",
"wizard",
"panel"
]
| [
"public",
"wizard",
"panel",
"get",
"current",
"wizard",
"panel",
"(",
")",
"{",
"return",
"curr",
"wiz",
"panel",
";",
"}"
]
|
[
"find",
"purchase",
"order",
"by",
"id",
"for",
"valid",
"response",
"try",
"integer",
"i",
"ds",
"with",
"value",
"&",
"lt",
";",
"&",
"#",
"x",
"3",
"d",
";",
"5",
"or",
"&",
"gt",
";",
"10",
"other",
"values",
"will",
"generated",
"exceptions"
]
| [
"public",
"order",
"get",
"order",
"by",
"id",
"(",
"long",
"order",
"id",
")",
"throws",
"api",
"exception",
"{",
"object",
"local",
"var",
"post",
"body",
"=",
"null",
";",
"/",
"/",
"verify",
"the",
"required",
"parameter",
"'",
"order",
"id",
"'",
"is",
"set",
"if",
"(",
"order",
"id",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"api",
"exception",
"(",
"400",
",",
"\"",
"missing",
"the",
"required",
"parameter",
"'",
"order",
"id",
"'",
"when",
"calling",
"get",
"order",
"by",
"id",
"\"",
")",
";",
"}",
"/",
"/",
"create",
"path",
"and",
"map",
"variables",
"string",
"local",
"var",
"path",
"=",
"\"",
"/",
"store",
"/",
"order",
"/",
"{",
"order",
"id",
"}",
"\"",
"replace",
"all",
"(",
"\"",
"\\",
"\\",
"{",
"format",
"\\",
"\\",
"}",
"\"",
",",
"\"",
"json",
"\"",
")",
"replace",
"all",
"(",
"\"",
"\\",
"\\",
"{",
"\"",
"+",
"\"",
"order",
"id",
"\"",
"+",
"\"",
"\\",
"\\",
"}",
"\"",
",",
"api",
"invoker",
"escape",
"string",
"(",
"order",
"id",
"to",
"string",
"(",
")",
")",
")",
";",
"/",
"/",
"query",
"params",
"list",
"<",
"pair",
">",
"local",
"var",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
"pair",
">",
"(",
")",
";",
"/",
"/",
"header",
"params",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"header",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"/",
"/",
"form",
"params",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"form",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"string",
"[",
"]",
"local",
"var",
"content",
"types",
"=",
"{",
"}",
";",
"string",
"local",
"var",
"content",
"type",
"=",
"local",
"var",
"content",
"types",
"length",
">",
"0",
"?",
"local",
"var",
"content",
"types",
"[",
"0",
"]",
":",
"\"",
"application",
"/",
"json",
"\"",
";",
"if",
"(",
"local",
"var",
"content",
"type",
"starts",
"with",
"(",
"\"",
"multipart",
"/",
"form",
"-",
"data",
"\"",
")",
")",
"{",
"/",
"/",
"file",
"uploading",
"multipart",
"entity",
"builder",
"local",
"var",
"builder",
"=",
"multipart",
"entity",
"builder",
"create",
"(",
")",
";",
"local",
"var",
"post",
"body",
"=",
"local",
"var",
"builder",
"build",
"(",
")",
";",
"}",
"else",
"{",
"/",
"/",
"normal",
"form",
"params",
"}",
"try",
"{",
"string",
"local",
"var",
"response",
"=",
"api",
"invoker",
"invoke",
"a",
"p",
"i",
"(",
"base",
"path",
",",
"local",
"var",
"path",
",",
"\"",
"get",
"\"",
",",
"local",
"var",
"query",
"params",
",",
"local",
"var",
"post",
"body",
",",
"local",
"var",
"header",
"params",
",",
"local",
"var",
"form",
"params",
",",
"local",
"var",
"content",
"type",
")",
";",
"if",
"(",
"local",
"var",
"response",
"!",
"=",
"null",
")",
"{",
"return",
"(",
"order",
")",
"api",
"invoker",
"deserialize",
"(",
"local",
"var",
"response",
",",
"\"",
"\"",
",",
"order",
"class",
")",
";",
"}",
"else",
"{",
"return",
"null",
";",
"}",
"}",
"catch",
"(",
"api",
"exception",
"ex",
")",
"{",
"throw",
"ex",
";",
"}",
"}"
]
|
[
"add",
"an",
"attribute",
"for",
"a",
"transactional",
"method",
"method",
"names",
"can",
"end",
"or",
"start",
"with",
"\"",
"\"",
"for",
"matching",
"multiple",
"methods"
]
| [
"public",
"void",
"add",
"transactional",
"method",
"(",
"class",
"<",
"?",
">",
"clazz",
",",
"string",
"mapped",
"name",
",",
"transaction",
"attribute",
"attr",
")",
"{",
"assert",
"not",
"null",
"(",
"clazz",
",",
"\"",
"class",
"must",
"not",
"be",
"null",
"\"",
")",
";",
"assert",
"not",
"null",
"(",
"mapped",
"name",
",",
"\"",
"mapped",
"name",
"must",
"not",
"be",
"null",
"\"",
")",
";",
"string",
"name",
"=",
"clazz",
"get",
"name",
"(",
")",
"+",
"'",
"'",
"+",
"mapped",
"name",
";",
"method",
"[",
"]",
"methods",
"=",
"clazz",
"get",
"declared",
"methods",
"(",
")",
";",
"list",
"<",
"method",
">",
"matching",
"methods",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"for",
"(",
"method",
"method",
":",
"methods",
")",
"{",
"if",
"(",
"is",
"match",
"(",
"method",
"get",
"name",
"(",
")",
",",
"mapped",
"name",
")",
")",
"{",
"matching",
"methods",
"add",
"(",
"method",
")",
";",
"}",
"}",
"if",
"(",
"matching",
"methods",
"is",
"empty",
"(",
")",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"could",
"not",
"find",
"method",
"'",
"\"",
"+",
"mapped",
"name",
"+",
"\"",
"'",
"on",
"class",
"[",
"\"",
"+",
"clazz",
"get",
"name",
"(",
")",
"+",
"\"",
"]",
"\"",
")",
";",
"}",
"/",
"/",
"register",
"all",
"matching",
"methods",
"for",
"(",
"method",
"method",
":",
"matching",
"methods",
")",
"{",
"string",
"reg",
"method",
"name",
"=",
"this",
"method",
"name",
"map",
"get",
"(",
"method",
")",
";",
"if",
"(",
"reg",
"method",
"name",
"=",
"=",
"null",
"|",
"|",
"(",
"!",
"reg",
"method",
"name",
"equals",
"(",
"name",
")",
"&",
"&",
"reg",
"method",
"name",
"length",
"(",
")",
"<",
"=",
"name",
"length",
"(",
")",
")",
")",
"{",
"/",
"/",
"no",
"already",
"registered",
"method",
"name",
",",
"or",
"more",
"specific",
"/",
"/",
"method",
"name",
"specification",
"now",
"-",
">",
"(",
"re",
"-",
")",
"register",
"method",
"if",
"(",
"logger",
"is",
"debug",
"enabled",
"(",
")",
"&",
"&",
"reg",
"method",
"name",
"!",
"=",
"null",
")",
"{",
"logger",
"debug",
"(",
"\"",
"replacing",
"attribute",
"for",
"transactional",
"method",
"[",
"\"",
"+",
"method",
"+",
"\"",
"]",
":",
"current",
"name",
"'",
"\"",
"+",
"name",
"+",
"\"",
"'",
"is",
"more",
"specific",
"than",
"'",
"\"",
"+",
"reg",
"method",
"name",
"+",
"\"",
"'",
"\"",
")",
";",
"}",
"this",
"method",
"name",
"map",
"put",
"(",
"method",
",",
"name",
")",
";",
"add",
"transactional",
"method",
"(",
"method",
",",
"attr",
")",
";",
"}",
"else",
"{",
"if",
"(",
"logger",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"logger",
"debug",
"(",
"\"",
"keeping",
"attribute",
"for",
"transactional",
"method",
"[",
"\"",
"+",
"method",
"+",
"\"",
"]",
":",
"current",
"name",
"'",
"\"",
"+",
"name",
"+",
"\"",
"'",
"is",
"not",
"more",
"specific",
"than",
"'",
"\"",
"+",
"reg",
"method",
"name",
"+",
"\"",
"'",
"\"",
")",
";",
"}",
"}",
"}",
"}"
]
|
[
"execute",
"the",
"command",
"asynchronously"
]
| [
"public",
"static",
"utils",
"task",
"<",
"command",
"result",
">",
"exec",
"cmd",
"async",
"(",
"final",
"string",
"command",
",",
"final",
"boolean",
"is",
"rooted",
",",
"final",
"utils",
"consumer",
"<",
"command",
"result",
">",
"consumer",
")",
"{",
"return",
"exec",
"cmd",
"async",
"(",
"new",
"string",
"[",
"]",
"{",
"command",
"}",
",",
"is",
"rooted",
",",
"true",
",",
"consumer",
")",
";",
"}"
]
|
[
"delete",
"user",
"this",
"can",
"only",
"be",
"done",
"by",
"the",
"logged",
"in",
"user",
"<",
"b",
">",
"400",
"<",
"b",
">",
"-",
"invalid",
"username",
"supplied",
"<",
"b",
">",
"404",
"<",
"b",
">",
"-",
"user",
"not",
"found"
]
| [
"public",
"void",
"delete",
"user",
"(",
"string",
"username",
")",
"throws",
"rest",
"client",
"exception",
"{",
"delete",
"user",
"with",
"http",
"info",
"(",
"username",
")",
";",
"}"
]
|
[
"performs",
"necessary",
"checks",
",",
"cancels",
"the",
"task",
"and",
"calls",
"the",
"runnable",
"upon",
"completion"
]
| [
"void",
"cancel",
"task",
"(",
"task",
"manager",
"task",
"manager",
",",
"runnable",
"runnable",
",",
"string",
"reason",
")",
";"
]
|
[
"test",
"the",
"property",
"'",
"int",
"3",
"2",
"'"
]
| [
"public",
"void",
"int",
"3",
"2",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"int",
"3",
"2",
"}"
]
|
[
"get",
"the",
"cursor",
"location",
"if",
"there",
"is",
"no",
"current",
"view",
",",
"then",
"return",
"null"
]
| [
"byte",
"block",
"info",
"get",
"cursor",
"location",
"(",
")",
"{",
"if",
"(",
"current",
"view",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"return",
"current",
"view",
"get",
"viewer",
"cursor",
"location",
"(",
")",
";",
"}"
]
|
[
"computes",
"the",
"barycentric",
"coordinates",
"v",
",",
"w",
"for",
"the",
"specified",
"point",
"in",
"the",
"triangle",
"if",
"barycentric",
"x",
">",
"=",
"0",
"&",
"&",
"barycentric",
"y",
">",
"=",
"0",
"&",
"&",
"barycentric",
"x",
"+",
"barycentric",
"y",
"<",
"=",
"1",
"then",
"the",
"point",
"is",
"inside",
"the",
"triangle",
"if",
"vertices",
"a",
",",
"b",
",",
"c",
"have",
"values",
"aa",
",",
"bb",
",",
"cc",
"then",
"to",
"get",
"an",
"interpolated",
"value",
"at",
"point",
"p",
":",
"geometry",
"utils",
"barycentric",
"(",
"p",
",",
"a",
",",
"b",
",",
"c",
",",
"barycentric",
")",
";",
"float",
"u",
"=",
"1",
"f",
"-",
"barycentric",
"x",
"-",
"barycentric",
"y",
";",
"float",
"x",
"=",
"u",
"aa",
"x",
"+",
"barycentric",
"x",
"bb",
"x",
"+",
"barycentric",
"y",
"cc",
"x",
";",
"float",
"y",
"=",
"u",
"aa",
"y",
"+",
"barycentric",
"x",
"bb",
"y",
"+",
"barycentric",
"y",
"cc",
"y",
";"
]
| [
"static",
"public",
"vector",
"2",
"to",
"barycoord",
"(",
"vector",
"2",
"p",
",",
"vector",
"2",
"a",
",",
"vector",
"2",
"b",
",",
"vector",
"2",
"c",
",",
"vector",
"2",
"barycentric",
"out",
")",
"{",
"vector",
"2",
"v",
"0",
"=",
"tmp",
"1",
"set",
"(",
"b",
")",
"sub",
"(",
"a",
")",
";",
"vector",
"2",
"v",
"1",
"=",
"tmp",
"2",
"set",
"(",
"c",
")",
"sub",
"(",
"a",
")",
";",
"vector",
"2",
"v",
"2",
"=",
"tmp",
"3",
"set",
"(",
"p",
")",
"sub",
"(",
"a",
")",
";",
"float",
"d",
"0",
"0",
"=",
"v",
"0",
"dot",
"(",
"v",
"0",
")",
";",
"float",
"d",
"0",
"1",
"=",
"v",
"0",
"dot",
"(",
"v",
"1",
")",
";",
"float",
"d",
"1",
"1",
"=",
"v",
"1",
"dot",
"(",
"v",
"1",
")",
";",
"float",
"d",
"2",
"0",
"=",
"v",
"2",
"dot",
"(",
"v",
"0",
")",
";",
"float",
"d",
"2",
"1",
"=",
"v",
"2",
"dot",
"(",
"v",
"1",
")",
";",
"float",
"denom",
"=",
"d",
"0",
"0",
"*",
"d",
"1",
"1",
"-",
"d",
"0",
"1",
"*",
"d",
"0",
"1",
";",
"barycentric",
"out",
"x",
"=",
"(",
"d",
"1",
"1",
"*",
"d",
"2",
"0",
"-",
"d",
"0",
"1",
"*",
"d",
"2",
"1",
")",
"/",
"denom",
";",
"barycentric",
"out",
"y",
"=",
"(",
"d",
"0",
"0",
"*",
"d",
"2",
"1",
"-",
"d",
"0",
"1",
"*",
"d",
"2",
"0",
")",
"/",
"denom",
";",
"return",
"barycentric",
"out",
";",
"}"
]
|
[
"specifies",
"the",
"computation",
"of",
"a",
"median",
"(",
"i",
"e",
"the",
"1st",
"2",
"-",
"quantile",
")"
]
| [
"public",
"static",
"scale",
"and",
"index",
"median",
"(",
")",
"{",
"return",
"scale",
"(",
"2",
")",
"index",
"(",
"1",
")",
";",
"}"
]
|
[
"tries",
"to",
"release",
"the",
"memory",
"for",
"the",
"specified",
"segment",
"if",
"the",
"segment",
"has",
"already",
"been",
"released",
",",
"it",
"is",
"only",
"freed",
"if",
"it",
"is",
"null",
"or",
"has",
"no",
"owner",
",",
"the",
"request",
"is",
"simply",
"ignored",
"the",
"segment",
"is",
"only",
"freed",
"and",
"made",
"eligible",
"for",
"reclamation",
"by",
"the",
"gc",
"the",
"segment",
"will",
"be",
"returned",
"to",
"the",
"memory",
"pool",
",",
"increasing",
"its",
"available",
"limit",
"for",
"the",
"later",
"allocations"
]
| [
"public",
"void",
"release",
"(",
"memory",
"segment",
"segment",
")",
"{",
"preconditions",
"check",
"state",
"(",
"!",
"is",
"shut",
"down",
",",
"\"",
"memory",
"manager",
"has",
"been",
"shut",
"down",
"\"",
")",
";",
"/",
"/",
"check",
"if",
"segment",
"is",
"null",
"or",
"has",
"already",
"been",
"freed",
"if",
"(",
"segment",
"=",
"=",
"null",
"|",
"|",
"segment",
"get",
"owner",
"(",
")",
"=",
"=",
"null",
")",
"{",
"return",
";",
"}",
"/",
"/",
"remove",
"the",
"reference",
"in",
"the",
"map",
"for",
"the",
"owner",
"try",
"{",
"allocated",
"segments",
"compute",
"if",
"present",
"(",
"segment",
"get",
"owner",
"(",
")",
",",
"(",
"o",
",",
"segs",
"for",
"owner",
")",
"-",
">",
"{",
"segment",
"free",
"(",
")",
";",
"segs",
"for",
"owner",
"remove",
"(",
"segment",
")",
";",
"return",
"segs",
"for",
"owner",
"is",
"empty",
"(",
")",
"?",
"null",
":",
"segs",
"for",
"owner",
";",
"}",
")",
";",
"}",
"catch",
"(",
"throwable",
"t",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"error",
"removing",
"book",
"-",
"keeping",
"reference",
"to",
"allocated",
"memory",
"segment",
"\"",
",",
"t",
")",
";",
"}",
"}"
]
|
[
"tests",
"join",
"program",
"with",
"replicated",
"data",
"source",
"behind",
"flat",
"map"
]
| [
"public",
"void",
"check",
"join",
"with",
"replicated",
"source",
"input",
"behind",
"flat",
"map",
"(",
")",
"{",
"execution",
"environment",
"env",
"=",
"execution",
"environment",
"create",
"local",
"environment",
"(",
")",
";",
"env",
"set",
"parallelism",
"(",
"default",
"parallelism",
")",
";",
"tuple",
"type",
"info",
"<",
"tuple",
"1",
"<",
"string",
">",
">",
"type",
"info",
"=",
"tuple",
"type",
"info",
"get",
"basic",
"tuple",
"type",
"info",
"(",
"string",
"class",
")",
";",
"replicating",
"input",
"format",
"<",
"tuple",
"1",
"<",
"string",
">",
",",
"file",
"input",
"split",
">",
"rif",
"=",
"new",
"replicating",
"input",
"format",
"<",
"tuple",
"1",
"<",
"string",
">",
",",
"file",
"input",
"split",
">",
"(",
"new",
"tuple",
"csv",
"input",
"format",
"<",
"tuple",
"1",
"<",
"string",
">",
">",
"(",
"new",
"path",
"(",
"\"",
"/",
"some",
"/",
"path",
"\"",
")",
",",
"type",
"info",
")",
")",
";",
"data",
"set",
"<",
"tuple",
"1",
"<",
"string",
">",
">",
"source",
"1",
"=",
"env",
"create",
"input",
"(",
"rif",
",",
"new",
"tuple",
"type",
"info",
"<",
"tuple",
"1",
"<",
"string",
">",
">",
"(",
"basic",
"type",
"info",
"string",
"type",
"info",
")",
")",
";",
"data",
"set",
"<",
"tuple",
"1",
"<",
"string",
">",
">",
"source",
"2",
"=",
"env",
"read",
"csv",
"file",
"(",
"\"",
"/",
"some",
"/",
"otherpath",
"\"",
")",
"types",
"(",
"string",
"class",
")",
";",
"data",
"sink",
"<",
"tuple",
"2",
"<",
"tuple",
"1",
"<",
"string",
">",
",",
"tuple",
"1",
"<",
"string",
">",
">",
">",
"out",
"=",
"source",
"1",
"flat",
"map",
"(",
"new",
"id",
"flat",
"map",
"(",
")",
")",
"join",
"(",
"source",
"2",
")",
"where",
"(",
"\"",
"*",
"\"",
")",
"equal",
"to",
"(",
"\"",
"*",
"\"",
")",
"write",
"as",
"text",
"(",
"\"",
"/",
"some",
"/",
"newpath",
"\"",
")",
";",
"plan",
"plan",
"=",
"env",
"create",
"program",
"plan",
"(",
")",
";",
"/",
"/",
"submit",
"the",
"plan",
"to",
"the",
"compiler",
"optimized",
"plan",
"o",
"plan",
"=",
"compile",
"no",
"stats",
"(",
"plan",
")",
";",
"/",
"/",
"check",
"the",
"optimized",
"plan",
"/",
"/",
"when",
"join",
"should",
"have",
"forward",
"strategy",
"on",
"both",
"sides",
"sink",
"plan",
"node",
"sink",
"node",
"=",
"o",
"plan",
"get",
"data",
"sinks",
"(",
")",
"iterator",
"(",
")",
"next",
"(",
")",
";",
"dual",
"input",
"plan",
"node",
"join",
"node",
"=",
"(",
"dual",
"input",
"plan",
"node",
")",
"sink",
"node",
"get",
"predecessor",
"(",
")",
";",
"ship",
"strategy",
"type",
"join",
"in",
"1",
"=",
"join",
"node",
"get",
"input",
"1",
"(",
")",
"get",
"ship",
"strategy",
"(",
")",
";",
"ship",
"strategy",
"type",
"join",
"in",
"2",
"=",
"join",
"node",
"get",
"input",
"2",
"(",
")",
"get",
"ship",
"strategy",
"(",
")",
";",
"assert",
"assert",
"equals",
"(",
"\"",
"invalid",
"ship",
"strategy",
"for",
"an",
"operator",
"\"",
",",
"ship",
"strategy",
"type",
"forward",
",",
"join",
"in",
"1",
")",
";",
"assert",
"assert",
"equals",
"(",
"\"",
"invalid",
"ship",
"strategy",
"for",
"an",
"operator",
"\"",
",",
"ship",
"strategy",
"type",
"forward",
",",
"join",
"in",
"2",
")",
";",
"}"
]
|
[
"process",
"the",
"symbol",
"table",
"section",
"of",
"the",
"xml",
"file"
]
| [
"void",
"read",
"(",
"xml",
"pull",
"parser",
"parser",
",",
"boolean",
"is",
"overwrite",
"primary",
",",
"task",
"monitor",
"monitor",
")",
"throws",
"cancelled",
"exception",
"{",
"read",
"(",
"parser",
",",
"is",
"overwrite",
"primary",
",",
"1",
",",
"monitor",
")",
";",
"}"
]
|
[
"undoes",
"the",
"last",
"action"
]
| [
"public",
"void",
"undo",
"(",
")",
"{",
"undo",
"(",
"true",
")",
";",
"}"
]
|
[
"waits",
"for",
"the",
"all",
"the",
"services",
"to",
"reach",
"a",
"terminal",
"state",
"after",
"this",
"method",
"returns",
"all",
"services",
"will",
"either",
"be",
"{",
"@",
"linkplain",
"service",
"state",
"#",
"terminated",
"terminated",
"}",
"or",
"{",
"@",
"linkplain",
"service",
"state",
"#",
"failed",
"failed",
"}"
]
| [
"public",
"void",
"await",
"stopped",
"(",
")",
"{",
"state",
"await",
"stopped",
"(",
")",
";",
"}"
]
|
[
"<",
"code",
">",
"repeated",
"io",
"netty",
"example",
"worldclock",
"local",
"time",
"local",
"time",
"=",
"1",
";",
"<",
"code",
">"
]
| [
"public",
"java",
"util",
"list",
"<",
"io",
"netty",
"example",
"worldclock",
"world",
"clock",
"protocol",
"local",
"time",
"builder",
">",
"get",
"local",
"time",
"builder",
"list",
"(",
")",
"{",
"return",
"get",
"local",
"time",
"field",
"builder",
"(",
")",
"get",
"builder",
"list",
"(",
")",
";",
"}"
]
|
[
"copies",
"the",
"contents",
"of",
"this",
"directory",
"recursively",
"into",
"the",
"specified",
"target",
"directory"
]
| [
"public",
"int",
"copy",
"recursive",
"to",
"(",
"file",
"path",
"target",
")",
"throws",
"i",
"o",
"exception",
",",
"interrupted",
"exception",
"{",
"return",
"copy",
"recursive",
"to",
"(",
"\"",
"*",
"*",
"/",
"*",
"\"",
",",
"target",
")",
";",
"}"
]
|
[
"to",
"simplify",
"code",
",",
"this",
"doesn",
"'",
"t",
"actually",
"invoke",
"the",
"underlying",
"{",
"@",
"link",
"#",
"execute",
"(",
")",
"}",
"method",
"this",
"is",
"ok",
"because",
"in",
"almost",
"all",
"cases",
",",
"doing",
"so",
"would",
"imply",
"invoking",
"{",
"@",
"link",
"#",
"enqueue",
"(",
"callback",
")",
"}",
"anyway"
]
| [
"@",
"override",
"protected",
"void",
"do",
"execute",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"/",
"/",
"enqueue",
"the",
"call",
"invocation",
"on",
"the",
"executor",
"and",
"block",
"until",
"it",
"completes",
"do",
"enqueue",
"(",
"noop",
"callback",
")",
";",
"if",
"(",
"!",
"await",
"(",
"latch",
")",
")",
"throw",
"new",
"interrupted",
"i",
"o",
"exception",
"(",
")",
";",
"/",
"/",
"check",
"if",
"the",
"run",
"resulted",
"in",
"an",
"exception",
"throwable",
"t",
"=",
"this",
"throwable",
";",
"if",
"(",
"t",
"=",
"=",
"null",
")",
"return",
"null",
";",
"/",
"/",
"success",
"/",
"/",
"coerce",
"the",
"throwable",
"to",
"the",
"signature",
"of",
"call",
"execute",
"(",
")",
"if",
"(",
"t",
"instanceof",
"error",
")",
"throw",
"(",
"error",
")",
"t",
";",
"if",
"(",
"t",
"instanceof",
"i",
"o",
"exception",
")",
"throw",
"(",
"i",
"o",
"exception",
")",
"t",
";",
"if",
"(",
"t",
"instanceof",
"runtime",
"exception",
")",
"throw",
"(",
"runtime",
"exception",
")",
"t",
";",
"throw",
"new",
"runtime",
"exception",
"(",
"t",
")",
";",
"}"
]
|
[
"get",
"the",
"interval",
"from",
"{",
"@",
"code",
"histogram",
"aggregation",
"}",
"or",
"throw",
"an",
"{",
"@",
"code",
"illegal",
"state",
"exception",
"}",
"if",
"{",
"@",
"code",
"histogram",
"aggregation",
"}",
"is",
"not",
"a",
"{",
"@",
"link",
"histogram",
"aggregation",
"builder",
"}",
"or",
"a",
"{",
"@",
"link",
"date",
"histogram",
"aggregation",
"builder",
"}"
]
| [
"public",
"static",
"long",
"get",
"histogram",
"interval",
"millis",
"(",
"aggregation",
"builder",
"histogram",
"aggregation",
")",
"{",
"if",
"(",
"histogram",
"aggregation",
"instanceof",
"histogram",
"aggregation",
"builder",
")",
"{",
"return",
"(",
"long",
")",
"(",
"(",
"histogram",
"aggregation",
"builder",
")",
"histogram",
"aggregation",
")",
"interval",
"(",
")",
";",
"}",
"else",
"if",
"(",
"histogram",
"aggregation",
"instanceof",
"date",
"histogram",
"aggregation",
"builder",
")",
"{",
"return",
"validate",
"and",
"get",
"date",
"histogram",
"interval",
"(",
"(",
"date",
"histogram",
"aggregation",
"builder",
")",
"histogram",
"aggregation",
")",
";",
"}",
"else",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"invalid",
"histogram",
"aggregation",
"[",
"\"",
"+",
"histogram",
"aggregation",
"get",
"name",
"(",
")",
"+",
"\"",
"]",
"\"",
")",
";",
"}",
"}"
]
|
[
"add",
"a",
"custom",
"formatter",
",",
"applying",
"it",
"to",
"all",
"fields",
"matching",
"the",
"{",
"@",
"link",
"formatter",
"}",
"-",
"declared",
"type",
"registers",
"a",
"corresponding",
"{",
"@",
"link",
"property",
"editor",
"}",
"adapter",
"underneath",
"the",
"covers"
]
| [
"public",
"void",
"add",
"custom",
"formatter",
"(",
"formatter",
"<",
"?",
">",
"formatter",
")",
"{",
"formatter",
"property",
"editor",
"adapter",
"adapter",
"=",
"new",
"formatter",
"property",
"editor",
"adapter",
"(",
"formatter",
")",
";",
"get",
"property",
"editor",
"registry",
"(",
")",
"register",
"custom",
"editor",
"(",
"adapter",
"get",
"field",
"type",
"(",
")",
",",
"adapter",
")",
";",
"}"
]
|
[
"return",
"the",
"attribute",
"of",
"the",
"specified",
"keyed",
"object",
"as",
"a",
"string"
]
| [
"public",
"string",
"get",
"value",
"as",
"string",
"(",
"keyed",
"object",
"o",
")",
"{",
"try",
"{",
"return",
"integer",
"to",
"string",
"(",
"get",
"value",
"(",
"o",
")",
")",
";",
"}",
"catch",
"(",
"ghidra",
"util",
"exception",
"no",
"value",
"exception",
"exc",
")",
"{",
"return",
"\"",
"0",
"\"",
";",
"}",
"}"
]
|
[
"returns",
"list",
"of",
"groups",
"for",
"a",
"user",
"this",
"calls",
"{",
"@",
"link",
"ldap",
"groups",
"mapping",
"}",
"'",
"s",
"get",
"groups",
"and",
"applies",
"the",
"configured",
"rules",
"on",
"group",
"names",
"before",
"returning"
]
| [
"public",
"synchronized",
"list",
"<",
"string",
">",
"get",
"groups",
"(",
"string",
"user",
")",
"{",
"list",
"<",
"string",
">",
"groups",
"=",
"super",
"get",
"groups",
"(",
"user",
")",
";",
"switch",
"(",
"rule",
")",
"{",
"case",
"to",
"upper",
":",
"return",
"groups",
"stream",
"(",
")",
"map",
"(",
"string",
"utils",
":",
":",
"to",
"upper",
"case",
")",
"collect",
"(",
"collectors",
"to",
"list",
"(",
")",
")",
";",
"case",
"to",
"lower",
":",
"return",
"groups",
"stream",
"(",
")",
"map",
"(",
"string",
"utils",
":",
":",
"to",
"lower",
"case",
")",
"collect",
"(",
"collectors",
"to",
"list",
"(",
")",
")",
";",
"case",
"none",
":",
"default",
":",
"return",
"groups",
";",
"}",
"}"
]
|
[
"copies",
"important",
"fields",
"from",
"the",
"current",
"http",
"request",
"and",
"makes",
"them",
"available",
"during",
"{",
"@",
"link",
"#",
"compute",
"}",
"this",
"is",
"necessary",
"because",
"some",
"model",
"methods",
"such",
"as",
"{",
"@",
"link",
"abstract",
"item",
"#",
"get",
"url",
"}",
"behave",
"differently",
"when",
"called",
"from",
"a",
"request"
]
| [
"private",
"static",
"request",
"impl",
"create",
"mock",
"request",
"(",
")",
"{",
"request",
"impl",
"current",
"request",
"=",
"(",
"request",
"impl",
")",
"stapler",
"get",
"current",
"request",
"(",
")",
";",
"http",
"servlet",
"request",
"original",
"=",
"(",
"http",
"servlet",
"request",
")",
"current",
"request",
"get",
"request",
"(",
")",
";",
"final",
"map",
"<",
"string",
",",
"object",
">",
"getters",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"for",
"(",
"method",
"method",
":",
"http",
"servlet",
"request",
"class",
"get",
"methods",
"(",
")",
")",
"{",
"string",
"m",
"=",
"method",
"get",
"name",
"(",
")",
";",
"if",
"(",
"(",
"m",
"starts",
"with",
"(",
"\"",
"get",
"\"",
")",
"|",
"|",
"m",
"starts",
"with",
"(",
"\"",
"is",
"\"",
")",
")",
"&",
"&",
"method",
"get",
"parameter",
"types",
"(",
")",
"length",
"=",
"=",
"0",
")",
"{",
"class",
"<",
"?",
">",
"type",
"=",
"method",
"get",
"return",
"type",
"(",
")",
";",
"/",
"/",
"todo",
"could",
"add",
"other",
"types",
"which",
"are",
"known",
"to",
"be",
"safe",
"to",
"copy",
":",
"cookie",
"[",
"]",
",",
"principal",
",",
"http",
"session",
",",
"etc",
"if",
"(",
"type",
"is",
"primitive",
"(",
")",
"|",
"|",
"type",
"=",
"=",
"string",
"class",
"|",
"|",
"type",
"=",
"=",
"locale",
"class",
")",
"{",
"try",
"{",
"getters",
"put",
"(",
"m",
",",
"method",
"invoke",
"(",
"original",
")",
")",
";",
"}",
"catch",
"(",
"exception",
"x",
")",
"{",
"log",
"log",
"(",
"level",
"warning",
",",
"\"",
"cannot",
"mock",
"stapler",
"request",
"\"",
"+",
"method",
",",
"x",
")",
";",
"}",
"}",
"}",
"}",
"list",
"/",
"*",
"<",
"ancestor",
"impl",
">",
"*",
"/",
"ancestors",
"=",
"current",
"request",
"ancestors",
";",
"log",
"log",
"(",
"level",
"finer",
",",
"\"",
"mocking",
"ancestors",
"{",
"0",
"}",
"using",
"{",
"1",
"}",
"\"",
",",
"new",
"object",
"[",
"]",
"{",
"ancestors",
",",
"getters",
"}",
")",
";",
"token",
"list",
"tokens",
"=",
"current",
"request",
"tokens",
";",
"return",
"new",
"request",
"impl",
"(",
"stapler",
"get",
"current",
"(",
")",
",",
"(",
"http",
"servlet",
"request",
")",
"proxy",
"new",
"proxy",
"instance",
"(",
"progressive",
"rendering",
"class",
"get",
"class",
"loader",
"(",
")",
",",
"new",
"class",
"<",
"?",
">",
"[",
"]",
"{",
"http",
"servlet",
"request",
"class",
"}",
",",
"new",
"invocation",
"handler",
"(",
")",
"{",
"@",
"override",
"public",
"object",
"invoke",
"(",
"object",
"proxy",
",",
"method",
"method",
",",
"object",
"[",
"]",
"args",
")",
"throws",
"throwable",
"{",
"string",
"m",
"=",
"method",
"get",
"name",
"(",
")",
";",
"if",
"(",
"getters",
"contains",
"key",
"(",
"m",
")",
")",
"{",
"return",
"getters",
"get",
"(",
"m",
")",
";",
"}",
"else",
"{",
"/",
"/",
"todo",
"implement",
"other",
"methods",
"as",
"needed",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
"m",
")",
";",
"}",
"}",
"}",
")",
",",
"ancestors",
",",
"tokens",
")",
";",
"}"
]
|
[
"returns",
"a",
"{",
"@",
"link",
"java",
"proto",
"aspect",
"common",
"}",
"instance",
"that",
"handles",
"logic",
"for",
"{",
"@",
"code",
"java",
"proto",
"library",
"}"
]
| [
"static",
"java",
"proto",
"aspect",
"common",
"get",
"speed",
"instance",
"(",
"rule",
"context",
"rule",
"context",
",",
"java",
"semantics",
"java",
"semantics",
",",
"rpc",
"support",
"rpc",
"support",
")",
"{",
"return",
"new",
"java",
"proto",
"aspect",
"common",
"(",
"rule",
"context",
",",
"java",
"semantics",
",",
"rpc",
"support",
",",
"speed",
"proto",
"toolchain",
"attr",
",",
"speed",
"jar",
"suffix",
")",
";",
"}"
]
|
[
"return",
"time",
"duration",
"in",
"the",
"given",
"time",
"unit",
"valid",
"units",
"are",
"encoded",
"in",
"properties",
"as",
"suffixes",
":",
"nanoseconds",
"(",
"ns",
")",
",",
"microseconds",
"(",
"us",
")",
",",
"milliseconds",
"(",
"ms",
")",
",",
"seconds",
"(",
"s",
")",
",",
"minutes",
"(",
"m",
")",
",",
"hours",
"(",
"h",
")",
",",
"and",
"days",
"(",
"d",
")"
]
| [
"public",
"long",
"get",
"time",
"duration",
"helper",
"(",
"string",
"name",
",",
"string",
"v",
"str",
",",
"time",
"unit",
"unit",
")",
"{",
"v",
"str",
"=",
"v",
"str",
"trim",
"(",
")",
";",
"v",
"str",
"=",
"string",
"utils",
"to",
"lower",
"case",
"(",
"v",
"str",
")",
";",
"parsed",
"time",
"duration",
"v",
"unit",
"=",
"parsed",
"time",
"duration",
"unit",
"for",
"(",
"v",
"str",
")",
";",
"if",
"(",
"null",
"=",
"=",
"v",
"unit",
")",
"{",
"log",
"deprecation",
"(",
"\"",
"no",
"unit",
"for",
"\"",
"+",
"name",
"+",
"\"",
"(",
"\"",
"+",
"v",
"str",
"+",
"\"",
")",
"assuming",
"\"",
"+",
"unit",
")",
";",
"v",
"unit",
"=",
"parsed",
"time",
"duration",
"unit",
"for",
"(",
"unit",
")",
";",
"}",
"else",
"{",
"v",
"str",
"=",
"v",
"str",
"substring",
"(",
"0",
",",
"v",
"str",
"last",
"index",
"of",
"(",
"v",
"unit",
"suffix",
"(",
")",
")",
")",
";",
"}",
"long",
"raw",
"=",
"long",
"parse",
"long",
"(",
"v",
"str",
")",
";",
"long",
"converted",
"=",
"unit",
"convert",
"(",
"raw",
",",
"v",
"unit",
"unit",
"(",
")",
")",
";",
"if",
"(",
"v",
"unit",
"unit",
"(",
")",
"convert",
"(",
"converted",
",",
"unit",
")",
"<",
"raw",
")",
"{",
"log",
"deprecation",
"(",
"\"",
"possible",
"loss",
"of",
"precision",
"converting",
"\"",
"+",
"v",
"str",
"+",
"v",
"unit",
"suffix",
"(",
")",
"+",
"\"",
"to",
"\"",
"+",
"unit",
"+",
"\"",
"for",
"\"",
"+",
"name",
")",
";",
"}",
"return",
"converted",
";",
"}"
]
|
[
"get",
"my",
"string"
]
| [
"public",
"string",
"get",
"my",
"string",
"(",
")",
"{",
"return",
"my",
"string",
";",
"}"
]
|
[
"sets",
"the",
"<",
"code",
">",
"prefix",
"array",
"<",
"code",
">",
"property"
]
| [
"public",
"xml",
"item",
"prefix",
"array",
"(",
"list",
"<",
"integer",
">",
"prefix",
"array",
")",
"{",
"this",
"prefix",
"array",
"=",
"prefix",
"array",
";",
"return",
"this",
";",
"}"
]
|
[
"adds",
"the",
"specified",
"vertices",
"to",
"the",
"cache",
"each",
"vertex",
"should",
"have",
"5",
"elements",
",",
"one",
"for",
"each",
"of",
"the",
"attributes",
":",
"x",
",",
"y",
",",
"color",
",",
"u",
",",
"and",
"v",
"if",
"indexed",
"geometry",
"is",
"used",
",",
"each",
"image",
"should",
"be",
"specified",
"as",
"4",
"vertices",
",",
"otherwise",
"each",
"image",
"should",
"be",
"specified",
"as",
"6",
"vertices"
]
| [
"public",
"void",
"add",
"(",
"texture",
"texture",
",",
"float",
"[",
"]",
"vertices",
",",
"int",
"offset",
",",
"int",
"length",
")",
"{",
"if",
"(",
"current",
"cache",
"=",
"=",
"null",
")",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"begin",
"cache",
"must",
"be",
"called",
"before",
"add",
"\"",
")",
";",
"int",
"vertices",
"per",
"image",
"=",
"mesh",
"get",
"num",
"indices",
"(",
")",
">",
"0",
"?",
"4",
":",
"6",
";",
"int",
"count",
"=",
"length",
"/",
"(",
"vertices",
"per",
"image",
"*",
"vertex",
"size",
")",
"*",
"6",
";",
"int",
"last",
"index",
"=",
"textures",
"size",
"-",
"1",
";",
"if",
"(",
"last",
"index",
"<",
"0",
"|",
"|",
"textures",
"get",
"(",
"last",
"index",
")",
"!",
"=",
"texture",
")",
"{",
"textures",
"add",
"(",
"texture",
")",
";",
"counts",
"add",
"(",
"count",
")",
";",
"}",
"else",
"counts",
"incr",
"(",
"last",
"index",
",",
"count",
")",
";",
"mesh",
"get",
"vertices",
"buffer",
"(",
")",
"put",
"(",
"vertices",
",",
"offset",
",",
"length",
")",
";",
"}"
]
|
[
"dequeues",
"the",
"playing",
"period",
"holder",
"from",
"the",
"front",
"of",
"the",
"queue",
"and",
"advances",
"the",
"playing",
"period",
"holder",
"to",
"be",
"the",
"next",
"item",
"in",
"the",
"queue"
]
| [
"public",
"media",
"period",
"holder",
"advance",
"playing",
"period",
"(",
")",
"{",
"if",
"(",
"playing",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"if",
"(",
"playing",
"=",
"=",
"reading",
")",
"{",
"reading",
"=",
"playing",
"get",
"next",
"(",
")",
";",
"}",
"playing",
"release",
"(",
")",
";",
"length",
"-",
"-",
";",
"if",
"(",
"length",
"=",
"=",
"0",
")",
"{",
"loading",
"=",
"null",
";",
"old",
"front",
"period",
"uid",
"=",
"playing",
"uid",
";",
"old",
"front",
"period",
"window",
"sequence",
"number",
"=",
"playing",
"info",
"id",
"window",
"sequence",
"number",
";",
"}",
"playing",
"=",
"playing",
"get",
"next",
"(",
")",
";",
"notify",
"queue",
"update",
"(",
")",
";",
"return",
"playing",
";",
"}"
]
|
[
"model",
"tests",
"for",
"tag"
]
| [
"public",
"void",
"test",
"tag",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"tag",
"}"
]
|
[
"creates",
"a",
"new",
"{",
"@",
"code",
"session",
"windows",
"}",
"{",
"@",
"link",
"window",
"assigner",
"}",
"that",
"assigns",
"elements",
"to",
"sessions",
"based",
"on",
"the",
"element",
"timestamp"
]
| [
"public",
"static",
"processing",
"time",
"session",
"windows",
"with",
"gap",
"(",
"time",
"size",
")",
"{",
"return",
"new",
"processing",
"time",
"session",
"windows",
"(",
"size",
"to",
"milliseconds",
"(",
")",
")",
";",
"}"
]
|
[
"get",
"server",
"port",
"of",
"this",
"http",
"server"
]
| [
"public",
"static",
"string",
"get",
"port",
"(",
")",
"{",
"if",
"(",
"runtime",
"port",
">",
"0",
")",
"{",
"return",
"string",
"value",
"of",
"(",
"runtime",
"port",
")",
";",
"}",
"return",
"sentinel",
"config",
"get",
"config",
"(",
"server",
"port",
")",
";",
"}"
]
|
[
"retrieve",
"the",
"given",
"annotation",
"'",
"s",
"attributes",
"as",
"an",
"{",
"@",
"link",
"annotation",
"attributes",
"}",
"map",
"this",
"method",
"provides",
"fully",
"recursive",
"annotation",
"reading",
"capabilities",
"on",
"par",
"with",
"the",
"reflection",
"-",
"based",
"{",
"@",
"link",
"org",
"springframework",
"core",
"type",
"standard",
"annotation",
"metadata",
"}"
]
| [
"public",
"static",
"annotation",
"attributes",
"get",
"annotation",
"attributes",
"(",
"annotation",
"annotation",
",",
"boolean",
"class",
"values",
"as",
"string",
",",
"boolean",
"nested",
"annotations",
"as",
"map",
")",
"{",
"return",
"get",
"annotation",
"attributes",
"(",
"null",
",",
"annotation",
",",
"class",
"values",
"as",
"string",
",",
"nested",
"annotations",
"as",
"map",
")",
";",
"}"
]
|
[
"allows",
"to",
"override",
"the",
"node",
"client",
"username",
"(",
"used",
"while",
"sending",
"requests",
"to",
"the",
"test",
"cluster",
")",
"when",
"the",
"{",
"@",
"link",
"org",
"elasticsearch",
"test",
"e",
"s",
"integ",
"test",
"case",
"cluster",
"scope",
"}",
"is",
"set",
"to",
"{",
"@",
"link",
"org",
"elasticsearch",
"test",
"e",
"s",
"integ",
"test",
"case",
"scope",
"#",
"suite",
"}",
"or",
"{",
"@",
"link",
"org",
"elasticsearch",
"test",
"e",
"s",
"integ",
"test",
"case",
"scope",
"#",
"test",
"}"
]
| [
"protected",
"string",
"node",
"client",
"username",
"(",
")",
"{",
"return",
"security",
"default",
"settings",
"node",
"client",
"username",
"(",
")",
";",
"}"
]
|
[
"helper",
"for",
"{",
"@",
"link",
"#",
"process",
"block",
"}",
",",
"which",
"merges",
"frames",
"and",
"adds",
"to",
"the",
"work",
"set",
",",
"as",
"necessary"
]
| [
"private",
"void",
"merge",
"and",
"work",
"as",
"necessary",
"(",
"int",
"label",
",",
"int",
"pred",
",",
"subroutine",
"called",
"subroutine",
",",
"frame",
"frame",
",",
"int",
"[",
"]",
"work",
"set",
")",
"{",
"frame",
"existing",
"=",
"start",
"frames",
"[",
"label",
"]",
";",
"frame",
"merged",
";",
"if",
"(",
"existing",
"!",
"=",
"null",
")",
"{",
"/",
"*",
"*",
"some",
"other",
"block",
"also",
"continues",
"at",
"this",
"label",
"merge",
"*",
"the",
"frames",
",",
"and",
"re",
"-",
"set",
"the",
"bit",
"in",
"the",
"work",
"set",
"if",
"there",
"*",
"was",
"a",
"change",
"*",
"/",
"if",
"(",
"called",
"subroutine",
"!",
"=",
"null",
")",
"{",
"merged",
"=",
"existing",
"merge",
"with",
"subroutine",
"caller",
"(",
"frame",
",",
"called",
"subroutine",
"get",
"start",
"block",
"(",
")",
",",
"pred",
")",
";",
"}",
"else",
"{",
"merged",
"=",
"existing",
"merge",
"with",
"(",
"frame",
")",
";",
"}",
"if",
"(",
"merged",
"!",
"=",
"existing",
")",
"{",
"start",
"frames",
"[",
"label",
"]",
"=",
"merged",
";",
"bits",
"set",
"(",
"work",
"set",
",",
"label",
")",
";",
"}",
"}",
"else",
"{",
"/",
"/",
"this",
"is",
"the",
"first",
"time",
"this",
"label",
"has",
"been",
"encountered",
"if",
"(",
"called",
"subroutine",
"!",
"=",
"null",
")",
"{",
"start",
"frames",
"[",
"label",
"]",
"=",
"frame",
"make",
"new",
"subroutine",
"start",
"frame",
"(",
"label",
",",
"pred",
")",
";",
"}",
"else",
"{",
"start",
"frames",
"[",
"label",
"]",
"=",
"frame",
";",
"}",
"bits",
"set",
"(",
"work",
"set",
",",
"label",
")",
";",
"}",
"}"
]
|
[
"imports",
"the",
"given",
"files",
"into",
"the",
"specified",
"ghidra",
"project",
"folder"
]
| [
"public",
"void",
"import",
"files",
"(",
"domain",
"folder",
"folder",
",",
"list",
"<",
"file",
">",
"files",
")",
";"
]
|
[
"this",
"method",
"returns",
"the",
"normalized",
"name",
"of",
"the",
"result",
"queue",
"currently",
"only",
"makes",
"sense",
"when",
"result",
"=",
"=",
"place",
"normalized",
"value",
"must",
"be",
"set",
"externally",
",",
"this",
"class",
"cannot",
"normalize",
"it",
"just",
"provides",
"a",
"way",
"to",
"store",
"the",
"normalized",
"name",
"of",
"a",
"queue"
]
| [
"public",
"string",
"get",
"normalized",
"queue",
"(",
")",
"{",
"return",
"normalized",
"queue",
";",
"}"
]
|
[
"returns",
"the",
"list",
"of",
"selected",
"track",
"selection",
"overrides",
"there",
"will",
"be",
"at",
"most",
"one",
"override",
"for",
"each",
"track",
"group"
]
| [
"public",
"list",
"<",
"selection",
"override",
">",
"get",
"overrides",
"(",
")",
"{",
"list",
"<",
"selection",
"override",
">",
"override",
"list",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"overrides",
"size",
"(",
")",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"overrides",
"size",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"override",
"list",
"add",
"(",
"overrides",
"value",
"at",
"(",
"i",
")",
")",
";",
"}",
"return",
"override",
"list",
";",
"}"
]
|
[
"return",
"the",
"underlying",
"type",
"provider"
]
| [
"type",
"provider",
"get",
"type",
"provider",
"(",
")",
";"
]
|
[
"get",
"the",
"group",
"paths",
"that",
"are",
"in",
"the",
"tree",
"selection"
]
| [
"public",
"group",
"path",
"[",
"]",
"get",
"group",
"paths",
"(",
")",
"{",
"return",
"group",
"paths",
";",
"}"
]
|
[
"this",
"test",
"checks",
"a",
"race",
"condition",
"between",
"getting",
"and",
"adding",
"tokens",
"for",
"the",
"current",
"user",
"calling",
"user",
"group",
"information",
"get",
"current",
"user",
"(",
")",
"returns",
"a",
"new",
"object",
"each",
"time",
",",
"so",
"simply",
"making",
"these",
"methods",
"synchronized",
"was",
"not",
"enough",
"to",
"prevent",
"race",
"conditions",
"and",
"causing",
"a",
"concurrent",
"modification",
"exception",
"these",
"methods",
"are",
"synchronized",
"on",
"the",
"subject",
",",
"which",
"is",
"the",
"same",
"object",
"between",
"user",
"group",
"information",
"instances",
"this",
"test",
"tries",
"to",
"cause",
"a",
"cme",
",",
"by",
"exposing",
"the",
"race",
"condition",
"previously",
"this",
"test",
"would",
"fail",
"every",
"time",
";",
"now",
"it",
"does",
"not"
]
| [
"public",
"void",
"test",
"token",
"race",
"condition",
"(",
")",
"throws",
"exception",
"{",
"user",
"group",
"information",
"user",
"group",
"info",
"=",
"user",
"group",
"information",
"create",
"user",
"for",
"testing",
"(",
"user",
"name",
",",
"group",
"names",
")",
";",
"user",
"group",
"info",
"do",
"as",
"(",
"new",
"privileged",
"exception",
"action",
"<",
"void",
">",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"run",
"(",
")",
"throws",
"exception",
"{",
"/",
"/",
"make",
"sure",
"it",
"is",
"not",
"the",
"same",
"as",
"the",
"login",
"user",
"because",
"we",
"use",
"the",
"/",
"/",
"same",
"ugi",
"object",
"for",
"every",
"instantiation",
"of",
"the",
"login",
"user",
"and",
"you",
"/",
"/",
"won",
"'",
"t",
"run",
"into",
"the",
"race",
"condition",
"otherwise",
"assert",
"not",
"equals",
"(",
"user",
"group",
"information",
"get",
"login",
"user",
"(",
")",
",",
"user",
"group",
"information",
"get",
"current",
"user",
"(",
")",
")",
";",
"get",
"token",
"thread",
"thread",
"=",
"new",
"get",
"token",
"thread",
"(",
")",
";",
"try",
"{",
"thread",
"start",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"100",
";",
"i",
"+",
"+",
")",
"{",
"@",
"suppress",
"warnings",
"(",
"\"",
"unchecked",
"\"",
")",
"token",
"<",
"?",
"extends",
"token",
"identifier",
">",
"t",
"=",
"mock",
"(",
"token",
"class",
")",
";",
"when",
"(",
"t",
"get",
"service",
"(",
")",
")",
"then",
"return",
"(",
"new",
"text",
"(",
"\"",
"t",
"\"",
"+",
"i",
")",
")",
";",
"user",
"group",
"information",
"get",
"current",
"user",
"(",
")",
"add",
"token",
"(",
"t",
")",
";",
"assert",
"null",
"(",
"\"",
"concurrent",
"modification",
"exception",
"encountered",
"\"",
",",
"thread",
"cme",
")",
";",
"}",
"}",
"catch",
"(",
"concurrent",
"modification",
"exception",
"cme",
")",
"{",
"cme",
"print",
"stack",
"trace",
"(",
")",
";",
"fail",
"(",
"\"",
"concurrent",
"modification",
"exception",
"encountered",
"\"",
")",
";",
"}",
"finally",
"{",
"thread",
"run",
"thread",
"=",
"false",
";",
"thread",
"join",
"(",
"5",
"*",
"1000",
")",
";",
"}",
"return",
"null",
";",
"}",
"}",
")",
";",
"}"
]
|
[
"returns",
"a",
"(",
"wrapped",
")",
"{",
"@",
"link",
"marshalled",
"credential",
"provider",
"}",
"which",
"requires",
"the",
"marshalled",
"credentials",
"to",
"contain",
"session",
"secrets"
]
| [
"public",
"a",
"w",
"s",
"credential",
"provider",
"list",
"bind",
"to",
"token",
"identifier",
"(",
"final",
"abstract",
"s",
"3",
"a",
"token",
"identifier",
"retrieved",
"identifier",
")",
"throws",
"i",
"o",
"exception",
"{",
"role",
"token",
"identifier",
"token",
"identifier",
"=",
"convert",
"token",
"identifier",
"(",
"retrieved",
"identifier",
",",
"role",
"token",
"identifier",
"class",
")",
";",
"set",
"token",
"identifier",
"(",
"optional",
"of",
"(",
"token",
"identifier",
")",
")",
";",
"marshalled",
"credentials",
"marshalled",
"credentials",
"=",
"token",
"identifier",
"get",
"marshalled",
"credentials",
"(",
")",
";",
"set",
"expiration",
"date",
"time",
"(",
"marshalled",
"credentials",
"get",
"expiration",
"date",
"time",
"(",
")",
")",
";",
"return",
"new",
"a",
"w",
"s",
"credential",
"provider",
"list",
"(",
"\"",
"role",
"token",
"binding",
"\"",
",",
"new",
"marshalled",
"credential",
"provider",
"(",
"component",
",",
"get",
"store",
"context",
"(",
")",
"get",
"fs",
"u",
"r",
"i",
"(",
")",
",",
"get",
"config",
"(",
")",
",",
"marshalled",
"credentials",
",",
"marshalled",
"credentials",
"credential",
"type",
"required",
"session",
"only",
")",
")",
";",
"}"
]
|
[
"test",
"serialization",
"and",
"deserialization",
"of",
"the",
"test",
"shape"
]
| [
"public",
"void",
"test",
"serialization",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"for",
"(",
"int",
"runs",
"=",
"0",
";",
"runs",
"<",
"number",
"of",
"testbuilders",
";",
"runs",
"+",
"+",
")",
"{",
"sb",
"test",
"shape",
"=",
"create",
"test",
"shape",
"builder",
"(",
")",
";",
"sb",
"deserialized",
"shape",
"=",
"copy",
"shape",
"(",
"test",
"shape",
")",
";",
"assert",
"equals",
"(",
"test",
"shape",
",",
"deserialized",
"shape",
")",
";",
"assert",
"equals",
"(",
"test",
"shape",
"hash",
"code",
"(",
")",
",",
"deserialized",
"shape",
"hash",
"code",
"(",
")",
")",
";",
"assert",
"not",
"same",
"(",
"test",
"shape",
",",
"deserialized",
"shape",
")",
";",
"}",
"}"
]
|
[
"collects",
"the",
"attributes",
"of",
"this",
"field",
"into",
"the",
"given",
"set",
"of",
"attribute",
"prototypes"
]
| [
"final",
"void",
"collect",
"attribute",
"prototypes",
"(",
"final",
"attribute",
"set",
"attribute",
"prototypes",
")",
"{",
"attribute",
"prototypes",
"add",
"attributes",
"(",
"first",
"attribute",
")",
";",
"}"
]
|
[
"initialize",
"the",
"given",
"{",
"@",
"code",
"message",
"header",
"accessor",
"}"
]
| [
"void",
"init",
"headers",
"(",
"message",
"header",
"accessor",
"header",
"accessor",
")",
";"
]
|
[
"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",
"\"",
")",
";",
"}"
]
|
[
"return",
"the",
"method",
"parameter",
"bound",
"to",
"the",
"request",
"header"
]
| [
"public",
"final",
"method",
"parameter",
"get",
"parameter",
"(",
")",
"{",
"return",
"this",
"parameter",
";",
"}"
]
|
[
"gets",
"the",
"data",
"node",
"rpc",
"port"
]
| [
"public",
"int",
"get",
"port",
"(",
")",
"{",
"return",
"port",
";",
"}"
]
|
[
"test",
"the",
"property",
"'",
"name",
"'"
]
| [
"public",
"void",
"name",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"name",
"}"
]
|
[
"add",
"a",
"custom",
"{",
"@",
"link",
"object",
"error",
"}",
"or",
"{",
"@",
"link",
"field",
"error",
"}",
"to",
"the",
"errors",
"list",
"intended",
"to",
"be",
"used",
"by",
"cooperating",
"strategies",
"such",
"as",
"{",
"@",
"link",
"binding",
"error",
"processor",
"}"
]
| [
"void",
"add",
"error",
"(",
"object",
"error",
"error",
")",
";"
]
|
[
"not",
"supported",
"<",
"b",
">",
"you",
"are",
"attempting",
"to",
"create",
"a",
"multiset",
"that",
"may",
"contain",
"a",
"non",
"-",
"{",
"@",
"code",
"comparable",
"}",
"element",
"<",
"b",
">",
"proper",
"calls",
"will",
"resolve",
"to",
"the",
"version",
"in",
"{",
"@",
"code",
"immutable",
"sorted",
"multiset",
"}",
",",
"not",
"this",
"dummy",
"version"
]
| [
"public",
"static",
"<",
"e",
">",
"immutable",
"sorted",
"multiset",
"<",
"e",
">",
"of",
"(",
"e",
"e",
"1",
",",
"e",
"e",
"2",
",",
"e",
"e",
"3",
",",
"e",
"e",
"4",
")",
"{",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
")",
";",
"}"
]
|
[
"parses",
"a",
"job",
"i",
"d",
"from",
"the",
"given",
"string"
]
| [
"public",
"static",
"job",
"i",
"d",
"from",
"hex",
"string",
"(",
"string",
"hex",
"string",
")",
"{",
"try",
"{",
"return",
"new",
"job",
"i",
"d",
"(",
"string",
"utils",
"hex",
"string",
"to",
"byte",
"(",
"hex",
"string",
")",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"cannot",
"parse",
"job",
"i",
"d",
"from",
"\\",
"\"",
"\"",
"+",
"hex",
"string",
"+",
"\"",
"\\",
"\"",
"the",
"expected",
"format",
"is",
"\"",
"+",
"\"",
"[",
"0",
"-",
"9a",
"-",
"f",
"a",
"-",
"f",
"]",
"{",
"32",
"}",
",",
"e",
"g",
"fd",
"7",
"2",
"0",
"1",
"4d",
"4c",
"8",
"6",
"4",
"9",
"9",
"3a",
"2e",
"5a",
"9",
"2",
"8",
"7b",
"4a",
"9c",
"5d",
"\"",
",",
"e",
")",
";",
"}",
"}"
]
|
[
"initializes",
"the",
"registry",
"based",
"on",
"available",
"parameters",
"in",
"the",
"hadoop",
"configuration"
]
| [
"void",
"initialize",
"zones",
"(",
"configuration",
"conf",
")",
"throws",
"i",
"o",
"exception",
"{",
"ttl",
"=",
"conf",
"get",
"time",
"duration",
"(",
"key",
"dns",
"ttl",
",",
"1l",
",",
"time",
"unit",
"seconds",
")",
";",
"record",
"creator",
"factory",
"set",
"ttl",
"(",
"ttl",
")",
";",
"set",
"d",
"n",
"s",
"s",
"e",
"c",
"enabled",
"(",
"conf",
")",
";",
"initialize",
"zones",
"from",
"files",
"(",
"conf",
")",
";",
"zone",
"registry",
"zone",
"=",
"configure",
"zone",
"(",
"name",
"from",
"string",
"(",
"domain",
"name",
")",
",",
"conf",
")",
";",
"zones",
"put",
"(",
"registry",
"zone",
"get",
"origin",
"(",
")",
",",
"registry",
"zone",
")",
";",
"initialize",
"reverse",
"lookup",
"zone",
"(",
"conf",
")",
";",
"string",
"builder",
"builder",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"builder",
"append",
"(",
"\"",
"dns",
"zones",
":",
"\"",
")",
"append",
"(",
"system",
"line",
"separator",
"(",
")",
")",
";",
"for",
"(",
"map",
"entry",
"<",
"name",
",",
"zone",
">",
"entry",
":",
"zones",
"entry",
"set",
"(",
")",
")",
"{",
"builder",
"append",
"(",
"system",
"line",
"separator",
"(",
")",
")",
"append",
"(",
"entry",
"get",
"value",
"(",
")",
")",
";",
"}",
"log",
"info",
"(",
"builder",
"to",
"string",
"(",
")",
")",
";",
"}"
]
|
[
"returns",
"true",
"if",
"both",
"drag",
"offsets",
"(",
"x",
"and",
"y",
")",
"are",
"zero",
"or",
"smaller"
]
| [
"public",
"boolean",
"has",
"no",
"drag",
"offset",
"(",
")",
"{",
"return",
"m",
"trans",
"offset",
"x",
"<",
"=",
"0",
"&",
"&",
"m",
"trans",
"offset",
"y",
"<",
"=",
"0",
";",
"}"
]
|
[
"get",
"the",
"bitfield",
"packing",
"information",
"associated",
"with",
"the",
"underlying",
"data",
"organization"
]
| [
"public",
"default",
"bit",
"field",
"packing",
"get",
"bit",
"field",
"packing",
"(",
")",
"{",
"return",
"get",
"data",
"organization",
"(",
")",
"get",
"bit",
"field",
"packing",
"(",
")",
";",
"}"
]
|
[
"get",
"date",
"time"
]
| [
"public",
"date",
"get",
"date",
"time",
"(",
")",
"{",
"return",
"date",
"time",
";",
"}"
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.