docstring_tokens
list | code_tokens
list |
|---|---|
[
"determine",
"whether",
"the",
"name",
"of",
"the",
"supplied",
"node",
"is",
"equal",
"to",
"the",
"supplied",
"name",
"the",
"default",
"implementation",
"checks",
"the",
"supplied",
"desired",
"name",
"against",
"both",
"{",
"@",
"link",
"node",
"#",
"get",
"node",
"name",
"(",
")",
"}",
"and",
"{",
"@",
"link",
"node",
"#",
"get",
"local",
"name",
"(",
")",
"}",
"subclasses",
"may",
"override",
"the",
"default",
"implementation",
"to",
"provide",
"a",
"different",
"mechanism",
"for",
"comparing",
"node",
"names"
] |
[
"public",
"boolean",
"node",
"name",
"equals",
"(",
"node",
"node",
",",
"string",
"desired",
"name",
")",
"{",
"return",
"desired",
"name",
"equals",
"(",
"node",
"get",
"node",
"name",
"(",
")",
")",
"|",
"|",
"desired",
"name",
"equals",
"(",
"get",
"local",
"name",
"(",
"node",
")",
")",
";",
"}"
] |
[
"find",
"all",
"eligible",
"advisor",
"beans",
"in",
"the",
"current",
"bean",
"factory",
",",
"ignoring",
"factory",
"beans",
"and",
"excluding",
"beans",
"that",
"are",
"currently",
"in",
"creation"
] |
[
"public",
"list",
"<",
"advisor",
">",
"find",
"advisor",
"beans",
"(",
")",
"{",
"/",
"/",
"determine",
"list",
"of",
"advisor",
"bean",
"names",
",",
"if",
"not",
"cached",
"already",
"string",
"[",
"]",
"advisor",
"names",
"=",
"this",
"cached",
"advisor",
"bean",
"names",
";",
"if",
"(",
"advisor",
"names",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"do",
"not",
"initialize",
"factory",
"beans",
"here",
":",
"we",
"need",
"to",
"leave",
"all",
"regular",
"beans",
"/",
"/",
"uninitialized",
"to",
"let",
"the",
"auto",
"-",
"proxy",
"creator",
"apply",
"to",
"them",
"!",
"advisor",
"names",
"=",
"bean",
"factory",
"utils",
"bean",
"names",
"for",
"type",
"including",
"ancestors",
"(",
"this",
"bean",
"factory",
",",
"advisor",
"class",
",",
"true",
",",
"false",
")",
";",
"this",
"cached",
"advisor",
"bean",
"names",
"=",
"advisor",
"names",
";",
"}",
"if",
"(",
"advisor",
"names",
"length",
"=",
"=",
"0",
")",
"{",
"return",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"}",
"list",
"<",
"advisor",
">",
"advisors",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"for",
"(",
"string",
"name",
":",
"advisor",
"names",
")",
"{",
"if",
"(",
"is",
"eligible",
"bean",
"(",
"name",
")",
")",
"{",
"if",
"(",
"this",
"bean",
"factory",
"is",
"currently",
"in",
"creation",
"(",
"name",
")",
")",
"{",
"if",
"(",
"logger",
"is",
"trace",
"enabled",
"(",
")",
")",
"{",
"logger",
"trace",
"(",
"\"",
"skipping",
"currently",
"created",
"advisor",
"'",
"\"",
"+",
"name",
"+",
"\"",
"'",
"\"",
")",
";",
"}",
"}",
"else",
"{",
"try",
"{",
"advisors",
"add",
"(",
"this",
"bean",
"factory",
"get",
"bean",
"(",
"name",
",",
"advisor",
"class",
")",
")",
";",
"}",
"catch",
"(",
"bean",
"creation",
"exception",
"ex",
")",
"{",
"throwable",
"root",
"cause",
"=",
"ex",
"get",
"most",
"specific",
"cause",
"(",
")",
";",
"if",
"(",
"root",
"cause",
"instanceof",
"bean",
"currently",
"in",
"creation",
"exception",
")",
"{",
"bean",
"creation",
"exception",
"bce",
"=",
"(",
"bean",
"creation",
"exception",
")",
"root",
"cause",
";",
"string",
"bce",
"bean",
"name",
"=",
"bce",
"get",
"bean",
"name",
"(",
")",
";",
"if",
"(",
"bce",
"bean",
"name",
"!",
"=",
"null",
"&",
"&",
"this",
"bean",
"factory",
"is",
"currently",
"in",
"creation",
"(",
"bce",
"bean",
"name",
")",
")",
"{",
"if",
"(",
"logger",
"is",
"trace",
"enabled",
"(",
")",
")",
"{",
"logger",
"trace",
"(",
"\"",
"skipping",
"advisor",
"'",
"\"",
"+",
"name",
"+",
"\"",
"'",
"with",
"dependency",
"on",
"currently",
"created",
"bean",
":",
"\"",
"+",
"ex",
"get",
"message",
"(",
")",
")",
";",
"}",
"/",
"/",
"ignore",
":",
"indicates",
"a",
"reference",
"back",
"to",
"the",
"bean",
"we",
"'",
"re",
"trying",
"to",
"advise",
"/",
"/",
"we",
"want",
"to",
"find",
"advisors",
"other",
"than",
"the",
"currently",
"created",
"bean",
"itself",
"continue",
";",
"}",
"}",
"throw",
"ex",
";",
"}",
"}",
"}",
"}",
"return",
"advisors",
";",
"}"
] |
[
"gets",
"the",
"interval",
"(",
"in",
"milliseconds",
")",
"between",
"consecutive",
"attempts",
"to",
"cancel",
"a",
"running",
"task"
] |
[
"public",
"long",
"get",
"task",
"cancellation",
"interval",
"(",
")",
"{",
"return",
"this",
"task",
"cancellation",
"interval",
"millis",
";",
"}"
] |
[
"gets",
"the",
"name",
"of",
"this",
"stream"
] |
[
"public",
"static",
"string",
"get",
"name",
"(",
")",
"{",
"return",
"\"",
"#",
"us",
"\"",
";",
"}"
] |
[
"enabledisable",
"developmental",
"debug"
] |
[
"public",
"void",
"set",
"apply",
"code",
"scope",
"block",
"comments",
"(",
"boolean",
"apply",
"code",
"scope",
"block",
"comments",
")",
"{",
"this",
"apply",
"code",
"scope",
"block",
"comments",
"=",
"apply",
"code",
"scope",
"block",
"comments",
";",
"}"
] |
[
"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",
";",
"}"
] |
[
"create",
"a",
"file",
"status",
"iterator",
"against",
"a",
"provided",
"list",
"of",
"file",
"status",
",",
"with",
"a",
"given",
"status",
"filter"
] |
[
"remote",
"iterator",
"<",
"s",
"3",
"a",
"file",
"status",
">",
"create",
"provided",
"file",
"status",
"iterator",
"(",
"s",
"3",
"a",
"file",
"status",
"[",
"]",
"file",
"statuses",
",",
"path",
"filter",
"filter",
",",
"file",
"status",
"acceptor",
"acceptor",
")",
"{",
"return",
"filtering",
"remote",
"iterator",
"(",
"remote",
"iterator",
"from",
"array",
"(",
"file",
"statuses",
")",
",",
"status",
"-",
">",
"filter",
"accept",
"(",
"status",
"get",
"path",
"(",
")",
")",
"&",
"&",
"acceptor",
"accept",
"(",
"status",
")",
")",
";",
"}"
] |
[
"returns",
"the",
"next",
"fluff",
"(",
"surrounding",
"class",
"names",
")",
"from",
"the",
"descriptor"
] |
[
"public",
"string",
"next",
"fluff",
"(",
")",
"{",
"int",
"fluff",
"start",
"index",
"=",
"index",
";",
"/",
"/",
"find",
"the",
"first",
"token",
"marking",
"the",
"start",
"of",
"a",
"class",
"name",
"'",
"l",
"'",
"or",
"'",
"'",
"loop",
":",
"while",
"(",
"index",
"<",
"descriptor",
"length",
"(",
")",
")",
"{",
"switch",
"(",
"descriptor",
"char",
"at",
"(",
"index",
"+",
"+",
")",
")",
"{",
"case",
"class",
"constants",
"type",
"generic",
"start",
":",
"{",
"nesting",
"level",
"+",
"+",
";",
"/",
"/",
"make",
"sure",
"we",
"have",
"a",
"stack",
"if",
"(",
"accumulated",
"class",
"names",
"=",
"=",
"null",
")",
"{",
"accumulated",
"class",
"names",
"=",
"new",
"stack",
"(",
")",
";",
"}",
"/",
"/",
"remember",
"the",
"accumulated",
"class",
"name",
"accumulated",
"class",
"names",
"push",
"(",
"accumulated",
"class",
"name",
")",
";",
"break",
";",
"}",
"case",
"class",
"constants",
"type",
"generic",
"end",
":",
"{",
"nesting",
"level",
"-",
"-",
";",
"/",
"/",
"return",
"to",
"the",
"accumulated",
"class",
"name",
"outside",
"the",
"/",
"/",
"generic",
"block",
"accumulated",
"class",
"name",
"=",
"(",
"string",
")",
"accumulated",
"class",
"names",
"pop",
"(",
")",
";",
"continue",
"loop",
";",
"}",
"case",
"class",
"constants",
"type",
"generic",
"bound",
":",
"case",
"class",
"constants",
"type",
"array",
":",
"{",
"continue",
"loop",
";",
"}",
"case",
"class",
"constants",
"type",
"class",
"start",
":",
"{",
"/",
"/",
"we",
"'",
"ve",
"found",
"the",
"start",
"of",
"an",
"ordinary",
"class",
"name",
"nesting",
"level",
"+",
"=",
"2",
";",
"is",
"inner",
"class",
"name",
"=",
"false",
";",
"break",
"loop",
";",
"}",
"case",
"class",
"constants",
"type",
"class",
"end",
":",
"{",
"nesting",
"level",
"-",
"=",
"2",
";",
"break",
";",
"}",
"case",
"java",
"constants",
"inner",
"class",
"separator",
":",
"{",
"/",
"/",
"we",
"'",
"ve",
"found",
"the",
"start",
"of",
"an",
"inner",
"class",
"name",
"in",
"a",
"signature",
"is",
"inner",
"class",
"name",
"=",
"true",
";",
"break",
"loop",
";",
"}",
"case",
"class",
"constants",
"type",
"generic",
"variable",
"start",
":",
"{",
"/",
"/",
"we",
"'",
"ve",
"found",
"the",
"start",
"of",
"a",
"type",
"identifier",
"skip",
"to",
"the",
"end",
"while",
"(",
"descriptor",
"char",
"at",
"(",
"index",
"+",
"+",
")",
"!",
"=",
"class",
"constants",
"type",
"class",
"end",
")",
";",
"break",
";",
"}",
"}",
"if",
"(",
"nesting",
"level",
"=",
"=",
"1",
"&",
"&",
"descriptor",
"char",
"at",
"(",
"index",
")",
"!",
"=",
"class",
"constants",
"type",
"generic",
"end",
")",
"{",
"/",
"/",
"we",
"'",
"re",
"at",
"the",
"start",
"of",
"a",
"type",
"parameter",
"skip",
"to",
"the",
"start",
"/",
"/",
"of",
"the",
"bounds",
"while",
"(",
"descriptor",
"char",
"at",
"(",
"index",
"+",
"+",
")",
"!",
"=",
"class",
"constants",
"type",
"generic",
"bound",
")",
";",
"}",
"}",
"return",
"descriptor",
"substring",
"(",
"fluff",
"start",
"index",
",",
"index",
")",
";",
"}"
] |
[
"set",
"a",
"config",
"value",
"to",
"specify",
"how",
"many",
"models",
"should",
"be",
"built",
"at",
"a",
"time",
"if",
"not",
"set",
",",
"or",
"set",
"to",
"null",
",",
"the",
"config",
"value",
"off",
"of",
"the",
"currently",
"set",
"paged",
"list",
"is",
"used",
"if",
"no",
"paged",
"list",
"is",
"set",
",",
"{",
"@",
"link",
"#",
"default",
"config",
"}",
"is",
"used",
"{",
"@",
"link",
"config",
"#",
"initial",
"load",
"size",
"hint",
"}",
"dictates",
"how",
"many",
"models",
"are",
"built",
"on",
"first",
"load",
"this",
"should",
"be",
"several",
"times",
"the",
"number",
"of",
"items",
"shown",
"on",
"screen",
",",
"and",
"is",
"generally",
"equal",
"to",
"or",
"larger",
"than",
"page",
"size",
"{",
"@",
"link",
"config",
"#",
"page",
"size",
"}",
"dictates",
"how",
"many",
"models",
"are",
"built",
"at",
"a",
"time",
"after",
"first",
"load",
"this",
"should",
"be",
"several",
"times",
"the",
"number",
"of",
"items",
"shown",
"on",
"screen",
"(",
"roughly",
"1",
"0x",
",",
"and",
"at",
"least",
"5x",
")",
"if",
"this",
"value",
"is",
"too",
"small",
"models",
"will",
"be",
"rebuilt",
"very",
"often",
"as",
"the",
"user",
"scrolls",
",",
"potentially",
"hurting",
"performance",
"in",
"the",
"worst",
"case",
",",
"if",
"this",
"value",
"is",
"too",
"small",
",",
"not",
"enough",
"models",
"will",
"be",
"created",
"to",
"fill",
"the",
"whole",
"screen",
"and",
"the",
"controller",
"will",
"enter",
"an",
"infinite",
"loop",
"of",
"rebuilding",
"models",
"{",
"@",
"link",
"config",
"#",
"prefetch",
"distance",
"}",
"defines",
"how",
"far",
"from",
"the",
"edge",
"of",
"built",
"models",
"the",
"user",
"must",
"scroll",
"to",
"trigger",
"further",
"model",
"building",
"should",
"be",
"significantly",
"less",
"than",
"page",
"size",
"(",
"roughly",
"14",
")",
",",
"and",
"more",
"than",
"the",
"number",
"of",
"items",
"shown",
"on",
"screen",
"if",
"this",
"value",
"is",
"too",
"big",
"models",
"will",
"be",
"rebuilt",
"very",
"often",
"as",
"the",
"user",
"scrolls",
",",
"potentially",
"hurting",
"performance",
"if",
"this",
"number",
"is",
"too",
"small",
"then",
"the",
"user",
"may",
"have",
"to",
"wait",
"while",
"models",
"are",
"rebuilt",
"as",
"they",
"scroll",
"for",
"example",
",",
"if",
"5",
"items",
"are",
"shown",
"on",
"screen",
"at",
"once",
"you",
"might",
"have",
"a",
"initial",
"load",
"size",
"hint",
"of",
"50",
",",
"a",
"page",
"size",
"of",
"50",
",",
"and",
"a",
"prefetch",
"distance",
"of",
"10"
] |
[
"public",
"void",
"set",
"config",
"(",
"@",
"nullable",
"config",
"config",
")",
"{",
"custom",
"config",
"=",
"config",
";",
"}"
] |
[
"changes",
"the",
"current",
"animation",
"by",
"blending",
"the",
"new",
"on",
"top",
"of",
"the",
"old",
"during",
"the",
"transition",
"time"
] |
[
"protected",
"animation",
"desc",
"animate",
"(",
"final",
"animation",
"desc",
"anim",
",",
"float",
"transition",
"time",
")",
"{",
"if",
"(",
"current",
"=",
"=",
"null",
"|",
"|",
"current",
"loop",
"count",
"=",
"=",
"0",
")",
"current",
"=",
"anim",
";",
"else",
"if",
"(",
"in",
"action",
")",
"queue",
"(",
"anim",
",",
"transition",
"time",
")",
";",
"else",
"if",
"(",
"!",
"allow",
"same",
"animation",
"&",
"&",
"anim",
"!",
"=",
"null",
"&",
"&",
"current",
"animation",
"=",
"=",
"anim",
"animation",
")",
"{",
"anim",
"time",
"=",
"current",
"time",
";",
"animation",
"pool",
"free",
"(",
"current",
")",
";",
"current",
"=",
"anim",
";",
"}",
"else",
"{",
"if",
"(",
"previous",
"!",
"=",
"null",
")",
"{",
"remove",
"animation",
"(",
"previous",
"animation",
")",
";",
"animation",
"pool",
"free",
"(",
"previous",
")",
";",
"}",
"previous",
"=",
"current",
";",
"current",
"=",
"anim",
";",
"transition",
"current",
"time",
"=",
"0f",
";",
"transition",
"target",
"time",
"=",
"transition",
"time",
";",
"}",
"return",
"anim",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"small",
"camel",
"'"
] |
[
"public",
"void",
"small",
"camel",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"small",
"camel",
"}"
] |
[
"returns",
"an",
"instance",
"of",
"{",
"@",
"link",
"yarn",
"exception",
"}"
] |
[
"public",
"static",
"yarn",
"exception",
"get",
"remote",
"exception",
"(",
"string",
"message",
")",
"{",
"return",
"new",
"yarn",
"exception",
"(",
"message",
")",
";",
"}"
] |
[
"user",
"code",
"can",
"call",
"this",
"method",
"to",
"signal",
"that",
"it",
"begins",
"to",
"write",
"a",
"new",
"partition",
"of",
"operator",
"state",
"each",
"previously",
"written",
"partition",
"is",
"considered",
"finalimmutable",
"as",
"soon",
"as",
"this",
"method",
"is",
"called",
"again"
] |
[
"public",
"void",
"start",
"new",
"partition",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"partition",
"offsets",
"add",
"(",
"delegate",
"get",
"pos",
"(",
")",
")",
";",
"}"
] |
[
"returns",
"an",
"immutable",
"sorted",
"multiset",
"containing",
"the",
"given",
"elements",
"sorted",
"by",
"the",
"given",
"{",
"@",
"code",
"comparator",
"}"
] |
[
"public",
"static",
"<",
"e",
">",
"immutable",
"sorted",
"multiset",
"<",
"e",
">",
"copy",
"of",
"(",
"comparator",
"<",
"?",
"super",
"e",
">",
"comparator",
",",
"iterator",
"<",
"?",
"extends",
"e",
">",
"elements",
")",
"{",
"check",
"not",
"null",
"(",
"comparator",
")",
";",
"return",
"new",
"builder",
"<",
"e",
">",
"(",
"comparator",
")",
"add",
"all",
"(",
"elements",
")",
"build",
"(",
")",
";",
"}"
] |
[
"returns",
"if",
"the",
"entry",
"is",
"in",
"the",
"main",
"space",
"'",
"s",
"protected",
"queue"
] |
[
"public",
"boolean",
"in",
"main",
"protected",
"(",
")",
"{",
"return",
"get",
"queue",
"type",
"(",
")",
"=",
"=",
"protected",
";",
"}"
] |
[
"whether",
"the",
"collector",
"requires",
"an",
"extra",
"query",
"to",
"identify",
"the",
"changes"
] |
[
"boolean",
"query",
"for",
"changes",
"(",
")",
";"
] |
[
"use",
"to",
"define",
"the",
"{",
"@",
"link",
"transition",
"animator",
"}",
"that",
"drives",
"the",
"animation",
"the",
"default",
"is",
"a",
"spring"
] |
[
"public",
"transition",
"units",
"builder",
"animator",
"(",
"transition",
"animator",
"animator",
")",
"{",
"m",
"transition",
"animator",
"=",
"animator",
";",
"return",
"this",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] |
[
"public",
"v",
"replace",
"(",
"k",
"key",
",",
"v",
"value",
")",
"{",
"return",
"null",
";",
"}"
] |
[
"adds",
"a",
"key",
"-",
"value",
"mapping",
"to",
"the",
"built",
"multimap",
"if",
"it",
"is",
"not",
"already",
"present"
] |
[
"public",
"builder",
"<",
"k",
",",
"v",
">",
"put",
"(",
"k",
"key",
",",
"v",
"value",
")",
"{",
"super",
"put",
"(",
"key",
",",
"value",
")",
";",
"return",
"this",
";",
"}"
] |
[
"parses",
"the",
"structures",
"referenced",
"by",
"this",
"{",
"@",
"link",
"dyld",
"cache",
"header",
"}",
"from",
"memory"
] |
[
"public",
"void",
"parse",
"from",
"memory",
"(",
"program",
"program",
",",
"address",
"space",
"space",
",",
"message",
"log",
"log",
",",
"task",
"monitor",
"monitor",
")",
"throws",
"cancelled",
"exception",
"{",
"if",
"(",
"header",
"type",
">",
"=",
"6",
")",
"{",
"parse",
"accelerator",
"info",
"(",
"program",
",",
"space",
",",
"log",
",",
"monitor",
")",
";",
"}",
"}"
] |
[
"the",
"total",
"time",
"this",
"request",
"has",
"throttled",
"itself",
"not",
"including",
"the",
"current",
"throttle",
"time",
"if",
"it",
"is",
"currently",
"sleeping"
] |
[
"public",
"time",
"value",
"get",
"throttled",
"(",
")",
"{",
"return",
"throttled",
";",
"}"
] |
[
"fire",
"an",
"alias",
"-",
"registered",
"event"
] |
[
"public",
"void",
"fire",
"alias",
"registered",
"(",
"string",
"bean",
"name",
",",
"string",
"alias",
",",
"@",
"nullable",
"object",
"source",
")",
"{",
"this",
"event",
"listener",
"alias",
"registered",
"(",
"new",
"alias",
"definition",
"(",
"bean",
"name",
",",
"alias",
",",
"source",
")",
")",
";",
"}"
] |
[
"sets",
"the",
"data",
"to",
"be",
"parsed"
] |
[
"public",
"void",
"set",
"data",
"(",
"extractor",
"input",
"extractor",
"input",
")",
"{",
"this",
"byte",
"buffer",
"data",
"=",
"null",
";",
"this",
"extractor",
"input",
"=",
"extractor",
"input",
";",
"end",
"of",
"extractor",
"input",
"=",
"false",
";",
"if",
"(",
"temp",
"buffer",
"=",
"=",
"null",
")",
"{",
"temp",
"buffer",
"=",
"new",
"byte",
"[",
"temp",
"buffer",
"size",
"]",
";",
"}",
"}"
] |
[
"set",
"the",
"instance",
"that",
"matches",
"the",
"one",
"of",
"child",
"schema",
",",
"check",
"the",
"instance",
"parameter",
"is",
"valid",
"against",
"the",
"one",
"of",
"child",
"schemas",
":",
"quadrilateral",
",",
"triangle",
"it",
"could",
"be",
"an",
"instance",
"of",
"the",
"'",
"one",
"of",
"'",
"schemas",
"the",
"one",
"of",
"child",
"schemas",
"may",
"themselves",
"be",
"a",
"composed",
"schema",
"(",
"all",
"of",
",",
"any",
"of",
",",
"one",
"of",
")"
] |
[
"public",
"void",
"set",
"actual",
"instance",
"(",
"object",
"instance",
")",
"{",
"if",
"(",
"instance",
"=",
"=",
"null",
")",
"{",
"super",
"set",
"actual",
"instance",
"(",
"instance",
")",
";",
"return",
";",
"}",
"if",
"(",
"json",
"is",
"instance",
"of",
"(",
"quadrilateral",
"class",
",",
"instance",
",",
"new",
"hash",
"set",
"<",
"class",
"<",
"?",
">",
">",
"(",
")",
")",
")",
"{",
"super",
"set",
"actual",
"instance",
"(",
"instance",
")",
";",
"return",
";",
"}",
"if",
"(",
"json",
"is",
"instance",
"of",
"(",
"triangle",
"class",
",",
"instance",
",",
"new",
"hash",
"set",
"<",
"class",
"<",
"?",
">",
">",
"(",
")",
")",
")",
"{",
"super",
"set",
"actual",
"instance",
"(",
"instance",
")",
";",
"return",
";",
"}",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"invalid",
"instance",
"type",
"must",
"be",
"quadrilateral",
",",
"triangle",
"\"",
")",
";",
"}"
] |
[
"adds",
"a",
"directive",
",",
"skipping",
"most",
"error",
"checking",
"this",
"should",
"only",
"be",
"called",
"internally",
"in",
"special",
"scenarios",
"like",
"edit",
"log",
"replay"
] |
[
"cache",
"directive",
"info",
"add",
"directive",
"from",
"edit",
"log",
"(",
"cache",
"directive",
"info",
"directive",
")",
"throws",
"invalid",
"request",
"exception",
"{",
"long",
"id",
"=",
"directive",
"get",
"id",
"(",
")",
";",
"cache",
"directive",
"entry",
"=",
"new",
"cache",
"directive",
"(",
"directive",
")",
";",
"cache",
"pool",
"pool",
"=",
"cache",
"pools",
"get",
"(",
"directive",
"get",
"pool",
"(",
")",
")",
";",
"add",
"internal",
"(",
"entry",
",",
"pool",
")",
";",
"if",
"(",
"next",
"directive",
"id",
"<",
"=",
"id",
")",
"{",
"next",
"directive",
"id",
"=",
"id",
"+",
"1",
";",
"}",
"return",
"entry",
"to",
"info",
"(",
")",
";",
"}"
] |
[
"sets",
"the",
"total",
"size",
"of",
"the",
"parameters"
] |
[
"private",
"static",
"void",
"set",
"parameter",
"size",
"(",
"method",
"method",
",",
"int",
"parameter",
"size",
")",
"{",
"method",
"optimization",
"info",
"info",
"=",
"method",
"optimization",
"info",
"get",
"method",
"optimization",
"info",
"(",
"method",
")",
";",
"if",
"(",
"info",
"!",
"=",
"null",
")",
"{",
"info",
"set",
"parameter",
"size",
"(",
"parameter",
"size",
")",
";",
"}",
"}"
] |
[
"returns",
"a",
"direct",
"iterator",
"over",
"the",
"keys"
] |
[
"public",
"iterator",
"<",
"integer",
">",
"keys",
"it",
"(",
")",
"{",
"final",
"iterator",
"<",
"int",
"cursor",
">",
"iterator",
"=",
"map",
"keys",
"(",
")",
"iterator",
"(",
")",
";",
"return",
"new",
"iterator",
"<",
"integer",
">",
"(",
")",
"{",
"@",
"override",
"public",
"boolean",
"has",
"next",
"(",
")",
"{",
"return",
"iterator",
"has",
"next",
"(",
")",
";",
"}",
"@",
"override",
"public",
"integer",
"next",
"(",
")",
"{",
"return",
"iterator",
"next",
"(",
")",
"value",
";",
"}",
"@",
"override",
"public",
"void",
"remove",
"(",
")",
"{",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
")",
";",
"}",
"}",
";",
"}"
] |
[
"this",
"method",
"will",
"delegate",
"to",
"the",
"{",
"@",
"link",
"section",
"}",
"spec",
"method",
"annotated",
"with",
"{",
"@",
"link",
"on",
"data",
"bound",
"}"
] |
[
"protected",
"void",
"data",
"bound",
"(",
"section",
"context",
"c",
")",
"{",
"}"
] |
[
"destroy",
"a",
"rigid",
"body",
"given",
"a",
"definition",
"no",
"reference",
"to",
"the",
"definition",
"is",
"retained",
"this",
"function",
"is",
"locked",
"during",
"callbacks",
"@",
"warning",
"this",
"automatically",
"deletes",
"all",
"associated",
"shapes",
"and",
"joints",
"@",
"warning",
"this",
"function",
"is",
"locked",
"during",
"callbacks"
] |
[
"public",
"void",
"destroy",
"body",
"(",
"body",
"body",
")",
"{",
"assert",
"(",
"m",
"body",
"count",
">",
"0",
")",
";",
"assert",
"(",
"is",
"locked",
"(",
")",
"=",
"=",
"false",
")",
";",
"if",
"(",
"is",
"locked",
"(",
")",
")",
"{",
"return",
";",
"}",
"/",
"/",
"delete",
"the",
"attached",
"joints",
"joint",
"edge",
"je",
"=",
"body",
"m",
"joint",
"list",
";",
"while",
"(",
"je",
"!",
"=",
"null",
")",
"{",
"joint",
"edge",
"je",
"0",
"=",
"je",
";",
"je",
"=",
"je",
"next",
";",
"if",
"(",
"m",
"destruction",
"listener",
"!",
"=",
"null",
")",
"{",
"m",
"destruction",
"listener",
"say",
"goodbye",
"(",
"je",
"0",
"joint",
")",
";",
"}",
"destroy",
"joint",
"(",
"je",
"0",
"joint",
")",
";",
"body",
"m",
"joint",
"list",
"=",
"je",
";",
"}",
"body",
"m",
"joint",
"list",
"=",
"null",
";",
"/",
"/",
"delete",
"the",
"attached",
"contacts",
"contact",
"edge",
"ce",
"=",
"body",
"m",
"contact",
"list",
";",
"while",
"(",
"ce",
"!",
"=",
"null",
")",
"{",
"contact",
"edge",
"ce",
"0",
"=",
"ce",
";",
"ce",
"=",
"ce",
"next",
";",
"m",
"contact",
"manager",
"destroy",
"(",
"ce",
"0",
"contact",
")",
";",
"}",
"body",
"m",
"contact",
"list",
"=",
"null",
";",
"fixture",
"f",
"=",
"body",
"m",
"fixture",
"list",
";",
"while",
"(",
"f",
"!",
"=",
"null",
")",
"{",
"fixture",
"f",
"0",
"=",
"f",
";",
"f",
"=",
"f",
"m",
"next",
";",
"if",
"(",
"m",
"destruction",
"listener",
"!",
"=",
"null",
")",
"{",
"m",
"destruction",
"listener",
"say",
"goodbye",
"(",
"f",
"0",
")",
";",
"}",
"f",
"0",
"destroy",
"proxies",
"(",
"m",
"contact",
"manager",
"m",
"broad",
"phase",
")",
";",
"f",
"0",
"destroy",
"(",
")",
";",
"/",
"/",
"todo",
"djm",
"recycle",
"fixtures",
"(",
"here",
"or",
"in",
"that",
"destroy",
"method",
")",
"body",
"m",
"fixture",
"list",
"=",
"f",
";",
"body",
"m",
"fixture",
"count",
"-",
"=",
"1",
";",
"}",
"body",
"m",
"fixture",
"list",
"=",
"null",
";",
"body",
"m",
"fixture",
"count",
"=",
"0",
";",
"/",
"/",
"remove",
"world",
"body",
"list",
"if",
"(",
"body",
"m",
"prev",
"!",
"=",
"null",
")",
"{",
"body",
"m",
"prev",
"m",
"next",
"=",
"body",
"m",
"next",
";",
"}",
"if",
"(",
"body",
"m",
"next",
"!",
"=",
"null",
")",
"{",
"body",
"m",
"next",
"m",
"prev",
"=",
"body",
"m",
"prev",
";",
"}",
"if",
"(",
"body",
"=",
"=",
"m",
"body",
"list",
")",
"{",
"m",
"body",
"list",
"=",
"body",
"m",
"next",
";",
"}",
"-",
"-",
"m",
"body",
"count",
";",
"/",
"/",
"todo",
"djm",
"recycle",
"body",
"}"
] |
[
"prepare",
"the",
"test",
"webapp",
"by",
"creating",
"the",
"directory",
"from",
"the",
"test",
"properties",
"fail",
"if",
"the",
"directory",
"cannot",
"be",
"created"
] |
[
"protected",
"static",
"void",
"prepare",
"test",
"webapp",
"(",
")",
"{",
"string",
"webapps",
"=",
"system",
"get",
"property",
"(",
"test",
"build",
"webapps",
",",
"build",
"webapps",
"dir",
")",
";",
"file",
"test",
"webapp",
"dir",
"=",
"new",
"file",
"(",
"webapps",
"+",
"file",
"separator",
"char",
"+",
"test",
")",
";",
"try",
"{",
"if",
"(",
"!",
"test",
"webapp",
"dir",
"exists",
"(",
")",
")",
"{",
"if",
"(",
"!",
"test",
"webapp",
"dir",
"mkdirs",
"(",
")",
")",
"{",
"fail",
"(",
"\"",
"test",
"webapp",
"dir",
"\"",
"+",
"test",
"webapp",
"dir",
"get",
"canonical",
"path",
"(",
")",
"+",
"\"",
"can",
"not",
"be",
"created",
"\"",
")",
";",
"}",
"}",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"}",
"}"
] |
[
"invalidates",
"all",
"meshes",
"so",
"the",
"next",
"time",
"they",
"are",
"rendered",
"new",
"vbo",
"handles",
"are",
"generated"
] |
[
"public",
"static",
"void",
"invalidate",
"all",
"meshes",
"(",
"application",
"app",
")",
"{",
"array",
"<",
"mesh",
">",
"meshes",
"array",
"=",
"meshes",
"get",
"(",
"app",
")",
";",
"if",
"(",
"meshes",
"array",
"=",
"=",
"null",
")",
"return",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"meshes",
"array",
"size",
";",
"i",
"+",
"+",
")",
"{",
"meshes",
"array",
"get",
"(",
"i",
")",
"vertices",
"invalidate",
"(",
")",
";",
"meshes",
"array",
"get",
"(",
"i",
")",
"indices",
"invalidate",
"(",
")",
";",
"}",
"}"
] |
[
"applies",
"a",
"special",
"case",
"of",
"a",
"reduce",
"transformation",
"(",
"max",
"by",
")",
"on",
"a",
"grouped",
"{",
"@",
"link",
"data",
"set",
"}",
"the",
"transformation",
"consecutively",
"calls",
"a",
"{",
"@",
"link",
"reduce",
"function",
"}",
"until",
"only",
"a",
"single",
"element",
"remains",
"which",
"is",
"the",
"result",
"of",
"the",
"transformation",
"a",
"reduce",
"function",
"combines",
"two",
"elements",
"into",
"one",
"new",
"element",
"of",
"the",
"same",
"type"
] |
[
"public",
"reduce",
"operator",
"<",
"t",
">",
"max",
"by",
"(",
"int",
"fields",
")",
"{",
"/",
"/",
"check",
"for",
"using",
"a",
"tuple",
"if",
"(",
"!",
"this",
"input",
"data",
"set",
"get",
"type",
"(",
")",
"is",
"tuple",
"type",
"(",
")",
"|",
"|",
"!",
"(",
"this",
"input",
"data",
"set",
"get",
"type",
"(",
")",
"instanceof",
"tuple",
"type",
"info",
")",
")",
"{",
"throw",
"new",
"invalid",
"program",
"exception",
"(",
"\"",
"method",
"max",
"by",
"(",
"int",
")",
"only",
"works",
"on",
"tuples",
"\"",
")",
";",
"}",
"return",
"new",
"reduce",
"operator",
"<",
"t",
">",
"(",
"this",
",",
"new",
"select",
"by",
"max",
"function",
"(",
"(",
"tuple",
"type",
"info",
")",
"this",
"input",
"data",
"set",
"get",
"type",
"(",
")",
",",
"fields",
")",
",",
"utils",
"get",
"call",
"location",
"name",
"(",
")",
")",
";",
"}",
"/",
"/",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"/",
"/",
"group",
"operations",
"/",
"/",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-"
] |
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
] |
[
"private",
"string",
"to",
"indented",
"string",
"(",
"java",
"lang",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"gets",
"the",
"original",
"source",
"jars",
"provided",
"as",
"inputs",
"to",
"this",
"rule",
"these",
"should",
"contain",
"java",
"source",
"files",
",",
"but",
"can",
"contain",
"other",
"files",
"as",
"well"
] |
[
"public",
"collection",
"<",
"artifact",
">",
"get",
"source",
"jars",
"(",
")",
"{",
"return",
"source",
"jars",
";",
"}"
] |
[
"gets",
"the",
"name",
"of",
"the",
"rule",
"associated",
"with",
"this",
"rule",
"tag"
] |
[
"public",
"final",
"string",
"get",
"rule",
"name",
"(",
")",
"{",
"return",
"rule",
"name",
";",
"}"
] |
[
"if",
"this",
"returns",
"0",
",",
"no",
"errors",
"were",
"encountered",
"during",
"binding"
] |
[
"public",
"final",
"int",
"get",
"exception",
"count",
"(",
")",
"{",
"return",
"this",
"property",
"access",
"exceptions",
"length",
";",
"}"
] |
[
"tests",
"merge",
"with",
"fallthrough",
"conflict",
"1",
")",
"fallthrough",
"conflict",
"for",
"1",
"0",
"0",
"2f",
"5d",
"(",
"latest",
")",
"vs",
"1",
"0",
"0",
"2f",
"5d",
"(",
"my",
")",
"2",
")",
"mem",
"(",
"latest",
")",
"vs",
"fallthrough",
"(",
"my",
")",
"ref",
"for",
"1",
"0",
"0",
"2f",
"5",
"5",
"choose",
"my",
"for",
"1",
"automerge",
"my",
"from",
"2",
"due",
"to",
"latest",
"rejected",
"in",
"1"
] |
[
"public",
"void",
"test",
"add",
"mem",
"fallthrough",
"conflict",
"5",
"(",
")",
"throws",
"exception",
"{",
"mtf",
"initialize",
"(",
"\"",
"notepad",
"merge",
"listing",
"test",
"\"",
",",
"new",
"program",
"modifier",
"listener",
"(",
")",
"{",
"/",
"*",
"(",
"non",
"-",
"javadoc",
")",
"*",
"@",
"see",
"ghidra",
"framework",
"data",
"program",
"modifier",
"listener",
"#",
"modify",
"latest",
"(",
"ghidra",
"program",
"database",
"program",
"d",
"b",
")",
"*",
"/",
"@",
"override",
"public",
"void",
"modify",
"latest",
"(",
"program",
"d",
"b",
"program",
")",
"{",
"int",
"tx",
"id",
"=",
"program",
"start",
"transaction",
"(",
"\"",
"modify",
"latest",
"program",
"\"",
")",
";",
"boolean",
"commit",
"=",
"false",
";",
"try",
"{",
"reference",
"manager",
"ref",
"mgr",
"=",
"program",
"get",
"reference",
"manager",
"(",
")",
";",
"ref",
"mgr",
"add",
"memory",
"reference",
"(",
"addr",
"(",
"program",
",",
"\"",
"0x",
"0",
"1",
"0",
"0",
"2f",
"4",
"9",
"\"",
")",
",",
"addr",
"(",
"program",
",",
"\"",
"0x",
"0",
"1",
"0",
"0",
"2f",
"5",
"5",
"\"",
")",
",",
"ref",
"type",
"read",
"write",
",",
"source",
"type",
"user",
"defined",
",",
"-",
"1",
")",
";",
"ref",
"mgr",
"add",
"memory",
"reference",
"(",
"addr",
"(",
"program",
",",
"\"",
"0x",
"0",
"1",
"0",
"0",
"2f",
"4",
"9",
"\"",
")",
",",
"addr",
"(",
"program",
",",
"\"",
"0x",
"0",
"1",
"0",
"0",
"2f",
"5d",
"\"",
")",
",",
"ref",
"type",
"fall",
"through",
",",
"source",
"type",
"user",
"defined",
",",
"-",
"1",
")",
";",
"commit",
"=",
"true",
";",
"}",
"finally",
"{",
"program",
"end",
"transaction",
"(",
"tx",
"id",
",",
"commit",
")",
";",
"}",
"}",
"/",
"*",
"(",
"non",
"-",
"javadoc",
")",
"*",
"@",
"see",
"ghidra",
"framework",
"data",
"program",
"modifier",
"listener",
"#",
"modify",
"private",
"(",
"ghidra",
"program",
"database",
"program",
"d",
"b",
")",
"*",
"/",
"@",
"override",
"public",
"void",
"modify",
"private",
"(",
"program",
"d",
"b",
"program",
")",
"{",
"int",
"tx",
"id",
"=",
"program",
"start",
"transaction",
"(",
"\"",
"modify",
"my",
"program",
"\"",
")",
";",
"boolean",
"commit",
"=",
"false",
";",
"try",
"{",
"reference",
"manager",
"ref",
"mgr",
"=",
"program",
"get",
"reference",
"manager",
"(",
")",
";",
"ref",
"mgr",
"add",
"memory",
"reference",
"(",
"addr",
"(",
"program",
",",
"\"",
"0x",
"0",
"1",
"0",
"0",
"2f",
"4",
"9",
"\"",
")",
",",
"addr",
"(",
"program",
",",
"\"",
"0x",
"0",
"1",
"0",
"0",
"2f",
"5",
"5",
"\"",
")",
",",
"ref",
"type",
"fall",
"through",
",",
"source",
"type",
"user",
"defined",
",",
"-",
"1",
")",
";",
"ref",
"mgr",
"add",
"memory",
"reference",
"(",
"addr",
"(",
"program",
",",
"\"",
"0x",
"0",
"1",
"0",
"0",
"2f",
"4",
"9",
"\"",
")",
",",
"addr",
"(",
"program",
",",
"\"",
"0x",
"0",
"1",
"0",
"0",
"2f",
"5d",
"\"",
")",
",",
"ref",
"type",
"read",
"write",
",",
"source",
"type",
"user",
"defined",
",",
"-",
"1",
")",
";",
"commit",
"=",
"true",
";",
"}",
"finally",
"{",
"program",
"end",
"transaction",
"(",
"tx",
"id",
",",
"commit",
")",
";",
"}",
"}",
"}",
")",
";",
"execute",
"merge",
"(",
"ask",
"user",
")",
";",
"choose",
"code",
"unit",
"(",
"\"",
"0x",
"1",
"0",
"0",
"2f",
"4",
"9",
"\"",
",",
"\"",
"0x",
"1",
"0",
"0",
"2f",
"4a",
"\"",
",",
"keep",
"latest",
")",
";",
"/",
"/",
"fallthrough",
"is",
"now",
"a",
"code",
"unit",
"diff",
"wait",
"for",
"merge",
"completion",
"(",
")",
";",
"reference",
"manager",
"ref",
"mgr",
"=",
"result",
"program",
"get",
"reference",
"manager",
"(",
")",
";",
"reference",
"[",
"]",
"refs",
";",
"refs",
"=",
"ref",
"mgr",
"get",
"references",
"from",
"(",
"addr",
"(",
"\"",
"0x",
"0",
"1",
"0",
"0",
"2f",
"4",
"9",
"\"",
")",
",",
"-",
"1",
")",
";",
"assert",
"equals",
"(",
"2",
",",
"refs",
"length",
")",
";",
"arrays",
"sort",
"(",
"refs",
")",
";",
"assert",
"equals",
"(",
"addr",
"(",
"\"",
"0x",
"0",
"1",
"0",
"0",
"2f",
"5",
"5",
"\"",
")",
",",
"refs",
"[",
"0",
"]",
"get",
"to",
"address",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"ref",
"type",
"read",
"write",
",",
"refs",
"[",
"0",
"]",
"get",
"reference",
"type",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"true",
",",
"refs",
"[",
"0",
"]",
"is",
"primary",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"addr",
"(",
"\"",
"0x",
"0",
"1",
"0",
"0",
"2f",
"5d",
"\"",
")",
",",
"refs",
"[",
"1",
"]",
"get",
"to",
"address",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"ref",
"type",
"fall",
"through",
",",
"refs",
"[",
"1",
"]",
"get",
"reference",
"type",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"false",
",",
"refs",
"[",
"1",
"]",
"is",
"primary",
"(",
")",
")",
";",
"}"
] |
[
"concatenate",
"a",
"set",
"of",
"points",
"to",
"a",
"polygon"
] |
[
"private",
"static",
"edge",
"[",
"]",
"concat",
"(",
"int",
"component",
",",
"boolean",
"direction",
",",
"coordinate",
"[",
"]",
"points",
",",
"final",
"int",
"point",
"offset",
",",
"edge",
"[",
"]",
"edges",
",",
"final",
"int",
"edge",
"offset",
",",
"int",
"length",
")",
"{",
"assert",
"edges",
"length",
">",
"=",
"length",
"+",
"edge",
"offset",
";",
"assert",
"points",
"length",
">",
"=",
"length",
"+",
"point",
"offset",
";",
"edges",
"[",
"edge",
"offset",
"]",
"=",
"new",
"edge",
"(",
"points",
"[",
"point",
"offset",
"]",
",",
"null",
")",
";",
"for",
"(",
"int",
"i",
"=",
"1",
";",
"i",
"<",
"length",
";",
"i",
"+",
"+",
")",
"{",
"if",
"(",
"direction",
")",
"{",
"edges",
"[",
"edge",
"offset",
"+",
"i",
"]",
"=",
"new",
"edge",
"(",
"points",
"[",
"point",
"offset",
"+",
"i",
"]",
",",
"edges",
"[",
"edge",
"offset",
"+",
"i",
"-",
"1",
"]",
")",
";",
"edges",
"[",
"edge",
"offset",
"+",
"i",
"]",
"component",
"=",
"component",
";",
"}",
"else",
"if",
"(",
"!",
"edges",
"[",
"edge",
"offset",
"+",
"i",
"-",
"1",
"]",
"coordinate",
"equals",
"(",
"points",
"[",
"point",
"offset",
"+",
"i",
"]",
")",
")",
"{",
"edges",
"[",
"edge",
"offset",
"+",
"i",
"-",
"1",
"]",
"next",
"=",
"edges",
"[",
"edge",
"offset",
"+",
"i",
"]",
"=",
"new",
"edge",
"(",
"points",
"[",
"point",
"offset",
"+",
"i",
"]",
",",
"null",
")",
";",
"edges",
"[",
"edge",
"offset",
"+",
"i",
"-",
"1",
"]",
"component",
"=",
"component",
";",
"}",
"else",
"{",
"throw",
"new",
"invalid",
"shape",
"exception",
"(",
"\"",
"provided",
"shape",
"has",
"duplicate",
"consecutive",
"coordinates",
"at",
":",
"\"",
"+",
"points",
"[",
"point",
"offset",
"+",
"i",
"]",
")",
";",
"}",
"}",
"if",
"(",
"direction",
")",
"{",
"edges",
"[",
"edge",
"offset",
"]",
"set",
"next",
"(",
"edges",
"[",
"edge",
"offset",
"+",
"length",
"-",
"1",
"]",
")",
";",
"edges",
"[",
"edge",
"offset",
"]",
"component",
"=",
"component",
";",
"}",
"else",
"{",
"edges",
"[",
"edge",
"offset",
"+",
"length",
"-",
"1",
"]",
"set",
"next",
"(",
"edges",
"[",
"edge",
"offset",
"]",
")",
";",
"edges",
"[",
"edge",
"offset",
"+",
"length",
"-",
"1",
"]",
"component",
"=",
"component",
";",
"}",
"return",
"edges",
";",
"}"
] |
[
"add",
"a",
"cookie",
"with",
"the",
"given",
"value",
"to",
"the",
"response",
",",
"using",
"the",
"cookie",
"descriptor",
"settings",
"of",
"this",
"generator",
"delegates",
"to",
"{",
"@",
"link",
"#",
"create",
"cookie",
"}",
"for",
"cookie",
"creation"
] |
[
"public",
"void",
"add",
"cookie",
"(",
"http",
"servlet",
"response",
"response",
",",
"string",
"cookie",
"value",
")",
"{",
"assert",
"not",
"null",
"(",
"response",
",",
"\"",
"http",
"servlet",
"response",
"must",
"not",
"be",
"null",
"\"",
")",
";",
"cookie",
"cookie",
"=",
"create",
"cookie",
"(",
"cookie",
"value",
")",
";",
"integer",
"max",
"age",
"=",
"get",
"cookie",
"max",
"age",
"(",
")",
";",
"if",
"(",
"max",
"age",
"!",
"=",
"null",
")",
"{",
"cookie",
"set",
"max",
"age",
"(",
"max",
"age",
")",
";",
"}",
"if",
"(",
"is",
"cookie",
"secure",
"(",
")",
")",
"{",
"cookie",
"set",
"secure",
"(",
"true",
")",
";",
"}",
"if",
"(",
"is",
"cookie",
"http",
"only",
"(",
")",
")",
"{",
"cookie",
"set",
"http",
"only",
"(",
"true",
")",
";",
"}",
"response",
"add",
"cookie",
"(",
"cookie",
")",
";",
"if",
"(",
"logger",
"is",
"trace",
"enabled",
"(",
")",
")",
"{",
"logger",
"trace",
"(",
"\"",
"added",
"cookie",
"[",
"\"",
"+",
"get",
"cookie",
"name",
"(",
")",
"+",
"\"",
"=",
"\"",
"+",
"cookie",
"value",
"+",
"\"",
"]",
"\"",
")",
";",
"}",
"}"
] |
[
"called",
"repeatedly",
"by",
"the",
"player",
"when",
"it",
"'",
"s",
"loading",
"the",
"source",
",",
"has",
"yet",
"to",
"start",
"playback",
",",
"and",
"has",
"the",
"minimum",
"amount",
"of",
"data",
"necessary",
"for",
"playback",
"to",
"be",
"started",
"the",
"value",
"returned",
"determines",
"whether",
"playback",
"is",
"actually",
"started",
"the",
"load",
"control",
"may",
"opt",
"to",
"return",
"{",
"@",
"code",
"false",
"}",
"until",
"some",
"condition",
"has",
"been",
"met",
"(",
"e",
"g",
"a",
"certain",
"amount",
"of",
"media",
"is",
"buffered",
")"
] |
[
"boolean",
"should",
"start",
"playback",
"(",
"long",
"buffered",
"duration",
"us",
",",
"float",
"playback",
"speed",
",",
"boolean",
"rebuffering",
")",
";"
] |
[
"fetch",
"any",
"sessions",
"with",
"the",
"matching",
"key",
"and",
"the",
"sessions",
"end",
"is",
"&",
"ge",
";",
"earliest",
"session",
"end",
"time",
"and",
"the",
"sessions",
"start",
"is",
"&",
"le",
";",
"latest",
"session",
"start",
"time",
"iterating",
"from",
"latest",
"to",
"earliest",
"this",
"iterator",
"must",
"be",
"closed",
"after",
"use"
] |
[
"default",
"key",
"value",
"iterator",
"<",
"windowed",
"<",
"k",
">",
",",
"agg",
">",
"backward",
"find",
"sessions",
"(",
"final",
"k",
"key",
",",
"final",
"long",
"earliest",
"session",
"end",
"time",
",",
"final",
"long",
"latest",
"session",
"start",
"time",
")",
"{",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
"\"",
"this",
"api",
"is",
"not",
"supported",
"by",
"this",
"implementation",
"of",
"read",
"only",
"session",
"store",
"\"",
")",
";",
"}"
] |
[
"clear",
"job",
"state",
"form",
"the",
"registry",
",",
"usually",
"called",
"after",
"job",
"finish"
] |
[
"void",
"clear",
"job",
"(",
"job",
"i",
"d",
"job",
"i",
"d",
")",
"throws",
"i",
"o",
"exception",
";"
] |
[
"returns",
"base",
"6",
"4",
"representation",
"of",
"specified",
"byte",
"array"
] |
[
"public",
"static",
"string",
"encode",
"(",
"byte",
"[",
"]",
"data",
")",
"{",
"return",
"encode",
"(",
"data",
",",
"0",
",",
"data",
"length",
")",
";",
"}"
] |
[
"parses",
"the",
"given",
"string",
"with",
"a",
"default",
"unit"
] |
[
"public",
"static",
"memory",
"size",
"parse",
"(",
"string",
"text",
",",
"memory",
"unit",
"default",
"unit",
")",
"throws",
"illegal",
"argument",
"exception",
"{",
"if",
"(",
"!",
"has",
"unit",
"(",
"text",
")",
")",
"{",
"return",
"parse",
"(",
"text",
"+",
"default",
"unit",
"get",
"units",
"(",
")",
"[",
"0",
"]",
")",
";",
"}",
"return",
"parse",
"(",
"text",
")",
";",
"}"
] |
[
"look",
"up",
"the",
"best",
"-",
"matching",
"handler",
"method",
"for",
"the",
"current",
"request",
"if",
"multiple",
"matches",
"are",
"found",
",",
"the",
"best",
"match",
"is",
"selected"
] |
[
"protected",
"handler",
"method",
"lookup",
"handler",
"method",
"(",
"string",
"lookup",
"path",
",",
"http",
"servlet",
"request",
"request",
")",
"throws",
"exception",
"{",
"list",
"<",
"match",
">",
"matches",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"list",
"<",
"t",
">",
"direct",
"path",
"matches",
"=",
"this",
"mapping",
"registry",
"get",
"mappings",
"by",
"direct",
"path",
"(",
"lookup",
"path",
")",
";",
"if",
"(",
"direct",
"path",
"matches",
"!",
"=",
"null",
")",
"{",
"add",
"matching",
"mappings",
"(",
"direct",
"path",
"matches",
",",
"matches",
",",
"request",
")",
";",
"}",
"if",
"(",
"matches",
"is",
"empty",
"(",
")",
")",
"{",
"add",
"matching",
"mappings",
"(",
"this",
"mapping",
"registry",
"get",
"registrations",
"(",
")",
"key",
"set",
"(",
")",
",",
"matches",
",",
"request",
")",
";",
"}",
"if",
"(",
"!",
"matches",
"is",
"empty",
"(",
")",
")",
"{",
"match",
"best",
"match",
"=",
"matches",
"get",
"(",
"0",
")",
";",
"if",
"(",
"matches",
"size",
"(",
")",
">",
"1",
")",
"{",
"comparator",
"<",
"match",
">",
"comparator",
"=",
"new",
"match",
"comparator",
"(",
"get",
"mapping",
"comparator",
"(",
"request",
")",
")",
";",
"matches",
"sort",
"(",
"comparator",
")",
";",
"best",
"match",
"=",
"matches",
"get",
"(",
"0",
")",
";",
"if",
"(",
"logger",
"is",
"trace",
"enabled",
"(",
")",
")",
"{",
"logger",
"trace",
"(",
"matches",
"size",
"(",
")",
"+",
"\"",
"matching",
"mappings",
":",
"\"",
"+",
"matches",
")",
";",
"}",
"if",
"(",
"cors",
"utils",
"is",
"pre",
"flight",
"request",
"(",
"request",
")",
")",
"{",
"return",
"preflight",
"ambiguous",
"match",
";",
"}",
"match",
"second",
"best",
"match",
"=",
"matches",
"get",
"(",
"1",
")",
";",
"if",
"(",
"comparator",
"compare",
"(",
"best",
"match",
",",
"second",
"best",
"match",
")",
"=",
"=",
"0",
")",
"{",
"method",
"m",
"1",
"=",
"best",
"match",
"handler",
"method",
"get",
"method",
"(",
")",
";",
"method",
"m",
"2",
"=",
"second",
"best",
"match",
"handler",
"method",
"get",
"method",
"(",
")",
";",
"string",
"uri",
"=",
"request",
"get",
"request",
"u",
"r",
"i",
"(",
")",
";",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"ambiguous",
"handler",
"methods",
"mapped",
"for",
"'",
"\"",
"+",
"uri",
"+",
"\"",
"'",
":",
"{",
"\"",
"+",
"m",
"1",
"+",
"\"",
",",
"\"",
"+",
"m",
"2",
"+",
"\"",
"}",
"\"",
")",
";",
"}",
"}",
"request",
"set",
"attribute",
"(",
"best",
"matching",
"handler",
"attribute",
",",
"best",
"match",
"handler",
"method",
")",
";",
"handle",
"match",
"(",
"best",
"match",
"mapping",
",",
"lookup",
"path",
",",
"request",
")",
";",
"return",
"best",
"match",
"handler",
"method",
";",
"}",
"else",
"{",
"return",
"handle",
"no",
"match",
"(",
"this",
"mapping",
"registry",
"get",
"registrations",
"(",
")",
"key",
"set",
"(",
")",
",",
"lookup",
"path",
",",
"request",
")",
";",
"}",
"}"
] |
[
"returns",
"<",
"code",
">",
"true",
"<",
"code",
">",
"iff",
"the",
"local",
"node",
"is",
"the",
"master",
"node",
"of",
"the",
"cluster"
] |
[
"public",
"boolean",
"local",
"node",
"master",
"(",
")",
"{",
"return",
"state",
"nodes",
"(",
")",
"is",
"local",
"node",
"elected",
"master",
"(",
")",
";",
"}"
] |
[
"return",
"a",
"recycler",
"based",
"on",
"a",
"deque"
] |
[
"public",
"static",
"<",
"t",
">",
"recycler",
"<",
"t",
">",
"deque",
"(",
"recycler",
"c",
"<",
"t",
">",
"c",
",",
"int",
"limit",
")",
"{",
"return",
"new",
"deque",
"recycler",
"<",
">",
"(",
"c",
",",
"new",
"array",
"deque",
"<",
">",
"(",
")",
",",
"limit",
")",
";",
"}"
] |
[
"this",
"method",
"gets",
"the",
"value",
"of",
"the",
"{",
"@",
"link",
"#",
"reaches",
"into",
"outer",
"context",
"}",
"field",
"as",
"it",
"existed",
"prior",
"to",
"the",
"introduction",
"of",
"the",
"{",
"@",
"link",
"#",
"is",
"precedence",
"filter",
"suppressed",
"}",
"method"
] |
[
"public",
"final",
"int",
"get",
"outer",
"context",
"depth",
"(",
")",
"{",
"return",
"reaches",
"into",
"outer",
"context",
"&",
"~",
"suppress",
"precedence",
"filter",
";",
"}"
] |
[
"check",
"if",
"the",
"execution",
"has",
"been",
"cancelled"
] |
[
"boolean",
"is",
"cancelled",
"(",
")",
";"
] |
[
"returns",
"true",
"if",
"the",
"given",
"file",
"is",
"loaded"
] |
[
"public",
"boolean",
"is",
"loaded",
"(",
")",
"{",
"return",
"this",
"loaded",
";",
"}"
] |
[
"is",
"dynamic",
"client",
"registration",
"request",
"protected",
"boolean"
] |
[
"private",
"boolean",
"is",
"dynamic",
"client",
"registration",
"request",
"protected",
"(",
")",
"{",
"return",
"this",
"dynamic",
"client",
"registration",
"mode",
"=",
"=",
"oidc",
"constants",
"dynamic",
"client",
"registration",
"mode",
"protected",
";",
"}"
] |
[
"returns",
"the",
"comparator",
"that",
"orders",
"the",
"elements",
",",
"which",
"is",
"{",
"@",
"link",
"ordering",
"#",
"natural",
"(",
")",
"}",
"when",
"the",
"natural",
"ordering",
"of",
"the",
"elements",
"is",
"used",
"note",
"that",
"its",
"behavior",
"is",
"not",
"consistent",
"with",
"{",
"@",
"link",
"sorted",
"set",
"#",
"comparator",
"(",
")",
"}",
",",
"which",
"returns",
"{",
"@",
"code",
"null",
"}",
"to",
"indicate",
"natural",
"ordering"
] |
[
"public",
"comparator",
"<",
"?",
"super",
"e",
">",
"comparator",
"(",
")",
"{",
"return",
"comparator",
";",
"}"
] |
[
"attempt",
"to",
"acquire",
"a",
"sempahore",
"within",
"a",
"given",
"timeout",
"this",
"is",
"useful",
"for",
"unit",
"tests",
"where",
"we",
"need",
"to",
"ignore",
"interrupted",
"exception",
"when",
"attempting",
"to",
"take",
"a",
"semaphore",
",",
"but",
"still",
"want",
"to",
"honor",
"the",
"overall",
"test",
"timeout"
] |
[
"private",
"void",
"uninterruptibly",
"acquire",
"(",
"long",
"timeout",
"ms",
")",
"throws",
"exception",
"{",
"long",
"start",
"time",
"ms",
"=",
"time",
"monotonic",
"now",
"(",
")",
";",
"while",
"(",
"true",
")",
"{",
"long",
"rem",
"time",
"=",
"start",
"time",
"ms",
"+",
"timeout",
"ms",
"-",
"time",
"monotonic",
"now",
"(",
")",
";",
"if",
"(",
"rem",
"time",
"<",
"0",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"failed",
"to",
"acquire",
"the",
"semaphore",
"within",
"\"",
"+",
"timeout",
"ms",
"+",
"\"",
"milliseconds",
"\"",
")",
";",
"}",
"try",
"{",
"if",
"(",
"sem",
"try",
"acquire",
"(",
"1",
",",
"rem",
"time",
",",
"time",
"unit",
"milliseconds",
")",
")",
"{",
"return",
";",
"}",
"}",
"catch",
"(",
"interrupted",
"exception",
"e",
")",
"{",
"got",
"interruption",
"set",
"(",
"true",
")",
";",
"}",
"}",
"}"
] |
[
"parser",
"to",
"convert",
"a",
"string",
"representation",
"of",
"a",
"placement",
"spec",
"to",
"mapping",
"from",
"source",
"tag",
"to",
"placement",
"constraint"
] |
[
"public",
"static",
"map",
"<",
"string",
",",
"placement",
"spec",
">",
"parse",
"(",
"string",
"specs",
")",
"throws",
"illegal",
"argument",
"exception",
"{",
"log",
"info",
"(",
"\"",
"parsing",
"placement",
"specs",
":",
"[",
"{",
"}",
"]",
"\"",
",",
"specs",
")",
";",
"map",
"<",
"string",
",",
"placement",
"spec",
">",
"p",
"specs",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"map",
"<",
"source",
"tags",
",",
"placement",
"constraint",
">",
"parsed",
";",
"try",
"{",
"parsed",
"=",
"placement",
"constraint",
"parser",
"parse",
"placement",
"spec",
"(",
"specs",
")",
";",
"for",
"(",
"map",
"entry",
"<",
"source",
"tags",
",",
"placement",
"constraint",
">",
"entry",
":",
"parsed",
"entry",
"set",
"(",
")",
")",
"{",
"log",
"info",
"(",
"\"",
"parsed",
"source",
"tag",
":",
"{",
"}",
",",
"number",
"of",
"allocations",
":",
"{",
"}",
"\"",
",",
"entry",
"get",
"key",
"(",
")",
"get",
"tag",
"(",
")",
",",
"entry",
"get",
"key",
"(",
")",
"get",
"num",
"of",
"allocations",
"(",
")",
")",
";",
"if",
"(",
"entry",
"get",
"value",
"(",
")",
"!",
"=",
"null",
")",
"{",
"log",
"info",
"(",
"\"",
"parsed",
"constraint",
":",
"{",
"}",
"\"",
",",
"entry",
"get",
"value",
"(",
")",
"get",
"constraint",
"expr",
"(",
")",
"get",
"class",
"(",
")",
"get",
"simple",
"name",
"(",
")",
")",
";",
"}",
"else",
"{",
"log",
"info",
"(",
"\"",
"parsed",
"constraint",
"empty",
"\"",
")",
";",
"}",
"p",
"specs",
"put",
"(",
"entry",
"get",
"key",
"(",
")",
"get",
"tag",
"(",
")",
",",
"new",
"placement",
"spec",
"(",
"entry",
"get",
"key",
"(",
")",
"get",
"tag",
"(",
")",
",",
"entry",
"get",
"key",
"(",
")",
"get",
"num",
"of",
"allocations",
"(",
")",
",",
"entry",
"get",
"value",
"(",
")",
")",
")",
";",
"}",
"return",
"p",
"specs",
";",
"}",
"catch",
"(",
"placement",
"constraint",
"parse",
"exception",
"e",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"invalid",
"placement",
"spec",
":",
"\"",
"+",
"specs",
",",
"e",
")",
";",
"}",
"}"
] |
[
"add",
"the",
"given",
",",
"single",
"header",
"value",
"under",
"the",
"given",
"name"
] |
[
"public",
"void",
"add",
"(",
"string",
"header",
"name",
",",
"@",
"nullable",
"string",
"header",
"value",
")",
"{",
"this",
"headers",
"add",
"(",
"header",
"name",
",",
"header",
"value",
")",
";",
"}"
] |
[
"this",
"method",
"is",
"only",
"meant",
"to",
"be",
"called",
"internally",
"by",
"{",
"@",
"link",
"executor",
"}"
] |
[
"public",
"void",
"set",
"executable",
"(",
"executable",
"executable",
")",
"{",
"this",
"executable",
"=",
"executable",
";",
"if",
"(",
"executable",
"instanceof",
"run",
")",
"{",
"(",
"(",
"run",
")",
"executable",
")",
"set",
"queue",
"id",
"(",
"context",
"item",
"get",
"id",
"(",
")",
")",
";",
"}",
"}"
] |
[
"check",
"if",
"the",
"given",
"name",
"is",
"contained",
"in",
"the",
"list",
"of",
"matches"
] |
[
"public",
"boolean",
"contains",
"raw",
"name",
"(",
"string",
"name",
")",
"{",
"return",
"raw",
"names",
"contains",
"(",
"name",
")",
";",
"}"
] |
[
"batch",
"publish",
"sequences",
"called",
"when",
"all",
"of",
"the",
"events",
"have",
"been",
"filled"
] |
[
"void",
"publish",
"(",
"long",
"lo",
",",
"long",
"hi",
")",
";"
] |
[
"get",
"enum",
"string",
"required"
] |
[
"public",
"enum",
"string",
"required",
"enum",
"get",
"enum",
"string",
"required",
"(",
")",
"{",
"return",
"enum",
"string",
"required",
";",
"}"
] |
[
"retrieves",
"additional",
"configuration",
"for",
"the",
"graph",
"generation",
"process"
] |
[
"readable",
"config",
"get",
"graph",
"generator",
"config",
"(",
")",
";"
] |
[
"returns",
"the",
"address",
"to",
"the",
"proxy",
",",
"which",
"is",
"already",
"resolved"
] |
[
"public",
"socket",
"address",
"get",
"proxy",
"address",
"(",
")",
"{",
"return",
"proxy",
"address",
";",
"}"
] |
[
"returns",
"numeric",
"docvalues",
"view",
"of",
"raw",
"double",
"bits"
] |
[
"public",
"numeric",
"doc",
"values",
"get",
"raw",
"double",
"values",
"(",
")",
"{",
"return",
"new",
"abstract",
"numeric",
"doc",
"values",
"(",
")",
"{",
"private",
"int",
"doc",
"i",
"d",
"=",
"-",
"1",
";",
"@",
"override",
"public",
"boolean",
"advance",
"exact",
"(",
"int",
"target",
")",
"throws",
"i",
"o",
"exception",
"{",
"doc",
"i",
"d",
"=",
"target",
";",
"return",
"numeric",
"double",
"values",
"this",
"advance",
"exact",
"(",
"target",
")",
";",
"}",
"@",
"override",
"public",
"long",
"long",
"value",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"double",
"double",
"to",
"raw",
"long",
"bits",
"(",
"numeric",
"double",
"values",
"this",
"double",
"value",
"(",
")",
")",
";",
"}",
"@",
"override",
"public",
"int",
"doc",
"i",
"d",
"(",
")",
"{",
"return",
"doc",
"i",
"d",
";",
"}",
"}",
";",
"}"
] |
[
"set",
"the",
"transaction",
"interceptor",
"to",
"use",
"for",
"this",
"advisor"
] |
[
"public",
"void",
"set",
"transaction",
"interceptor",
"(",
"transaction",
"interceptor",
"interceptor",
")",
"{",
"this",
"transaction",
"interceptor",
"=",
"interceptor",
";",
"}"
] |
[
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"the",
"evaluation",
"of",
"the",
"extension",
"must",
"skipped",
"for",
"the",
"given",
"frame",
"otherwise",
"{",
"@",
"code",
"false",
"}"
] |
[
"boolean",
"must",
"skip",
"(",
"web",
"socket",
"frame",
"frame",
")",
";"
] |
[
"if",
"no",
"simple",
"naming",
"context",
"builder",
"is",
"already",
"configuring",
"jndi",
",",
"create",
"and",
"activate",
"one",
"otherwise",
"take",
"the",
"existing",
"activated",
"simple",
"naming",
"context",
"builder",
",",
"clear",
"it",
"and",
"return",
"it",
"this",
"is",
"mainly",
"intended",
"for",
"test",
"suites",
"that",
"want",
"to",
"reinitialize",
"jndi",
"bindings",
"from",
"scratch",
"repeatedly"
] |
[
"public",
"static",
"simple",
"naming",
"context",
"builder",
"empty",
"activated",
"context",
"builder",
"(",
")",
"throws",
"naming",
"exception",
"{",
"simple",
"naming",
"context",
"builder",
"builder",
"=",
"activated",
";",
"if",
"(",
"builder",
"!",
"=",
"null",
")",
"{",
"/",
"/",
"clear",
"already",
"activated",
"context",
"builder",
"builder",
"clear",
"(",
")",
";",
"}",
"else",
"{",
"/",
"/",
"create",
"and",
"activate",
"new",
"context",
"builder",
"builder",
"=",
"new",
"simple",
"naming",
"context",
"builder",
"(",
")",
";",
"/",
"/",
"the",
"activate",
"(",
")",
"call",
"will",
"cause",
"an",
"assignment",
"to",
"the",
"activated",
"variable",
"builder",
"activate",
"(",
")",
";",
"}",
"return",
"builder",
";",
"}"
] |
[
"add",
"a",
"listener"
] |
[
"public",
"spring",
"add",
"listener",
"(",
"spring",
"listener",
"new",
"listener",
")",
"{",
"if",
"(",
"new",
"listener",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"new",
"listener",
"is",
"required",
"\"",
")",
";",
"}",
"m",
"listeners",
"add",
"(",
"new",
"listener",
")",
";",
"return",
"this",
";",
"}"
] |
[
"resolves",
"the",
"current",
"version",
"of",
"the",
"document",
",",
"returning",
"null",
"if",
"not",
"found"
] |
[
"private",
"version",
"value",
"resolve",
"doc",
"version",
"(",
"final",
"operation",
"op",
",",
"boolean",
"load",
"seq",
"no",
")",
"throws",
"i",
"o",
"exception",
"{",
"assert",
"increment",
"version",
"lookup",
"(",
")",
";",
"/",
"/",
"used",
"for",
"asserting",
"in",
"tests",
"version",
"value",
"version",
"value",
"=",
"get",
"version",
"from",
"map",
"(",
"op",
"uid",
"(",
")",
"bytes",
"(",
")",
")",
";",
"if",
"(",
"version",
"value",
"=",
"=",
"null",
")",
"{",
"assert",
"increment",
"index",
"version",
"lookup",
"(",
")",
";",
"/",
"/",
"used",
"for",
"asserting",
"in",
"tests",
"final",
"versions",
"and",
"seq",
"no",
"resolver",
"doc",
"id",
"and",
"version",
"doc",
"id",
"and",
"version",
";",
"try",
"(",
"searcher",
"searcher",
"=",
"acquire",
"searcher",
"(",
"\"",
"load",
"version",
"\"",
",",
"searcher",
"scope",
"internal",
")",
")",
"{",
"doc",
"id",
"and",
"version",
"=",
"versions",
"and",
"seq",
"no",
"resolver",
"load",
"doc",
"id",
"and",
"version",
"(",
"searcher",
"get",
"index",
"reader",
"(",
")",
",",
"op",
"uid",
"(",
")",
",",
"load",
"seq",
"no",
")",
";",
"}",
"if",
"(",
"doc",
"id",
"and",
"version",
"!",
"=",
"null",
")",
"{",
"version",
"value",
"=",
"new",
"index",
"version",
"value",
"(",
"null",
",",
"doc",
"id",
"and",
"version",
"version",
",",
"doc",
"id",
"and",
"version",
"seq",
"no",
",",
"doc",
"id",
"and",
"version",
"primary",
"term",
")",
";",
"}",
"}",
"else",
"if",
"(",
"engine",
"config",
"is",
"enable",
"gc",
"deletes",
"(",
")",
"&",
"&",
"version",
"value",
"is",
"delete",
"(",
")",
"&",
"&",
"(",
"engine",
"config",
"get",
"thread",
"pool",
"(",
")",
"relative",
"time",
"in",
"millis",
"(",
")",
"-",
"(",
"(",
"delete",
"version",
"value",
")",
"version",
"value",
")",
"time",
")",
">",
"get",
"gc",
"deletes",
"in",
"millis",
"(",
")",
")",
"{",
"version",
"value",
"=",
"null",
";",
"}",
"return",
"version",
"value",
";",
"}"
] |
[
"appends",
"a",
"{",
"@",
"link",
"media",
"source",
"}",
"to",
"the",
"playlist"
] |
[
"public",
"synchronized",
"void",
"add",
"media",
"source",
"(",
"media",
"source",
"media",
"source",
")",
"{",
"add",
"media",
"source",
"(",
"media",
"sources",
"public",
"size",
"(",
")",
",",
"media",
"source",
")",
";",
"}"
] |
[
"assert",
"that",
"the",
"on",
"subscribe",
"method",
"was",
"called",
"exactly",
"once"
] |
[
"public",
"final",
"test",
"observer",
"ex",
"<",
"t",
">",
"assert",
"subscribed",
"(",
")",
"{",
"if",
"(",
"upstream",
"get",
"(",
")",
"=",
"=",
"null",
")",
"{",
"throw",
"fail",
"(",
"\"",
"not",
"subscribed",
"!",
"\"",
")",
";",
"}",
"return",
"this",
";",
"}"
] |
[
"generates",
"a",
"mock",
"histogram",
"to",
"use",
"for",
"testing",
"each",
"mock",
"bucket",
"holds",
"a",
"doc",
"count",
",",
"key",
"and",
"document",
"values",
"which",
"can",
"later",
"be",
"used",
"to",
"compute",
"metrics",
"and",
"compare",
"against",
"the",
"real",
"aggregation",
"results",
"gappiness",
"can",
"be",
"controlled",
"via",
"parameters"
] |
[
"public",
"static",
"array",
"list",
"<",
"mock",
"bucket",
">",
"generate",
"histogram",
"(",
"int",
"interval",
",",
"int",
"size",
",",
"double",
"gap",
"probability",
",",
"double",
"run",
"probability",
")",
"{",
"array",
"list",
"<",
"mock",
"bucket",
">",
"values",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"size",
")",
";",
"boolean",
"last",
"was",
"gap",
"=",
"false",
";",
"boolean",
"empty",
"histo",
"=",
"true",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"size",
";",
"i",
"+",
"+",
")",
"{",
"mock",
"bucket",
"bucket",
"=",
"new",
"mock",
"bucket",
"(",
")",
";",
"if",
"(",
"random",
"double",
"(",
")",
"<",
"gap",
"probability",
")",
"{",
"/",
"/",
"start",
"a",
"gap",
"bucket",
"count",
"=",
"0",
";",
"bucket",
"doc",
"values",
"=",
"new",
"double",
"[",
"0",
"]",
";",
"last",
"was",
"gap",
"=",
"true",
";",
"}",
"else",
"if",
"(",
"last",
"was",
"gap",
"&",
"&",
"random",
"double",
"(",
")",
"<",
"run",
"probability",
")",
"{",
"/",
"/",
"add",
"to",
"the",
"existing",
"gap",
"bucket",
"count",
"=",
"0",
";",
"bucket",
"doc",
"values",
"=",
"new",
"double",
"[",
"0",
"]",
";",
"last",
"was",
"gap",
"=",
"true",
";",
"}",
"else",
"{",
"bucket",
"count",
"=",
"random",
"int",
"between",
"(",
"1",
",",
"50",
")",
";",
"bucket",
"doc",
"values",
"=",
"new",
"double",
"[",
"bucket",
"count",
"]",
";",
"for",
"(",
"int",
"j",
"=",
"0",
";",
"j",
"<",
"bucket",
"count",
";",
"j",
"+",
"+",
")",
"{",
"bucket",
"doc",
"values",
"[",
"j",
"]",
"=",
"random",
"double",
"(",
")",
"*",
"random",
"int",
"between",
"(",
"-",
"20",
",",
"20",
")",
";",
"}",
"last",
"was",
"gap",
"=",
"false",
";",
"empty",
"histo",
"=",
"false",
";",
"}",
"bucket",
"key",
"=",
"i",
"*",
"interval",
";",
"values",
"add",
"(",
"bucket",
")",
";",
"}",
"if",
"(",
"empty",
"histo",
")",
"{",
"int",
"idx",
"=",
"random",
"int",
"between",
"(",
"0",
",",
"values",
"size",
"(",
")",
"-",
"1",
")",
";",
"mock",
"bucket",
"bucket",
"=",
"values",
"get",
"(",
"idx",
")",
";",
"bucket",
"count",
"=",
"random",
"int",
"between",
"(",
"1",
",",
"50",
")",
";",
"bucket",
"doc",
"values",
"=",
"new",
"double",
"[",
"bucket",
"count",
"]",
";",
"for",
"(",
"int",
"j",
"=",
"0",
";",
"j",
"<",
"bucket",
"count",
";",
"j",
"+",
"+",
")",
"{",
"bucket",
"doc",
"values",
"[",
"j",
"]",
"=",
"random",
"double",
"(",
")",
"*",
"random",
"int",
"between",
"(",
"-",
"20",
",",
"20",
")",
";",
"}",
"values",
"set",
"(",
"idx",
",",
"bucket",
")",
";",
"}",
"return",
"values",
";",
"}"
] |
[
"obtains",
"the",
"monitoring",
"result",
"currently",
"available",
",",
"or",
"null",
"if",
"no",
"data",
"is",
"available"
] |
[
"public",
"object",
"data",
"(",
"computer",
"c",
")",
"{",
"return",
"get",
"descriptor",
"(",
")",
"get",
"(",
"c",
")",
";",
"}"
] |
[
"rotates",
"this",
"vector",
"by",
"the",
"given",
"angle",
"in",
"degrees",
"around",
"the",
"given",
"axis"
] |
[
"public",
"vector",
"3",
"rotate",
"(",
"final",
"vector",
"3",
"axis",
",",
"float",
"degrees",
")",
"{",
"tmp",
"mat",
"set",
"to",
"rotation",
"(",
"axis",
",",
"degrees",
")",
";",
"return",
"this",
"mul",
"(",
"tmp",
"mat",
")",
";",
"}"
] |
[
"projects",
"a",
"{",
"@",
"link",
"tuple",
"}",
"{",
"@",
"link",
"data",
"stream",
"}",
"to",
"the",
"previously",
"selected",
"fields"
] |
[
"public",
"<",
"t0",
",",
"t1",
",",
"t2",
",",
"t3",
",",
"t4",
",",
"t5",
",",
"t6",
",",
"t7",
",",
"t8",
",",
"t9",
",",
"t10",
",",
"t11",
",",
"t12",
",",
"t13",
",",
"t14",
",",
"t15",
",",
"t16",
",",
"t17",
",",
"t18",
">",
"single",
"output",
"stream",
"operator",
"<",
"tuple",
"1",
"9",
"<",
"t0",
",",
"t1",
",",
"t2",
",",
"t3",
",",
"t4",
",",
"t5",
",",
"t6",
",",
"t7",
",",
"t8",
",",
"t9",
",",
"t10",
",",
"t11",
",",
"t12",
",",
"t13",
",",
"t14",
",",
"t15",
",",
"t16",
",",
"t17",
",",
"t18",
">",
">",
"project",
"tuple",
"1",
"9",
"(",
")",
"{",
"type",
"information",
"<",
"?",
">",
"[",
"]",
"f",
"types",
"=",
"extract",
"field",
"types",
"(",
"field",
"indexes",
",",
"data",
"stream",
"get",
"type",
"(",
")",
")",
";",
"tuple",
"type",
"info",
"<",
"tuple",
"1",
"9",
"<",
"t0",
",",
"t1",
",",
"t2",
",",
"t3",
",",
"t4",
",",
"t5",
",",
"t6",
",",
"t7",
",",
"t8",
",",
"t9",
",",
"t10",
",",
"t11",
",",
"t12",
",",
"t13",
",",
"t14",
",",
"t15",
",",
"t16",
",",
"t17",
",",
"t18",
">",
">",
"t",
"type",
"=",
"new",
"tuple",
"type",
"info",
"<",
"tuple",
"1",
"9",
"<",
"t0",
",",
"t1",
",",
"t2",
",",
"t3",
",",
"t4",
",",
"t5",
",",
"t6",
",",
"t7",
",",
"t8",
",",
"t9",
",",
"t10",
",",
"t11",
",",
"t12",
",",
"t13",
",",
"t14",
",",
"t15",
",",
"t16",
",",
"t17",
",",
"t18",
">",
">",
"(",
"f",
"types",
")",
";",
"return",
"data",
"stream",
"transform",
"(",
"\"",
"projection",
"\"",
",",
"t",
"type",
",",
"new",
"stream",
"project",
"<",
"in",
",",
"tuple",
"1",
"9",
"<",
"t0",
",",
"t1",
",",
"t2",
",",
"t3",
",",
"t4",
",",
"t5",
",",
"t6",
",",
"t7",
",",
"t8",
",",
"t9",
",",
"t10",
",",
"t11",
",",
"t12",
",",
"t13",
",",
"t14",
",",
"t15",
",",
"t16",
",",
"t17",
",",
"t18",
">",
">",
"(",
"field",
"indexes",
",",
"t",
"type",
"create",
"serializer",
"(",
"data",
"stream",
"get",
"execution",
"config",
"(",
")",
")",
")",
")",
";",
"}"
] |
[
"sets",
"the",
"focus",
"point",
"if",
"scale",
"type",
"focus",
"crop",
"is",
"used",
",",
"focus",
"point",
"will",
"attempted",
"to",
"be",
"centered",
"within",
"a",
"view",
"each",
"coordinate",
"is",
"a",
"real",
"number",
"in",
"[",
"0",
",",
"1",
"]",
"range",
",",
"in",
"the",
"coordinate",
"system",
"where",
"top",
"-",
"left",
"corner",
"of",
"the",
"image",
"corresponds",
"to",
"(",
"0",
",",
"0",
")",
"and",
"the",
"bottom",
"-",
"right",
"corner",
"corresponds",
"to",
"(",
"1",
",",
"1",
")"
] |
[
"public",
"void",
"set",
"focus",
"point",
"(",
"@",
"nullable",
"point",
"f",
"focus",
"point",
")",
"{",
"if",
"(",
"objects",
"equal",
"(",
"m",
"focus",
"point",
",",
"focus",
"point",
")",
")",
"{",
"return",
";",
"}",
"if",
"(",
"focus",
"point",
"=",
"=",
"null",
")",
"{",
"m",
"focus",
"point",
"=",
"null",
";",
"}",
"else",
"{",
"if",
"(",
"m",
"focus",
"point",
"=",
"=",
"null",
")",
"{",
"m",
"focus",
"point",
"=",
"new",
"point",
"f",
"(",
")",
";",
"}",
"m",
"focus",
"point",
"set",
"(",
"focus",
"point",
")",
";",
"}",
"configure",
"bounds",
"(",
")",
";",
"invalidate",
"self",
"(",
")",
";",
"}"
] |
[
"adds",
"projection",
"to",
"adjust",
"the",
"field",
"index",
"for",
"join",
"condition",
"e",
"g",
"sql",
":",
"select",
"from",
"l",
"where",
"b",
"in",
"(",
"select",
"count",
"(",
")",
"from",
"r",
"where",
"l",
"c",
"=",
"r",
"f",
"the",
"rel",
"in",
"sub",
"query",
"is",
"`",
"logical",
"aggregate",
"(",
"group",
"=",
"[",
"{",
"}",
"]",
",",
"expr",
"$",
"1",
"=",
"[",
"count",
"(",
")",
"]",
")",
"`",
"after",
"decorrelated",
",",
"it",
"was",
"changed",
"to",
"`",
"logical",
"aggregate",
"(",
"group",
"=",
"[",
"{",
"0",
"}",
"]",
",",
"expr",
"$",
"0",
"=",
"[",
"count",
"(",
")",
"]",
")",
"`",
",",
"and",
"the",
"output",
"index",
"of",
"`",
"count",
"(",
")",
"`",
"was",
"changed",
"from",
"0",
"to",
"1",
"so",
",",
"add",
"a",
"project",
"(",
"`",
"logical",
"project",
"(",
"expr",
"$",
"0",
"=",
"[",
"$",
"1",
"]",
",",
"f",
"=",
"[",
"$",
"0",
"]",
")",
"`",
")",
"to",
"adjust",
"output",
"fields",
"order"
] |
[
"private",
"rel",
"node",
"add",
"projection",
"for",
"in",
"(",
"rel",
"node",
"rel",
"node",
")",
"{",
"if",
"(",
"rel",
"node",
"instanceof",
"logical",
"project",
")",
"{",
"return",
"rel",
"node",
";",
"}",
"rel",
"data",
"type",
"row",
"type",
"=",
"rel",
"node",
"get",
"row",
"type",
"(",
")",
";",
"final",
"list",
"<",
"rex",
"node",
">",
"projects",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"row",
"type",
"get",
"field",
"count",
"(",
")",
";",
"+",
"+",
"i",
")",
"{",
"projects",
"add",
"(",
"rex",
"input",
"ref",
"of",
"(",
"i",
",",
"row",
"type",
")",
")",
";",
"}",
"rel",
"builder",
"clear",
"(",
")",
";",
"rel",
"builder",
"push",
"(",
"rel",
"node",
")",
";",
"rel",
"builder",
"project",
"(",
"projects",
",",
"row",
"type",
"get",
"field",
"names",
"(",
")",
",",
"true",
")",
";",
"return",
"rel",
"builder",
"build",
"(",
")",
";",
"}"
] |
[
"disable",
"write",
"by",
"making",
"the",
"mount",
"point",
"readonly"
] |
[
"static",
"void",
"disable",
"write",
"(",
"string",
"mount",
",",
"configuration",
"conf",
")",
"throws",
"i",
"o",
"exception",
"{",
"set",
"mount",
"read",
"only",
"(",
"mount",
",",
"true",
",",
"conf",
")",
";",
"}"
] |
[
"return",
"the",
"int",
"value",
"in",
"sp"
] |
[
"public",
"static",
"int",
"get",
"int",
"(",
"@",
"non",
"null",
"final",
"string",
"key",
",",
"final",
"int",
"default",
"value",
")",
"{",
"return",
"get",
"int",
"(",
"key",
",",
"default",
"value",
",",
"get",
"default",
"s",
"p",
"utils",
"(",
")",
")",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] |
[
"public",
"final",
"string",
"to",
"string",
"(",
")",
"{",
"return",
"this",
"get",
"class",
"(",
")",
"get",
"simple",
"name",
"(",
")",
"+",
"'",
"@",
"'",
"+",
"system",
"identity",
"hash",
"code",
"(",
"this",
")",
"+",
"\"",
"wrapping",
"\"",
"+",
"delegate",
";",
"}"
] |
[
"determine",
"auto",
"redirect",
"policy",
"for",
"provider"
] |
[
"protected",
"void",
"determine",
"auto",
"redirect",
"policy",
"for",
"provider",
"(",
"final",
"request",
"context",
"context",
",",
"final",
"web",
"application",
"service",
"service",
",",
"final",
"delegated",
"client",
"identity",
"provider",
"configuration",
"provider",
")",
"{",
"if",
"(",
"service",
"!",
"=",
"null",
")",
"{",
"val",
"registered",
"service",
"=",
"services",
"manager",
"find",
"service",
"by",
"(",
"service",
")",
";",
"val",
"delegated",
"policy",
"=",
"registered",
"service",
"get",
"access",
"strategy",
"(",
")",
"get",
"delegated",
"authentication",
"policy",
"(",
")",
";",
"if",
"(",
"delegated",
"policy",
"is",
"exclusive",
"(",
")",
"&",
"&",
"delegated",
"policy",
"get",
"allowed",
"providers",
"(",
")",
"size",
"(",
")",
"=",
"=",
"1",
"&",
"&",
"provider",
"get",
"name",
"(",
")",
"equals",
"ignore",
"case",
"(",
"delegated",
"policy",
"get",
"allowed",
"providers",
"(",
")",
"iterator",
"(",
")",
"next",
"(",
")",
")",
")",
"{",
"logger",
"trace",
"(",
"\"",
"registered",
"service",
"[",
"{",
"}",
"]",
"is",
"exclusively",
"allowed",
"to",
"use",
"provider",
"[",
"{",
"}",
"]",
"\"",
",",
"registered",
"service",
",",
"provider",
")",
";",
"provider",
"set",
"auto",
"redirect",
"(",
"true",
")",
";",
"web",
"utils",
"put",
"delegated",
"authentication",
"provider",
"primary",
"(",
"context",
",",
"provider",
")",
";",
"}",
"}",
"if",
"(",
"web",
"utils",
"get",
"delegated",
"authentication",
"provider",
"primary",
"(",
"context",
")",
"=",
"=",
"null",
"&",
"&",
"provider",
"is",
"auto",
"redirect",
"(",
")",
")",
"{",
"logger",
"trace",
"(",
"\"",
"provider",
"[",
"{",
"}",
"]",
"is",
"configured",
"to",
"auto",
"-",
"redirect",
"\"",
",",
"provider",
")",
";",
"web",
"utils",
"put",
"delegated",
"authentication",
"provider",
"primary",
"(",
"context",
",",
"provider",
")",
";",
"}",
"}"
] |
[
"give",
"the",
"{",
"@",
"link",
"node",
"provisioner",
"}",
"a",
"hint",
"that",
"now",
"would",
"be",
"a",
"good",
"time",
"to",
"think",
"about",
"provisioning",
"some",
"nodes",
"hints",
"are",
"throttled",
"to",
"one",
"every",
"second"
] |
[
"public",
"void",
"suggest",
"review",
"now",
"(",
")",
"{",
"if",
"(",
"!",
"queued",
"review",
")",
"{",
"long",
"delay",
"=",
"time",
"unit",
"seconds",
"to",
"millis",
"(",
"1",
")",
"-",
"(",
"system",
"current",
"time",
"millis",
"(",
")",
"-",
"last",
"suggested",
"review",
")",
";",
"if",
"(",
"delay",
"<",
"0",
")",
"{",
"last",
"suggested",
"review",
"=",
"system",
"current",
"time",
"millis",
"(",
")",
";",
"computer",
"thread",
"pool",
"for",
"remoting",
"submit",
"(",
"(",
")",
"-",
">",
"{",
"logger",
"fine",
"(",
"(",
")",
"-",
">",
"\"",
"running",
"suggested",
"review",
"for",
"\"",
"+",
"label",
")",
";",
"update",
"(",
")",
";",
"}",
")",
";",
"}",
"else",
"{",
"queued",
"review",
"=",
"true",
";",
"logger",
"fine",
"(",
"(",
")",
"-",
">",
"\"",
"running",
"suggested",
"review",
"in",
"\"",
"+",
"delay",
"+",
"\"",
"ms",
"for",
"\"",
"+",
"label",
")",
";",
"timer",
"get",
"(",
")",
"schedule",
"(",
"(",
")",
"-",
">",
"{",
"last",
"suggested",
"review",
"=",
"system",
"current",
"time",
"millis",
"(",
")",
";",
"logger",
"fine",
"(",
"(",
")",
"-",
">",
"\"",
"running",
"suggested",
"review",
"for",
"\"",
"+",
"label",
"+",
"\"",
"after",
"\"",
"+",
"delay",
"+",
"\"",
"ms",
"\"",
")",
";",
"update",
"(",
")",
";",
"}",
",",
"delay",
",",
"time",
"unit",
"milliseconds",
")",
";",
"}",
"}",
"else",
"{",
"logger",
"fine",
"(",
"(",
")",
"-",
">",
"\"",
"ignoring",
"suggested",
"review",
"for",
"\"",
"+",
"label",
")",
";",
"}",
"}"
] |
[
"{",
"@",
"link",
"option",
"#",
"metadata",
"tags",
"(",
")",
"}"
] |
[
"public",
"option",
"metadata",
"tag",
"[",
"]",
"get",
"option",
"metadata",
"tags",
"(",
")",
"{",
"return",
"option",
"annotation",
"metadata",
"tags",
"(",
")",
";",
"}"
] |
[
"returns",
"the",
"float",
"at",
"the",
"current",
"position",
"and",
"increases",
"the",
"position",
"by",
"1"
] |
[
"public",
"abstract",
"float",
"get",
"(",
")",
";"
] |
[
"assert",
"that",
"two",
"messages",
"are",
"equal",
",",
"producing",
"a",
"useful",
"message",
"if",
"not"
] |
[
"public",
"static",
"void",
"assert",
"equals",
"(",
"message",
"lite",
"expected",
",",
"message",
"lite",
"actual",
")",
"{",
"if",
"(",
"expected",
"=",
"=",
"null",
"|",
"|",
"actual",
"=",
"=",
"null",
")",
"{",
"assert",
"assert",
"equals",
"(",
"expected",
",",
"actual",
")",
";",
"}",
"else",
"{",
"if",
"(",
"!",
"expected",
"equals",
"(",
"actual",
")",
")",
"{",
"/",
"/",
"this",
"assert",
"equals",
"should",
"always",
"complete",
"assert",
"assert",
"equals",
"(",
"expected",
"to",
"string",
"(",
")",
",",
"actual",
"to",
"string",
"(",
")",
")",
";",
"/",
"/",
"but",
"if",
"it",
"doesn",
"'",
"t",
",",
"then",
"this",
"should",
"assert",
"assert",
"equals",
"(",
"expected",
",",
"actual",
")",
";",
"assert",
"fail",
"(",
"\"",
"messages",
"not",
"equal",
",",
"but",
"assert",
"equals",
"didn",
"'",
"t",
"throw",
"\"",
")",
";",
"}",
"}",
"}"
] |
[
"the",
"purpose",
"of",
"this",
"test",
"is",
"to",
"ensure",
"that",
"when",
"a",
"job",
"is",
"open",
"through",
"a",
"rolling",
"upgrade",
"we",
"upgrade",
"the",
"results",
"index",
"mappings",
"when",
"it",
"is",
"assigned",
"to",
"an",
"upgraded",
"node",
"even",
"if",
"no",
"other",
"ml",
"endpoint",
"is",
"called",
"after",
"the",
"upgrade"
] |
[
"public",
"void",
"test",
"snapshot",
"upgrader",
"(",
")",
"throws",
"exception",
"{",
"hlrc",
"=",
"new",
"hlrc",
"(",
"client",
"(",
")",
")",
"machine",
"learning",
"(",
")",
";",
"request",
"adjust",
"logging",
"levels",
"=",
"new",
"request",
"(",
"\"",
"put",
"\"",
",",
"\"",
"/",
"cluster",
"/",
"settings",
"\"",
")",
";",
"adjust",
"logging",
"levels",
"set",
"json",
"entity",
"(",
"\"",
"{",
"\\",
"\"",
"transient",
"\\",
"\"",
":",
"{",
"\"",
"+",
"\"",
"\\",
"\"",
"logger",
"org",
"elasticsearch",
"xpack",
"ml",
"\\",
"\"",
":",
"\\",
"\"",
"trace",
"\\",
"\"",
"\"",
"+",
"\"",
"}",
"}",
"\"",
")",
";",
"client",
"(",
")",
"perform",
"request",
"(",
"adjust",
"logging",
"levels",
")",
";",
"switch",
"(",
"cluster",
"type",
")",
"{",
"case",
"old",
":",
"create",
"job",
"and",
"snapshots",
"(",
")",
";",
"break",
";",
"case",
"mixed",
":",
"assume",
"true",
"(",
"\"",
"we",
"should",
"only",
"test",
"if",
"old",
"cluster",
"is",
"before",
"new",
"cluster",
"\"",
",",
"upgrade",
"from",
"version",
"before",
"(",
"version",
"current",
")",
")",
";",
"ensure",
"health",
"(",
"(",
"request",
"-",
">",
"{",
"request",
"add",
"parameter",
"(",
"\"",
"timeout",
"\"",
",",
"\"",
"7",
"0s",
"\"",
")",
";",
"request",
"add",
"parameter",
"(",
"\"",
"wait",
"for",
"nodes",
"\"",
",",
"\"",
"3",
"\"",
")",
";",
"request",
"add",
"parameter",
"(",
"\"",
"wait",
"for",
"status",
"\"",
",",
"\"",
"yellow",
"\"",
")",
";",
"}",
")",
")",
";",
"test",
"snapshot",
"upgrade",
"fails",
"on",
"mixed",
"cluster",
"(",
")",
";",
"break",
";",
"case",
"upgraded",
":",
"assume",
"true",
"(",
"\"",
"we",
"should",
"only",
"test",
"if",
"old",
"cluster",
"is",
"before",
"new",
"cluster",
"\"",
",",
"upgrade",
"from",
"version",
"before",
"(",
"version",
"current",
")",
")",
";",
"ensure",
"health",
"(",
"(",
"request",
"-",
">",
"{",
"request",
"add",
"parameter",
"(",
"\"",
"timeout",
"\"",
",",
"\"",
"7",
"0s",
"\"",
")",
";",
"request",
"add",
"parameter",
"(",
"\"",
"wait",
"for",
"nodes",
"\"",
",",
"\"",
"3",
"\"",
")",
";",
"request",
"add",
"parameter",
"(",
"\"",
"wait",
"for",
"status",
"\"",
",",
"\"",
"yellow",
"\"",
")",
";",
"}",
")",
")",
";",
"test",
"snapshot",
"upgrade",
"(",
")",
";",
"wait",
"for",
"pending",
"upgrader",
"tasks",
"(",
")",
";",
"break",
";",
"default",
":",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
"\"",
"unknown",
"cluster",
"type",
"[",
"\"",
"+",
"cluster",
"type",
"+",
"\"",
"]",
"\"",
")",
";",
"}",
"}"
] |
[
"emits",
"a",
"tuple",
"directly",
"to",
"the",
"specified",
"task",
"id",
"on",
"the",
"default",
"stream",
"if",
"the",
"target",
"bolt",
"does",
"not",
"subscribe",
"to",
"this",
"bolt",
"using",
"a",
"direct",
"grouping",
",",
"the",
"tuple",
"will",
"not",
"be",
"sent",
"if",
"the",
"specified",
"output",
"stream",
"is",
"not",
"declared",
"as",
"direct",
",",
"or",
"the",
"target",
"bolt",
"subscribes",
"with",
"a",
"non",
"-",
"direct",
"grouping",
",",
"an",
"error",
"will",
"occur",
"at",
"runtime",
"the",
"emitted",
"values",
"must",
"be",
"immutable",
"the",
"default",
"stream",
"must",
"be",
"declared",
"as",
"direct",
"in",
"the",
"topology",
"definition",
"see",
"output",
"declarer",
"#",
"declare",
"for",
"how",
"this",
"is",
"done",
"when",
"defining",
"topologies",
"in",
"java",
"note",
"that",
"this",
"method",
"does",
"not",
"use",
"anchors",
",",
"so",
"downstream",
"failures",
"won",
"'",
"t",
"affect",
"the",
"failure",
"status",
"of",
"any",
"spout",
"tuples"
] |
[
"public",
"void",
"emit",
"direct",
"(",
"int",
"task",
"id",
",",
"list",
"<",
"object",
">",
"tuple",
")",
"{",
"emit",
"direct",
"(",
"task",
"id",
",",
"utils",
"default",
"stream",
"id",
",",
"tuple",
")",
";",
"}"
] |
[
"set",
"the",
"default",
"username",
"that",
"this",
"adapter",
"should",
"use",
"for",
"retrieving",
"connections",
"default",
"is",
"no",
"specific",
"user",
"note",
"that",
"an",
"explicitly",
"specified",
"username",
"will",
"always",
"override",
"any",
"usernamepassword",
"specified",
"at",
"the",
"data",
"source",
"level"
] |
[
"public",
"void",
"set",
"username",
"(",
"string",
"username",
")",
"{",
"this",
"username",
"=",
"username",
";",
"}"
] |
[
"parse",
"and",
"validate",
"configs",
"against",
"this",
"configuration",
"definition",
"the",
"input",
"is",
"a",
"map",
"of",
"configs",
"it",
"is",
"expected",
"that",
"the",
"keys",
"of",
"the",
"map",
"are",
"strings",
",",
"but",
"the",
"values",
"can",
"either",
"be",
"strings",
"or",
"they",
"may",
"already",
"be",
"of",
"the",
"appropriate",
"type",
"(",
"int",
",",
"string",
",",
"etc",
")",
"this",
"will",
"work",
"equally",
"well",
"with",
"either",
"java",
"util",
"properties",
"instances",
"or",
"a",
"programmatically",
"constructed",
"map"
] |
[
"public",
"map",
"<",
"string",
",",
"object",
">",
"parse",
"(",
"map",
"<",
"?",
",",
"?",
">",
"props",
")",
"{",
"/",
"/",
"check",
"all",
"configurations",
"are",
"defined",
"list",
"<",
"string",
">",
"undefined",
"config",
"keys",
"=",
"undefined",
"dependent",
"configs",
"(",
")",
";",
"if",
"(",
"!",
"undefined",
"config",
"keys",
"is",
"empty",
"(",
")",
")",
"{",
"string",
"joined",
"=",
"utils",
"join",
"(",
"undefined",
"config",
"keys",
",",
"\"",
",",
"\"",
")",
";",
"throw",
"new",
"config",
"exception",
"(",
"\"",
"some",
"configurations",
"in",
"are",
"referred",
"in",
"the",
"dependents",
",",
"but",
"not",
"defined",
":",
"\"",
"+",
"joined",
")",
";",
"}",
"/",
"/",
"parse",
"all",
"known",
"keys",
"map",
"<",
"string",
",",
"object",
">",
"values",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"for",
"(",
"config",
"key",
"key",
":",
"config",
"keys",
"values",
"(",
")",
")",
"values",
"put",
"(",
"key",
"name",
",",
"parse",
"value",
"(",
"key",
",",
"props",
"get",
"(",
"key",
"name",
")",
",",
"props",
"contains",
"key",
"(",
"key",
"name",
")",
")",
")",
";",
"return",
"values",
";",
"}"
] |
[
"test",
"leader",
"election",
"finished",
"with",
"1",
"disloyal",
"voter",
"and",
"without",
"majority",
"followers",
",",
"expecting",
"to",
"see",
"the",
"quorum",
"stablized",
"only",
"after",
"waiting",
"for",
"max",
"time",
"to",
"wait",
"for",
"epoch"
] |
[
"public",
"void",
"test",
"leader",
"election",
"with",
"disloyal",
"voter",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"test",
"leader",
"election",
"(",
"5",
",",
"3",
",",
"1000",
",",
"10000",
")",
";",
"}"
] |
[
"retrieves",
"a",
"{",
"@",
"link",
"value",
"state",
"}",
"object",
"that",
"can",
"be",
"used",
"to",
"interact",
"with",
"fault",
"-",
"tolerant",
"state",
"that",
"is",
"scoped",
"to",
"the",
"window",
"and",
"key",
"of",
"the",
"current",
"trigger",
"invocation"
] |
[
"<",
"s",
"extends",
"serializable",
">",
"value",
"state",
"<",
"s",
">",
"get",
"key",
"value",
"state",
"(",
"string",
"name",
",",
"class",
"<",
"s",
">",
"state",
"type",
",",
"s",
"default",
"state",
")",
";"
] |
[
"set",
"the",
"{",
"@",
"link",
"message",
"handler",
"method",
"factory",
"}",
"to",
"use",
"to",
"build",
"the",
"{",
"@",
"link",
"invocable",
"handler",
"method",
"}",
"responsible",
"to",
"manage",
"the",
"invocation",
"of",
"this",
"endpoint"
] |
[
"public",
"void",
"set",
"message",
"handler",
"method",
"factory",
"(",
"message",
"handler",
"method",
"factory",
"message",
"handler",
"method",
"factory",
")",
"{",
"this",
"message",
"handler",
"method",
"factory",
"=",
"message",
"handler",
"method",
"factory",
";",
"}"
] |
[
"returns",
"true",
"if",
"this",
"single",
"subject",
"was",
"terminated",
"with",
"a",
"success",
"value"
] |
[
"public",
"boolean",
"has",
"value",
"(",
")",
"{",
"return",
"observers",
"get",
"(",
")",
"=",
"=",
"terminated",
"&",
"&",
"value",
"!",
"=",
"null",
";",
"}"
] |
[
"sets",
"the",
"value",
"of",
"the",
"given",
"{",
"@",
"code",
"entry",
"}",
"in",
"the",
"given",
"{",
"@",
"code",
"segment",
"}",
"to",
"be",
"the",
"given",
"{",
"@",
"code",
"value",
"}"
] |
[
"void",
"set",
"value",
"(",
"s",
"segment",
",",
"e",
"entry",
",",
"v",
"value",
")",
";"
] |
[
"returns",
"the",
"flags"
] |
[
"public",
"long",
"get",
"flags",
"(",
")",
"{",
"return",
"flags",
";",
"}"
] |
[
"test",
"if",
"{",
"@",
"link",
"king",
"joffrey",
"}",
"tells",
"us",
"what",
"event",
"he",
"received"
] |
[
"public",
"void",
"test",
"on",
"event",
"(",
")",
"{",
"final",
"var",
"king",
"joffrey",
"=",
"new",
"king",
"joffrey",
"(",
")",
";",
"int",
"stream",
"range",
"(",
"0",
",",
"event",
"values",
"(",
")",
"length",
")",
"for",
"each",
"(",
"i",
"-",
">",
"{",
"assert",
"equals",
"(",
"i",
",",
"appender",
"get",
"log",
"size",
"(",
")",
")",
";",
"var",
"event",
"=",
"event",
"values",
"(",
")",
"[",
"i",
"]",
";",
"king",
"joffrey",
"on",
"event",
"(",
"event",
")",
";",
"final",
"var",
"expected",
"message",
"=",
"\"",
"received",
"event",
"from",
"the",
"king",
"'",
"s",
"hand",
":",
"\"",
"+",
"event",
"to",
"string",
"(",
")",
";",
"assert",
"equals",
"(",
"expected",
"message",
",",
"appender",
"get",
"last",
"message",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"i",
"+",
"1",
",",
"appender",
"get",
"log",
"size",
"(",
")",
")",
";",
"}",
")",
";",
"}"
] |
[
"returns",
"pet",
"inventories",
"by",
"status",
"returns",
"a",
"map",
"of",
"status",
"codes",
"to",
"quantities"
] |
[
"public",
"map",
"<",
"string",
",",
"integer",
">",
"get",
"inventory",
"(",
")",
"{",
"try",
"{",
"map",
"<",
"string",
",",
"integer",
">",
"response",
"=",
"cache",
"get",
"object",
"(",
"\"",
"/",
"get",
"inventory",
"/",
"response",
"\"",
",",
"map",
"class",
")",
";",
"return",
"response",
";",
"}",
"catch",
"(",
"cache",
"exception",
"e",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"e",
")",
";",
"}",
"}"
] |
[
"resets",
"the",
"data",
"that",
"the",
"buffer",
"reads"
] |
[
"public",
"void",
"reset",
"(",
"byte",
"[",
"]",
"input",
",",
"int",
"start",
",",
"int",
"length",
")",
"{",
"buffer",
"reset",
"(",
"input",
",",
"start",
",",
"length",
")",
";",
"}"
] |
[
"writes",
"a",
"retention",
"lease",
"stats",
"object",
"to",
"a",
"stream",
"in",
"a",
"manner",
"suitable",
"for",
"later",
"reconstruction",
"via",
"{",
"@",
"link",
"#",
"retention",
"lease",
"stats",
"(",
"stream",
"input",
")",
"}",
"(",
"stream",
"input",
")",
"}"
] |
[
"public",
"void",
"write",
"to",
"(",
"final",
"stream",
"output",
"out",
")",
"throws",
"i",
"o",
"exception",
"{",
"retention",
"leases",
"write",
"to",
"(",
"out",
")",
";",
"}"
] |
[
"called",
"after",
"the",
"glfw",
"window",
"is",
"created",
"before",
"this",
"callback",
"is",
"received",
",",
"it",
"'",
"s",
"unsafe",
"to",
"use",
"any",
"{",
"@",
"link",
"lwjgl",
"3",
"window",
"}",
"member",
"functions",
"which",
",",
"for",
"their",
"part",
",",
"involve",
"calling",
"glfw",
"functions",
"for",
"the",
"main",
"window",
",",
"this",
"is",
"an",
"immediate",
"callback",
"from",
"inside",
"{",
"@",
"link",
"lwjgl",
"3",
"application",
"#",
"lwjgl",
"3",
"application",
"(",
"application",
"listener",
",",
"lwjgl",
"3",
"application",
"configuration",
")",
"}"
] |
[
"void",
"created",
"(",
"lwjgl",
"3",
"window",
"window",
")",
";"
] |
[
"removes",
"the",
"address",
"space",
"from",
"this",
"factory"
] |
[
"protected",
"void",
"remove",
"address",
"space",
"(",
"string",
"space",
"name",
")",
"{",
"address",
"space",
"deleted",
"space",
"=",
"space",
"name",
"table",
"get",
"(",
"space",
"name",
")",
";",
"if",
"(",
"deleted",
"space",
"!",
"=",
"null",
")",
"{",
"spaces",
"remove",
"(",
"deleted",
"space",
")",
";",
"space",
"name",
"table",
"remove",
"(",
"deleted",
"space",
"get",
"name",
"(",
")",
")",
";",
"space",
"lookup",
"remove",
"(",
"deleted",
"space",
"get",
"space",
"i",
"d",
"(",
")",
")",
";",
"if",
"(",
"deleted",
"space",
"get",
"type",
"(",
")",
"=",
"=",
"address",
"space",
"type",
"ram",
"|",
"|",
"deleted",
"space",
"get",
"type",
"(",
")",
"=",
"=",
"address",
"space",
"type",
"code",
")",
"{",
"memory",
"address",
"set",
"delete",
"range",
"(",
"deleted",
"space",
"get",
"min",
"address",
"(",
")",
",",
"deleted",
"space",
"get",
"max",
"address",
"(",
")",
")",
";",
"}",
"}",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.