docstring_tokens
list | code_tokens
list |
|---|---|
[
"maps",
"the",
"result",
"of",
"this",
"call",
"into",
"another",
",",
"as",
"defined",
"by",
"the",
"{",
"@",
"code",
"flat",
"mapper",
"}",
"function",
"this",
"is",
"used",
"to",
"chain",
"two",
"remote",
"calls",
"together",
"for",
"example",
",",
"you",
"could",
"use",
"this",
"to",
"chain",
"a",
"list",
"i",
"ds",
"call",
"to",
"a",
"get",
"by",
"i",
"ds",
"call",
"{",
"@",
"code",
"get",
"traces",
"call",
"=",
"get",
"ids",
"call",
"flat",
"map",
"(",
"ids",
"-",
">",
"get",
"traces",
"(",
"ids",
")",
")",
";",
"this",
"would",
"now",
"invoke",
"the",
"chain",
"traces",
"=",
"get",
"traces",
"call",
"enqueue",
"(",
"traces",
"callback",
")",
";",
"}",
"cancelation",
"propagates",
"to",
"the",
"mapped",
"call",
"this",
"method",
"intends",
"to",
"be",
"used",
"for",
"chaining",
"that",
"means",
"\"",
"this",
"\"",
"instance",
"should",
"be",
"discarded",
"in",
"favor",
"of",
"the",
"result",
"of",
"this",
"method"
]
| [
"public",
"final",
"<",
"r",
">",
"call",
"<",
"r",
">",
"flat",
"map",
"(",
"flat",
"mapper",
"<",
"v",
",",
"r",
">",
"flat",
"mapper",
")",
"{",
"return",
"new",
"flat",
"mapping",
"<",
"r",
",",
"v",
">",
"(",
"flat",
"mapper",
",",
"this",
")",
";",
"}"
]
|
[
"{",
"@",
"inherit",
"doc",
"}",
"note",
":",
"list",
"status",
"considers",
"listing",
"from",
"fallback",
"link",
"if",
"available",
"if",
"the",
"same",
"directory",
"path",
"is",
"present",
"in",
"configured",
"mount",
"path",
"as",
"well",
"as",
"in",
"fallback",
"fs",
",",
"then",
"only",
"the",
"fallback",
"path",
"will",
"be",
"listed",
"in",
"the",
"returned",
"result",
"except",
"for",
"link",
"if",
"any",
"of",
"the",
"the",
"immediate",
"children",
"of",
"the",
"given",
"path",
"f",
"is",
"a",
"symlink",
"(",
"mount",
"link",
")",
",",
"the",
"returned",
"file",
"status",
"object",
"of",
"that",
"children",
"would",
"be",
"represented",
"as",
"a",
"symlink",
"it",
"will",
"not",
"be",
"resolved",
"to",
"the",
"target",
"path",
"and",
"will",
"not",
"get",
"the",
"target",
"path",
"file",
"status",
"object",
"the",
"target",
"path",
"will",
"be",
"available",
"via",
"get",
"symlink",
"on",
"that",
"children",
"'",
"s",
"file",
"status",
"object",
"since",
"it",
"represents",
"as",
"symlink",
",",
"is",
"directory",
"on",
"that",
"children",
"'",
"s",
"file",
"status",
"will",
"return",
"false",
"this",
"behavior",
"can",
"be",
"changed",
"by",
"setting",
"an",
"advanced",
"configuration",
"fs",
"viewfs",
"mount",
"links",
"as",
"symlinks",
"to",
"false",
"in",
"this",
"case",
",",
"mount",
"points",
"will",
"be",
"represented",
"as",
"non",
"-",
"symlinks",
"and",
"all",
"the",
"filedirectory",
"attributes",
"like",
"permissions",
",",
"is",
"directory",
"etc",
"will",
"be",
"assigned",
"from",
"it",
"'",
"s",
"resolved",
"target",
"directoryfile",
"if",
"you",
"want",
"to",
"get",
"the",
"file",
"status",
"of",
"target",
"path",
"for",
"that",
"children",
",",
"you",
"may",
"want",
"to",
"use",
"get",
"file",
"status",
"api",
"with",
"that",
"children",
"'",
"s",
"symlink",
"path",
"please",
"see",
"{",
"@",
"link",
"view",
"file",
"system",
"#",
"get",
"file",
"status",
"(",
"path",
"f",
")",
"}",
"note",
":",
"in",
"view",
"file",
"system",
",",
"by",
"default",
"the",
"mount",
"links",
"are",
"represented",
"as",
"symlinks"
]
| [
"public",
"file",
"status",
"[",
"]",
"list",
"status",
"(",
"final",
"path",
"f",
")",
"throws",
"access",
"control",
"exception",
",",
"file",
"not",
"found",
"exception",
",",
"i",
"o",
"exception",
"{",
"inode",
"tree",
"resolve",
"result",
"<",
"file",
"system",
">",
"res",
"=",
"fs",
"state",
"resolve",
"(",
"get",
"uri",
"path",
"(",
"f",
")",
",",
"true",
")",
";",
"file",
"status",
"[",
"]",
"status",
"lst",
"=",
"res",
"target",
"file",
"system",
"list",
"status",
"(",
"res",
"remaining",
"path",
")",
";",
"if",
"(",
"!",
"res",
"is",
"internal",
"dir",
"(",
")",
")",
"{",
"/",
"/",
"we",
"need",
"to",
"change",
"the",
"name",
"in",
"the",
"file",
"status",
"as",
"described",
"in",
"/",
"/",
"{",
"@",
"link",
"#",
"get",
"file",
"status",
"}",
"int",
"i",
"=",
"0",
";",
"for",
"(",
"file",
"status",
"status",
":",
"status",
"lst",
")",
"{",
"status",
"lst",
"[",
"i",
"+",
"+",
"]",
"=",
"fix",
"file",
"status",
"(",
"status",
",",
"get",
"chrooted",
"path",
"(",
"res",
",",
"status",
",",
"f",
")",
")",
";",
"}",
"}",
"return",
"status",
"lst",
";",
"}"
]
|
[
"get",
"the",
"sums",
"for",
"the",
"bellard",
"formula"
]
| [
"public",
"static",
"<",
"t",
"extends",
"container",
"<",
"summation",
">",
">",
"map",
"<",
"parameter",
",",
"sum",
">",
"get",
"sums",
"(",
"long",
"b",
",",
"int",
"parts",
"per",
"sum",
",",
"map",
"<",
"parameter",
",",
"list",
"<",
"t",
">",
">",
"existing",
")",
"{",
"final",
"map",
"<",
"parameter",
",",
"sum",
">",
"sums",
"=",
"new",
"tree",
"map",
"<",
"parameter",
",",
"sum",
">",
"(",
")",
";",
"for",
"(",
"parameter",
"p",
":",
"parameter",
"values",
"(",
")",
")",
"{",
"final",
"sum",
"s",
"=",
"new",
"sum",
"(",
"b",
",",
"p",
",",
"parts",
"per",
"sum",
",",
"existing",
"get",
"(",
"p",
")",
")",
";",
"util",
"out",
"println",
"(",
"\"",
"put",
"\"",
"+",
"s",
")",
";",
"sums",
"put",
"(",
"p",
",",
"s",
")",
";",
"}",
"return",
"sums",
";",
"}"
]
|
[
"verify",
"non",
"-",
"ssl",
"client",
"to",
"ssl",
"server",
"failure"
]
| [
"public",
"void",
"test",
"s",
"s",
"l",
"server",
"failure",
"(",
")",
"throws",
"exception",
"{",
"/",
"/",
"non",
"-",
"ssl",
"client",
"connected",
"to",
"ssl",
"server",
"upload",
"jar",
"file",
"(",
"blob",
"ssl",
"server",
",",
"client",
"config",
")",
";",
"}"
]
|
[
"enter",
"a",
"parse",
"tree",
"produced",
"by",
"the",
"{",
"@",
"code",
"integer",
"literal",
"}",
"labeled",
"alternative",
"in",
"{",
"@",
"link",
"eql",
"base",
"parser",
"#",
"number",
"}"
]
| [
"void",
"enter",
"integer",
"literal",
"(",
"eql",
"base",
"parser",
"integer",
"literal",
"context",
"ctx",
")",
";"
]
|
[
"checks",
"if",
"the",
"provided",
"path",
"string",
"is",
"either",
"null",
"or",
"has",
"zero",
"length",
"and",
"throws",
"a",
"{",
"@",
"link",
"illegal",
"argument",
"exception",
"}",
"if",
"any",
"of",
"the",
"two",
"conditions",
"apply"
]
| [
"private",
"string",
"check",
"path",
"arg",
"(",
"string",
"path",
")",
"{",
"/",
"/",
"disallow",
"construction",
"of",
"a",
"path",
"from",
"an",
"empty",
"string",
"if",
"(",
"path",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"can",
"not",
"create",
"a",
"path",
"from",
"a",
"null",
"string",
"\"",
")",
";",
"}",
"if",
"(",
"path",
"length",
"(",
")",
"=",
"=",
"0",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"can",
"not",
"create",
"a",
"path",
"from",
"an",
"empty",
"string",
"\"",
")",
";",
"}",
"return",
"path",
";",
"}"
]
|
[
"returns",
"a",
"new",
"{",
"@",
"code",
"path",
"fragment",
"}",
"formed",
"by",
"replacing",
"the",
"extension",
"of",
"the",
"last",
"path",
"segment",
"of",
"{",
"@",
"code",
"path",
"}",
"with",
"{",
"@",
"code",
"new",
"extension",
"}",
"null",
"is",
"returned",
"iff",
"{",
"@",
"code",
"path",
"}",
"has",
"zero",
"segments",
"or",
"it",
"doesn",
"'",
"t",
"end",
"with",
"{",
"@",
"code",
"old",
"extension",
"}"
]
| [
"public",
"static",
"path",
"fragment",
"replace",
"extension",
"(",
"path",
"fragment",
"path",
",",
"string",
"new",
"extension",
",",
"string",
"old",
"extension",
")",
"{",
"string",
"base",
"=",
"path",
"get",
"base",
"name",
"(",
")",
";",
"if",
"(",
"!",
"base",
"ends",
"with",
"(",
"old",
"extension",
")",
")",
"{",
"return",
"null",
";",
"}",
"string",
"new",
"base",
"=",
"base",
"substring",
"(",
"0",
",",
"base",
"length",
"(",
")",
"-",
"old",
"extension",
"length",
"(",
")",
")",
"+",
"new",
"extension",
";",
"return",
"path",
"replace",
"name",
"(",
"new",
"base",
")",
";",
"}"
]
|
[
"get",
"super",
"group",
"name"
]
| [
"public",
"static",
"string",
"get",
"super",
"group",
"(",
")",
"{",
"return",
"super",
"group",
";",
"}"
]
|
[
"(",
"1",
",",
"2",
",",
"4",
",",
"8",
")",
"，"
]
| [
"public",
"static",
"<",
"e",
"extends",
"enum",
"<",
"e",
">",
">",
"long",
"generate",
"bits",
"(",
"final",
"class",
"<",
"e",
">",
"enum",
"class",
",",
"final",
"e",
"values",
")",
"{",
"return",
"enum",
"utils",
"generate",
"bit",
"vector",
"(",
"enum",
"class",
",",
"values",
")",
";",
"}"
]
|
[
"sets",
"the",
"<",
"code",
">",
"prefix",
"integer",
"<",
"code",
">",
"property"
]
| [
"public",
"void",
"set",
"prefix",
"integer",
"(",
"integer",
"prefix",
"integer",
")",
"{",
"this",
"prefix",
"integer",
"=",
"prefix",
"integer",
";",
"}"
]
|
[
"queue",
"an",
"animation",
"to",
"be",
"applied",
"when",
"the",
"{",
"@",
"link",
"#",
"current",
"}",
"animation",
"is",
"finished",
"if",
"the",
"current",
"animation",
"is",
"continuously",
"looping",
"it",
"will",
"be",
"synchronized",
"on",
"next",
"loop"
]
| [
"public",
"animation",
"desc",
"queue",
"(",
"final",
"string",
"id",
",",
"float",
"offset",
",",
"float",
"duration",
",",
"int",
"loop",
"count",
",",
"float",
"speed",
",",
"final",
"animation",
"listener",
"listener",
",",
"float",
"transition",
"time",
")",
"{",
"return",
"queue",
"(",
"obtain",
"(",
"id",
",",
"offset",
",",
"duration",
",",
"loop",
"count",
",",
"speed",
",",
"listener",
")",
",",
"transition",
"time",
")",
";",
"}"
]
|
[
"background",
"login",
"refresh",
"thread",
"will",
"sleep",
"until",
"the",
"specified",
"window",
"factor",
"relative",
"to",
"the",
"credential",
"'",
"s",
"total",
"lifetime",
"has",
"been",
"reached",
",",
"at",
"which",
"time",
"it",
"will",
"try",
"to",
"refresh",
"the",
"credential"
]
| [
"public",
"double",
"login",
"refresh",
"window",
"factor",
"(",
")",
"{",
"return",
"login",
"refresh",
"window",
"factor",
";",
"}"
]
|
[
"returns",
"a",
"{",
"@",
"link",
"future",
"}",
"that",
"will",
"get",
"notified",
"once",
"the",
"current",
"tls",
"handshake",
"completes"
]
| [
"public",
"future",
"<",
"channel",
">",
"handshake",
"future",
"(",
")",
"{",
"return",
"handshake",
"promise",
";",
"}"
]
|
[
"get",
"number",
"item"
]
| [
"public",
"big",
"decimal",
"get",
"number",
"item",
"(",
")",
"{",
"return",
"number",
"item",
";",
"}"
]
|
[
"add",
"a",
"parameter",
"with",
"the",
"given",
"name",
"and",
"value"
]
| [
"builder",
"param",
"(",
"string",
"name",
",",
"string",
"values",
")",
";"
]
|
[
"reroutes",
"the",
"routing",
"table",
"based",
"on",
"the",
"live",
"nodes",
"if",
"the",
"same",
"instance",
"of",
"cluster",
"state",
"is",
"returned",
",",
"then",
"no",
"change",
"has",
"been",
"made"
]
| [
"public",
"cluster",
"state",
"reroute",
"(",
"cluster",
"state",
"cluster",
"state",
",",
"string",
"reason",
")",
"{",
"cluster",
"state",
"fixed",
"cluster",
"state",
"=",
"adapt",
"auto",
"expand",
"replicas",
"(",
"cluster",
"state",
")",
";",
"routing",
"nodes",
"routing",
"nodes",
"=",
"get",
"mutable",
"routing",
"nodes",
"(",
"fixed",
"cluster",
"state",
")",
";",
"/",
"/",
"shuffle",
"the",
"unassigned",
"shards",
",",
"just",
"so",
"we",
"won",
"'",
"t",
"have",
"things",
"like",
"poison",
"failed",
"shards",
"routing",
"nodes",
"unassigned",
"(",
")",
"shuffle",
"(",
")",
";",
"routing",
"allocation",
"allocation",
"=",
"new",
"routing",
"allocation",
"(",
"allocation",
"deciders",
",",
"routing",
"nodes",
",",
"fixed",
"cluster",
"state",
",",
"cluster",
"info",
"service",
"get",
"cluster",
"info",
"(",
")",
",",
"snapshots",
"info",
"service",
"snapshot",
"shard",
"sizes",
"(",
")",
",",
"current",
"nano",
"time",
"(",
")",
")",
";",
"reroute",
"(",
"allocation",
")",
";",
"if",
"(",
"fixed",
"cluster",
"state",
"=",
"=",
"cluster",
"state",
"&",
"&",
"allocation",
"routing",
"nodes",
"changed",
"(",
")",
"=",
"=",
"false",
")",
"{",
"return",
"cluster",
"state",
";",
"}",
"return",
"build",
"result",
"and",
"log",
"health",
"change",
"(",
"cluster",
"state",
",",
"allocation",
",",
"reason",
")",
";",
"}"
]
|
[
"allocate",
"async",
"to",
"an",
"uam"
]
| [
"public",
"void",
"allocate",
"async",
"(",
"string",
"uam",
"id",
",",
"allocate",
"request",
"request",
",",
"async",
"callback",
"<",
"allocate",
"response",
">",
"callback",
")",
"throws",
"yarn",
"exception",
",",
"i",
"o",
"exception",
"{",
"if",
"(",
"!",
"this",
"unmanaged",
"app",
"master",
"map",
"contains",
"key",
"(",
"uam",
"id",
")",
")",
"{",
"throw",
"new",
"yarn",
"exception",
"(",
"\"",
"uam",
"\"",
"+",
"uam",
"id",
"+",
"\"",
"does",
"not",
"exist",
"\"",
")",
";",
"}",
"this",
"unmanaged",
"app",
"master",
"map",
"get",
"(",
"uam",
"id",
")",
"allocate",
"async",
"(",
"request",
",",
"callback",
")",
";",
"}"
]
|
[
"sets",
"the",
"{",
"@",
"link",
"memory",
"size",
"calculator",
"}",
"to",
"use",
"to",
"calculate",
"maximum",
"sizes",
"for",
"default",
"{",
"@",
"link",
"memory",
"cache",
"memory",
"caches",
"}",
"andor",
"default",
"{",
"@",
"link",
"bitmap",
"pool",
"bitmap",
"pools",
"}",
"the",
"given",
"{",
"@",
"link",
"memory",
"size",
"calculator",
"}",
"will",
"not",
"affect",
"custom",
"pools",
"or",
"caches",
"provided",
"via",
"{",
"@",
"link",
"#",
"set",
"bitmap",
"pool",
"(",
"bitmap",
"pool",
")",
"}",
"or",
"{",
"@",
"link",
"#",
"set",
"memory",
"cache",
"(",
"memory",
"cache",
")",
"}"
]
| [
"public",
"glide",
"builder",
"set",
"memory",
"size",
"calculator",
"(",
"@",
"nullable",
"memory",
"size",
"calculator",
"calculator",
")",
"{",
"this",
"memory",
"size",
"calculator",
"=",
"calculator",
";",
"return",
"this",
";",
"}"
]
|
[
"determine",
"whether",
"the",
"given",
"class",
"is",
"an",
"{",
"@",
"code",
"org",
"springframework",
"}",
"bean",
"class",
"that",
"is",
"not",
"annotated",
"as",
"a",
"user",
"or",
"test",
"{",
"@",
"link",
"component",
"}",
"which",
"indicates",
"that",
"there",
"is",
"no",
"{",
"@",
"link",
"event",
"listener",
"}",
"to",
"be",
"found",
"there"
]
| [
"private",
"static",
"boolean",
"is",
"spring",
"container",
"class",
"(",
"class",
"<",
"?",
">",
"clazz",
")",
"{",
"return",
"(",
"clazz",
"get",
"name",
"(",
")",
"starts",
"with",
"(",
"\"",
"org",
"springframework",
"\"",
")",
"&",
"&",
"!",
"annotated",
"element",
"utils",
"is",
"annotated",
"(",
"class",
"utils",
"get",
"user",
"class",
"(",
"clazz",
")",
",",
"component",
"class",
")",
")",
";",
"}"
]
|
[
"model",
"tests",
"for",
"additional",
"properties",
"number"
]
| [
"public",
"void",
"test",
"additional",
"properties",
"number",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"additional",
"properties",
"number",
"}"
]
|
[
"adds",
"display",
"image",
"task",
"to",
"execution",
"pool",
"image",
"will",
"be",
"set",
"to",
"image",
"aware",
"when",
"it",
"'",
"s",
"turn",
"<",
"br",
">",
"<",
"b",
">",
"note",
":",
"<",
"b",
">",
"{",
"@",
"link",
"#",
"init",
"(",
"image",
"loader",
"configuration",
")",
"}",
"method",
"must",
"be",
"called",
"before",
"this",
"method",
"call"
]
| [
"public",
"void",
"display",
"image",
"(",
"string",
"uri",
",",
"image",
"aware",
"image",
"aware",
",",
"display",
"image",
"options",
"options",
",",
"image",
"size",
"target",
"size",
",",
"image",
"loading",
"listener",
"listener",
",",
"image",
"loading",
"progress",
"listener",
"progress",
"listener",
")",
"{",
"check",
"configuration",
"(",
")",
";",
"if",
"(",
"image",
"aware",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"error",
"wrong",
"arguments",
")",
";",
"}",
"if",
"(",
"listener",
"=",
"=",
"null",
")",
"{",
"listener",
"=",
"default",
"listener",
";",
"}",
"if",
"(",
"options",
"=",
"=",
"null",
")",
"{",
"options",
"=",
"configuration",
"default",
"display",
"image",
"options",
";",
"}",
"if",
"(",
"text",
"utils",
"is",
"empty",
"(",
"uri",
")",
")",
"{",
"engine",
"cancel",
"display",
"task",
"for",
"(",
"image",
"aware",
")",
";",
"listener",
"on",
"loading",
"started",
"(",
"uri",
",",
"image",
"aware",
"get",
"wrapped",
"view",
"(",
")",
")",
";",
"if",
"(",
"options",
"should",
"show",
"image",
"for",
"empty",
"uri",
"(",
")",
")",
"{",
"image",
"aware",
"set",
"image",
"drawable",
"(",
"options",
"get",
"image",
"for",
"empty",
"uri",
"(",
"configuration",
"resources",
")",
")",
";",
"}",
"else",
"{",
"image",
"aware",
"set",
"image",
"drawable",
"(",
"null",
")",
";",
"}",
"listener",
"on",
"loading",
"complete",
"(",
"uri",
",",
"image",
"aware",
"get",
"wrapped",
"view",
"(",
")",
",",
"null",
")",
";",
"return",
";",
"}",
"if",
"(",
"target",
"size",
"=",
"=",
"null",
")",
"{",
"target",
"size",
"=",
"image",
"size",
"utils",
"define",
"target",
"size",
"for",
"view",
"(",
"image",
"aware",
",",
"configuration",
"get",
"max",
"image",
"size",
"(",
")",
")",
";",
"}",
"string",
"memory",
"cache",
"key",
"=",
"memory",
"cache",
"utils",
"generate",
"key",
"(",
"uri",
",",
"target",
"size",
")",
";",
"engine",
"prepare",
"display",
"task",
"for",
"(",
"image",
"aware",
",",
"memory",
"cache",
"key",
")",
";",
"listener",
"on",
"loading",
"started",
"(",
"uri",
",",
"image",
"aware",
"get",
"wrapped",
"view",
"(",
")",
")",
";",
"bitmap",
"bmp",
"=",
"configuration",
"memory",
"cache",
"get",
"(",
"memory",
"cache",
"key",
")",
";",
"if",
"(",
"bmp",
"!",
"=",
"null",
"&",
"&",
"!",
"bmp",
"is",
"recycled",
"(",
")",
")",
"{",
"l",
"d",
"(",
"log",
"load",
"image",
"from",
"memory",
"cache",
",",
"memory",
"cache",
"key",
")",
";",
"if",
"(",
"options",
"should",
"post",
"process",
"(",
")",
")",
"{",
"image",
"loading",
"info",
"image",
"loading",
"info",
"=",
"new",
"image",
"loading",
"info",
"(",
"uri",
",",
"image",
"aware",
",",
"target",
"size",
",",
"memory",
"cache",
"key",
",",
"options",
",",
"listener",
",",
"progress",
"listener",
",",
"engine",
"get",
"lock",
"for",
"uri",
"(",
"uri",
")",
")",
";",
"process",
"and",
"display",
"image",
"task",
"display",
"task",
"=",
"new",
"process",
"and",
"display",
"image",
"task",
"(",
"engine",
",",
"bmp",
",",
"image",
"loading",
"info",
",",
"define",
"handler",
"(",
"options",
")",
")",
";",
"if",
"(",
"options",
"is",
"sync",
"loading",
"(",
")",
")",
"{",
"display",
"task",
"run",
"(",
")",
";",
"}",
"else",
"{",
"engine",
"submit",
"(",
"display",
"task",
")",
";",
"}",
"}",
"else",
"{",
"options",
"get",
"displayer",
"(",
")",
"display",
"(",
"bmp",
",",
"image",
"aware",
",",
"loaded",
"from",
"memory",
"cache",
")",
";",
"listener",
"on",
"loading",
"complete",
"(",
"uri",
",",
"image",
"aware",
"get",
"wrapped",
"view",
"(",
")",
",",
"bmp",
")",
";",
"}",
"}",
"else",
"{",
"if",
"(",
"options",
"should",
"show",
"image",
"on",
"loading",
"(",
")",
")",
"{",
"image",
"aware",
"set",
"image",
"drawable",
"(",
"options",
"get",
"image",
"on",
"loading",
"(",
"configuration",
"resources",
")",
")",
";",
"}",
"else",
"if",
"(",
"options",
"is",
"reset",
"view",
"before",
"loading",
"(",
")",
")",
"{",
"image",
"aware",
"set",
"image",
"drawable",
"(",
"null",
")",
";",
"}",
"image",
"loading",
"info",
"image",
"loading",
"info",
"=",
"new",
"image",
"loading",
"info",
"(",
"uri",
",",
"image",
"aware",
",",
"target",
"size",
",",
"memory",
"cache",
"key",
",",
"options",
",",
"listener",
",",
"progress",
"listener",
",",
"engine",
"get",
"lock",
"for",
"uri",
"(",
"uri",
")",
")",
";",
"load",
"and",
"display",
"image",
"task",
"display",
"task",
"=",
"new",
"load",
"and",
"display",
"image",
"task",
"(",
"engine",
",",
"image",
"loading",
"info",
",",
"define",
"handler",
"(",
"options",
")",
")",
";",
"if",
"(",
"options",
"is",
"sync",
"loading",
"(",
")",
")",
"{",
"display",
"task",
"run",
"(",
")",
";",
"}",
"else",
"{",
"engine",
"submit",
"(",
"display",
"task",
")",
";",
"}",
"}",
"}"
]
|
[
"map",
"the",
"route",
"for",
"http",
"put",
"requests"
]
| [
"public",
"static",
"void",
"put",
"(",
"string",
"path",
",",
"route",
"route",
")",
"{",
"get",
"instance",
"(",
")",
"put",
"(",
"path",
",",
"route",
")",
";",
"}"
]
|
[
"all",
"the",
"datafeed",
"ids",
"for",
"which",
"to",
"get",
"configuration",
"information"
]
| [
"public",
"list",
"<",
"string",
">",
"get",
"datafeed",
"ids",
"(",
")",
"{",
"return",
"datafeed",
"ids",
";",
"}"
]
|
[
"gets",
"the",
"offset",
"of",
"the",
"field",
"in",
"this",
"rtti",
"4",
"that",
"has",
"the",
"rtti",
"3",
"pointer"
]
| [
"public",
"static",
"int",
"get",
"rtti",
"3",
"pointer",
"component",
"offset",
"(",
")",
"{",
"return",
"rtti",
"3",
"ptr",
"offset",
";",
"}"
]
|
[
"returns",
"the",
"status",
"phrase",
"of",
"this",
"status"
]
| [
"public",
"string",
"status",
"phrase",
"(",
")",
"{",
"return",
"status",
"phrase",
";",
"}"
]
|
[
"return",
"the",
"resource",
"loader",
"that",
"this",
"metadata",
"reader",
"factory",
"has",
"been",
"constructed",
"with"
]
| [
"public",
"final",
"resource",
"loader",
"get",
"resource",
"loader",
"(",
")",
"{",
"return",
"this",
"resource",
"loader",
";",
"}"
]
|
[
"set",
"the",
"storage",
"policy",
"for",
"a",
"file",
"or",
"a",
"directory"
]
| [
"void",
"set",
"storage",
"policy",
"(",
"string",
"src",
",",
"string",
"policy",
"name",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"string",
"operation",
"name",
"=",
"\"",
"set",
"storage",
"policy",
"\"",
";",
"check",
"operation",
"(",
"operation",
"category",
"write",
")",
";",
"check",
"storage",
"policy",
"enabled",
"(",
"\"",
"set",
"storage",
"policy",
"\"",
",",
"true",
")",
";",
"final",
"f",
"s",
"permission",
"checker",
"pc",
"=",
"get",
"permission",
"checker",
"(",
")",
";",
"f",
"s",
"permission",
"checker",
"set",
"operation",
"type",
"(",
"operation",
"name",
")",
";",
"file",
"status",
"audit",
"stat",
"=",
"null",
";",
"try",
"{",
"write",
"lock",
"(",
")",
";",
"try",
"{",
"check",
"operation",
"(",
"operation",
"category",
"write",
")",
";",
"check",
"name",
"node",
"safe",
"mode",
"(",
"\"",
"cannot",
"set",
"storage",
"policy",
"for",
"\"",
"+",
"src",
")",
";",
"audit",
"stat",
"=",
"f",
"s",
"dir",
"attr",
"op",
"set",
"storage",
"policy",
"(",
"dir",
",",
"pc",
",",
"block",
"manager",
",",
"src",
",",
"policy",
"name",
")",
";",
"}",
"finally",
"{",
"write",
"unlock",
"(",
"operation",
"name",
",",
"get",
"lock",
"report",
"info",
"supplier",
"(",
"src",
",",
"null",
",",
"audit",
"stat",
")",
")",
";",
"}",
"}",
"catch",
"(",
"access",
"control",
"exception",
"e",
")",
"{",
"log",
"audit",
"event",
"(",
"false",
",",
"operation",
"name",
",",
"src",
")",
";",
"throw",
"e",
";",
"}",
"get",
"edit",
"log",
"(",
")",
"log",
"sync",
"(",
")",
";",
"log",
"audit",
"event",
"(",
"true",
",",
"operation",
"name",
",",
"src",
",",
"null",
",",
"audit",
"stat",
")",
";",
"}"
]
|
[
"convert",
"a",
"column",
"name",
"with",
"underscores",
"to",
"the",
"corresponding",
"property",
"name",
"using",
"\"",
"camel",
"case",
"\"",
"a",
"name",
"like",
"\"",
"customer",
"number",
"\"",
"would",
"match",
"a",
"\"",
"customer",
"number",
"\"",
"property",
"name"
]
| [
"public",
"static",
"string",
"convert",
"underscore",
"name",
"to",
"property",
"name",
"(",
"@",
"nullable",
"string",
"name",
")",
"{",
"string",
"builder",
"result",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"boolean",
"next",
"is",
"upper",
"=",
"false",
";",
"if",
"(",
"name",
"!",
"=",
"null",
"&",
"&",
"name",
"length",
"(",
")",
">",
"0",
")",
"{",
"if",
"(",
"name",
"length",
"(",
")",
">",
"1",
"&",
"&",
"name",
"char",
"at",
"(",
"1",
")",
"=",
"=",
"'",
"'",
")",
"{",
"result",
"append",
"(",
"character",
"to",
"upper",
"case",
"(",
"name",
"char",
"at",
"(",
"0",
")",
")",
")",
";",
"}",
"else",
"{",
"result",
"append",
"(",
"character",
"to",
"lower",
"case",
"(",
"name",
"char",
"at",
"(",
"0",
")",
")",
")",
";",
"}",
"for",
"(",
"int",
"i",
"=",
"1",
";",
"i",
"<",
"name",
"length",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"char",
"c",
"=",
"name",
"char",
"at",
"(",
"i",
")",
";",
"if",
"(",
"c",
"=",
"=",
"'",
"'",
")",
"{",
"next",
"is",
"upper",
"=",
"true",
";",
"}",
"else",
"{",
"if",
"(",
"next",
"is",
"upper",
")",
"{",
"result",
"append",
"(",
"character",
"to",
"upper",
"case",
"(",
"c",
")",
")",
";",
"next",
"is",
"upper",
"=",
"false",
";",
"}",
"else",
"{",
"result",
"append",
"(",
"character",
"to",
"lower",
"case",
"(",
"c",
")",
")",
";",
"}",
"}",
"}",
"}",
"return",
"result",
"to",
"string",
"(",
")",
";",
"}"
]
|
[
"returns",
"the",
"extended",
"tcp",
"keepidle",
"socket",
"option",
",",
"if",
"available",
"on",
"this",
"jdk"
]
| [
"public",
"static",
"socket",
"option",
"<",
"integer",
">",
"get",
"tcp",
"keep",
"idle",
"socket",
"option",
"or",
"null",
"(",
")",
"{",
"return",
"get",
"extended",
"socket",
"option",
"or",
"null",
"(",
"\"",
"tcp",
"keepidle",
"\"",
")",
";",
"}"
]
|
[
"closes",
"this",
"input",
"stream",
"and",
"releases",
"any",
"system",
"resources",
"associated",
"with",
"the",
"stream",
"this",
"method",
"simply",
"performs",
"<",
"code",
">",
"in",
"close",
"(",
")",
"<",
"code",
">",
"@",
"exception",
"i",
"o",
"exception",
"if",
"an",
"io",
"error",
"occurs"
]
| [
"public",
"void",
"close",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"in",
"close",
"(",
")",
";",
"}"
]
|
[
"ensure",
"that",
"an",
"exception",
"thrown",
"by",
"the",
"check",
"routine",
"is",
"propagated"
]
| [
"public",
"void",
"test",
"exception",
"is",
"propagated",
"(",
")",
"throws",
"exception",
"{",
"final",
"throwing",
"checkable",
"target",
"=",
"new",
"throwing",
"checkable",
"(",
")",
";",
"final",
"fake",
"timer",
"timer",
"=",
"new",
"fake",
"timer",
"(",
")",
";",
"throttled",
"async",
"checker",
"<",
"boolean",
",",
"boolean",
">",
"checker",
"=",
"new",
"throttled",
"async",
"checker",
"<",
">",
"(",
"timer",
",",
"min",
"error",
"check",
"gap",
",",
"0",
",",
"get",
"executor",
"service",
"(",
")",
")",
";",
"final",
"optional",
"<",
"listenable",
"future",
"<",
"boolean",
">",
">",
"olf",
"=",
"checker",
"schedule",
"(",
"target",
",",
"true",
")",
";",
"assert",
"true",
"(",
"olf",
"is",
"present",
"(",
")",
")",
";",
"try",
"{",
"olf",
"get",
"(",
")",
"get",
"(",
")",
";",
"fail",
"(",
"\"",
"failed",
"to",
"get",
"expected",
"execution",
"exception",
"\"",
")",
";",
"}",
"catch",
"(",
"execution",
"exception",
"ee",
")",
"{",
"assert",
"true",
"(",
"ee",
"get",
"cause",
"(",
")",
"instanceof",
"dummy",
"exception",
")",
";",
"}",
"}"
]
|
[
"adds",
"the",
"given",
"chunk",
"to",
"the",
"model"
]
| [
"public",
"void",
"add",
"(",
"chunk",
"chunk",
")",
"{",
"chunks",
"add",
"(",
"chunk",
")",
";",
"}"
]
|
[
"get",
"the",
"interpolated",
"transform",
"at",
"a",
"specific",
"time"
]
| [
"public",
"final",
"void",
"get",
"transform",
"(",
"final",
"transform",
"xf",
",",
"final",
"float",
"beta",
")",
"{",
"assert",
"(",
"xf",
"!",
"=",
"null",
")",
";",
"/",
"/",
"xf",
"-",
">",
"p",
"=",
"(",
"1",
"0f",
"-",
"beta",
")",
"*",
"c",
"0",
"+",
"beta",
"*",
"c",
";",
"/",
"/",
"float",
"3",
"2",
"angle",
"=",
"(",
"1",
"0f",
"-",
"beta",
")",
"*",
"a",
"0",
"+",
"beta",
"*",
"a",
";",
"/",
"/",
"xf",
"-",
">",
"q",
"set",
"(",
"angle",
")",
";",
"xf",
"p",
"x",
"=",
"(",
"1",
"0f",
"-",
"beta",
")",
"*",
"c",
"0",
"x",
"+",
"beta",
"*",
"c",
"x",
";",
"xf",
"p",
"y",
"=",
"(",
"1",
"0f",
"-",
"beta",
")",
"*",
"c",
"0",
"y",
"+",
"beta",
"*",
"c",
"y",
";",
"float",
"angle",
"=",
"(",
"1",
"0f",
"-",
"beta",
")",
"*",
"a",
"0",
"+",
"beta",
"*",
"a",
";",
"xf",
"q",
"set",
"(",
"angle",
")",
";",
"/",
"/",
"shift",
"to",
"origin",
"/",
"/",
"xf",
"-",
">",
"p",
"-",
"=",
"b",
"2",
"mul",
"(",
"xf",
"-",
">",
"q",
",",
"local",
"center",
")",
";",
"final",
"rot",
"q",
"=",
"xf",
"q",
";",
"xf",
"p",
"x",
"-",
"=",
"q",
"c",
"*",
"local",
"center",
"x",
"-",
"q",
"s",
"*",
"local",
"center",
"y",
";",
"xf",
"p",
"y",
"-",
"=",
"q",
"s",
"*",
"local",
"center",
"x",
"+",
"q",
"c",
"*",
"local",
"center",
"y",
";",
"}"
]
|
[
"the",
"tasks",
"included",
"in",
"this",
"assignment"
]
| [
"public",
"collection",
"<",
"connector",
"task",
"id",
">",
"tasks",
"(",
")",
"{",
"return",
"task",
"ids",
";",
"}"
]
|
[
"get",
"attribute",
"integer"
]
| [
"public",
"integer",
"get",
"attribute",
"integer",
"(",
")",
"{",
"return",
"attribute",
"integer",
";",
"}"
]
|
[
"only",
"select",
"executions",
"which",
"are",
"part",
"of",
"a",
"process",
"that",
"have",
"at",
"least",
"one",
"variable",
"with",
"the",
"given",
"value",
"byte",
"-",
"arrays",
"and",
"{",
"@",
"link",
"serializable",
"}",
"objects",
"(",
"which",
"are",
"not",
"primitive",
"type",
"wrappers",
")",
"are",
"not",
"supported"
]
| [
"execution",
"query",
"process",
"variable",
"value",
"equals",
"(",
"object",
"variable",
"value",
")",
";"
]
|
[
"a",
"live",
"view",
"of",
"deps",
"known",
"to",
"have",
"already",
"been",
"requested",
"either",
"through",
"an",
"earlier",
"call",
"to",
"{",
"@",
"link",
"sky",
"function",
"#",
"compute",
"}",
"or",
"inferred",
"during",
"change",
"pruning",
"should",
"return",
"{",
"@",
"code",
"null",
"}",
"if",
"unknown"
]
| [
"default",
"grouped",
"list",
"<",
"sky",
"key",
">",
"get",
"temporary",
"direct",
"deps",
"(",
")",
"{",
"return",
"null",
";",
"}"
]
|
[
"from",
"real",
"-",
"time",
"collision",
"detection",
",",
"p",
"1",
"7",
"9"
]
| [
"public",
"final",
"boolean",
"raycast",
"(",
"final",
"ray",
"cast",
"output",
"output",
",",
"final",
"ray",
"cast",
"input",
"input",
",",
"i",
"world",
"pool",
"arg",
"pool",
")",
"{",
"float",
"tmin",
"=",
"-",
"float",
"max",
"value",
";",
"float",
"tmax",
"=",
"float",
"max",
"value",
";",
"final",
"vec",
"2",
"p",
"=",
"arg",
"pool",
"pop",
"vec",
"2",
"(",
")",
";",
"final",
"vec",
"2",
"d",
"=",
"arg",
"pool",
"pop",
"vec",
"2",
"(",
")",
";",
"final",
"vec",
"2",
"abs",
"d",
"=",
"arg",
"pool",
"pop",
"vec",
"2",
"(",
")",
";",
"final",
"vec",
"2",
"normal",
"=",
"arg",
"pool",
"pop",
"vec",
"2",
"(",
")",
";",
"p",
"set",
"(",
"input",
"p",
"1",
")",
";",
"d",
"set",
"(",
"input",
"p",
"2",
")",
"sub",
"local",
"(",
"input",
"p",
"1",
")",
";",
"vec",
"2",
"abs",
"to",
"out",
"(",
"d",
",",
"abs",
"d",
")",
";",
"/",
"/",
"x",
"then",
"y",
"if",
"(",
"abs",
"d",
"x",
"<",
"settings",
"epsilon",
")",
"{",
"/",
"/",
"parallel",
"if",
"(",
"p",
"x",
"<",
"lower",
"bound",
"x",
"|",
"|",
"upper",
"bound",
"x",
"<",
"p",
"x",
")",
"{",
"arg",
"pool",
"push",
"vec",
"2",
"(",
"4",
")",
";",
"return",
"false",
";",
"}",
"}",
"else",
"{",
"final",
"float",
"inv",
"d",
"=",
"1",
"0f",
"/",
"d",
"x",
";",
"float",
"t",
"1",
"=",
"(",
"lower",
"bound",
"x",
"-",
"p",
"x",
")",
"*",
"inv",
"d",
";",
"float",
"t",
"2",
"=",
"(",
"upper",
"bound",
"x",
"-",
"p",
"x",
")",
"*",
"inv",
"d",
";",
"/",
"/",
"sign",
"of",
"the",
"normal",
"vector",
"float",
"s",
"=",
"-",
"1",
"0f",
";",
"if",
"(",
"t",
"1",
">",
"t",
"2",
")",
"{",
"final",
"float",
"temp",
"=",
"t",
"1",
";",
"t",
"1",
"=",
"t",
"2",
";",
"t",
"2",
"=",
"temp",
";",
"s",
"=",
"1",
"0f",
";",
"}",
"/",
"/",
"push",
"the",
"min",
"up",
"if",
"(",
"t",
"1",
">",
"tmin",
")",
"{",
"normal",
"set",
"zero",
"(",
")",
";",
"normal",
"x",
"=",
"s",
";",
"tmin",
"=",
"t",
"1",
";",
"}",
"/",
"/",
"pull",
"the",
"max",
"down",
"tmax",
"=",
"math",
"utils",
"min",
"(",
"tmax",
",",
"t",
"2",
")",
";",
"if",
"(",
"tmin",
">",
"tmax",
")",
"{",
"arg",
"pool",
"push",
"vec",
"2",
"(",
"4",
")",
";",
"return",
"false",
";",
"}",
"}",
"if",
"(",
"abs",
"d",
"y",
"<",
"settings",
"epsilon",
")",
"{",
"/",
"/",
"parallel",
"if",
"(",
"p",
"y",
"<",
"lower",
"bound",
"y",
"|",
"|",
"upper",
"bound",
"y",
"<",
"p",
"y",
")",
"{",
"arg",
"pool",
"push",
"vec",
"2",
"(",
"4",
")",
";",
"return",
"false",
";",
"}",
"}",
"else",
"{",
"final",
"float",
"inv",
"d",
"=",
"1",
"0f",
"/",
"d",
"y",
";",
"float",
"t",
"1",
"=",
"(",
"lower",
"bound",
"y",
"-",
"p",
"y",
")",
"*",
"inv",
"d",
";",
"float",
"t",
"2",
"=",
"(",
"upper",
"bound",
"y",
"-",
"p",
"y",
")",
"*",
"inv",
"d",
";",
"/",
"/",
"sign",
"of",
"the",
"normal",
"vector",
"float",
"s",
"=",
"-",
"1",
"0f",
";",
"if",
"(",
"t",
"1",
">",
"t",
"2",
")",
"{",
"final",
"float",
"temp",
"=",
"t",
"1",
";",
"t",
"1",
"=",
"t",
"2",
";",
"t",
"2",
"=",
"temp",
";",
"s",
"=",
"1",
"0f",
";",
"}",
"/",
"/",
"push",
"the",
"min",
"up",
"if",
"(",
"t",
"1",
">",
"tmin",
")",
"{",
"normal",
"set",
"zero",
"(",
")",
";",
"normal",
"y",
"=",
"s",
";",
"tmin",
"=",
"t",
"1",
";",
"}",
"/",
"/",
"pull",
"the",
"max",
"down",
"tmax",
"=",
"math",
"utils",
"min",
"(",
"tmax",
",",
"t",
"2",
")",
";",
"if",
"(",
"tmin",
">",
"tmax",
")",
"{",
"arg",
"pool",
"push",
"vec",
"2",
"(",
"4",
")",
";",
"return",
"false",
";",
"}",
"}",
"/",
"/",
"does",
"the",
"ray",
"start",
"inside",
"the",
"box",
"?",
"/",
"/",
"does",
"the",
"ray",
"intersect",
"beyond",
"the",
"max",
"fraction",
"?",
"if",
"(",
"tmin",
"<",
"0",
"0f",
"|",
"|",
"input",
"max",
"fraction",
"<",
"tmin",
")",
"{",
"arg",
"pool",
"push",
"vec",
"2",
"(",
"4",
")",
";",
"return",
"false",
";",
"}",
"/",
"/",
"intersection",
"output",
"fraction",
"=",
"tmin",
";",
"output",
"normal",
"x",
"=",
"normal",
"x",
";",
"output",
"normal",
"y",
"=",
"normal",
"y",
";",
"arg",
"pool",
"push",
"vec",
"2",
"(",
"4",
")",
";",
"return",
"true",
";",
"}"
]
|
[
"return",
"a",
"short",
"representation",
"of",
"this",
"handler",
"method",
"for",
"log",
"message",
"purposes"
]
| [
"public",
"string",
"get",
"short",
"log",
"message",
"(",
")",
"{",
"return",
"get",
"bean",
"type",
"(",
")",
"get",
"name",
"(",
")",
"+",
"\"",
"#",
"\"",
"+",
"this",
"method",
"get",
"name",
"(",
")",
"+",
"\"",
"[",
"\"",
"+",
"this",
"method",
"get",
"parameter",
"count",
"(",
")",
"+",
"\"",
"args",
"]",
"\"",
";",
"}"
]
|
[
"string",
"representation",
"of",
"this",
"event",
"for",
"debugging",
"purposes"
]
| [
"public",
"string",
"to",
"string",
"(",
")",
"{",
"string",
"buffer",
"sb",
"=",
"new",
"string",
"buffer",
"(",
"\"",
"tree",
"name",
"=",
"\"",
")",
";",
"sb",
"append",
"(",
"tree",
"name",
")",
";",
"sb",
"append",
"(",
"\"",
",",
"group",
"paths",
"=",
"{",
"\"",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"group",
"paths",
"length",
";",
"i",
"+",
"+",
")",
"{",
"sb",
"append",
"(",
"\"",
"[",
"\"",
")",
";",
"sb",
"append",
"(",
"group",
"paths",
"[",
"i",
"]",
"to",
"string",
"(",
")",
")",
";",
"sb",
"append",
"(",
"\"",
"]",
"\"",
")",
";",
"if",
"(",
"i",
"<",
"group",
"paths",
"length",
"-",
"1",
")",
"{",
"sb",
"append",
"(",
"\"",
",",
"\"",
")",
";",
"}",
"}",
"sb",
"append",
"(",
"\"",
"}",
"\"",
")",
";",
"return",
"sb",
"to",
"string",
"(",
")",
";",
"}"
]
|
[
"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",
"\"",
")",
";",
"}"
]
|
[
"get",
"prefix",
"ns",
"boolean"
]
| [
"public",
"boolean",
"get",
"prefix",
"ns",
"boolean",
"(",
")",
"{",
"return",
"prefix",
"ns",
"boolean",
";",
"}"
]
|
[
"get",
"block",
"locations",
"from",
"the",
"underlying",
"fs",
"and",
"fix",
"their",
"offsets",
"and",
"lengths"
]
| [
"public",
"block",
"location",
"[",
"]",
"get",
"file",
"block",
"locations",
"(",
"file",
"status",
"file",
",",
"long",
"start",
",",
"long",
"len",
")",
"throws",
"i",
"o",
"exception",
"{",
"har",
"status",
"hstatus",
"=",
"get",
"file",
"har",
"status",
"(",
"file",
"get",
"path",
"(",
")",
")",
";",
"path",
"part",
"path",
"=",
"new",
"path",
"(",
"archive",
"path",
",",
"hstatus",
"get",
"part",
"name",
"(",
")",
")",
";",
"file",
"status",
"part",
"status",
"=",
"metadata",
"get",
"part",
"file",
"status",
"(",
"part",
"path",
")",
";",
"/",
"/",
"get",
"all",
"part",
"blocks",
"that",
"overlap",
"with",
"the",
"desired",
"file",
"blocks",
"block",
"location",
"[",
"]",
"locations",
"=",
"fs",
"get",
"file",
"block",
"locations",
"(",
"part",
"status",
",",
"hstatus",
"get",
"start",
"index",
"(",
")",
"+",
"start",
",",
"len",
")",
";",
"return",
"fix",
"block",
"locations",
"(",
"locations",
",",
"start",
",",
"len",
",",
"hstatus",
"get",
"start",
"index",
"(",
")",
")",
";",
"}"
]
|
[
"sets",
"the",
"overlay",
"color",
"for",
"corner",
"type",
"{",
"@",
"link",
"type",
"#",
"overlay",
"color",
"}"
]
| [
"public",
"void",
"set",
"overlay",
"color",
"(",
"int",
"overlay",
"color",
")",
"{",
"m",
"overlay",
"color",
"=",
"overlay",
"color",
";",
"invalidate",
"self",
"(",
")",
";",
"}"
]
|
[
"model",
"tests",
"for",
"outer",
"enum"
]
| [
"public",
"void",
"test",
"outer",
"enum",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"outer",
"enum",
"}"
]
|
[
"for",
"debugging",
",",
"print",
"out",
"the",
"computed",
"sets",
"to",
"the",
"given",
"stream"
]
| [
"public",
"void",
"print",
"(",
"print",
"stream",
"out",
")",
"{",
"out",
"print",
"(",
"\"",
"nullable",
":",
"\"",
")",
";",
"for",
"(",
"assembly",
"non",
"terminal",
"nt",
":",
"nullable",
")",
"{",
"out",
"print",
"(",
"nt",
"+",
"\"",
"\"",
")",
";",
"}",
"out",
"println",
"(",
")",
";",
"out",
"println",
"(",
"\"",
"firsts",
":",
"\"",
")",
";",
"for",
"(",
"assembly",
"non",
"terminal",
"nt",
":",
"grammar",
"non",
"terminals",
"(",
")",
")",
"{",
"out",
"print",
"(",
"nt",
"+",
"\"",
"\\",
"t",
"\"",
")",
";",
"for",
"(",
"assembly",
"terminal",
"f",
":",
"first",
"get",
"(",
"nt",
")",
")",
"{",
"out",
"print",
"(",
"f",
"+",
"\"",
"\"",
")",
";",
"}",
"out",
"println",
"(",
")",
";",
"}",
"out",
"println",
"(",
"\"",
"follows",
":",
"\"",
")",
";",
"for",
"(",
"assembly",
"non",
"terminal",
"nt",
":",
"grammar",
"non",
"terminals",
"(",
")",
")",
"{",
"out",
"print",
"(",
"nt",
"+",
"\"",
"\\",
"t",
"\"",
")",
";",
"for",
"(",
"assembly",
"terminal",
"f",
":",
"follow",
"get",
"(",
"nt",
")",
")",
"{",
"out",
"print",
"(",
"f",
"+",
"\"",
"\"",
")",
";",
"}",
"out",
"println",
"(",
")",
";",
"}",
"}"
]
|
[
"returns",
"the",
"{",
"@",
"link",
"health",
"check",
"}",
"instance",
"with",
"a",
"given",
"name"
]
| [
"public",
"health",
"check",
"get",
"health",
"check",
"(",
"string",
"name",
")",
"{",
"return",
"health",
"checks",
"get",
"(",
"name",
")",
";",
"}"
]
|
[
"should",
"the",
"detailed",
"task",
"information",
"be",
"returned"
]
| [
"public",
"list",
"tasks",
"request",
"set",
"detailed",
"(",
"boolean",
"detailed",
")",
"{",
"this",
"detailed",
"=",
"detailed",
";",
"return",
"this",
";",
"}"
]
|
[
"revoke",
"the",
"provided",
"o",
"auth",
"token"
]
| [
"private",
"void",
"revoke",
"token",
"(",
"final",
"string",
"token",
")",
"{",
"logger",
"debug",
"(",
"\"",
"revoking",
"token",
"[",
"{",
"}",
"]",
"\"",
",",
"token",
")",
";",
"get",
"o",
"auth",
"configuration",
"context",
"(",
")",
"get",
"ticket",
"registry",
"(",
")",
"delete",
"ticket",
"(",
"token",
")",
";",
"}"
]
|
[
"encode",
"an",
"object",
"of",
"type",
"t",
"to",
"a",
"data",
"buffer",
"this",
"is",
"useful",
"for",
"scenarios",
",",
"that",
"distinct",
"messages",
"(",
"or",
"events",
")",
"are",
"encoded",
"and",
"handled",
"individually",
",",
"in",
"fully",
"aggregated",
"form",
"by",
"default",
"this",
"method",
"raises",
"{",
"@",
"link",
"unsupported",
"operation",
"exception",
"}",
"and",
"it",
"is",
"expected",
"that",
"some",
"encoders",
"cannot",
"produce",
"a",
"single",
"buffer",
"or",
"cannot",
"do",
"so",
"synchronously",
"(",
"e",
"g",
"encoding",
"a",
"{",
"@",
"code",
"resource",
"}",
")"
]
| [
"default",
"data",
"buffer",
"encode",
"value",
"(",
"t",
"value",
",",
"data",
"buffer",
"factory",
"buffer",
"factory",
",",
"resolvable",
"type",
"value",
"type",
",",
"@",
"nullable",
"mime",
"type",
"mime",
"type",
",",
"@",
"nullable",
"map",
"<",
"string",
",",
"object",
">",
"hints",
")",
"{",
"/",
"/",
"it",
"may",
"not",
"be",
"possible",
"to",
"produce",
"a",
"single",
"data",
"buffer",
"synchronously",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
")",
";",
"}"
]
|
[
"return",
"the",
"configured",
"argument",
"resolvers"
]
| [
"public",
"list",
"<",
"handler",
"method",
"argument",
"resolver",
">",
"get",
"resolvers",
"(",
")",
"{",
"return",
"this",
"resolvers",
"get",
"resolvers",
"(",
")",
";",
"}"
]
|
[
"the",
"version",
"of",
"the",
"plugin"
]
| [
"public",
"string",
"get",
"version",
"(",
")",
"{",
"return",
"version",
";",
"}"
]
|
[
"projects",
"a",
"{",
"@",
"link",
"tuple",
"}",
"{",
"@",
"link",
"data",
"stream",
"}",
"to",
"the",
"previously",
"selected",
"fields"
]
| [
"public",
"<",
"t0",
",",
"t1",
",",
"t2",
",",
"t3",
",",
"t4",
",",
"t5",
">",
"single",
"output",
"stream",
"operator",
"<",
"tuple",
"6",
"<",
"t0",
",",
"t1",
",",
"t2",
",",
"t3",
",",
"t4",
",",
"t5",
">",
">",
"project",
"tuple",
"6",
"(",
")",
"{",
"type",
"information",
"<",
"?",
">",
"[",
"]",
"f",
"types",
"=",
"extract",
"field",
"types",
"(",
"field",
"indexes",
",",
"data",
"stream",
"get",
"type",
"(",
")",
")",
";",
"tuple",
"type",
"info",
"<",
"tuple",
"6",
"<",
"t0",
",",
"t1",
",",
"t2",
",",
"t3",
",",
"t4",
",",
"t5",
">",
">",
"t",
"type",
"=",
"new",
"tuple",
"type",
"info",
"<",
"tuple",
"6",
"<",
"t0",
",",
"t1",
",",
"t2",
",",
"t3",
",",
"t4",
",",
"t5",
">",
">",
"(",
"f",
"types",
")",
";",
"return",
"data",
"stream",
"transform",
"(",
"\"",
"projection",
"\"",
",",
"t",
"type",
",",
"new",
"stream",
"project",
"<",
"in",
",",
"tuple",
"6",
"<",
"t0",
",",
"t1",
",",
"t2",
",",
"t3",
",",
"t4",
",",
"t5",
">",
">",
"(",
"field",
"indexes",
",",
"t",
"type",
"create",
"serializer",
"(",
"data",
"stream",
"get",
"execution",
"config",
"(",
")",
")",
")",
")",
";",
"}"
]
|
[
"clear",
"the",
"names",
"added",
"during",
"checking",
"name",
"uniqueness"
]
| [
"public",
"void",
"clear",
"(",
")",
"{",
"used",
"names",
"clear",
"(",
")",
";",
"}"
]
|
[
"returns",
"the",
"statement",
"id",
"of",
"the",
"statement",
"that",
"caused",
"the",
"failure"
]
| [
"public",
"string",
"get",
"failing",
"statement",
"id",
"(",
")",
"{",
"return",
"batch",
"result",
"get",
"mapped",
"statement",
"(",
")",
"get",
"id",
"(",
")",
";",
"}"
]
|
[
"test",
"field",
"get",
"set",
"from",
"json"
]
| [
"public",
"void",
"test",
"field",
"get",
"set",
"from",
"json",
"(",
")",
"{",
"string",
"from",
"json",
"=",
"\"",
"{",
"\\",
"n",
"\"",
"+",
"\"",
"\\",
"t",
"\\",
"\"",
"body",
"\\",
"\"",
":",
"\\",
"\"",
"\"",
"+",
"body",
"field",
"+",
"\"",
"\\",
"\"",
",",
"\\",
"n",
"\"",
"+",
"\"",
"\\",
"t",
"\\",
"\"",
"codec",
"\\",
"\"",
":",
"\"",
"+",
"codec",
"field",
"+",
"\"",
",",
"\\",
"n",
"\"",
"+",
"\"",
"\\",
"t",
"\\",
"\"",
"compressor",
"\\",
"\"",
":",
"\"",
"+",
"compress",
"field",
"+",
"\"",
",",
"\\",
"n",
"\"",
"+",
"\"",
"\\",
"t",
"\\",
"\"",
"head",
"map",
"\\",
"\"",
":",
"\"",
"+",
"head",
"field",
"+",
"\"",
",",
"\\",
"n",
"\"",
"+",
"\"",
"\\",
"t",
"\\",
"\"",
"id",
"\\",
"\"",
":",
"\"",
"+",
"id",
"field",
"+",
"\"",
",",
"\\",
"n",
"\"",
"+",
"\"",
"\\",
"t",
"\\",
"\"",
"message",
"type",
"\\",
"\"",
":",
"\"",
"+",
"msg",
"type",
"field",
"+",
"\"",
"\\",
"n",
"\"",
"+",
"\"",
"}",
"\"",
";",
"rpc",
"message",
"from",
"json",
"message",
"=",
"json",
"parse",
"object",
"(",
"from",
"json",
",",
"rpc",
"message",
"class",
")",
";",
"assert",
"that",
"(",
"from",
"json",
"message",
"get",
"body",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"body",
"field",
")",
";",
"assert",
"that",
"(",
"from",
"json",
"message",
"get",
"id",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"id",
"field",
")",
";",
"rpc",
"message",
"to",
"json",
"message",
"=",
"new",
"rpc",
"message",
"(",
")",
";",
"to",
"json",
"message",
"set",
"body",
"(",
"body",
"field",
")",
";",
"to",
"json",
"message",
"set",
"id",
"(",
"id",
"field",
")",
";",
"to",
"json",
"message",
"set",
"message",
"type",
"(",
"msg",
"type",
"field",
")",
";",
"to",
"json",
"message",
"set",
"codec",
"(",
"codec",
"field",
")",
";",
"to",
"json",
"message",
"set",
"compressor",
"(",
"compress",
"field",
")",
";",
"to",
"json",
"message",
"set",
"head",
"map",
"(",
"head",
"field",
")",
";",
"string",
"to",
"json",
"=",
"json",
"to",
"j",
"s",
"o",
"n",
"string",
"(",
"to",
"json",
"message",
",",
"true",
")",
";",
"assert",
"that",
"(",
"from",
"json",
")",
"is",
"equal",
"to",
"(",
"to",
"json",
")",
";",
"}"
]
|
[
"remove",
"the",
"given",
"button",
"from",
"the",
"dialog"
]
| [
"protected",
"void",
"remove",
"button",
"(",
"j",
"button",
"button",
")",
"{",
"button",
"panel",
"remove",
"(",
"button",
")",
";",
"root",
"panel",
"validate",
"(",
")",
";",
"}"
]
|
[
"makes",
"sure",
"that",
"arrays",
"are",
"compared",
"by",
"content",
"auto",
"-",
"value",
"promises",
"that",
"but",
"i",
"want",
"to",
"be",
"really",
"sure",
"as",
"we",
"'",
"d",
"never",
"get",
"any",
"cache",
"hits",
"if",
"arrays",
"were",
"compared",
"by",
"reference"
]
| [
"public",
"void",
"test",
"content",
"matters",
"(",
")",
"{",
"assert",
"that",
"(",
"dexing",
"key",
"create",
"(",
"false",
",",
"false",
",",
"1",
",",
"13",
",",
"new",
"byte",
"[",
"]",
"{",
"1",
",",
"2",
",",
"3",
"}",
")",
")",
"is",
"equal",
"to",
"(",
"dexing",
"key",
"create",
"(",
"false",
",",
"false",
",",
"1",
",",
"13",
",",
"new",
"byte",
"[",
"]",
"{",
"1",
",",
"2",
",",
"3",
"}",
")",
")",
";",
"assert",
"that",
"(",
"dexing",
"key",
"create",
"(",
"false",
",",
"false",
",",
"1",
",",
"13",
",",
"new",
"byte",
"[",
"]",
"{",
"1",
",",
"2",
",",
"3",
"}",
")",
")",
"is",
"not",
"equal",
"to",
"(",
"dexing",
"key",
"create",
"(",
"false",
",",
"false",
",",
"1",
",",
"13",
",",
"new",
"byte",
"[",
"]",
"{",
"1",
",",
"3",
",",
"3",
"}",
")",
")",
";",
"}"
]
|
[
"convert",
"a",
"java",
"time",
"instant",
"to",
"a",
"long",
"value",
"which",
"is",
"stored",
"in",
"lucene",
"the",
"long",
"value",
"resembles",
"the",
"nanoseconds",
"since",
"the",
"epoch"
]
| [
"public",
"static",
"long",
"to",
"long",
"(",
"instant",
"instant",
")",
"{",
"if",
"(",
"instant",
"is",
"before",
"(",
"instant",
"epoch",
")",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"date",
"[",
"\"",
"+",
"instant",
"+",
"\"",
"]",
"is",
"before",
"the",
"epoch",
"in",
"1970",
"and",
"cannot",
"be",
"\"",
"+",
"\"",
"stored",
"in",
"nanosecond",
"resolution",
"\"",
")",
";",
"}",
"if",
"(",
"instant",
"is",
"after",
"(",
"max",
"nanosecond",
"instant",
")",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"date",
"[",
"\"",
"+",
"instant",
"+",
"\"",
"]",
"is",
"after",
"2262",
"-",
"04",
"-",
"11t23",
":",
"47",
":",
"16",
"854775807",
"and",
"cannot",
"be",
"\"",
"+",
"\"",
"stored",
"in",
"nanosecond",
"resolution",
"\"",
")",
";",
"}",
"return",
"instant",
"get",
"epoch",
"second",
"(",
")",
"*",
"1",
"000",
"000",
"000",
"+",
"instant",
"get",
"nano",
"(",
")",
";",
"}"
]
|
[
"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",
"\"",
")",
";",
"}"
]
|
[
"set",
"or",
"override",
"the",
"specified",
"header",
"values",
"under",
"the",
"given",
"name",
"if",
"you",
"need",
"to",
"add",
"header",
"values",
",",
"remove",
"headers",
",",
"etc",
",",
"use",
"{",
"@",
"link",
"#",
"headers",
"(",
"consumer",
")",
"}",
"for",
"greater",
"control"
]
| [
"builder",
"header",
"(",
"string",
"header",
"name",
",",
"string",
"header",
"values",
")",
";"
]
|
[
"sets",
"the",
"descriptor",
"index"
]
| [
"protected",
"void",
"set",
"descriptor",
"index",
"(",
"int",
"index",
")",
"{",
"u",
"2descriptor",
"index",
"=",
"index",
";",
"}"
]
|
[
"notifies",
"that",
"more",
"data",
"is",
"received",
"to",
"continue",
"decoding"
]
| [
"abstract",
"decoding",
"result",
"on",
"channel",
"read",
"(",
"byte",
"buf",
"data",
")",
"throws",
"exception",
";"
]
|
[
"return",
"the",
"\"",
"allow",
"\"",
"header",
"value",
"to",
"use",
"in",
"response",
"to",
"an",
"http",
"options",
"request",
"based",
"on",
"the",
"configured",
"{",
"@",
"link",
"#",
"set",
"supported",
"methods",
"supported",
"methods",
"}",
"also",
"automatically",
"adding",
"\"",
"options",
"\"",
"to",
"the",
"list",
"even",
"if",
"not",
"present",
"as",
"a",
"supported",
"method",
"this",
"means",
"subclasses",
"don",
"'",
"t",
"have",
"to",
"explicitly",
"list",
"\"",
"options",
"\"",
"as",
"a",
"supported",
"method",
"as",
"long",
"as",
"http",
"options",
"requests",
"are",
"handled",
"before",
"making",
"a",
"call",
"to",
"{",
"@",
"link",
"#",
"check",
"request",
"(",
"http",
"servlet",
"request",
")",
"}"
]
| [
"protected",
"string",
"get",
"allow",
"header",
"(",
")",
"{",
"return",
"this",
"allow",
"header",
";",
"}"
]
|
[
"returns",
"the",
"sources",
"to",
"compile",
",",
"including",
"any",
"source",
"jar",
"entries"
]
| [
"private",
"immutable",
"list",
"<",
"java",
"file",
"object",
">",
"get",
"sources",
"(",
"options",
"parser",
"options",
"parser",
",",
"standard",
"java",
"file",
"manager",
"file",
"manager",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"immutable",
"list",
"builder",
"<",
"java",
"file",
"object",
">",
"sources",
"=",
"immutable",
"list",
"builder",
"(",
")",
";",
"sources",
"add",
"all",
"(",
"file",
"manager",
"get",
"java",
"file",
"objects",
"from",
"strings",
"(",
"options",
"parser",
"get",
"source",
"files",
"(",
")",
")",
")",
";",
"for",
"(",
"string",
"source",
"jar",
":",
"options",
"parser",
"get",
"source",
"jars",
"(",
")",
")",
"{",
"for",
"(",
"final",
"path",
"root",
":",
"get",
"jar",
"file",
"system",
"(",
"paths",
"get",
"(",
"source",
"jar",
")",
")",
"get",
"root",
"directories",
"(",
")",
")",
"{",
"files",
"walk",
"file",
"tree",
"(",
"root",
",",
"new",
"simple",
"file",
"visitor",
"<",
"path",
">",
"(",
")",
"{",
"@",
"override",
"public",
"file",
"visit",
"result",
"visit",
"file",
"(",
"path",
"path",
",",
"basic",
"file",
"attributes",
"attrs",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"path",
"get",
"file",
"name",
"(",
")",
"to",
"string",
"(",
")",
"ends",
"with",
"(",
"\"",
"java",
"\"",
")",
")",
"{",
"sources",
"add",
"(",
"new",
"source",
"jar",
"file",
"object",
"(",
"root",
",",
"path",
")",
")",
";",
"}",
"return",
"file",
"visit",
"result",
"continue",
";",
"}",
"}",
")",
";",
"}",
"}",
"return",
"sources",
"build",
"(",
")",
";",
"}"
]
|
[
"should",
"activate",
"multifactor",
"authentication",
"for",
"user",
"?"
]
| [
"protected",
"boolean",
"should",
"activate",
"multifactor",
"authentication",
"for",
"(",
"final",
"request",
"context",
"request",
"context",
",",
"final",
"passwordless",
"user",
"account",
"user",
")",
"{",
"val",
"status",
"=",
"user",
"get",
"multifactor",
"authentication",
"eligible",
"(",
")",
";",
"if",
"(",
"status",
"is",
"true",
"(",
")",
")",
"{",
"logger",
"trace",
"(",
"\"",
"passwordless",
"account",
"[",
"{",
"}",
"]",
"is",
"eligible",
"for",
"multifactor",
"authentication",
"\"",
",",
"user",
")",
";",
"return",
"true",
";",
"}",
"if",
"(",
"status",
"is",
"false",
"(",
")",
")",
"{",
"logger",
"trace",
"(",
"\"",
"passwordless",
"account",
"[",
"{",
"}",
"]",
"is",
"not",
"eligible",
"for",
"multifactor",
"authentication",
"\"",
",",
"user",
")",
";",
"return",
"false",
";",
"}",
"return",
"cas",
"properties",
"get",
"authn",
"(",
")",
"get",
"passwordless",
"(",
")",
"is",
"multifactor",
"authentication",
"activated",
"(",
")",
";",
"}"
]
|
[
"builds",
"an",
"{",
"@",
"link",
"intent",
"}",
"for",
"adding",
"a",
"new",
"download"
]
| [
"public",
"static",
"intent",
"build",
"add",
"download",
"intent",
"(",
"context",
"context",
",",
"class",
"<",
"?",
"extends",
"download",
"service",
">",
"clazz",
",",
"download",
"request",
"download",
"request",
",",
"int",
"stop",
"reason",
",",
"boolean",
"foreground",
")",
"{",
"return",
"get",
"intent",
"(",
"context",
",",
"clazz",
",",
"action",
"add",
"download",
",",
"foreground",
")",
"put",
"extra",
"(",
"key",
"download",
"request",
",",
"download",
"request",
")",
"put",
"extra",
"(",
"key",
"stop",
"reason",
",",
"stop",
"reason",
")",
";",
"}"
]
|
[
"the",
"length",
"of",
"the",
"key",
"in",
"bytes"
]
| [
"public",
"int",
"key",
"size",
"(",
")",
"{",
"if",
"(",
"magic",
"(",
")",
"=",
"=",
"record",
"batch",
"magic",
"value",
"v0",
")",
"return",
"buffer",
"get",
"int",
"(",
"key",
"size",
"offset",
"v0",
")",
";",
"else",
"return",
"buffer",
"get",
"int",
"(",
"key",
"size",
"offset",
"v1",
")",
";",
"}"
]
|
[
"add",
"{",
"@",
"code",
"edge",
"}",
"to",
"the",
"set",
"of",
"incoming",
"edges",
"implicitly",
"adds",
"{",
"@",
"code",
"node",
"}",
"as",
"a",
"predecessor"
]
| [
"void",
"add",
"in",
"edge",
"(",
"e",
"edge",
",",
"n",
"node",
",",
"boolean",
"is",
"self",
"loop",
")",
";"
]
|
[
"tokenize",
"the",
"given",
"{",
"@",
"code",
"string",
"}",
"into",
"a",
"{",
"@",
"code",
"string",
"}",
"array",
"via",
"a",
"{",
"@",
"link",
"string",
"tokenizer",
"}",
"trims",
"tokens",
"and",
"omits",
"empty",
"tokens",
"the",
"given",
"{",
"@",
"code",
"delimiters",
"}",
"string",
"can",
"consist",
"of",
"any",
"number",
"of",
"delimiter",
"characters",
"each",
"of",
"those",
"characters",
"can",
"be",
"used",
"to",
"separate",
"tokens",
"a",
"delimiter",
"is",
"always",
"a",
"single",
"character",
";",
"for",
"multi",
"-",
"character",
"delimiters",
",",
"consider",
"using",
"{",
"@",
"link",
"#",
"delimited",
"list",
"to",
"string",
"array",
"}"
]
| [
"public",
"static",
"string",
"[",
"]",
"tokenize",
"to",
"string",
"array",
"(",
"@",
"nullable",
"string",
"str",
",",
"string",
"delimiters",
")",
"{",
"return",
"tokenize",
"to",
"string",
"array",
"(",
"str",
",",
"delimiters",
",",
"true",
",",
"true",
")",
";",
"}"
]
|
[
"returns",
"an",
"input",
"source",
"that",
"reads",
"from",
"the",
"given",
"char",
"array",
"the",
"caller",
"must",
"not",
"subsequently",
"modify",
"the",
"array"
]
| [
"public",
"static",
"parser",
"input",
"from",
"char",
"array",
"(",
"char",
"[",
"]",
"content",
",",
"string",
"file",
")",
"{",
"return",
"new",
"parser",
"input",
"(",
"content",
",",
"file",
")",
";",
"}"
]
|
[
"create",
"a",
"new",
"{",
"@",
"link",
"client",
"http",
"request",
"}",
"for",
"the",
"specified",
"uri",
"and",
"http",
"method",
"the",
"returned",
"request",
"can",
"be",
"written",
"to",
",",
"and",
"then",
"executed",
"by",
"calling",
"{",
"@",
"link",
"client",
"http",
"request",
"#",
"execute",
"(",
")",
"}"
]
| [
"client",
"http",
"request",
"create",
"request",
"(",
"uri",
"uri",
",",
"http",
"method",
"http",
"method",
")",
"throws",
"i",
"o",
"exception",
";"
]
|
[
"decides",
"whether",
"to",
"fail",
"and",
"fails",
"the",
"task",
"implicitly",
"or",
"by",
"throwing",
"an",
"exception"
]
| [
"boolean",
"fail",
"or",
"not",
"(",
"int",
"tracking",
"index",
")",
"throws",
"exception",
";"
]
|
[
"adds",
"a",
"handler",
"post",
"to",
"list",
"of",
"pending",
"messages"
]
| [
"protected",
"synchronized",
"boolean",
"add",
"handler",
"message",
"at",
"time",
"(",
"handler",
"wrapper",
"handler",
",",
"runnable",
"runnable",
",",
"long",
"time",
"ms",
")",
"{",
"if",
"(",
"time",
"ms",
"<",
"=",
"time",
"since",
"boot",
"ms",
")",
"{",
"return",
"handler",
"post",
"(",
"runnable",
")",
";",
"}",
"handler",
"messages",
"add",
"(",
"new",
"handler",
"message",
"data",
"(",
"time",
"ms",
",",
"handler",
",",
"runnable",
")",
")",
";",
"return",
"true",
";",
"}"
]
|
[
"there",
"is",
"no",
"persistent",
"storage",
"just",
"clear",
"the",
"buffers"
]
| [
"public",
"void",
"create",
"(",
"int",
"layout",
"version",
")",
"throws",
"i",
"o",
"exception",
"{",
"assert",
"double",
"buf",
"is",
"flushed",
"(",
")",
":",
"\"",
"previous",
"data",
"is",
"not",
"flushed",
"yet",
"\"",
";",
"this",
"double",
"buf",
"=",
"new",
"edits",
"double",
"buffer",
"(",
"default",
"buffer",
"size",
")",
";",
"set",
"current",
"log",
"version",
"(",
"layout",
"version",
")",
";",
"}"
]
|
[
"creates",
"list",
"of",
"users",
"with",
"given",
"input",
"array"
]
| [
"public",
"void",
"create",
"users",
"with",
"list",
"input",
"(",
"list",
"<",
"user",
">",
"body",
",",
"handler",
"<",
"async",
"result",
"<",
"void",
">",
">",
"result",
"handler",
")",
"{",
"delegate",
"create",
"users",
"with",
"list",
"input",
"(",
"body",
",",
"result",
"handler",
")",
";",
"}"
]
|
[
"test",
"that",
"the",
"indexed",
"shape",
"routing",
"can",
"be",
"provided",
"if",
"it",
"is",
"required"
]
| [
"public",
"void",
"test",
"index",
"shape",
"routing",
"(",
")",
"{",
"string",
"source",
"=",
"\"",
"{",
"\\",
"n",
"\"",
"+",
"\"",
"\\",
"\"",
"shape",
"\\",
"\"",
":",
"{",
"\\",
"n",
"\"",
"+",
"\"",
"\\",
"\"",
"type",
"\\",
"\"",
":",
"\\",
"\"",
"bbox",
"\\",
"\"",
",",
"\\",
"n",
"\"",
"+",
"\"",
"\\",
"\"",
"coordinates",
"\\",
"\"",
":",
"[",
"[",
"\"",
"+",
"-",
"float",
"max",
"value",
"+",
"\"",
",",
"\"",
"+",
"float",
"max",
"value",
"+",
"\"",
"]",
",",
"[",
"\"",
"+",
"float",
"max",
"value",
"+",
"\"",
",",
"\"",
"+",
"-",
"float",
"max",
"value",
"+",
"\"",
"]",
"]",
"\\",
"n",
"\"",
"+",
"\"",
"}",
"\\",
"n",
"\"",
"+",
"\"",
"}",
"\"",
";",
"client",
"(",
")",
"prepare",
"index",
"(",
"index",
")",
"set",
"id",
"(",
"\"",
"0",
"\"",
")",
"set",
"source",
"(",
"source",
",",
"x",
"content",
"type",
"json",
")",
"set",
"routing",
"(",
"\"",
"abc",
"\"",
")",
"get",
"(",
")",
";",
"client",
"(",
")",
"admin",
"(",
")",
"indices",
"(",
")",
"prepare",
"refresh",
"(",
"index",
")",
"get",
"(",
")",
";",
"search",
"response",
"search",
"response",
"=",
"client",
"(",
")",
"prepare",
"search",
"(",
"index",
")",
"set",
"query",
"(",
"new",
"shape",
"query",
"builder",
"(",
"field",
",",
"\"",
"0",
"\"",
")",
"indexed",
"shape",
"index",
"(",
"index",
")",
"indexed",
"shape",
"routing",
"(",
"\"",
"abc",
"\"",
")",
")",
"get",
"(",
")",
";",
"assert",
"that",
"(",
"search",
"response",
"get",
"hits",
"(",
")",
"get",
"total",
"hits",
"(",
")",
"value",
",",
"equal",
"to",
"(",
"(",
"long",
")",
"num",
"docs",
"+",
"1",
")",
")",
";",
"}"
]
|
[
"static",
"utility",
"to",
"parse",
"a",
"field",
"of",
"type",
"byte",
"from",
"a",
"byte",
"sequence",
"that",
"represents",
"text",
"characters",
"(",
"such",
"as",
"when",
"read",
"from",
"a",
"file",
"stream",
")"
]
| [
"public",
"static",
"final",
"byte",
"parse",
"field",
"(",
"byte",
"[",
"]",
"bytes",
",",
"int",
"start",
"pos",
",",
"int",
"length",
",",
"char",
"delimiter",
")",
"{",
"long",
"val",
"=",
"0",
";",
"boolean",
"neg",
"=",
"false",
";",
"if",
"(",
"bytes",
"[",
"start",
"pos",
"]",
"=",
"=",
"delimiter",
")",
"{",
"throw",
"new",
"number",
"format",
"exception",
"(",
"\"",
"empty",
"field",
"\"",
")",
";",
"}",
"if",
"(",
"bytes",
"[",
"start",
"pos",
"]",
"=",
"=",
"'",
"-",
"'",
")",
"{",
"neg",
"=",
"true",
";",
"start",
"pos",
"+",
"+",
";",
"length",
"-",
"-",
";",
"if",
"(",
"length",
"=",
"=",
"0",
"|",
"|",
"bytes",
"[",
"start",
"pos",
"]",
"=",
"=",
"delimiter",
")",
"{",
"throw",
"new",
"number",
"format",
"exception",
"(",
"\"",
"orphaned",
"minus",
"sign",
"\"",
")",
";",
"}",
"}",
"for",
"(",
";",
"length",
">",
"0",
";",
"start",
"pos",
"+",
"+",
",",
"length",
"-",
"-",
")",
"{",
"if",
"(",
"bytes",
"[",
"start",
"pos",
"]",
"=",
"=",
"delimiter",
")",
"{",
"return",
"(",
"byte",
")",
"(",
"neg",
"?",
"-",
"val",
":",
"val",
")",
";",
"}",
"if",
"(",
"bytes",
"[",
"start",
"pos",
"]",
"<",
"48",
"|",
"|",
"bytes",
"[",
"start",
"pos",
"]",
">",
"57",
")",
"{",
"throw",
"new",
"number",
"format",
"exception",
"(",
"\"",
"invalid",
"character",
"\"",
")",
";",
"}",
"val",
"*",
"=",
"10",
";",
"val",
"+",
"=",
"bytes",
"[",
"start",
"pos",
"]",
"-",
"48",
";",
"if",
"(",
"val",
">",
"byte",
"max",
"value",
"&",
"&",
"(",
"!",
"neg",
"|",
"|",
"val",
">",
"-",
"byte",
"min",
"value",
")",
")",
"{",
"throw",
"new",
"number",
"format",
"exception",
"(",
"\"",
"value",
"overflow",
"/",
"underflow",
"\"",
")",
";",
"}",
"}",
"return",
"(",
"byte",
")",
"(",
"neg",
"?",
"-",
"val",
":",
"val",
")",
";",
"}"
]
|
[
"convert",
"a",
"config",
"to",
"an",
"{",
"@",
"link",
"analyzer",
"}",
"this",
"may",
"be",
"a",
"global",
"analyzer",
"or",
"a",
"newly",
"created",
"custom",
"analyzer",
"in",
"the",
"case",
"of",
"a",
"global",
"analyzer",
"the",
"caller",
"must",
"not",
"close",
"it",
"when",
"they",
"have",
"finished",
"with",
"it",
"in",
"the",
"case",
"of",
"a",
"newly",
"created",
"custom",
"analyzer",
"the",
"caller",
"is",
"responsible",
"for",
"closing",
"it"
]
| [
"private",
"static",
"tuple",
"<",
"analyzer",
",",
"boolean",
">",
"make",
"analyzer",
"(",
"categorization",
"analyzer",
"config",
"config",
",",
"analysis",
"registry",
"analysis",
"registry",
")",
"throws",
"i",
"o",
"exception",
"{",
"string",
"analyzer",
"=",
"config",
"get",
"analyzer",
"(",
")",
";",
"if",
"(",
"analyzer",
"!",
"=",
"null",
")",
"{",
"analyzer",
"global",
"analyzer",
"=",
"analysis",
"registry",
"get",
"analyzer",
"(",
"analyzer",
")",
";",
"if",
"(",
"global",
"analyzer",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"failed",
"to",
"find",
"global",
"analyzer",
"[",
"\"",
"+",
"analyzer",
"+",
"\"",
"]",
"\"",
")",
";",
"}",
"return",
"new",
"tuple",
"<",
">",
"(",
"global",
"analyzer",
",",
"boolean",
"false",
")",
";",
"}",
"else",
"{",
"return",
"new",
"tuple",
"<",
">",
"(",
"analysis",
"registry",
"build",
"custom",
"analyzer",
"(",
"null",
",",
"false",
",",
"config",
"get",
"tokenizer",
"(",
")",
",",
"config",
"get",
"char",
"filters",
"(",
")",
",",
"config",
"get",
"token",
"filters",
"(",
")",
")",
",",
"boolean",
"true",
")",
";",
"}",
"}"
]
|
[
"release",
"this",
"connection",
"if",
"the",
"connection",
"was",
"closed",
",",
"close",
"the",
"proxy",
"otherwise",
",",
"mark",
"the",
"connection",
"as",
"not",
"used",
"by",
"us",
"anymore"
]
| [
"public",
"synchronized",
"void",
"release",
"(",
")",
"{",
"if",
"(",
"-",
"-",
"this",
"num",
"threads",
"=",
"=",
"0",
"&",
"&",
"this",
"closed",
")",
"{",
"close",
"(",
")",
";",
"}",
"}"
]
|
[
"returns",
"the",
"validator",
"to",
"validate",
"the",
"value",
"of",
"the",
"parameter"
]
| [
"public",
"param",
"validator",
"<",
"v",
">",
"get",
"validator",
"(",
")",
"{",
"return",
"validator",
";",
"}"
]
|
[
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"the",
"supplied",
"string",
"is",
"a",
"valid",
"uri",
"ip",
"string",
"literal",
",",
"{",
"@",
"code",
"false",
"}",
"otherwise"
]
| [
"public",
"static",
"boolean",
"is",
"uri",
"inet",
"address",
"(",
"string",
"ip",
"string",
")",
"{",
"return",
"for",
"uri",
"string",
"no",
"throw",
"(",
"ip",
"string",
")",
"!",
"=",
"null",
";",
"}"
]
|
[
"pop",
"all",
"fragments"
]
| [
"public",
"static",
"void",
"pop",
"all",
"(",
"@",
"non",
"null",
"final",
"fragment",
"manager",
"fm",
")",
"{",
"pop",
"all",
"(",
"fm",
",",
"true",
")",
";",
"}"
]
|
[
"set",
"the",
"additional",
"(",
"undeclared",
")",
"property",
"with",
"the",
"specified",
"name",
"and",
"value",
"if",
"the",
"property",
"does",
"not",
"already",
"exist",
",",
"create",
"it",
"otherwise",
"replace",
"it"
]
| [
"public",
"quadrilateral",
"put",
"additional",
"property",
"(",
"string",
"key",
",",
"object",
"value",
")",
"{",
"if",
"(",
"this",
"additional",
"properties",
"=",
"=",
"null",
")",
"{",
"this",
"additional",
"properties",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"object",
">",
"(",
")",
";",
"}",
"this",
"additional",
"properties",
"put",
"(",
"key",
",",
"value",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"com",
"taobao",
"hsf",
"metadata",
"store",
"metadata",
"info",
"store",
"service",
"redis",
"publish",
"class",
"info",
"(",
"service",
"metadata",
")"
]
| [
"public",
"static",
"service",
"definition",
"generate",
"metadata",
"(",
"class",
"<",
"?",
">",
"interface",
"class",
")",
"{",
"service",
"definition",
"sd",
"=",
"new",
"service",
"definition",
"(",
")",
";",
"sd",
"set",
"canonical",
"name",
"(",
"interface",
"class",
"get",
"canonical",
"name",
"(",
")",
")",
";",
"sd",
"set",
"code",
"source",
"(",
"class",
"utils",
"get",
"code",
"source",
"(",
"interface",
"class",
")",
")",
";",
"type",
"definition",
"builder",
"builder",
"=",
"new",
"type",
"definition",
"builder",
"(",
")",
";",
"list",
"<",
"method",
">",
"methods",
"=",
"class",
"utils",
"get",
"public",
"non",
"static",
"methods",
"(",
"interface",
"class",
")",
";",
"for",
"(",
"method",
"method",
":",
"methods",
")",
"{",
"method",
"definition",
"md",
"=",
"new",
"method",
"definition",
"(",
")",
";",
"md",
"set",
"name",
"(",
"method",
"get",
"name",
"(",
")",
")",
";",
"class",
"<",
"?",
">",
"[",
"]",
"param",
"types",
"=",
"method",
"get",
"parameter",
"types",
"(",
")",
";",
"type",
"[",
"]",
"generic",
"param",
"types",
"=",
"method",
"get",
"generic",
"parameter",
"types",
"(",
")",
";",
"string",
"[",
"]",
"parameter",
"types",
"=",
"new",
"string",
"[",
"param",
"types",
"length",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"param",
"types",
"length",
";",
"i",
"+",
"+",
")",
"{",
"try",
"{",
"type",
"definition",
"td",
"=",
"builder",
"build",
"(",
"generic",
"param",
"types",
"[",
"i",
"]",
",",
"param",
"types",
"[",
"i",
"]",
")",
";",
"parameter",
"types",
"[",
"i",
"]",
"=",
"td",
"get",
"type",
"(",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"parameter",
"types",
"[",
"i",
"]",
"=",
"param",
"types",
"[",
"i",
"]",
"get",
"name",
"(",
")",
";",
"}",
"}",
"md",
"set",
"parameter",
"types",
"(",
"parameter",
"types",
")",
";",
"try",
"{",
"type",
"definition",
"td",
"=",
"builder",
"build",
"(",
"method",
"get",
"generic",
"return",
"type",
"(",
")",
",",
"method",
"get",
"return",
"type",
"(",
")",
")",
";",
"md",
"set",
"return",
"type",
"(",
"td",
"get",
"type",
"(",
")",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"md",
"set",
"return",
"type",
"(",
"method",
"get",
"return",
"type",
"(",
")",
"get",
"name",
"(",
")",
")",
";",
"}",
"sd",
"get",
"methods",
"(",
")",
"add",
"(",
"md",
")",
";",
"}",
"sd",
"set",
"types",
"(",
"builder",
"get",
"type",
"definitions",
"(",
")",
")",
";",
"return",
"sd",
";",
"}"
]
|
[
"get",
"a",
"{",
"@",
"link",
"dubbo",
"rest",
"service",
"metadata",
"}",
"by",
"the",
"specified",
"service",
"name",
"if",
"{",
"@",
"link",
"request",
"metadata",
"}",
"matched"
]
| [
"public",
"dubbo",
"rest",
"service",
"metadata",
"get",
"(",
"string",
"service",
"name",
",",
"request",
"metadata",
"request",
"metadata",
")",
"{",
"return",
"match",
"(",
"dubbo",
"rest",
"service",
"metadata",
"repository",
",",
"service",
"name",
",",
"request",
"metadata",
")",
";",
"}"
]
|
[
"test",
"that",
"program",
"merge",
"can",
"determine",
"the",
"user",
"defined",
"property",
"differences",
"between",
"program",
"1",
"and",
"program",
"2"
]
| [
"public",
"void",
"test",
"apply",
"user",
"defined",
"differences",
"(",
")",
"throws",
"exception",
"{",
"/",
"/",
"space",
"property",
"/",
"/",
"0x",
"1",
"0",
"0",
"1",
"8ae",
":",
"p",
"1",
"has",
"space",
"=",
"1",
"/",
"/",
"0x",
"1",
"0",
"0",
"1",
"8ba",
":",
"p",
"1",
"and",
"p",
"2",
"have",
"space",
"=",
"1",
"/",
"/",
"0x",
"1",
"0",
"0",
"1",
"8ce",
":",
"p",
"2",
"has",
"space",
"=",
"2",
"/",
"/",
"0x",
"1",
"0",
"0",
"1",
"8ff",
":",
"p",
"1",
"has",
"space",
"=",
"1",
"&",
"p",
"2",
"has",
"space",
"=",
"2",
"program",
"builder",
"1",
"set",
"int",
"property",
"(",
"\"",
"0x",
"1",
"0",
"0",
"1",
"8ae",
"\"",
",",
"\"",
"space",
"\"",
",",
"1",
")",
";",
"program",
"builder",
"1",
"set",
"int",
"property",
"(",
"\"",
"0x",
"1",
"0",
"0",
"1",
"8ba",
"\"",
",",
"\"",
"space",
"\"",
",",
"1",
")",
";",
"program",
"builder",
"1",
"set",
"int",
"property",
"(",
"\"",
"0x",
"1",
"0",
"0",
"1",
"8ff",
"\"",
",",
"\"",
"space",
"\"",
",",
"1",
")",
";",
"program",
"builder",
"2",
"set",
"int",
"property",
"(",
"\"",
"0x",
"1",
"0",
"0",
"1",
"8ba",
"\"",
",",
"\"",
"space",
"\"",
",",
"1",
")",
";",
"program",
"builder",
"2",
"set",
"int",
"property",
"(",
"\"",
"0x",
"1",
"0",
"0",
"1",
"8ce",
"\"",
",",
"\"",
"space",
"\"",
",",
"2",
")",
";",
"/",
"/",
"test",
"color",
"property",
"/",
"/",
"0x",
"1",
"0",
"0",
"2",
"4",
"8c",
":",
"p",
"1",
"=",
"cyan",
"&",
"p",
"2",
"=",
"white",
"/",
"/",
"0x",
"1",
"0",
"0",
"3",
"9dd",
":",
"p",
"1",
"=",
"black",
"/",
"/",
"0x",
"1",
"0",
"0",
"3",
"9f",
"1",
":",
"p",
"2",
"=",
"black",
"/",
"/",
"0x",
"1",
"0",
"0",
"3",
"9f",
"8",
":",
"p",
"1",
"=",
"black",
"&",
"p",
"2",
"=",
"black",
"program",
"builder",
"1",
"set",
"string",
"property",
"(",
"\"",
"0x",
"1",
"0",
"0",
"2",
"4",
"8c",
"\"",
",",
"\"",
"test",
"color",
"\"",
",",
"\"",
"cyan",
"\"",
")",
";",
"program",
"builder",
"1",
"set",
"string",
"property",
"(",
"\"",
"0x",
"1",
"0",
"0",
"3",
"9dd",
"\"",
",",
"\"",
"test",
"color",
"\"",
",",
"\"",
"black",
"\"",
")",
";",
"program",
"builder",
"1",
"set",
"string",
"property",
"(",
"\"",
"0x",
"1",
"0",
"0",
"3",
"9f",
"8",
"\"",
",",
"\"",
"test",
"color",
"\"",
",",
"\"",
"black",
"\"",
")",
";",
"program",
"builder",
"2",
"set",
"string",
"property",
"(",
"\"",
"0x",
"1",
"0",
"0",
"2",
"4",
"8c",
"\"",
",",
"\"",
"test",
"color",
"\"",
",",
"\"",
"white",
"\"",
")",
";",
"program",
"builder",
"2",
"set",
"string",
"property",
"(",
"\"",
"0x",
"1",
"0",
"0",
"3",
"9f",
"1",
"\"",
",",
"\"",
"test",
"color",
"\"",
",",
"\"",
"black",
"\"",
")",
";",
"program",
"builder",
"2",
"set",
"string",
"property",
"(",
"\"",
"0x",
"1",
"0",
"0",
"3",
"9f",
"8",
"\"",
",",
"\"",
"test",
"color",
"\"",
",",
"\"",
"black",
"\"",
")",
";",
"program",
"merge",
"=",
"new",
"program",
"merge",
"manager",
"(",
"p",
"1",
",",
"p",
"2",
",",
"task",
"monitor",
"adapter",
"dummy",
"monitor",
")",
";",
"address",
"set",
"as",
"=",
"new",
"address",
"set",
"(",
")",
";",
"as",
"add",
"range",
"(",
"addr",
"(",
"0x",
"1",
"0",
"0",
"1",
"8ae",
")",
",",
"addr",
"(",
"0x",
"1",
"0",
"0",
"1",
"8ae",
")",
")",
";",
"as",
"add",
"range",
"(",
"addr",
"(",
"0x",
"1",
"0",
"0",
"1",
"8ce",
")",
",",
"addr",
"(",
"0x",
"1",
"0",
"0",
"1",
"8ce",
")",
")",
";",
"as",
"add",
"range",
"(",
"addr",
"(",
"0x",
"1",
"0",
"0",
"1",
"8ff",
")",
",",
"addr",
"(",
"0x",
"1",
"0",
"0",
"1",
"8ff",
")",
")",
";",
"as",
"add",
"range",
"(",
"addr",
"(",
"0x",
"1",
"0",
"0",
"2",
"4",
"8c",
")",
",",
"addr",
"(",
"0x",
"1",
"0",
"0",
"2",
"4",
"8c",
")",
")",
";",
"as",
"add",
"range",
"(",
"addr",
"(",
"0x",
"1",
"0",
"0",
"3",
"9dd",
")",
",",
"addr",
"(",
"0x",
"1",
"0",
"0",
"3",
"9dd",
")",
")",
";",
"as",
"add",
"range",
"(",
"addr",
"(",
"0x",
"1",
"0",
"0",
"3",
"9f",
"1",
")",
",",
"addr",
"(",
"0x",
"1",
"0",
"0",
"3",
"9f",
"1",
")",
")",
";",
"program",
"merge",
"set",
"diff",
"filter",
"(",
"new",
"program",
"diff",
"filter",
"(",
"program",
"diff",
"filter",
"user",
"defined",
"diffs",
")",
")",
";",
"program",
"merge",
"set",
"merge",
"filter",
"(",
"new",
"program",
"merge",
"filter",
"(",
"program",
"merge",
"filter",
"properties",
",",
"program",
"merge",
"filter",
"replace",
")",
")",
";",
"address",
"set",
"view",
"expected",
"set",
"=",
"diff",
"utility",
"get",
"code",
"unit",
"set",
"(",
"as",
",",
"p",
"1",
")",
";",
"address",
"set",
"view",
"diff",
"set",
"=",
"program",
"merge",
"get",
"filtered",
"differences",
"(",
")",
";",
"assert",
"equals",
"(",
"expected",
"set",
",",
"diff",
"set",
")",
";",
"assert",
"equals",
"(",
"expected",
"set",
",",
"program",
"merge",
"get",
"filtered",
"differences",
"(",
")",
")",
";",
"program",
"merge",
"merge",
"(",
"expected",
"set",
",",
"task",
"monitor",
"adapter",
"dummy",
"monitor",
")",
";",
"assert",
"equals",
"(",
"new",
"address",
"set",
"(",
")",
",",
"program",
"merge",
"get",
"filtered",
"differences",
"(",
")",
")",
";",
"}"
]
|
[
"gets",
"the",
"list",
"of",
"instructions",
"inside",
"this",
"block"
]
| [
"public",
"insn",
"list",
"get",
"insns",
"(",
")",
"{",
"return",
"insns",
";",
"}"
]
|
[
"returns",
"the",
"{",
"@",
"link",
"type",
"}",
"corresponding",
"to",
"the",
"return",
"type",
"of",
"the",
"given",
"method",
"descriptor"
]
| [
"public",
"static",
"type",
"get",
"return",
"type",
"(",
"final",
"string",
"method",
"descriptor",
")",
"{",
"return",
"get",
"type",
"internal",
"(",
"method",
"descriptor",
",",
"get",
"return",
"type",
"offset",
"(",
"method",
"descriptor",
")",
",",
"method",
"descriptor",
"length",
"(",
")",
")",
";",
"}"
]
|
[
"creates",
"a",
"reconfigured",
"version",
"of",
"the",
"{",
"@",
"link",
"pojo",
"serializer",
"}"
]
| [
"private",
"static",
"<",
"t",
">",
"pojo",
"serializer",
"<",
"t",
">",
"construct",
"reconfigured",
"pojo",
"serializer",
"(",
"pojo",
"serializer",
"<",
"t",
">",
"original",
"new",
"pojo",
"serializer",
",",
"intermediate",
"compatibility",
"result",
"<",
"t",
">",
"field",
"serializer",
"compatibility",
",",
"linked",
"optional",
"map",
"<",
"class",
"<",
"?",
">",
",",
"type",
"serializer",
"snapshot",
"<",
"?",
">",
">",
"registered",
"serializer",
"snapshots",
",",
"intermediate",
"compatibility",
"result",
"<",
"t",
">",
"pre",
"existing",
"registrations",
"compatibility",
",",
"linked",
"optional",
"map",
"<",
"class",
"<",
"?",
">",
",",
"type",
"serializer",
"snapshot",
"<",
"?",
">",
">",
"non",
"registered",
"subclass",
"serializer",
"snapshots",
")",
"{",
"@",
"suppress",
"warnings",
"(",
"\"",
"unchecked",
"\"",
")",
"final",
"type",
"serializer",
"<",
"object",
">",
"[",
"]",
"reconfigured",
"field",
"serializers",
"=",
"construct",
"reconfigured",
"field",
"serializers",
"(",
"field",
"serializer",
"compatibility",
")",
";",
"tuple",
"2",
"<",
"linked",
"hash",
"map",
"<",
"class",
"<",
"?",
">",
",",
"integer",
">",
",",
"type",
"serializer",
"<",
"object",
">",
"[",
"]",
">",
"reconfigured",
"subclass",
"registry",
"=",
"construct",
"reconfigured",
"subclass",
"registry",
"(",
"original",
"new",
"pojo",
"serializer",
"get",
"bundled",
"subclass",
"serializer",
"registry",
"(",
")",
",",
"registered",
"serializer",
"snapshots",
",",
"pre",
"existing",
"registrations",
"compatibility",
")",
";",
"return",
"new",
"pojo",
"serializer",
"<",
">",
"(",
"original",
"new",
"pojo",
"serializer",
"get",
"pojo",
"class",
"(",
")",
",",
"original",
"new",
"pojo",
"serializer",
"get",
"fields",
"(",
")",
",",
"reconfigured",
"field",
"serializers",
",",
"reconfigured",
"subclass",
"registry",
"f",
"0",
",",
"reconfigured",
"subclass",
"registry",
"f",
"1",
",",
"restore",
"serializers",
"(",
"non",
"registered",
"subclass",
"serializer",
"snapshots",
"unwrap",
"optionals",
"(",
")",
")",
",",
"original",
"new",
"pojo",
"serializer",
"get",
"execution",
"config",
"(",
")",
")",
";",
"}"
]
|
[
"to",
"test",
"class",
"name",
"in",
"snake",
"case",
"to",
"test",
"class",
"name",
"in",
"snake",
"case"
]
| [
"public",
"client",
"test",
"classname",
"(",
"@",
"valid",
"client",
"body",
")",
";"
]
|
[
"add",
"a",
"listener",
"that",
"is",
"called",
"each",
"time",
"an",
"entry",
"is",
"evicted",
"from",
"the",
"cache",
"or",
"an",
"explicit",
"flush",
"is",
"called"
]
| [
"public",
"void",
"add",
"dirty",
"entry",
"flush",
"listener",
"(",
"final",
"string",
"namespace",
",",
"final",
"dirty",
"entry",
"flush",
"listener",
"listener",
")",
"{",
"final",
"named",
"cache",
"cache",
"=",
"get",
"or",
"create",
"cache",
"(",
"namespace",
")",
";",
"cache",
"set",
"listener",
"(",
"listener",
")",
";",
"}"
]
|
[
"returns",
"pet",
"inventories",
"by",
"status",
"returns",
"a",
"map",
"of",
"status",
"codes",
"to",
"quantities"
]
| [
"call",
"<",
"map",
"<",
"string",
",",
"integer",
">",
">",
"get",
"inventory",
"(",
")",
";"
]
|
[
"to",
"test",
"special",
"tags",
"to",
"test",
"special",
"tags",
"and",
"operation",
"id",
"starting",
"with",
"number"
]
| [
"public",
"void",
"call",
"1",
"2",
"3test",
"special",
"tags",
"(",
"client",
"body",
",",
"handler",
"<",
"async",
"result",
"<",
"client",
">",
">",
"result",
"handler",
")",
"{",
"call",
"1",
"2",
"3test",
"special",
"tags",
"(",
"body",
",",
"null",
",",
"result",
"handler",
")",
";",
"}"
]
|
[
"slow",
"dynamic",
"cast",
":",
"casts",
"{",
"@",
"code",
"value",
"}",
"to",
"an",
"instance",
"of",
"{",
"@",
"code",
"clazz",
"}",
"based",
"upon",
"inspection",
"if",
"{",
"@",
"code",
"lhs",
"}",
"is",
"null",
",",
"no",
"cast",
"takes",
"place"
]
| [
"static",
"object",
"dynamic",
"cast",
"(",
"class",
"<",
"?",
">",
"clazz",
",",
"object",
"value",
")",
"{",
"if",
"(",
"value",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"clazz",
"=",
"=",
"value",
"get",
"class",
"(",
")",
")",
"{",
"return",
"value",
";",
"}",
"if",
"(",
"clazz",
"=",
"=",
"integer",
"class",
")",
"{",
"return",
"get",
"number",
"(",
"value",
")",
"int",
"value",
"(",
")",
";",
"}",
"else",
"if",
"(",
"clazz",
"=",
"=",
"long",
"class",
")",
"{",
"return",
"get",
"number",
"(",
"value",
")",
"long",
"value",
"(",
")",
";",
"}",
"else",
"if",
"(",
"clazz",
"=",
"=",
"double",
"class",
")",
"{",
"return",
"get",
"number",
"(",
"value",
")",
"double",
"value",
"(",
")",
";",
"}",
"else",
"if",
"(",
"clazz",
"=",
"=",
"float",
"class",
")",
"{",
"return",
"get",
"number",
"(",
"value",
")",
"float",
"value",
"(",
")",
";",
"}",
"else",
"if",
"(",
"clazz",
"=",
"=",
"short",
"class",
")",
"{",
"return",
"get",
"number",
"(",
"value",
")",
"short",
"value",
"(",
")",
";",
"}",
"else",
"if",
"(",
"clazz",
"=",
"=",
"byte",
"class",
")",
"{",
"return",
"get",
"number",
"(",
"value",
")",
"byte",
"value",
"(",
")",
";",
"}",
"else",
"if",
"(",
"clazz",
"=",
"=",
"character",
"class",
")",
"{",
"return",
"(",
"char",
")",
"get",
"number",
"(",
"value",
")",
"int",
"value",
"(",
")",
";",
"}",
"return",
"clazz",
"cast",
"(",
"value",
")",
";",
"}",
"else",
"{",
"return",
"value",
";",
"}",
"}"
]
|
[
"removes",
"any",
"casts",
"that",
"change",
"nullability",
"but",
"not",
"type",
"for",
"example",
",",
"{",
"@",
"code",
"cast",
"(",
"1",
"=",
"0",
"as",
"boolean",
")",
"}",
"becomes",
"{",
"@",
"code",
"1",
"=",
"0",
"}"
]
| [
"public",
"rex",
"node",
"remove",
"nullability",
"cast",
"(",
"rex",
"node",
"e",
")",
"{",
"return",
"rex",
"util",
"remove",
"nullability",
"cast",
"(",
"rex",
"builder",
"get",
"type",
"factory",
"(",
")",
",",
"e",
")",
";",
"}"
]
|
[
"you",
"can",
"either",
"run",
"the",
"{",
"@",
"link",
"tiled",
"map",
"packer",
"#",
"main",
"(",
"string",
"[",
"]",
")",
"}",
"method",
"or",
"reference",
"this",
"class",
"in",
"your",
"own",
"project",
"and",
"call",
"this",
"method",
"if",
"working",
"with",
"lib",
"g",
"d",
"x",
"sources",
",",
"you",
"can",
"also",
"run",
"this",
"file",
"to",
"create",
"a",
"run",
"configuration",
"then",
"export",
"it",
"as",
"a",
"runnable",
"jar",
"to",
"run",
"from",
"a",
"nightly",
"build",
":",
"<",
"code",
">",
"<",
"br",
">",
"<",
"br",
">",
"linux",
"os",
"x",
"<",
"br",
">",
"java",
"-",
"cp",
"gdx",
"jar",
":",
"gdx",
"-",
"natives",
"jar",
":",
"gdx",
"-",
"backend",
"-",
"lwjgl",
"jar",
":",
"gdx",
"-",
"backend",
"-",
"lwjgl",
"-",
"natives",
"jar",
":",
"gdx",
"-",
"tiled",
"-",
"preprocessor",
"jar",
":",
"extensionsgdx",
"-",
"toolsgdx",
"-",
"tools",
"jar",
"com",
"badlogic",
"gdx",
"tiledmappacker",
"tiled",
"map",
"packer",
"input",
"dir",
"[",
"output",
"dir",
"]",
"[",
"-",
"-",
"strip",
"-",
"unused",
"]",
"[",
"-",
"-",
"combine",
"-",
"tilesets",
"]",
"[",
"-",
"v",
"]",
"<",
"br",
">",
"<",
"br",
">",
"windows",
"<",
"br",
">",
"java",
"-",
"cp",
"gdx",
"jar",
";",
"gdx",
"-",
"natives",
"jar",
";",
"gdx",
"-",
"backend",
"-",
"lwjgl",
"jar",
";",
"gdx",
"-",
"backend",
"-",
"lwjgl",
"-",
"natives",
"jar",
";",
"gdx",
"-",
"tiled",
"-",
"preprocessor",
"jar",
";",
"extensionsgdx",
"-",
"toolsgdx",
"-",
"tools",
"jar",
"com",
"badlogic",
"gdx",
"tiledmappacker",
"tiled",
"map",
"packer",
"input",
"dir",
"[",
"output",
"dir",
"]",
"[",
"-",
"-",
"strip",
"-",
"unused",
"]",
"[",
"-",
"-",
"combine",
"-",
"tilesets",
"]",
"[",
"-",
"v",
"]",
"<",
"br",
">",
"<",
"br",
">",
"<",
"code",
">",
"keep",
"in",
"mind",
"that",
"this",
"preprocessor",
"will",
"need",
"to",
"load",
"the",
"maps",
"by",
"using",
"the",
"{",
"@",
"link",
"tmx",
"map",
"loader",
"}",
"loader",
"and",
"this",
"in",
"turn",
"will",
"need",
"a",
"valid",
"open",
"g",
"l",
"context",
"to",
"work",
"process",
"a",
"directory",
"containing",
"tmx",
"map",
"files",
"representing",
"tiled",
"maps",
"and",
"produce",
"multiple",
",",
"or",
"a",
"single",
",",
"texture",
"atlas",
"as",
"well",
"as",
"new",
"processed",
"tmx",
"map",
"files",
",",
"correctly",
"referencing",
"the",
"generated",
"{",
"@",
"link",
"texture",
"atlas",
"}",
"by",
"using",
"the",
"\"",
"atlas",
"\"",
"custom",
"map",
"property"
]
| [
"public",
"void",
"process",
"input",
"dir",
"(",
"settings",
"texture",
"packer",
"settings",
")",
"throws",
"i",
"o",
"exception",
"{",
"file",
"handle",
"input",
"dir",
"handle",
"=",
"new",
"file",
"handle",
"(",
"input",
"dir",
"get",
"canonical",
"path",
"(",
")",
")",
";",
"file",
"[",
"]",
"map",
"files",
"in",
"current",
"dir",
"=",
"input",
"dir",
"list",
"files",
"(",
"new",
"tmx",
"filter",
"(",
")",
")",
";",
"tilesets",
"to",
"pack",
"=",
"new",
"object",
"map",
"<",
"string",
",",
"tiled",
"map",
"tile",
"set",
">",
"(",
")",
";",
"/",
"/",
"processes",
"the",
"maps",
"inside",
"input",
"dir",
"for",
"(",
"file",
"map",
"file",
":",
"map",
"files",
"in",
"current",
"dir",
")",
"{",
"process",
"single",
"map",
"(",
"map",
"file",
",",
"input",
"dir",
"handle",
",",
"texture",
"packer",
"settings",
")",
";",
"}",
"process",
"subdirectories",
"(",
"input",
"dir",
"handle",
",",
"texture",
"packer",
"settings",
")",
";",
"boolean",
"combine",
"tilesets",
"=",
"this",
"settings",
"combine",
"tilesets",
";",
"if",
"(",
"combine",
"tilesets",
"=",
"=",
"true",
")",
"{",
"pack",
"tilesets",
"(",
"input",
"dir",
"handle",
",",
"texture",
"packer",
"settings",
")",
";",
"}",
"}"
]
|
[
"returns",
"true",
"if",
"at",
"least",
"one",
"{",
"@",
"link",
"operator",
"subtask",
"state",
"}",
"in",
"subtask",
"states",
"by",
"operator",
"i",
"d",
"has",
"state"
]
| [
"public",
"boolean",
"has",
"state",
"(",
")",
"{",
"for",
"(",
"operator",
"subtask",
"state",
"operator",
"subtask",
"state",
":",
"subtask",
"states",
"by",
"operator",
"i",
"d",
"values",
"(",
")",
")",
"{",
"if",
"(",
"operator",
"subtask",
"state",
"!",
"=",
"null",
"&",
"&",
"operator",
"subtask",
"state",
"has",
"state",
"(",
")",
")",
"{",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}"
]
|
[
"get",
"the",
"http",
"status",
"code"
]
| [
"public",
"int",
"get",
"code",
"(",
")",
"{",
"return",
"code",
";",
"}"
]
|
[
"sets",
"view",
"tag",
"on",
"this",
"host"
]
| [
"public",
"void",
"set",
"view",
"tag",
"(",
"object",
"view",
"tag",
")",
"{",
"m",
"view",
"tag",
"=",
"view",
"tag",
";",
"}"
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.