docstring_tokens
list | code_tokens
list |
|---|---|
[
"delegate",
"to",
"the",
"appropriate",
"method",
"of",
"the",
"underlying",
"logger",
"use",
"this",
"method",
"sparingly",
"if",
"you",
"'",
"re",
"limiting",
"error",
"messages",
",",
"ask",
"yourself",
"whether",
"your",
"log",
"fits",
"better",
"as",
"a",
"warning"
] | [
"public",
"void",
"error",
"(",
"string",
"msg",
")",
"{",
"if",
"(",
"!",
"is",
"error",
"enabled",
"(",
")",
"|",
"|",
"!",
"is",
"error",
"enabled",
"(",
"marker",
")",
")",
"return",
";",
"if",
"(",
"should",
"log",
"(",
"msg",
")",
")",
"super",
"error",
"(",
"marker",
",",
"msg",
")",
";",
"}"
] |
[
"kill",
"the",
"process",
"when",
"the",
"channel",
"is",
"severed"
] | [
"public",
"synchronized",
"void",
"terminate",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"super",
"terminate",
"(",
"e",
")",
";",
"proc",
"destroy",
"(",
")",
";",
"/",
"/",
"the",
"stderr",
"copier",
"should",
"exit",
"by",
"itself",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] | [
"public",
"prepared",
"statement",
"prepare",
"statement",
"(",
"string",
"sql",
",",
"int",
"result",
"set",
"type",
",",
"int",
"concurrency",
")",
"throws",
"s",
"q",
"l",
"exception",
"{",
"return",
"proxy",
"factory",
"get",
"proxy",
"prepared",
"statement",
"(",
"this",
",",
"track",
"statement",
"(",
"delegate",
"prepare",
"statement",
"(",
"sql",
",",
"result",
"set",
"type",
",",
"concurrency",
")",
")",
")",
";",
"}"
] |
[
"parses",
"the",
"request",
"for",
"a",
"cross",
"domain",
"rpc"
] | [
"public",
"cross",
"domain",
"rpc",
"load",
"rpc",
"(",
"http",
"servlet",
"request",
"request",
")",
"throws",
"i",
"o",
"exception",
"{",
"charset",
"encoding",
";",
"try",
"{",
"string",
"enc",
"=",
"request",
"get",
"character",
"encoding",
"(",
")",
";",
"encoding",
"=",
"charset",
"for",
"name",
"(",
"enc",
")",
";",
"}",
"catch",
"(",
"illegal",
"argument",
"exception",
"|",
"null",
"pointer",
"exception",
"e",
")",
"{",
"encoding",
"=",
"utf",
"8",
";",
"}",
"/",
"/",
"we",
"tend",
"to",
"look",
"at",
"the",
"input",
"stream",
",",
"rather",
"than",
"the",
"reader",
"try",
"(",
"input",
"stream",
"in",
"=",
"request",
"get",
"input",
"stream",
"(",
")",
";",
"reader",
"reader",
"=",
"new",
"input",
"stream",
"reader",
"(",
"in",
",",
"encoding",
")",
";",
"json",
"input",
"json",
"input",
"=",
"json",
"new",
"input",
"(",
"reader",
")",
")",
"{",
"map",
"<",
"string",
",",
"object",
">",
"read",
"=",
"json",
"input",
"read",
"(",
"map",
"type",
")",
";",
"return",
"new",
"cross",
"domain",
"rpc",
"(",
"get",
"field",
"(",
"read",
",",
"field",
"method",
")",
",",
"get",
"field",
"(",
"read",
",",
"field",
"path",
")",
",",
"get",
"field",
"(",
"read",
",",
"field",
"data",
")",
")",
";",
"}",
"catch",
"(",
"json",
"exception",
"e",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"failed",
"to",
"parse",
"json",
"request",
":",
"\"",
"+",
"e",
"get",
"message",
"(",
")",
",",
"e",
")",
";",
"}",
"}"
] |
[
"gets",
"the",
"current",
"placeholder",
"text",
"for",
"the",
"text",
"box"
] | [
"public",
"string",
"get",
"placeholder",
"(",
")",
"{",
"return",
"placeholder",
";",
"}"
] |
[
"set",
"the",
"jsr",
"-",
"303",
"validator",
"factory",
"to",
"delegate",
"to",
"for",
"validating",
"beans",
",",
"using",
"its",
"default",
"validator",
"default",
"is",
"the",
"default",
"validator",
"factory",
"'",
"s",
"default",
"validator"
] | [
"public",
"void",
"set",
"validator",
"factory",
"(",
"validator",
"factory",
"validator",
"factory",
")",
"{",
"this",
"validator",
"=",
"validator",
"factory",
"get",
"validator",
"(",
")",
";",
"}"
] |
[
"this",
"method",
"has",
"to",
"be",
"called",
"in",
"the",
"{",
"@",
"link",
"fragment",
"#",
"on",
"create",
"view",
"(",
"android",
"view",
"layout",
"inflater",
",",
"android",
"view",
"view",
"group",
",",
"android",
"os",
"bundle",
")",
"}",
"method",
"it",
"sets",
"up",
"all",
"the",
"things",
"necessary",
"to",
"get",
"input",
",",
"render",
"via",
"open",
"g",
"l",
"and",
"so",
"on",
"uses",
"a",
"default",
"{",
"@",
"link",
"android",
"application",
"configuration",
"}",
"<",
"p",
">",
"note",
":",
"you",
"have",
"to",
"return",
"the",
"returned",
"view",
"from",
"the",
"{",
"@",
"link",
"fragment",
"#",
"on",
"create",
"view",
"(",
"android",
"view",
"layout",
"inflater",
",",
"android",
"view",
"view",
"group",
",",
"android",
"os",
"bundle",
")",
"}",
"!"
] | [
"public",
"view",
"initialize",
"for",
"view",
"(",
"application",
"listener",
"listener",
")",
"{",
"android",
"application",
"configuration",
"config",
"=",
"new",
"android",
"application",
"configuration",
"(",
")",
";",
"return",
"initialize",
"for",
"view",
"(",
"listener",
",",
"config",
")",
";",
"}"
] |
[
"the",
"children",
"of",
"this",
"element",
"<",
"code",
">",
"repeated",
"aapt",
"pb",
"xml",
"node",
"child",
"=",
"5",
";",
"<",
"code",
">"
] | [
"public",
"int",
"get",
"child",
"count",
"(",
")",
"{",
"return",
"child",
"size",
"(",
")",
";",
"}"
] |
[
"checks",
"the",
"specified",
"clusters",
"for",
"license",
"compatibility",
"the",
"specified",
"callback",
"will",
"be",
"invoked",
"once",
"if",
"all",
"clusters",
"are",
"license",
"-",
"compatible",
",",
"otherwise",
"the",
"specified",
"callback",
"will",
"be",
"invoked",
"once",
"on",
"the",
"first",
"cluster",
"that",
"is",
"not",
"license",
"-",
"compatible"
] | [
"public",
"void",
"check",
"remote",
"cluster",
"licenses",
"(",
"final",
"list",
"<",
"string",
">",
"cluster",
"aliases",
",",
"final",
"action",
"listener",
"<",
"license",
"check",
">",
"listener",
")",
"{",
"final",
"iterator",
"<",
"string",
">",
"cluster",
"aliases",
"iterator",
"=",
"cluster",
"aliases",
"iterator",
"(",
")",
";",
"if",
"(",
"cluster",
"aliases",
"iterator",
"has",
"next",
"(",
")",
"=",
"=",
"false",
")",
"{",
"listener",
"on",
"response",
"(",
"license",
"check",
"success",
"(",
")",
")",
";",
"return",
";",
"}",
"final",
"atomic",
"reference",
"<",
"string",
">",
"cluster",
"alias",
"=",
"new",
"atomic",
"reference",
"<",
">",
"(",
")",
";",
"final",
"action",
"listener",
"<",
"x",
"pack",
"info",
"response",
">",
"info",
"listener",
"=",
"new",
"action",
"listener",
"<",
"x",
"pack",
"info",
"response",
">",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"on",
"response",
"(",
"final",
"x",
"pack",
"info",
"response",
"x",
"pack",
"info",
"response",
")",
"{",
"final",
"x",
"pack",
"info",
"response",
"license",
"info",
"license",
"info",
"=",
"x",
"pack",
"info",
"response",
"get",
"license",
"info",
"(",
")",
";",
"if",
"(",
"license",
"info",
"=",
"=",
"null",
")",
"{",
"listener",
"on",
"failure",
"(",
"new",
"resource",
"not",
"found",
"exception",
"(",
"\"",
"license",
"info",
"is",
"missing",
"for",
"cluster",
"[",
"\"",
"+",
"cluster",
"alias",
"get",
"(",
")",
"+",
"\"",
"]",
"\"",
")",
")",
";",
"return",
";",
"}",
"if",
"(",
"(",
"license",
"info",
"get",
"status",
"(",
")",
"=",
"=",
"license",
"status",
"active",
")",
"=",
"=",
"false",
"|",
"|",
"predicate",
"test",
"(",
"license",
"operation",
"mode",
"parse",
"(",
"license",
"info",
"get",
"mode",
"(",
")",
")",
")",
"=",
"=",
"false",
")",
"{",
"listener",
"on",
"response",
"(",
"license",
"check",
"failure",
"(",
"new",
"remote",
"cluster",
"license",
"info",
"(",
"cluster",
"alias",
"get",
"(",
")",
",",
"license",
"info",
")",
")",
")",
";",
"return",
";",
"}",
"if",
"(",
"cluster",
"aliases",
"iterator",
"has",
"next",
"(",
")",
")",
"{",
"cluster",
"alias",
"set",
"(",
"cluster",
"aliases",
"iterator",
"next",
"(",
")",
")",
";",
"/",
"/",
"recurse",
"to",
"the",
"next",
"cluster",
"remote",
"cluster",
"license",
"(",
"cluster",
"alias",
"get",
"(",
")",
",",
"this",
")",
";",
"}",
"else",
"{",
"listener",
"on",
"response",
"(",
"license",
"check",
"success",
"(",
")",
")",
";",
"}",
"}",
"@",
"override",
"public",
"void",
"on",
"failure",
"(",
"final",
"exception",
"e",
")",
"{",
"final",
"string",
"message",
"=",
"\"",
"could",
"not",
"determine",
"the",
"license",
"type",
"for",
"cluster",
"[",
"\"",
"+",
"cluster",
"alias",
"get",
"(",
")",
"+",
"\"",
"]",
"\"",
";",
"listener",
"on",
"failure",
"(",
"new",
"elasticsearch",
"exception",
"(",
"message",
",",
"e",
")",
")",
";",
"}",
"}",
";",
"/",
"/",
"check",
"the",
"license",
"on",
"the",
"first",
"cluster",
",",
"and",
"then",
"we",
"recursively",
"check",
"licenses",
"on",
"the",
"remaining",
"clusters",
"cluster",
"alias",
"set",
"(",
"cluster",
"aliases",
"iterator",
"next",
"(",
")",
")",
";",
"remote",
"cluster",
"license",
"(",
"cluster",
"alias",
"get",
"(",
")",
",",
"info",
"listener",
")",
";",
"}"
] |
[
"set",
"the",
"body",
"of",
"the",
"response",
"entity",
"and",
"returns",
"it"
] | [
"<",
"t",
">",
"response",
"entity",
"<",
"t",
">",
"body",
"(",
"@",
"nullable",
"t",
"body",
")",
";"
] |
[
"utility",
"method",
"to",
"generate",
"a",
"password",
"reset",
"url"
] | [
"public",
"string",
"build",
"password",
"reset",
"url",
"(",
"final",
"string",
"username",
",",
"final",
"password",
"management",
"service",
"password",
"management",
"service",
",",
"final",
"cas",
"configuration",
"properties",
"cas",
"properties",
",",
"final",
"web",
"application",
"service",
"service",
")",
"{",
"val",
"token",
"=",
"password",
"management",
"service",
"create",
"token",
"(",
"username",
")",
";",
"if",
"(",
"string",
"utils",
"is",
"not",
"blank",
"(",
"username",
")",
"&",
"&",
"string",
"utils",
"is",
"not",
"blank",
"(",
"token",
")",
")",
"{",
"val",
"transient",
"factory",
"=",
"(",
"transient",
"session",
"ticket",
"factory",
")",
"this",
"ticket",
"factory",
"get",
"(",
"transient",
"session",
"ticket",
"class",
")",
";",
"val",
"pm",
"=",
"cas",
"properties",
"get",
"authn",
"(",
")",
"get",
"pm",
"(",
")",
";",
"val",
"expiration",
"seconds",
"=",
"time",
"unit",
"minutes",
"to",
"seconds",
"(",
"pm",
"get",
"reset",
"(",
")",
"get",
"expiration",
"minutes",
"(",
")",
")",
";",
"val",
"properties",
"=",
"collection",
"utils",
"<",
"string",
",",
"serializable",
">",
"wrap",
"(",
"password",
"management",
"webflow",
"utils",
"flowscope",
"parameter",
"name",
"token",
",",
"token",
",",
"expiration",
"policy",
"class",
"get",
"name",
"(",
")",
",",
"hard",
"timeout",
"expiration",
"policy",
"builder",
"(",
")",
"time",
"to",
"kill",
"in",
"seconds",
"(",
"expiration",
"seconds",
")",
"build",
"(",
")",
")",
";",
"val",
"ticket",
"=",
"transient",
"factory",
"create",
"(",
"service",
",",
"properties",
")",
";",
"this",
"ticket",
"registry",
"add",
"ticket",
"(",
"ticket",
")",
";",
"val",
"reset",
"url",
"=",
"new",
"string",
"builder",
"(",
"cas",
"properties",
"get",
"server",
"(",
")",
"get",
"prefix",
"(",
")",
")",
"append",
"(",
"'",
"/",
"'",
")",
"append",
"(",
"cas",
"webflow",
"configurer",
"flow",
"id",
"login",
")",
"append",
"(",
"'",
"?",
"'",
")",
"append",
"(",
"password",
"management",
"webflow",
"utils",
"request",
"parameter",
"name",
"password",
"reset",
"token",
")",
"append",
"(",
"'",
"=",
"'",
")",
"append",
"(",
"ticket",
"get",
"id",
"(",
")",
")",
";",
"if",
"(",
"service",
"!",
"=",
"null",
")",
"{",
"val",
"encode",
"service",
"url",
"=",
"uri",
"utils",
"encode",
"(",
"service",
"get",
"original",
"url",
"(",
")",
",",
"standard",
"charsets",
"utf",
"8",
")",
";",
"reset",
"url",
"append",
"(",
"'",
"&",
"'",
")",
"append",
"(",
"cas",
"protocol",
"constants",
"parameter",
"service",
")",
"append",
"(",
"'",
"=",
"'",
")",
"append",
"(",
"encode",
"service",
"url",
")",
";",
"}",
"val",
"url",
"=",
"reset",
"url",
"to",
"string",
"(",
")",
";",
"logger",
"debug",
"(",
"\"",
"final",
"password",
"reset",
"url",
"designed",
"for",
"[",
"{",
"}",
"]",
"is",
"[",
"{",
"}",
"]",
"\"",
",",
"username",
",",
"url",
")",
";",
"return",
"url",
";",
"}",
"logger",
"error",
"(",
"\"",
"could",
"not",
"create",
"password",
"reset",
"url",
"since",
"no",
"reset",
"token",
"could",
"be",
"generated",
"\"",
")",
";",
"return",
"null",
";",
"}"
] |
[
"the",
"value",
"of",
"the",
"num",
"element",
"value",
"pairs",
"item",
"gives",
"the",
"number",
"of",
"element",
"-",
"value",
"pairs",
"of",
"the",
"annotation",
"represented",
"by",
"this",
"annotation",
"structure",
"note",
"that",
"a",
"maximum",
"of",
"65535",
"element",
"-",
"value",
"pairs",
"may",
"be",
"contained",
"in",
"a",
"single",
"annotation"
] | [
"public",
"int",
"get",
"number",
"of",
"element",
"value",
"pairs",
"(",
")",
"{",
"return",
"number",
"of",
"element",
"value",
"pairs",
"&",
"0xffff",
";",
"}"
] |
[
"locates",
"the",
"firefox",
"binary",
"by",
"platform"
] | [
"private",
"static",
"stream",
"<",
"executable",
">",
"locate",
"firefox",
"binaries",
"from",
"platform",
"(",
")",
"{",
"list",
"<",
"executable",
">",
"executables",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"platform",
"current",
"=",
"platform",
"get",
"current",
"(",
")",
";",
"if",
"(",
"current",
"is",
"(",
"windows",
")",
")",
"{",
"executables",
"add",
"all",
"(",
"stream",
"of",
"(",
"\"",
"mozilla",
"firefox",
"\\",
"\\",
"firefox",
"exe",
"\"",
",",
"\"",
"firefox",
"developer",
"edition",
"\\",
"\\",
"firefox",
"exe",
"\"",
",",
"\"",
"nightly",
"\\",
"\\",
"firefox",
"exe",
"\"",
")",
"map",
"(",
"firefox",
"binary",
":",
":",
"get",
"paths",
"in",
"program",
"files",
")",
"flat",
"map",
"(",
"list",
":",
":",
"stream",
")",
"map",
"(",
"file",
":",
":",
"new",
")",
"filter",
"(",
"file",
":",
":",
"exists",
")",
"map",
"(",
"executable",
":",
":",
"new",
")",
"collect",
"(",
"to",
"list",
"(",
")",
")",
")",
";",
"}",
"else",
"if",
"(",
"current",
"is",
"(",
"mac",
")",
")",
"{",
"/",
"/",
"system",
"file",
"binary",
"=",
"new",
"file",
"(",
"\"",
"/",
"applications",
"/",
"firefox",
"app",
"/",
"contents",
"/",
"mac",
"o",
"s",
"/",
"firefox",
"-",
"bin",
"\"",
")",
";",
"if",
"(",
"binary",
"exists",
"(",
")",
")",
"{",
"executables",
"add",
"(",
"new",
"executable",
"(",
"binary",
")",
")",
";",
"}",
"/",
"/",
"user",
"home",
"binary",
"=",
"new",
"file",
"(",
"system",
"get",
"property",
"(",
"\"",
"user",
"home",
"\"",
")",
"+",
"binary",
"get",
"absolute",
"path",
"(",
")",
")",
";",
"if",
"(",
"binary",
"exists",
"(",
")",
")",
"{",
"executables",
"add",
"(",
"new",
"executable",
"(",
"binary",
")",
")",
";",
"}",
"}",
"else",
"if",
"(",
"current",
"is",
"(",
"unix",
")",
")",
"{",
"string",
"system",
"firefox",
"bin",
"=",
"new",
"executable",
"finder",
"(",
")",
"find",
"(",
"\"",
"firefox",
"-",
"bin",
"\"",
")",
";",
"if",
"(",
"system",
"firefox",
"bin",
"!",
"=",
"null",
")",
"{",
"executables",
"add",
"(",
"new",
"executable",
"(",
"new",
"file",
"(",
"system",
"firefox",
"bin",
")",
")",
")",
";",
"}",
"}",
"string",
"system",
"firefox",
"=",
"new",
"executable",
"finder",
"(",
")",
"find",
"(",
"\"",
"firefox",
"\"",
")",
";",
"if",
"(",
"system",
"firefox",
"!",
"=",
"null",
")",
"{",
"path",
"firefox",
"path",
"=",
"new",
"file",
"(",
"system",
"firefox",
")",
"to",
"path",
"(",
")",
";",
"if",
"(",
"files",
"is",
"symbolic",
"link",
"(",
"firefox",
"path",
")",
")",
"{",
"try",
"{",
"path",
"real",
"path",
"=",
"firefox",
"path",
"to",
"real",
"path",
"(",
")",
";",
"file",
"attempt",
"1",
"=",
"real",
"path",
"get",
"parent",
"(",
")",
"resolve",
"(",
"\"",
"firefox",
"\"",
")",
"to",
"file",
"(",
")",
";",
"if",
"(",
"attempt",
"1",
"exists",
"(",
")",
")",
"{",
"executables",
"add",
"(",
"new",
"executable",
"(",
"attempt",
"1",
")",
")",
";",
"}",
"else",
"{",
"file",
"attempt",
"2",
"=",
"real",
"path",
"get",
"parent",
"(",
")",
"resolve",
"(",
"\"",
"firefox",
"-",
"bin",
"\"",
")",
"to",
"file",
"(",
")",
";",
"if",
"(",
"attempt",
"2",
"exists",
"(",
")",
")",
"{",
"executables",
"add",
"(",
"new",
"executable",
"(",
"attempt",
"2",
")",
")",
";",
"}",
"}",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"/",
"/",
"ignore",
"this",
"path",
"}",
"}",
"else",
"{",
"executables",
"add",
"(",
"new",
"executable",
"(",
"new",
"file",
"(",
"system",
"firefox",
")",
")",
")",
";",
"}",
"}",
"return",
"executables",
"stream",
"(",
")",
";",
"}"
] |
[
"process",
"the",
"current",
"meta",
"-",
"data",
"with",
"the",
"provided",
"configuration",
"options"
] | [
"public",
"void",
"process",
"meta",
"data",
"(",
"data",
"source",
"data",
"source",
",",
"list",
"<",
"string",
">",
"declared",
"columns",
",",
"string",
"[",
"]",
"generated",
"key",
"names",
")",
"{",
"this",
"meta",
"data",
"provider",
"=",
"table",
"meta",
"data",
"provider",
"factory",
"create",
"meta",
"data",
"provider",
"(",
"data",
"source",
",",
"this",
")",
";",
"this",
"table",
"columns",
"=",
"reconcile",
"columns",
"to",
"use",
"(",
"declared",
"columns",
",",
"generated",
"key",
"names",
")",
";",
"}"
] |
[
"whether",
"the",
"condition",
"has",
"any",
"media",
"type",
"expressions"
] | [
"public",
"boolean",
"is",
"empty",
"(",
")",
"{",
"return",
"this",
"expressions",
"is",
"empty",
"(",
")",
";",
"}"
] |
[
"reduce",
"consumes",
"and",
"produces",
"t",
"so",
"can",
"'",
"t",
"do",
"covariance",
"https",
":",
"github",
"com",
"reactive",
"x",
"rx",
"javaissues",
"3",
"6",
"0",
"#",
"issuecomment",
"-",
"24203016"
] | [
"public",
"void",
"reduce",
"with",
"covariant",
"objects",
"(",
")",
"{",
"flowable",
"<",
"movie",
">",
"horror",
"movies",
"=",
"flowable",
"<",
"movie",
">",
"just",
"(",
"new",
"horror",
"movie",
"(",
")",
")",
";",
"maybe",
"<",
"movie",
">",
"reduce",
"result",
"2",
"=",
"horror",
"movies",
"reduce",
"(",
"new",
"bi",
"function",
"<",
"movie",
",",
"movie",
",",
"movie",
">",
"(",
")",
"{",
"@",
"override",
"public",
"movie",
"apply",
"(",
"movie",
"t",
"1",
",",
"movie",
"t",
"2",
")",
"{",
"return",
"t",
"2",
";",
"}",
"}",
")",
";",
"assert",
"not",
"null",
"(",
"reduce",
"result",
"2",
")",
";",
"}"
] |
[
"get",
"prefix",
"string"
] | [
"public",
"string",
"get",
"prefix",
"string",
"(",
")",
"{",
"return",
"prefix",
"string",
";",
"}"
] |
[
"finds",
"pets",
"by",
"tags",
"multiple",
"tags",
"can",
"be",
"provided",
"with",
"comma",
"separated",
"strings",
"use",
"tag",
"1",
",",
"tag",
"2",
",",
"tag",
"3",
"for",
"testing"
] | [
"public",
"void",
"find",
"pets",
"by",
"tags",
"test",
"(",
")",
"{",
"list",
"<",
"string",
">",
"tags",
"=",
"null",
";",
"/",
"/",
"list",
"<",
"pet",
">",
"response",
"=",
"api",
"find",
"pets",
"by",
"tags",
"(",
"tags",
")",
";",
"/",
"/",
"assert",
"not",
"null",
"(",
"response",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
] |
[
"a",
"sensible",
"definition",
"of",
"{",
"@",
"link",
"#",
"first",
"entry",
"(",
")",
"}",
"in",
"terms",
"of",
"{",
"@",
"code",
"entry",
"set",
"(",
")",
"iterator",
"(",
")",
"}",
"if",
"you",
"override",
"{",
"@",
"link",
"#",
"entry",
"set",
"(",
")",
"}",
",",
"you",
"may",
"wish",
"to",
"override",
"{",
"@",
"link",
"#",
"first",
"entry",
"(",
")",
"}",
"to",
"forward",
"to",
"this",
"implementation"
] | [
"protected",
"entry",
"<",
"e",
">",
"standard",
"first",
"entry",
"(",
")",
"{",
"iterator",
"<",
"entry",
"<",
"e",
">",
">",
"entry",
"iterator",
"=",
"entry",
"set",
"(",
")",
"iterator",
"(",
")",
";",
"if",
"(",
"!",
"entry",
"iterator",
"has",
"next",
"(",
")",
")",
"{",
"return",
"null",
";",
"}",
"entry",
"<",
"e",
">",
"entry",
"=",
"entry",
"iterator",
"next",
"(",
")",
";",
"return",
"multisets",
"immutable",
"entry",
"(",
"entry",
"get",
"element",
"(",
")",
",",
"entry",
"get",
"count",
"(",
")",
")",
";",
"}"
] |
[
"return",
"the",
"number",
"of",
"bytes",
"stored",
"in",
"this",
"<",
"code",
">",
"fast",
"byte",
"array",
"output",
"stream",
"<",
"code",
">"
] | [
"public",
"int",
"size",
"(",
")",
"{",
"return",
"(",
"this",
"already",
"buffered",
"size",
"+",
"this",
"index",
")",
";",
"}"
] |
[
"returns",
"the",
"type",
"record",
"number"
] | [
"public",
"record",
"number",
"get",
"type",
"record",
"number",
"(",
")",
"{",
"return",
"type",
"record",
"number",
";",
"}"
] |
[
"sets",
"how",
"many",
"search",
"requests",
"specified",
"in",
"this",
"multi",
"search",
"requests",
"are",
"allowed",
"to",
"be",
"ran",
"concurrently"
] | [
"public",
"multi",
"search",
"request",
"builder",
"set",
"max",
"concurrent",
"search",
"requests",
"(",
"int",
"max",
"concurrent",
"search",
"requests",
")",
"{",
"request",
"(",
")",
"max",
"concurrent",
"search",
"requests",
"(",
"max",
"concurrent",
"search",
"requests",
")",
";",
"return",
"this",
";",
"}"
] |
[
"we",
"need",
"to",
"detect",
"this",
"as",
"\"",
"code",
"-",
"style",
"\"",
"aspect",
"j",
"aspects",
"should",
"not",
"be",
"interpreted",
"by",
"spring",
"aop"
] | [
"private",
"boolean",
"compiled",
"by",
"ajc",
"(",
"class",
"<",
"?",
">",
"clazz",
")",
"{",
"/",
"/",
"the",
"a",
"j",
"type",
"system",
"goes",
"to",
"great",
"lengths",
"to",
"provide",
"a",
"uniform",
"appearance",
"between",
"code",
"-",
"style",
"and",
"/",
"/",
"annotation",
"-",
"style",
"aspects",
"therefore",
"there",
"is",
"no",
"'",
"clean",
"'",
"way",
"to",
"tell",
"them",
"apart",
"here",
"we",
"rely",
"on",
"/",
"/",
"an",
"implementation",
"detail",
"of",
"the",
"aspect",
"j",
"compiler",
"for",
"(",
"field",
"field",
":",
"clazz",
"get",
"declared",
"fields",
"(",
")",
")",
"{",
"if",
"(",
"field",
"get",
"name",
"(",
")",
"starts",
"with",
"(",
"ajc",
"magic",
")",
")",
"{",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}"
] |
[
"order",
"by",
"job",
"id",
"(",
"needs",
"to",
"be",
"followed",
"by",
"{",
"@",
"link",
"#",
"asc",
"(",
")",
"}",
"or",
"{",
"@",
"link",
"#",
"desc",
"(",
")",
"}",
")"
] | [
"suspended",
"job",
"query",
"order",
"by",
"job",
"id",
"(",
")",
";"
] |
[
"returns",
"the",
"binary",
"operator",
"'",
"s",
"return",
"type",
"this",
"method",
"can",
"extract",
"a",
"type",
"in",
"4",
"different",
"ways",
":",
"1",
"by",
"using",
"the",
"generics",
"of",
"the",
"base",
"class",
"like",
"my",
"function",
"<",
"x",
",",
"y",
",",
"z",
",",
"in",
",",
"out",
">",
"this",
"is",
"what",
"output",
"type",
"argument",
"index",
"(",
"in",
"this",
"example",
"\"",
"4",
"\"",
")",
"is",
"good",
"for",
"2",
"by",
"using",
"input",
"type",
"inference",
"sub",
"my",
"function",
"<",
"t",
",",
"string",
",",
"string",
",",
"string",
",",
"t",
">",
"this",
"is",
"what",
"input",
"type",
"argument",
"index",
"(",
"in",
"this",
"example",
"\"",
"0",
"\"",
")",
"and",
"in",
"type",
"is",
"good",
"for",
"3",
"by",
"using",
"the",
"static",
"method",
"that",
"a",
"compiler",
"generates",
"for",
"java",
"lambdas",
"this",
"is",
"what",
"lambda",
"output",
"type",
"argument",
"indices",
"is",
"good",
"for",
"given",
"that",
"my",
"function",
"has",
"the",
"following",
"single",
"abstract",
"method",
":",
"<",
"code",
">",
"void",
"apply",
"(",
"in",
"value",
",",
"collector",
"<",
"out",
">",
"value",
")",
"<",
"code",
">",
"lambda",
"type",
"indices",
"allow",
"the",
"extraction",
"of",
"a",
"type",
"from",
"lambdas",
"to",
"extract",
"the",
"output",
"type",
"<",
"b",
">",
"out",
"<",
"b",
">",
"from",
"the",
"function",
"one",
"should",
"pass",
"{",
"@",
"code",
"new",
"int",
"[",
"]",
"{",
"1",
",",
"0",
"}",
"}",
"\"",
"1",
"\"",
"for",
"selecting",
"the",
"parameter",
"and",
"0",
"for",
"the",
"first",
"generic",
"in",
"this",
"type",
"use",
"{",
"@",
"code",
"type",
"extractor",
"no",
"index",
"}",
"for",
"selecting",
"the",
"return",
"type",
"of",
"the",
"lambda",
"for",
"extraction",
"or",
"if",
"the",
"class",
"cannot",
"be",
"a",
"lambda",
"because",
"it",
"is",
"not",
"a",
"single",
"abstract",
"method",
"interface",
"4",
"by",
"using",
"interfaces",
"such",
"as",
"{",
"@",
"link",
"type",
"info",
"factory",
"}",
"or",
"{",
"@",
"link",
"result",
"type",
"queryable",
"}",
"see",
"also",
"comments",
"in",
"the",
"header",
"of",
"this",
"class"
] | [
"public",
"static",
"<",
"in1",
",",
"in2",
",",
"out",
">",
"type",
"information",
"<",
"out",
">",
"get",
"binary",
"operator",
"return",
"type",
"(",
"function",
"function",
",",
"class",
"<",
"?",
">",
"base",
"class",
",",
"int",
"input",
"1",
"type",
"argument",
"index",
",",
"int",
"input",
"2",
"type",
"argument",
"index",
",",
"int",
"output",
"type",
"argument",
"index",
",",
"int",
"[",
"]",
"lambda",
"output",
"type",
"argument",
"indices",
",",
"type",
"information",
"<",
"in1",
">",
"in",
"1",
"type",
",",
"type",
"information",
"<",
"in2",
">",
"in",
"2",
"type",
",",
"string",
"function",
"name",
",",
"boolean",
"allow",
"missing",
")",
"{",
"preconditions",
"check",
"argument",
"(",
"in",
"1",
"type",
"=",
"=",
"null",
"|",
"|",
"input",
"1",
"type",
"argument",
"index",
">",
"=",
"0",
",",
"\"",
"input",
"1",
"type",
"argument",
"index",
"was",
"not",
"provided",
"\"",
")",
";",
"preconditions",
"check",
"argument",
"(",
"in",
"2",
"type",
"=",
"=",
"null",
"|",
"|",
"input",
"2",
"type",
"argument",
"index",
">",
"=",
"0",
",",
"\"",
"input",
"2",
"type",
"argument",
"index",
"was",
"not",
"provided",
"\"",
")",
";",
"preconditions",
"check",
"argument",
"(",
"output",
"type",
"argument",
"index",
">",
"=",
"0",
",",
"\"",
"output",
"type",
"argument",
"index",
"was",
"not",
"provided",
"\"",
")",
";",
"preconditions",
"check",
"argument",
"(",
"lambda",
"output",
"type",
"argument",
"indices",
"!",
"=",
"null",
",",
"\"",
"indices",
"for",
"output",
"type",
"arguments",
"within",
"lambda",
"not",
"provided",
"\"",
")",
";",
"/",
"/",
"explicit",
"result",
"type",
"has",
"highest",
"precedence",
"if",
"(",
"function",
"instanceof",
"result",
"type",
"queryable",
")",
"{",
"return",
"(",
"(",
"result",
"type",
"queryable",
"<",
"out",
">",
")",
"function",
")",
"get",
"produced",
"type",
"(",
")",
";",
"}",
"/",
"/",
"perform",
"extraction",
"try",
"{",
"final",
"lambda",
"executable",
"exec",
";",
"try",
"{",
"exec",
"=",
"check",
"and",
"extract",
"lambda",
"(",
"function",
")",
";",
"}",
"catch",
"(",
"type",
"extraction",
"exception",
"e",
")",
"{",
"throw",
"new",
"invalid",
"types",
"exception",
"(",
"\"",
"internal",
"error",
"occurred",
"\"",
",",
"e",
")",
";",
"}",
"if",
"(",
"exec",
"!",
"=",
"null",
")",
"{",
"final",
"method",
"sam",
"=",
"type",
"extraction",
"utils",
"get",
"single",
"abstract",
"method",
"(",
"base",
"class",
")",
";",
"final",
"int",
"base",
"parameters",
"len",
"=",
"sam",
"get",
"parameter",
"types",
"(",
")",
"length",
";",
"/",
"/",
"parameters",
"must",
"be",
"accessed",
"from",
"behind",
",",
"since",
"jvm",
"can",
"add",
"additional",
"parameters",
"/",
"/",
"e",
"g",
"when",
"using",
"local",
"variables",
"inside",
"lambda",
"function",
"final",
"int",
"param",
"len",
"=",
"exec",
"get",
"parameter",
"types",
"(",
")",
"length",
";",
"final",
"type",
"output",
";",
"if",
"(",
"lambda",
"output",
"type",
"argument",
"indices",
"length",
">",
"0",
")",
"{",
"output",
"=",
"type",
"extraction",
"utils",
"extract",
"type",
"from",
"lambda",
"(",
"base",
"class",
",",
"exec",
",",
"lambda",
"output",
"type",
"argument",
"indices",
",",
"param",
"len",
",",
"base",
"parameters",
"len",
")",
";",
"}",
"else",
"{",
"output",
"=",
"exec",
"get",
"return",
"type",
"(",
")",
";",
"type",
"extraction",
"utils",
"validate",
"lambda",
"type",
"(",
"base",
"class",
",",
"output",
")",
";",
"}",
"return",
"new",
"type",
"extractor",
"(",
")",
"private",
"create",
"type",
"info",
"(",
"output",
",",
"in",
"1",
"type",
",",
"in",
"2",
"type",
")",
";",
"}",
"else",
"{",
"if",
"(",
"in",
"1",
"type",
"!",
"=",
"null",
")",
"{",
"validate",
"input",
"type",
"(",
"base",
"class",
",",
"function",
"get",
"class",
"(",
")",
",",
"input",
"1",
"type",
"argument",
"index",
",",
"in",
"1",
"type",
")",
";",
"}",
"if",
"(",
"in",
"2",
"type",
"!",
"=",
"null",
")",
"{",
"validate",
"input",
"type",
"(",
"base",
"class",
",",
"function",
"get",
"class",
"(",
")",
",",
"input",
"2",
"type",
"argument",
"index",
",",
"in",
"2",
"type",
")",
";",
"}",
"return",
"new",
"type",
"extractor",
"(",
")",
"private",
"create",
"type",
"info",
"(",
"base",
"class",
",",
"function",
"get",
"class",
"(",
")",
",",
"output",
"type",
"argument",
"index",
",",
"in",
"1",
"type",
",",
"in",
"2",
"type",
")",
";",
"}",
"}",
"catch",
"(",
"invalid",
"types",
"exception",
"e",
")",
"{",
"if",
"(",
"allow",
"missing",
")",
"{",
"return",
"(",
"type",
"information",
"<",
"out",
">",
")",
"new",
"missing",
"type",
"info",
"(",
"function",
"name",
"!",
"=",
"null",
"?",
"function",
"name",
":",
"function",
"to",
"string",
"(",
")",
",",
"e",
")",
";",
"}",
"else",
"{",
"throw",
"e",
";",
"}",
"}",
"}"
] |
[
"let",
"sub",
"-",
"classes",
"of",
"update",
"site",
"provide",
"their",
"own",
"signature",
"validator"
] | [
"protected",
"j",
"s",
"o",
"n",
"signature",
"validator",
"get",
"json",
"signature",
"validator",
"(",
")",
"{",
"return",
"get",
"json",
"signature",
"validator",
"(",
"null",
")",
";",
"}"
] |
[
"load",
"the",
"state",
"store",
"driver",
"if",
"successful",
",",
"refresh",
"cached",
"data",
"tables"
] | [
"public",
"void",
"load",
"driver",
"(",
")",
"{",
"synchronized",
"(",
"this",
"driver",
")",
"{",
"if",
"(",
"!",
"is",
"driver",
"ready",
"(",
")",
")",
"{",
"string",
"driver",
"name",
"=",
"this",
"driver",
"get",
"class",
"(",
")",
"get",
"simple",
"name",
"(",
")",
";",
"if",
"(",
"this",
"driver",
"init",
"(",
"conf",
",",
"get",
"identifier",
"(",
")",
",",
"get",
"supported",
"records",
"(",
")",
",",
"metrics",
")",
")",
"{",
"log",
"info",
"(",
"\"",
"connection",
"to",
"the",
"state",
"store",
"driver",
"{",
"}",
"is",
"open",
"and",
"ready",
"\"",
",",
"driver",
"name",
")",
";",
"this",
"refresh",
"caches",
"(",
")",
";",
"}",
"else",
"{",
"log",
"error",
"(",
"\"",
"cannot",
"initialize",
"state",
"store",
"driver",
"{",
"}",
"\"",
",",
"driver",
"name",
")",
";",
"}",
"}",
"}",
"}"
] |
[
"returns",
"a",
"collection",
"that",
"applies",
"{",
"@",
"code",
"function",
"}",
"to",
"each",
"element",
"of",
"{",
"@",
"code",
"from",
"collection",
"}",
"the",
"returned",
"collection",
"is",
"a",
"live",
"view",
"of",
"{",
"@",
"code",
"from",
"collection",
"}",
";",
"changes",
"to",
"one",
"affect",
"the",
"other",
"the",
"returned",
"collection",
"'",
"s",
"{",
"@",
"code",
"add",
"(",
")",
"}",
"and",
"{",
"@",
"code",
"add",
"all",
"(",
")",
"}",
"methods",
"throw",
"an",
"{",
"@",
"link",
"unsupported",
"operation",
"exception",
"}",
"all",
"other",
"collection",
"methods",
"are",
"supported",
",",
"as",
"long",
"as",
"{",
"@",
"code",
"from",
"collection",
"}",
"supports",
"them",
"the",
"returned",
"collection",
"isn",
"'",
"t",
"threadsafe",
"or",
"serializable",
",",
"even",
"if",
"{",
"@",
"code",
"from",
"collection",
"}",
"is",
"when",
"a",
"live",
"view",
"is",
"not",
"needed",
",",
"it",
"may",
"be",
"faster",
"to",
"copy",
"the",
"transformed",
"collection",
"and",
"use",
"the",
"copy",
"if",
"the",
"input",
"{",
"@",
"code",
"collection",
"}",
"is",
"known",
"to",
"be",
"a",
"{",
"@",
"code",
"list",
"}",
",",
"consider",
"{",
"@",
"link",
"lists",
"#",
"transform",
"}",
"if",
"only",
"an",
"{",
"@",
"code",
"iterable",
"}",
"is",
"available",
",",
"use",
"{",
"@",
"link",
"iterables",
"#",
"transform",
"}",
"<",
"b",
">",
"{",
"@",
"code",
"stream",
"}",
"equivalent",
":",
"<",
"b",
">",
"{",
"@",
"link",
"java",
"util",
"stream",
"stream",
"#",
"map",
"stream",
"map",
"}"
] | [
"public",
"static",
"<",
"f",
",",
"t",
">",
"collection",
"<",
"t",
">",
"transform",
"(",
"collection",
"<",
"f",
">",
"from",
"collection",
",",
"function",
"<",
"?",
"super",
"f",
",",
"t",
">",
"function",
")",
"{",
"return",
"new",
"transformed",
"collection",
"<",
">",
"(",
"from",
"collection",
",",
"function",
")",
";",
"}"
] |
[
"get",
"has",
"teeth"
] | [
"public",
"boolean",
"get",
"has",
"teeth",
"(",
")",
"{",
"return",
"has",
"teeth",
";",
"}"
] |
[
"convert",
"mega",
"bytes",
"to",
"bytes"
] | [
"private",
"static",
"long",
"convert",
"m",
"bytes",
"to",
"bytes",
"(",
"long",
"mb",
")",
"{",
"return",
"mb",
"*",
"1024l",
"*",
"1024l",
";",
"}"
] |
[
"sets",
"the",
"<",
"code",
">",
"class",
"name",
"<",
"code",
">",
"property"
] | [
"public",
"animal",
"class",
"name",
"(",
"string",
"class",
"name",
")",
"{",
"this",
"class",
"name",
"=",
"class",
"name",
";",
"return",
"this",
";",
"}"
] |
[
"returns",
"a",
"result",
"that",
"indicates",
"there",
"is",
"no",
"possible",
"way",
"for",
"the",
"new",
"serializer",
"to",
"be",
"use",
"-",
"able",
"this",
"normally",
"indicates",
"that",
"there",
"is",
"no",
"common",
"java",
"class",
"between",
"what",
"the",
"previous",
"bytes",
"can",
"be",
"deserialized",
"into",
"and",
"what",
"can",
"be",
"written",
"by",
"the",
"new",
"serializer",
"in",
"this",
"case",
",",
"there",
"is",
"no",
"possible",
"way",
"for",
"the",
"new",
"serializer",
"to",
"continue",
"to",
"be",
"used",
",",
"even",
"with",
"migration",
"recovery",
"of",
"the",
"flink",
"job",
"will",
"fail"
] | [
"public",
"static",
"<",
"t",
">",
"type",
"serializer",
"schema",
"compatibility",
"<",
"t",
">",
"incompatible",
"(",
")",
"{",
"return",
"new",
"type",
"serializer",
"schema",
"compatibility",
"<",
">",
"(",
"type",
"incompatible",
",",
"null",
")",
";",
"}"
] |
[
"returns",
"a",
"hash",
"code",
",",
"having",
"the",
"same",
"bit",
"length",
"as",
"each",
"of",
"the",
"input",
"hash",
"codes",
",",
"that",
"combines",
"the",
"information",
"of",
"these",
"hash",
"codes",
"in",
"an",
"ordered",
"fashion",
"that",
"is",
",",
"whenever",
"two",
"equal",
"hash",
"codes",
"are",
"produced",
"by",
"two",
"calls",
"to",
"this",
"method",
",",
"it",
"is",
"as",
"likely",
"as",
"possible",
"that",
"each",
"was",
"computed",
"from",
"the",
"same",
"input",
"hash",
"codes",
"in",
"the",
"same",
"order"
] | [
"public",
"static",
"hash",
"code",
"combine",
"ordered",
"(",
"iterable",
"<",
"hash",
"code",
">",
"hash",
"codes",
")",
"{",
"iterator",
"<",
"hash",
"code",
">",
"iterator",
"=",
"hash",
"codes",
"iterator",
"(",
")",
";",
"check",
"argument",
"(",
"iterator",
"has",
"next",
"(",
")",
",",
"\"",
"must",
"be",
"at",
"least",
"1",
"hash",
"code",
"to",
"combine",
"\"",
")",
";",
"int",
"bits",
"=",
"iterator",
"next",
"(",
")",
"bits",
"(",
")",
";",
"byte",
"[",
"]",
"result",
"bytes",
"=",
"new",
"byte",
"[",
"bits",
"/",
"8",
"]",
";",
"for",
"(",
"hash",
"code",
"hash",
"code",
":",
"hash",
"codes",
")",
"{",
"byte",
"[",
"]",
"next",
"bytes",
"=",
"hash",
"code",
"as",
"bytes",
"(",
")",
";",
"check",
"argument",
"(",
"next",
"bytes",
"length",
"=",
"=",
"result",
"bytes",
"length",
",",
"\"",
"all",
"hashcodes",
"must",
"have",
"the",
"same",
"bit",
"length",
"\"",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"next",
"bytes",
"length",
";",
"i",
"+",
"+",
")",
"{",
"result",
"bytes",
"[",
"i",
"]",
"=",
"(",
"byte",
")",
"(",
"result",
"bytes",
"[",
"i",
"]",
"*",
"37",
"^",
"next",
"bytes",
"[",
"i",
"]",
")",
";",
"}",
"}",
"return",
"hash",
"code",
"from",
"bytes",
"no",
"copy",
"(",
"result",
"bytes",
")",
";",
"}"
] |
[
"gets",
"the",
"name",
"of",
"the",
"given",
"opcode"
] | [
"public",
"static",
"string",
"get",
"name",
"(",
"int",
"opcode",
")",
"{",
"return",
"get",
"(",
"opcode",
")",
"get",
"name",
"(",
")",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] | [
"public",
"final",
"statement",
"get",
"statement",
"(",
")",
"throws",
"s",
"q",
"l",
"exception",
"{",
"return",
"statement",
";",
"}"
] |
[
"the",
"total",
"time",
"spent",
"executing",
"refreshes",
"(",
"in",
"milliseconds",
")"
] | [
"public",
"long",
"get",
"total",
"time",
"in",
"millis",
"(",
")",
"{",
"return",
"this",
"total",
"time",
"in",
"millis",
";",
"}"
] |
[
"starts",
"the",
"given",
"{",
"@",
"link",
"kafka",
"streams",
"}",
"instances",
"and",
"waits",
"for",
"all",
"of",
"them",
"to",
"reach",
"the",
"{",
"@",
"link",
"state",
"#",
"running",
"}",
"state",
"at",
"the",
"same",
"time",
"note",
"that",
"states",
"may",
"change",
"between",
"the",
"time",
"that",
"this",
"method",
"returns",
"and",
"the",
"calling",
"function",
"executes",
"its",
"next",
"statement",
"if",
"the",
"application",
"is",
"already",
"started",
",",
"use",
"{",
"@",
"link",
"#",
"wait",
"for",
"application",
"state",
"(",
"list",
",",
"state",
",",
"duration",
")",
"}",
"to",
"wait",
"for",
"instances",
"to",
"reach",
"{",
"@",
"link",
"state",
"#",
"running",
"}",
"state"
] | [
"public",
"static",
"void",
"start",
"application",
"and",
"wait",
"until",
"running",
"(",
"final",
"list",
"<",
"kafka",
"streams",
">",
"streams",
"list",
",",
"final",
"duration",
"timeout",
")",
"throws",
"exception",
"{",
"final",
"lock",
"state",
"lock",
"=",
"new",
"reentrant",
"lock",
"(",
")",
";",
"final",
"condition",
"state",
"update",
"=",
"state",
"lock",
"new",
"condition",
"(",
")",
";",
"final",
"map",
"<",
"kafka",
"streams",
",",
"state",
">",
"state",
"map",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"for",
"(",
"final",
"kafka",
"streams",
"streams",
":",
"streams",
"list",
")",
"{",
"state",
"map",
"put",
"(",
"streams",
",",
"streams",
"state",
"(",
")",
")",
";",
"final",
"state",
"listener",
"prev",
"state",
"listener",
"=",
"get",
"state",
"listener",
"(",
"streams",
")",
";",
"final",
"state",
"listener",
"new",
"state",
"listener",
"=",
"(",
"new",
"state",
",",
"old",
"state",
")",
"-",
">",
"{",
"state",
"lock",
"lock",
"(",
")",
";",
"try",
"{",
"state",
"map",
"put",
"(",
"streams",
",",
"new",
"state",
")",
";",
"if",
"(",
"new",
"state",
"=",
"=",
"state",
"running",
")",
"{",
"if",
"(",
"state",
"map",
"values",
"(",
")",
"stream",
"(",
")",
"all",
"match",
"(",
"state",
"-",
">",
"state",
"=",
"=",
"state",
"running",
")",
")",
"{",
"state",
"update",
"signal",
"all",
"(",
")",
";",
"}",
"}",
"}",
"finally",
"{",
"state",
"lock",
"unlock",
"(",
")",
";",
"}",
"}",
";",
"streams",
"set",
"state",
"listener",
"(",
"prev",
"state",
"listener",
"!",
"=",
"null",
"?",
"new",
"composite",
"state",
"listener",
"(",
"prev",
"state",
"listener",
",",
"new",
"state",
"listener",
")",
":",
"new",
"state",
"listener",
")",
";",
"}",
"for",
"(",
"final",
"kafka",
"streams",
"streams",
":",
"streams",
"list",
")",
"{",
"streams",
"start",
"(",
")",
";",
"}",
"final",
"long",
"expected",
"end",
"=",
"system",
"current",
"time",
"millis",
"(",
")",
"+",
"timeout",
"to",
"millis",
"(",
")",
";",
"state",
"lock",
"lock",
"(",
")",
";",
"try",
"{",
"/",
"/",
"we",
"use",
"while",
"true",
"here",
"because",
"we",
"want",
"to",
"run",
"this",
"test",
"at",
"least",
"once",
",",
"even",
"if",
"the",
"/",
"/",
"timeout",
"has",
"expired",
"while",
"(",
"true",
")",
"{",
"final",
"map",
"<",
"kafka",
"streams",
",",
"state",
">",
"non",
"running",
"streams",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"for",
"(",
"final",
"entry",
"<",
"kafka",
"streams",
",",
"state",
">",
"entry",
":",
"state",
"map",
"entry",
"set",
"(",
")",
")",
"{",
"if",
"(",
"entry",
"get",
"value",
"(",
")",
"!",
"=",
"state",
"running",
")",
"{",
"non",
"running",
"streams",
"put",
"(",
"entry",
"get",
"key",
"(",
")",
",",
"entry",
"get",
"value",
"(",
")",
")",
";",
"}",
"}",
"if",
"(",
"non",
"running",
"streams",
"is",
"empty",
"(",
")",
")",
"{",
"return",
";",
"}",
"final",
"long",
"millis",
"remaining",
"=",
"expected",
"end",
"-",
"system",
"current",
"time",
"millis",
"(",
")",
";",
"if",
"(",
"millis",
"remaining",
"<",
"=",
"0",
")",
"{",
"fail",
"(",
"\"",
"application",
"did",
"not",
"reach",
"a",
"running",
"state",
"for",
"all",
"streams",
"instances",
"\"",
"+",
"\"",
"non",
"-",
"running",
"instances",
":",
"\"",
"+",
"non",
"running",
"streams",
")",
";",
"}",
"state",
"update",
"await",
"(",
"millis",
"remaining",
",",
"time",
"unit",
"milliseconds",
")",
";",
"}",
"}",
"finally",
"{",
"state",
"lock",
"unlock",
"(",
")",
";",
"}",
"}"
] |
[
"gets",
"a",
"64",
"-",
"bit",
"floating",
"point",
"number",
"at",
"the",
"specified",
"absolute",
"{",
"@",
"code",
"index",
"}",
"in",
"this",
"buffer",
"in",
"little",
"endian",
"byte",
"order",
"this",
"method",
"does",
"not",
"modify",
"{",
"@",
"code",
"reader",
"index",
"}",
"or",
"{",
"@",
"code",
"writer",
"index",
"}",
"of",
"this",
"buffer"
] | [
"public",
"double",
"get",
"double",
"l",
"e",
"(",
"int",
"index",
")",
"{",
"return",
"double",
"long",
"bits",
"to",
"double",
"(",
"get",
"long",
"l",
"e",
"(",
"index",
")",
")",
";",
"}"
] |
[
"get",
"the",
"default",
"permission",
"for",
"directory",
"and",
"symlink",
"in",
"previous",
"versions",
",",
"this",
"default",
"permission",
"was",
"also",
"used",
"to",
"create",
"files",
",",
"so",
"files",
"created",
"end",
"up",
"with",
"ugo",
"+",
"x",
"permission",
"see",
"hadoop",
"-",
"9155",
"for",
"detail",
"two",
"new",
"methods",
"are",
"added",
"to",
"solve",
"this",
",",
"please",
"use",
"{",
"@",
"link",
"fs",
"permission",
"#",
"get",
"dir",
"default",
"(",
")",
"}",
"for",
"directory",
",",
"and",
"use",
"{",
"@",
"link",
"fs",
"permission",
"#",
"get",
"file",
"default",
"(",
")",
"}",
"for",
"file",
"this",
"method",
"is",
"kept",
"for",
"compatibility"
] | [
"public",
"static",
"fs",
"permission",
"get",
"default",
"(",
")",
"{",
"return",
"new",
"fs",
"permission",
"(",
"(",
"short",
")",
"00777",
")",
";",
"}"
] |
[
"a",
"sensible",
"definition",
"of",
"{",
"@",
"link",
"#",
"hash",
"code",
"}",
"in",
"terms",
"of",
"the",
"{",
"@",
"code",
"iterator",
"}",
"method",
"of",
"{",
"@",
"link",
"#",
"entry",
"set",
"}",
"if",
"you",
"override",
"{",
"@",
"link",
"#",
"entry",
"set",
"}",
",",
"you",
"may",
"wish",
"to",
"override",
"{",
"@",
"link",
"#",
"hash",
"code",
"}",
"to",
"forward",
"to",
"this",
"implementation"
] | [
"protected",
"int",
"standard",
"hash",
"code",
"(",
")",
"{",
"return",
"sets",
"hash",
"code",
"impl",
"(",
"entry",
"set",
"(",
")",
")",
";",
"}"
] |
[
"retrieves",
"the",
"qid",
"allocated",
"to",
"a",
"given",
"new",
"cell"
] | [
"public",
"string",
"get",
"qid",
"(",
"long",
"id",
")",
"{",
"return",
"map",
"get",
"(",
"id",
")",
";",
"}"
] |
[
"returns",
"a",
"{",
"@",
"code",
"spliterator",
"}",
"that",
"iterates",
"over",
"the",
"elements",
"of",
"the",
"spliterators",
"generated",
"by",
"applying",
"{",
"@",
"code",
"function",
"}",
"to",
"the",
"elements",
"of",
"{",
"@",
"code",
"from",
"spliterator",
"}"
] | [
"static",
"<",
"in",
"element",
"t",
",",
"out",
"element",
"t",
">",
"spliterator",
"<",
"out",
"element",
"t",
">",
"flat",
"map",
"(",
"spliterator",
"<",
"in",
"element",
"t",
">",
"from",
"spliterator",
",",
"function",
"<",
"?",
"super",
"in",
"element",
"t",
",",
"spliterator",
"<",
"out",
"element",
"t",
">",
">",
"function",
",",
"int",
"top",
"characteristics",
",",
"long",
"top",
"size",
")",
"{",
"check",
"argument",
"(",
"(",
"top",
"characteristics",
"&",
"spliterator",
"subsized",
")",
"=",
"=",
"0",
",",
"\"",
"flat",
"map",
"does",
"not",
"support",
"subsized",
"characteristic",
"\"",
")",
";",
"check",
"argument",
"(",
"(",
"top",
"characteristics",
"&",
"spliterator",
"sorted",
")",
"=",
"=",
"0",
",",
"\"",
"flat",
"map",
"does",
"not",
"support",
"sorted",
"characteristic",
"\"",
")",
";",
"check",
"not",
"null",
"(",
"from",
"spliterator",
")",
";",
"check",
"not",
"null",
"(",
"function",
")",
";",
"return",
"new",
"flat",
"map",
"spliterator",
"of",
"object",
"<",
"in",
"element",
"t",
",",
"out",
"element",
"t",
">",
"(",
"null",
",",
"from",
"spliterator",
",",
"function",
",",
"top",
"characteristics",
",",
"top",
"size",
")",
";",
"}"
] |
[
"set",
"the",
"span",
"of",
"bold"
] | [
"public",
"span",
"utils",
"set",
"bold",
"(",
")",
"{",
"is",
"bold",
"=",
"true",
";",
"return",
"this",
";",
"}"
] |
[
"translate",
"a",
"data",
"representation",
"into",
"fields",
"set",
"in",
"given",
"event"
] | [
"void",
"translate",
"to",
"(",
"t",
"event",
",",
"long",
"sequence",
",",
"a",
"arg",
"0",
")",
";"
] |
[
"iterate",
"over",
"all",
"current",
"storage",
"directories",
",",
"inspecting",
"them",
"with",
"the",
"given",
"inspector"
] | [
"void",
"inspect",
"storage",
"dirs",
"(",
"f",
"s",
"image",
"storage",
"inspector",
"inspector",
")",
"throws",
"i",
"o",
"exception",
"{",
"/",
"/",
"process",
"each",
"of",
"the",
"storage",
"directories",
"to",
"find",
"the",
"pair",
"of",
"/",
"/",
"newest",
"image",
"file",
"and",
"edit",
"file",
"for",
"(",
"iterator",
"<",
"storage",
"directory",
">",
"it",
"=",
"dir",
"iterator",
"(",
")",
";",
"it",
"has",
"next",
"(",
")",
";",
")",
"{",
"storage",
"directory",
"sd",
"=",
"it",
"next",
"(",
")",
";",
"inspector",
"inspect",
"directory",
"(",
"sd",
")",
";",
"}",
"}"
] |
[
"releases",
"a",
"lease",
"(",
"identified",
"by",
"the",
"lease",
"holder",
"object",
")",
"for",
"the",
"given",
"type",
"if",
"no",
"further",
"leases",
"exist",
",",
"the",
"resource",
"is",
"disposed",
"this",
"method",
"takes",
"an",
"additional",
"hook",
"that",
"is",
"called",
"when",
"the",
"resource",
"is",
"disposed"
] | [
"void",
"release",
"(",
"string",
"type",
",",
"object",
"lease",
"holder",
",",
"consumer",
"<",
"long",
">",
"releaser",
")",
"throws",
"exception",
"{",
"lock",
"lock",
"(",
")",
";",
"try",
"{",
"final",
"leased",
"resource",
"<",
"?",
">",
"resource",
"=",
"reserved",
"resources",
"get",
"(",
"type",
")",
";",
"if",
"(",
"resource",
"=",
"=",
"null",
")",
"{",
"return",
";",
"}",
"if",
"(",
"resource",
"remove",
"lease",
"holder",
"(",
"lease",
"holder",
")",
")",
"{",
"try",
"{",
"reserved",
"resources",
"remove",
"(",
"type",
")",
";",
"resource",
"dispose",
"(",
")",
";",
"}",
"finally",
"{",
"releaser",
"accept",
"(",
"resource",
"size",
"(",
")",
")",
";",
"}",
"}",
"}",
"finally",
"{",
"lock",
"unlock",
"(",
")",
";",
"}",
"}"
] |
[
"on",
"a",
"concurrent",
"computation",
"that",
"returns",
"null",
",",
"all",
"threads",
"should",
"get",
"an",
"invalid",
"cache",
"load",
"exception",
",",
"with",
"the",
"loader",
"only",
"called",
"once",
"the",
"result",
"should",
"not",
"be",
"cached",
"(",
"a",
"later",
"request",
"should",
"call",
"the",
"loader",
"again",
")"
] | [
"private",
"static",
"void",
"test",
"concurrent",
"loading",
"null",
"(",
"caffeine",
"<",
"object",
",",
"object",
">",
"builder",
")",
"throws",
"interrupted",
"exception",
"{",
"int",
"count",
"=",
"10",
";",
"final",
"atomic",
"integer",
"call",
"count",
"=",
"new",
"atomic",
"integer",
"(",
")",
";",
"final",
"count",
"down",
"latch",
"start",
"signal",
"=",
"new",
"count",
"down",
"latch",
"(",
"count",
"+",
"1",
")",
";",
"loading",
"cache",
"<",
"string",
",",
"string",
">",
"cache",
"=",
"caffeinated",
"guava",
"build",
"(",
"builder",
",",
"new",
"cache",
"loader",
"<",
"string",
",",
"string",
">",
"(",
")",
"{",
"@",
"override",
"public",
"string",
"load",
"(",
"string",
"key",
")",
"{",
"call",
"count",
"increment",
"and",
"get",
"(",
")",
";",
"assert",
"true",
"(",
"uninterruptibles",
"await",
"uninterruptibly",
"(",
"start",
"signal",
",",
"300",
",",
"time",
"unit",
"seconds",
")",
")",
";",
"return",
"null",
";",
"}",
"}",
")",
";",
"list",
"<",
"object",
">",
"result",
"=",
"do",
"concurrent",
"get",
"(",
"cache",
",",
"\"",
"bar",
"\"",
",",
"count",
",",
"start",
"signal",
")",
";",
"assert",
"equals",
"(",
"count",
",",
"call",
"count",
"get",
"(",
")",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"count",
";",
"i",
"+",
"+",
")",
"{",
"assert",
"true",
"(",
"result",
"get",
"(",
"i",
")",
"instanceof",
"invalid",
"cache",
"load",
"exception",
")",
";",
"}",
"/",
"/",
"subsequent",
"calls",
"should",
"call",
"the",
"loader",
"again",
",",
"not",
"get",
"the",
"old",
"exception",
"try",
"{",
"cache",
"get",
"unchecked",
"(",
"\"",
"bar",
"\"",
")",
";",
"fail",
"(",
")",
";",
"}",
"catch",
"(",
"invalid",
"cache",
"load",
"exception",
"expected",
")",
"{",
"}",
"assert",
"equals",
"(",
"count",
"+",
"1",
",",
"call",
"count",
"get",
"(",
")",
")",
";",
"}"
] |
[
"gets",
"the",
"\"",
"lib",
"\"",
"directories",
"from",
"the",
"given",
"modules"
] | [
"public",
"static",
"collection",
"<",
"resource",
"file",
">",
"get",
"module",
"lib",
"directories",
"(",
"map",
"<",
"string",
",",
"g",
"module",
">",
"modules",
")",
"{",
"list",
"<",
"resource",
"file",
">",
"library",
"directories",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"for",
"(",
"g",
"module",
"module",
":",
"modules",
"values",
"(",
")",
")",
"{",
"module",
"collect",
"existing",
"module",
"dirs",
"(",
"library",
"directories",
",",
"\"",
"lib",
"\"",
")",
";",
"/",
"/",
"in",
"testing",
"mode",
",",
"we",
"run",
"out",
"of",
"an",
"intermediate",
"build",
"state",
"the",
"module",
"jars",
"/",
"/",
"live",
"in",
"a",
"build",
"/",
"libs",
"directory",
"we",
"only",
"want",
"to",
"look",
"in",
"here",
"when",
"testing",
"because",
"/",
"/",
"other",
"run",
"modes",
"(",
"such",
"as",
"a",
"ghidra",
"release",
"launched",
"from",
"a",
"user",
"'",
"s",
"eclipse",
")",
"may",
"contain",
"/",
"/",
"build",
"remnants",
"that",
"could",
"cause",
"problems",
"if",
"discovered",
"if",
"(",
"system",
"utilities",
"is",
"in",
"testing",
"mode",
"(",
")",
")",
"{",
"module",
"collect",
"existing",
"module",
"dirs",
"(",
"library",
"directories",
",",
"\"",
"libs",
"\"",
")",
";",
"}",
"}",
"return",
"library",
"directories",
";",
"}"
] |
[
"lists",
"recursive",
"files",
"of",
"this",
"directory",
"with",
"pattern",
"matching",
"the",
"default",
"implementation",
"calls",
"{",
"@",
"link",
"#",
"list",
"(",
")",
"}",
"recursively",
"inside",
"{",
"@",
"link",
"#",
"run",
"}",
"and",
"applies",
"filtering",
"to",
"the",
"result",
"implementations",
"may",
"wish",
"to",
"override",
"this",
"more",
"efficiently",
"this",
"method",
"allows",
"the",
"user",
"to",
"specify",
"that",
"symlinks",
"should",
"not",
"be",
"followed",
"by",
"passing",
"no",
"follow",
"links",
"as",
"true",
"however",
",",
"some",
"implementations",
"may",
"not",
"be",
"able",
"to",
"reliably",
"prevent",
"link",
"following",
"the",
"base",
"implementation",
"here",
"in",
"virtual",
"file",
"ignores",
"this",
"parameter"
] | [
"public",
"@",
"non",
"null",
"collection",
"<",
"string",
">",
"list",
"(",
"@",
"non",
"null",
"string",
"includes",
",",
"@",
"check",
"for",
"null",
"string",
"excludes",
",",
"boolean",
"use",
"default",
"excludes",
",",
"boolean",
"no",
"follow",
"links",
")",
"throws",
"i",
"o",
"exception",
"{",
"collection",
"<",
"string",
">",
"r",
"=",
"run",
"(",
"new",
"collect",
"files",
"(",
"this",
")",
")",
";",
"list",
"<",
"tokenized",
"pattern",
">",
"include",
"patterns",
"=",
"patterns",
"(",
"includes",
")",
";",
"list",
"<",
"tokenized",
"pattern",
">",
"exclude",
"patterns",
"=",
"patterns",
"(",
"excludes",
")",
";",
"if",
"(",
"use",
"default",
"excludes",
")",
"{",
"for",
"(",
"string",
"patt",
":",
"directory",
"scanner",
"get",
"default",
"excludes",
"(",
")",
")",
"{",
"exclude",
"patterns",
"add",
"(",
"new",
"tokenized",
"pattern",
"(",
"patt",
"replace",
"(",
"'",
"/",
"'",
",",
"file",
"separator",
"char",
")",
")",
")",
";",
"}",
"}",
"return",
"r",
"stream",
"(",
")",
"filter",
"(",
"p",
"-",
">",
"{",
"tokenized",
"path",
"path",
"=",
"new",
"tokenized",
"path",
"(",
"p",
"replace",
"(",
"'",
"/",
"'",
",",
"file",
"separator",
"char",
")",
")",
";",
"return",
"include",
"patterns",
"stream",
"(",
")",
"any",
"match",
"(",
"patt",
"-",
">",
"patt",
"match",
"path",
"(",
"path",
",",
"true",
")",
")",
"&",
"&",
"exclude",
"patterns",
"stream",
"(",
")",
"none",
"match",
"(",
"patt",
"-",
">",
"patt",
"match",
"path",
"(",
"path",
",",
"true",
")",
")",
";",
"}",
")",
"collect",
"(",
"collectors",
"to",
"set",
"(",
")",
")",
";",
"}"
] |
[
"get",
"double",
"minimum",
":",
"67",
"8",
"maximum",
":",
"123",
"4"
] | [
"public",
"double",
"get",
"double",
"(",
")",
"{",
"return",
"double",
";",
"}"
] |
[
"tests",
"that",
"application",
"files",
"are",
"deleted",
"when",
"the",
"yarn",
"application",
"master",
"is",
"de",
"-",
"registered"
] | [
"public",
"void",
"test",
"delete",
"application",
"files",
"(",
")",
"throws",
"exception",
"{",
"new",
"context",
"(",
")",
"{",
"{",
"final",
"file",
"application",
"dir",
"=",
"folder",
"new",
"folder",
"(",
"\"",
"flink",
"\"",
")",
";",
"env",
"put",
"(",
"flink",
"yarn",
"files",
",",
"application",
"dir",
"get",
"canonical",
"path",
"(",
")",
")",
";",
"run",
"test",
"(",
"(",
")",
"-",
">",
"{",
"get",
"driver",
"(",
")",
"deregister",
"application",
"(",
"application",
"status",
"succeeded",
",",
"null",
")",
";",
"assert",
"false",
"(",
"\"",
"yarn",
"application",
"directory",
"was",
"not",
"removed",
"\"",
",",
"files",
"exists",
"(",
"application",
"dir",
"to",
"path",
"(",
")",
")",
")",
";",
"}",
")",
";",
"}",
"}",
";",
"}"
] |
[
"return",
"the",
"\"",
"cache",
"-",
"control",
"\"",
"header",
"value",
",",
"if",
"any"
] | [
"public",
"string",
"get",
"header",
"value",
"(",
")",
"{",
"string",
"header",
"value",
"=",
"to",
"header",
"value",
"(",
")",
";",
"return",
"(",
"string",
"utils",
"has",
"text",
"(",
"header",
"value",
")",
"?",
"header",
"value",
":",
"null",
")",
";",
"}"
] |
[
"return",
"the",
"supplied",
"configuration",
"for",
"testing",
"or",
"otherwise",
"load",
"a",
"new",
"configuration"
] | [
"private",
"configuration",
"load",
"conf",
"(",
")",
"{",
"configuration",
"c",
";",
"if",
"(",
"supplied",
"conf",
"!",
"=",
"null",
")",
"{",
"c",
"=",
"supplied",
"conf",
";",
"}",
"else",
"{",
"/",
"/",
"the",
"config",
"we",
"'",
"re",
"handed",
"in",
"init",
"(",
")",
"isn",
"'",
"t",
"the",
"one",
"we",
"want",
"here",
",",
"so",
"we",
"/",
"/",
"create",
"a",
"new",
"one",
"to",
"pick",
"up",
"the",
"full",
"settings",
"c",
"=",
"new",
"configuration",
"(",
")",
";",
"}",
"return",
"c",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}",
"because",
"a",
"{",
"@",
"code",
"tree",
"multimap",
"}",
"has",
"unique",
"sorted",
"keys",
",",
"this",
"method",
"returns",
"a",
"{",
"@",
"link",
"navigable",
"set",
"}",
",",
"instead",
"of",
"the",
"{",
"@",
"link",
"java",
"util",
"set",
"}",
"specified",
"in",
"the",
"{",
"@",
"link",
"multimap",
"}",
"interface"
] | [
"public",
"navigable",
"set",
"<",
"k",
">",
"key",
"set",
"(",
")",
"{",
"return",
"(",
"navigable",
"set",
"<",
"k",
">",
")",
"super",
"key",
"set",
"(",
")",
";",
"}"
] |
[
"visit",
"a",
"parse",
"tree",
"produced",
"by",
"the",
"{",
"@",
"code",
"time",
"escaped",
"literal",
"}",
"labeled",
"alternative",
"in",
"{",
"@",
"link",
"sql",
"base",
"parser",
"#",
"constant",
"}"
] | [
"t",
"visit",
"time",
"escaped",
"literal",
"(",
"sql",
"base",
"parser",
"time",
"escaped",
"literal",
"context",
"ctx",
")",
";"
] |
[
"tests",
"that",
"track",
"selector",
"will",
"select",
"audio",
"track",
"with",
"{",
"@",
"link",
"c",
"#",
"selection",
"flag",
"default",
"}",
"given",
"default",
"values",
"of",
"{",
"@",
"link",
"parameters",
"}"
] | [
"public",
"void",
"select",
"tracks",
"select",
"track",
"with",
"selection",
"flag",
"(",
")",
"throws",
"exception",
"{",
"format",
"builder",
"format",
"builder",
"=",
"audio",
"format",
"build",
"upon",
"(",
")",
";",
"format",
"audio",
"format",
"=",
"format",
"builder",
"set",
"selection",
"flags",
"(",
"0",
")",
"build",
"(",
")",
";",
"format",
"format",
"with",
"selection",
"flag",
"=",
"format",
"builder",
"set",
"selection",
"flags",
"(",
"c",
"selection",
"flag",
"default",
")",
"build",
"(",
")",
";",
"track",
"group",
"array",
"track",
"groups",
"=",
"wrap",
"formats",
"(",
"audio",
"format",
",",
"format",
"with",
"selection",
"flag",
")",
";",
"track",
"selector",
"result",
"result",
"=",
"track",
"selector",
"select",
"tracks",
"(",
"new",
"renderer",
"capabilities",
"[",
"]",
"{",
"all",
"audio",
"format",
"supported",
"renderer",
"capabilities",
"}",
",",
"track",
"groups",
",",
"period",
"id",
",",
"timeline",
")",
";",
"assert",
"fixed",
"selection",
"(",
"result",
"selections",
"get",
"(",
"0",
")",
",",
"track",
"groups",
",",
"format",
"with",
"selection",
"flag",
")",
";",
"}"
] |
[
"verifies",
"that",
"the",
"serialization",
"of",
"a",
"map",
"using",
"the",
"given",
"map",
"state",
"matches",
"the",
"deserialization",
"with",
"{",
"@",
"link",
"kv",
"state",
"serializer",
"#",
"deserialize",
"list",
"}"
] | [
"public",
"static",
"void",
"test",
"map",
"serialization",
"(",
"final",
"long",
"key",
",",
"final",
"internal",
"map",
"state",
"<",
"long",
",",
"void",
"namespace",
",",
"long",
",",
"string",
">",
"map",
"state",
")",
"throws",
"exception",
"{",
"type",
"serializer",
"<",
"long",
">",
"user",
"key",
"serializer",
"=",
"long",
"serializer",
"instance",
";",
"type",
"serializer",
"<",
"string",
">",
"user",
"value",
"serializer",
"=",
"string",
"serializer",
"instance",
";",
"map",
"state",
"set",
"current",
"namespace",
"(",
"void",
"namespace",
"instance",
")",
";",
"/",
"/",
"map",
"final",
"int",
"num",
"elements",
"=",
"10",
";",
"final",
"map",
"<",
"long",
",",
"string",
">",
"expected",
"values",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"1",
";",
"i",
"<",
"=",
"num",
"elements",
";",
"i",
"+",
"+",
")",
"{",
"final",
"long",
"value",
"=",
"thread",
"local",
"random",
"current",
"(",
")",
"next",
"long",
"(",
")",
";",
"expected",
"values",
"put",
"(",
"value",
",",
"long",
"to",
"string",
"(",
"value",
")",
")",
";",
"map",
"state",
"put",
"(",
"value",
",",
"long",
"to",
"string",
"(",
"value",
")",
")",
";",
"}",
"expected",
"values",
"put",
"(",
"0l",
",",
"null",
")",
";",
"map",
"state",
"put",
"(",
"0l",
",",
"null",
")",
";",
"final",
"byte",
"[",
"]",
"serialized",
"key",
"=",
"kv",
"state",
"serializer",
"serialize",
"key",
"and",
"namespace",
"(",
"key",
",",
"long",
"serializer",
"instance",
",",
"void",
"namespace",
"instance",
",",
"void",
"namespace",
"serializer",
"instance",
")",
";",
"final",
"byte",
"[",
"]",
"serialized",
"values",
"=",
"map",
"state",
"get",
"serialized",
"value",
"(",
"serialized",
"key",
",",
"map",
"state",
"get",
"key",
"serializer",
"(",
")",
",",
"map",
"state",
"get",
"namespace",
"serializer",
"(",
")",
",",
"map",
"state",
"get",
"value",
"serializer",
"(",
")",
")",
";",
"map",
"<",
"long",
",",
"string",
">",
"actual",
"values",
"=",
"kv",
"state",
"serializer",
"deserialize",
"map",
"(",
"serialized",
"values",
",",
"user",
"key",
"serializer",
",",
"user",
"value",
"serializer",
")",
";",
"assert",
"equals",
"(",
"expected",
"values",
"size",
"(",
")",
",",
"actual",
"values",
"size",
"(",
")",
")",
";",
"for",
"(",
"map",
"entry",
"<",
"long",
",",
"string",
">",
"actual",
"entry",
":",
"actual",
"values",
"entry",
"set",
"(",
")",
")",
"{",
"assert",
"equals",
"(",
"expected",
"values",
"get",
"(",
"actual",
"entry",
"get",
"key",
"(",
")",
")",
",",
"actual",
"entry",
"get",
"value",
"(",
")",
")",
";",
"}",
"/",
"/",
"single",
"value",
"byte",
"array",
"output",
"stream",
"baos",
"=",
"new",
"byte",
"array",
"output",
"stream",
"(",
")",
";",
"long",
"expected",
"key",
"=",
"thread",
"local",
"random",
"current",
"(",
")",
"next",
"long",
"(",
")",
";",
"string",
"expected",
"value",
"=",
"long",
"to",
"string",
"(",
"expected",
"key",
")",
";",
"byte",
"[",
"]",
"is",
"null",
"=",
"{",
"0",
"}",
";",
"baos",
"write",
"(",
"kv",
"state",
"serializer",
"serialize",
"value",
"(",
"expected",
"key",
",",
"user",
"key",
"serializer",
")",
")",
";",
"baos",
"write",
"(",
"is",
"null",
")",
";",
"baos",
"write",
"(",
"kv",
"state",
"serializer",
"serialize",
"value",
"(",
"expected",
"value",
",",
"user",
"value",
"serializer",
")",
")",
";",
"byte",
"[",
"]",
"serialized",
"value",
"=",
"baos",
"to",
"byte",
"array",
"(",
")",
";",
"map",
"<",
"long",
",",
"string",
">",
"actual",
"value",
"=",
"kv",
"state",
"serializer",
"deserialize",
"map",
"(",
"serialized",
"value",
",",
"user",
"key",
"serializer",
",",
"user",
"value",
"serializer",
")",
";",
"assert",
"equals",
"(",
"1",
",",
"actual",
"value",
"size",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"expected",
"value",
",",
"actual",
"value",
"get",
"(",
"expected",
"key",
")",
")",
";",
"}"
] |
[
"sha",
"base",
"64",
"string"
] | [
"public",
"static",
"string",
"sha",
"base",
"6",
"4",
"(",
"final",
"string",
"salt",
",",
"final",
"string",
"data",
")",
"{",
"return",
"sha",
"base",
"6",
"4",
"(",
"salt",
",",
"data",
",",
"null",
")",
";",
"}"
] |
[
"create",
"a",
"new",
"log",
"file",
"and",
"return",
"the",
"{",
"@",
"link",
"f",
"s",
"data",
"output",
"stream",
"}",
"if",
"a",
"file",
"with",
"the",
"specified",
"path",
"already",
"exists",
",",
"add",
"a",
"suffix",
",",
"starting",
"with",
"1",
"and",
"try",
"again",
"keep",
"incrementing",
"the",
"suffix",
"until",
"a",
"nonexistent",
"target",
"path",
"is",
"found",
"once",
"the",
"file",
"is",
"open",
",",
"update",
"{",
"@",
"link",
"#",
"current",
"f",
"s",
"out",
"stream",
"}",
",",
"{",
"@",
"link",
"#",
"current",
"out",
"stream",
"}",
",",
"and",
"{",
"@",
"#",
"link",
"#",
"current",
"file",
"path",
"}",
"are",
"set",
"appropriately"
] | [
"private",
"void",
"create",
"log",
"file",
"(",
"path",
"initial",
")",
"throws",
"i",
"o",
"exception",
"{",
"path",
"current",
"attempt",
"=",
"initial",
";",
"/",
"/",
"start",
"at",
"0",
"so",
"that",
"if",
"the",
"base",
"filname",
"exists",
",",
"we",
"start",
"with",
"the",
"suffix",
"/",
"/",
"\"",
"1",
"\"",
"int",
"id",
"=",
"0",
";",
"while",
"(",
"true",
")",
"{",
"/",
"/",
"first",
"try",
"blindly",
"creating",
"the",
"file",
"if",
"we",
"fail",
",",
"it",
"either",
"means",
"/",
"/",
"the",
"file",
"exists",
",",
"or",
"the",
"operation",
"actually",
"failed",
"we",
"do",
"it",
"this",
"way",
"/",
"/",
"because",
"if",
"we",
"check",
"whether",
"the",
"file",
"exists",
",",
"it",
"might",
"still",
"be",
"created",
"/",
"/",
"by",
"the",
"time",
"we",
"try",
"to",
"create",
"it",
"creating",
"first",
"works",
"like",
"a",
"/",
"/",
"test",
"-",
"and",
"-",
"set",
"try",
"{",
"current",
"f",
"s",
"out",
"stream",
"=",
"file",
"system",
"create",
"(",
"current",
"attempt",
",",
"false",
")",
";",
"current",
"out",
"stream",
"=",
"new",
"print",
"stream",
"(",
"current",
"f",
"s",
"out",
"stream",
",",
"true",
",",
"standard",
"charsets",
"utf",
"8",
"name",
"(",
")",
")",
";",
"current",
"file",
"path",
"=",
"current",
"attempt",
";",
"break",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"ex",
")",
"{",
"/",
"/",
"now",
"we",
"can",
"check",
"to",
"see",
"if",
"the",
"file",
"exists",
"to",
"know",
"why",
"we",
"failed",
"if",
"(",
"file",
"system",
"exists",
"(",
"current",
"attempt",
")",
")",
"{",
"id",
"=",
"get",
"next",
"id",
"to",
"try",
"(",
"initial",
",",
"id",
")",
";",
"current",
"attempt",
"=",
"new",
"path",
"(",
"initial",
"to",
"string",
"(",
")",
"+",
"\"",
"\"",
"+",
"id",
")",
";",
"}",
"else",
"{",
"throw",
"ex",
";",
"}",
"}",
"}",
"}"
] |
[
"get",
"date",
"time"
] | [
"public",
"offset",
"date",
"time",
"get",
"date",
"time",
"(",
")",
"{",
"return",
"date",
"time",
";",
"}"
] |
[
"a",
"list",
"is",
"representable",
"as",
"a",
"tag",
"set",
"as",
"the",
"contents",
"of",
"itself",
"expressed",
"as",
"strings",
"so",
"a",
"{",
"@",
"code",
"list",
"<",
"string",
">",
"}",
"is",
"effectively",
"converted",
"to",
"a",
"{",
"@",
"code",
"set",
"<",
"string",
">",
"}"
] | [
"public",
"set",
"<",
"string",
">",
"to",
"tag",
"set",
"(",
"object",
"items",
",",
"string",
"name",
")",
"{",
"if",
"(",
"items",
"=",
"=",
"null",
")",
"{",
"string",
"msg",
"=",
"\"",
"illegal",
"tag",
"conversion",
"from",
"null",
"on",
"attribute",
"\"",
"+",
"name",
"+",
"\"",
"\"",
";",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"msg",
")",
";",
"}",
"set",
"<",
"string",
">",
"tags",
"=",
"new",
"linked",
"hash",
"set",
"<",
">",
"(",
")",
";",
"@",
"suppress",
"warnings",
"(",
"\"",
"unchecked",
"\"",
")",
"list",
"<",
"elem",
"t",
">",
"items",
"as",
"listof",
"elem",
"=",
"(",
"list",
"<",
"elem",
"t",
">",
")",
"items",
";",
"for",
"(",
"elem",
"t",
"element",
":",
"items",
"as",
"listof",
"elem",
")",
"{",
"tags",
"add",
"(",
"element",
"to",
"string",
"(",
")",
")",
";",
"}",
"return",
"tags",
";",
"}"
] |
[
"continues",
"a",
"join",
"transformation",
"and",
"defines",
"a",
"{",
"@",
"link",
"key",
"selector",
"}",
"function",
"for",
"the",
"second",
"join",
"{",
"@",
"link",
"data",
"set",
"}",
"the",
"key",
"selector",
"function",
"is",
"called",
"for",
"each",
"element",
"of",
"the",
"second",
"data",
"set",
"and",
"extracts",
"a",
"single",
"key",
"value",
"on",
"which",
"the",
"data",
"set",
"is",
"joined",
"the",
"resulting",
"{",
"@",
"link",
"default",
"join",
"}",
"wraps",
"each",
"pair",
"of",
"joining",
"elements",
"into",
"a",
"{",
"@",
"link",
"tuple",
"2",
"}",
",",
"with",
"the",
"element",
"of",
"the",
"first",
"input",
"being",
"the",
"first",
"field",
"of",
"the",
"tuple",
"and",
"the",
"element",
"of",
"the",
"second",
"input",
"being",
"the",
"second",
"field",
"of",
"the",
"tuple"
] | [
"public",
"<",
"k",
">",
"default",
"join",
"<",
"i1",
",",
"i2",
">",
"equal",
"to",
"(",
"key",
"selector",
"<",
"i2",
",",
"k",
">",
"key",
"selector",
")",
"{",
"type",
"information",
"<",
"k",
">",
"key",
"type",
"=",
"type",
"extractor",
"get",
"key",
"selector",
"types",
"(",
"key",
"selector",
",",
"input",
"2",
"get",
"type",
"(",
")",
")",
";",
"return",
"create",
"default",
"join",
"(",
"new",
"selector",
"function",
"keys",
"<",
">",
"(",
"input",
"2",
"clean",
"(",
"key",
"selector",
")",
",",
"input",
"2",
"get",
"type",
"(",
")",
",",
"key",
"type",
")",
")",
";",
"}"
] |
[
"used",
"for",
"asynchronous",
"execution",
"of",
"command",
"this",
"will",
"queue",
"up",
"the",
"command",
"on",
"the",
"thread",
"pool",
"and",
"return",
"an",
"{",
"@",
"link",
"future",
"}",
"to",
"get",
"the",
"result",
"once",
"it",
"completes",
"note",
":",
"if",
"configured",
"to",
"not",
"run",
"in",
"a",
"separate",
"thread",
",",
"this",
"will",
"have",
"the",
"same",
"effect",
"as",
"{",
"@",
"link",
"#",
"execute",
"(",
")",
"}",
"and",
"will",
"block",
"we",
"don",
"'",
"t",
"throw",
"an",
"exception",
"in",
"that",
"case",
"but",
"just",
"flip",
"to",
"synchronous",
"execution",
"so",
"code",
"doesn",
"'",
"t",
"need",
"to",
"change",
"in",
"order",
"to",
"switch",
"a",
"circuit",
"from",
"running",
"a",
"separate",
"thread",
"to",
"the",
"calling",
"thread"
] | [
"public",
"future",
"<",
"r",
">",
"queue",
"(",
")",
";"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"find",
"purchase",
"order",
"by",
"id",
"for",
"valid",
"response",
"try",
"integer",
"i",
"ds",
"with",
"value",
"&",
"lt",
";",
"&",
"#",
"x",
"3",
"d",
";",
"5",
"or",
"&",
"gt",
";",
"10",
"other",
"values",
"will",
"generated",
"exceptions"
] | [
"public",
"completable",
"future",
"<",
"api",
"response",
"<",
"order",
">",
">",
"get",
"order",
"by",
"id",
"with",
"http",
"info",
"(",
"long",
"order",
"id",
")",
"throws",
"api",
"exception",
"{",
"try",
"{",
"http",
"request",
"builder",
"local",
"var",
"request",
"builder",
"=",
"get",
"order",
"by",
"id",
"request",
"builder",
"(",
"order",
"id",
")",
";",
"return",
"member",
"var",
"http",
"client",
"send",
"async",
"(",
"local",
"var",
"request",
"builder",
"build",
"(",
")",
",",
"http",
"response",
"body",
"handlers",
"of",
"string",
"(",
")",
")",
"then",
"compose",
"async",
"(",
"local",
"var",
"response",
"-",
">",
"{",
"if",
"(",
"local",
"var",
"response",
"status",
"code",
"(",
")",
"/",
"100",
"!",
"=",
"2",
")",
"{",
"return",
"completable",
"future",
"failed",
"future",
"(",
"get",
"api",
"exception",
"(",
"\"",
"get",
"order",
"by",
"id",
"\"",
",",
"local",
"var",
"response",
")",
")",
";",
"}",
"try",
"{",
"return",
"completable",
"future",
"completed",
"future",
"(",
"new",
"api",
"response",
"<",
"order",
">",
"(",
"local",
"var",
"response",
"status",
"code",
"(",
")",
",",
"local",
"var",
"response",
"headers",
"(",
")",
"map",
"(",
")",
",",
"member",
"var",
"object",
"mapper",
"read",
"value",
"(",
"local",
"var",
"response",
"body",
"(",
")",
",",
"new",
"type",
"reference",
"<",
"order",
">",
"(",
")",
"{",
"}",
")",
")",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"return",
"completable",
"future",
"failed",
"future",
"(",
"new",
"api",
"exception",
"(",
"e",
")",
")",
";",
"}",
"}",
")",
";",
"}",
"catch",
"(",
"api",
"exception",
"e",
")",
"{",
"return",
"completable",
"future",
"failed",
"future",
"(",
"e",
")",
";",
"}",
"}"
] |
[
"verify",
"that",
"paths",
"with",
"a",
"trailing",
"\"",
"\"",
"are",
"fixed",
"up"
] | [
"public",
"void",
"test",
"path",
"fixup",
"(",
")",
"throws",
"throwable",
"{",
"final",
"s",
"3",
"a",
"file",
"system",
"fs",
"=",
"get",
"file",
"system",
"(",
")",
";",
"path",
"path",
"=",
"fs",
"make",
"qualified",
"(",
"new",
"path",
"(",
"\"",
"path",
"\"",
")",
")",
";",
"string",
"trailing",
"=",
"path",
"to",
"uri",
"(",
")",
"to",
"string",
"(",
")",
"+",
"\"",
"/",
"\"",
";",
"verify",
"no",
"trailing",
"slash",
"(",
"\"",
"path",
"from",
"string",
"\"",
",",
"new",
"path",
"(",
"trailing",
")",
")",
";",
"/",
"/",
"here",
"the",
"problem",
":",
"the",
"uri",
"constructor",
"doesn",
"'",
"t",
"strip",
"trailing",
"\"",
"/",
"\"",
"chars",
"uri",
"trailing",
"u",
"r",
"i",
"=",
"verify",
"trailing",
"slash",
"(",
"\"",
"trailing",
"u",
"r",
"i",
"\"",
",",
"new",
"uri",
"(",
"trailing",
")",
")",
";",
"path",
"path",
"from",
"trailing",
"u",
"r",
"i",
"=",
"verify",
"trailing",
"slash",
"(",
"\"",
"path",
"from",
"trailing",
"u",
"r",
"i",
"\"",
",",
"new",
"path",
"(",
"trailing",
"u",
"r",
"i",
")",
")",
";",
"/",
"/",
"here",
"is",
"the",
"fixup",
"verify",
"no",
"trailing",
"slash",
"(",
"\"",
"path",
"from",
"fs",
"make",
"qualified",
"(",
")",
"\"",
",",
"fs",
"make",
"qualified",
"(",
"path",
"from",
"trailing",
"u",
"r",
"i",
")",
")",
";",
"}"
] |
[
"key",
"set",
"to",
"string",
"holds",
"to",
"string",
"of",
"elements"
] | [
"public",
"void",
"test",
"to",
"string",
"(",
")",
"{",
"assert",
"equals",
"(",
"\"",
"[",
"]",
"\"",
",",
"set",
"(",
")",
"to",
"string",
"(",
")",
")",
";",
"set",
"full",
"=",
"populated",
"set",
"(",
"3",
")",
";",
"string",
"s",
"=",
"full",
"to",
"string",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"3",
";",
"+",
"+",
"i",
")",
"{",
"assert",
"true",
"(",
"s",
"contains",
"(",
"string",
"value",
"of",
"(",
"i",
")",
")",
")",
";",
"}",
"}"
] |
[
"gets",
"the",
"rich",
"header",
"records"
] | [
"public",
"rich",
"header",
"record",
"[",
"]",
"get",
"records",
"(",
")",
"{",
"return",
"table",
"=",
"=",
"null",
"?",
"new",
"rich",
"header",
"record",
"[",
"0",
"]",
":",
"table",
"get",
"records",
"(",
")",
";",
"}"
] |
[
"positions",
"the",
"cursor",
"to",
"the",
"given",
"location"
] | [
"public",
"boolean",
"go",
"to",
"field",
"(",
"address",
"addr",
",",
"string",
"field",
"name",
",",
"int",
"occurrence",
",",
"int",
"row",
",",
"int",
"col",
")",
"{",
"return",
"go",
"to",
"field",
"(",
"addr",
",",
"field",
"name",
",",
"occurrence",
",",
"row",
",",
"col",
",",
"true",
")",
";",
"}"
] |
[
"test",
"get",
"degrees",
"(",
")",
"with",
"an",
"edge",
"having",
"a",
"src",
"id",
"and",
"a",
"trg",
"id",
"that",
"does",
"not",
"exist",
"in",
"the",
"vertex",
"data",
"set"
] | [
"public",
"void",
"test",
"get",
"degrees",
"invalid",
"edge",
"src",
"trg",
"id",
"(",
")",
"throws",
"exception",
"{",
"final",
"execution",
"environment",
"env",
"=",
"execution",
"environment",
"get",
"execution",
"environment",
"(",
")",
";",
"env",
"set",
"parallelism",
"(",
"parallelism",
")",
";",
"graph",
"<",
"long",
",",
"long",
",",
"long",
">",
"graph",
"=",
"graph",
"from",
"data",
"set",
"(",
"test",
"graph",
"utils",
"get",
"long",
"long",
"vertex",
"data",
"(",
"env",
")",
",",
"test",
"graph",
"utils",
"get",
"long",
"long",
"edge",
"invalid",
"src",
"trg",
"data",
"(",
"env",
")",
",",
"env",
")",
";",
"try",
"{",
"graph",
"get",
"degrees",
"(",
")",
"output",
"(",
"new",
"discarding",
"output",
"format",
"<",
">",
"(",
")",
")",
";",
"env",
"execute",
"(",
")",
";",
"fail",
"(",
"\"",
"graph",
"get",
"degrees",
"(",
")",
"did",
"not",
"fail",
"\"",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"/",
"/",
"we",
"expect",
"the",
"job",
"to",
"fail",
"with",
"an",
"exception",
"}",
"}"
] |
[
"find",
"the",
"index",
"which",
"represents",
"the",
"halfway",
"point",
"within",
"the",
"record",
"data"
] | [
"private",
"int",
"get",
"split",
"index",
"(",
")",
"{",
"int",
"halfway",
"=",
"(",
"(",
"key",
"count",
"=",
"=",
"0",
"?",
"buffer",
"length",
"(",
")",
":",
"get",
"record",
"data",
"offset",
"(",
"key",
"count",
"-",
"1",
")",
")",
"+",
"buffer",
"length",
"(",
")",
")",
"/",
"2",
";",
"int",
"min",
"=",
"1",
";",
"int",
"max",
"=",
"key",
"count",
"-",
"1",
";",
"while",
"(",
"min",
"<",
"max",
")",
"{",
"int",
"i",
"=",
"(",
"min",
"+",
"max",
")",
"/",
"2",
";",
"int",
"offset",
"=",
"get",
"record",
"data",
"offset",
"(",
"i",
")",
";",
"if",
"(",
"offset",
"=",
"=",
"halfway",
")",
"{",
"return",
"i",
";",
"}",
"else",
"if",
"(",
"offset",
"<",
"halfway",
")",
"{",
"max",
"=",
"i",
"-",
"1",
";",
"}",
"else",
"{",
"min",
"=",
"i",
"+",
"1",
";",
"}",
"}",
"return",
"min",
";",
"}"
] |
[
"return",
"the",
"oai",
"type",
"(",
"e",
"g",
"integer",
",",
"long",
",",
"etc",
")",
"corresponding",
"to",
"a",
"schema",
"$",
"ref",
"is",
"not",
"taken",
"into",
"account",
"by",
"this",
"method",
"if",
"the",
"schema",
"is",
"free",
"-",
"form",
"(",
"i",
"e",
"'",
"type",
":",
"object",
"'",
"with",
"no",
"properties",
")",
"or",
"inline",
"schema",
",",
"the",
"returned",
"oai",
"type",
"is",
"'",
"object",
"'"
] | [
"private",
"string",
"get",
"primitive",
"type",
"(",
"schema",
"schema",
")",
"{",
"if",
"(",
"schema",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"schema",
"cannot",
"be",
"null",
"in",
"get",
"primitive",
"type",
"\"",
")",
";",
"}",
"else",
"if",
"(",
"model",
"utils",
"is",
"null",
"type",
"(",
"schema",
")",
")",
"{",
"/",
"/",
"the",
"'",
"null",
"'",
"type",
"is",
"allowed",
"in",
"oas",
"3",
"1",
"and",
"above",
"it",
"is",
"not",
"supported",
"by",
"oas",
"3",
"0",
"x",
",",
"/",
"/",
"though",
"this",
"tooling",
"supports",
"it",
"return",
"\"",
"null",
"\"",
";",
"}",
"else",
"if",
"(",
"model",
"utils",
"is",
"decimal",
"schema",
"(",
"schema",
")",
")",
"{",
"/",
"/",
"special",
"handle",
"of",
"type",
":",
"string",
",",
"format",
":",
"number",
"return",
"\"",
"decimal",
"\"",
";",
"}",
"else",
"if",
"(",
"model",
"utils",
"is",
"byte",
"array",
"schema",
"(",
"schema",
")",
")",
"{",
"return",
"\"",
"byte",
"array",
"\"",
";",
"}",
"else",
"if",
"(",
"model",
"utils",
"is",
"file",
"schema",
"(",
"schema",
")",
")",
"{",
"return",
"\"",
"file",
"\"",
";",
"}",
"else",
"if",
"(",
"model",
"utils",
"is",
"binary",
"schema",
"(",
"schema",
")",
")",
"{",
"return",
"schema",
"type",
"util",
"binary",
"format",
";",
"}",
"else",
"if",
"(",
"model",
"utils",
"is",
"boolean",
"schema",
"(",
"schema",
")",
")",
"{",
"return",
"schema",
"type",
"util",
"boolean",
"type",
";",
"}",
"else",
"if",
"(",
"model",
"utils",
"is",
"date",
"schema",
"(",
"schema",
")",
")",
"{",
"return",
"schema",
"type",
"util",
"date",
"format",
";",
"}",
"else",
"if",
"(",
"model",
"utils",
"is",
"date",
"time",
"schema",
"(",
"schema",
")",
")",
"{",
"return",
"\"",
"date",
"time",
"\"",
";",
"}",
"else",
"if",
"(",
"model",
"utils",
"is",
"number",
"schema",
"(",
"schema",
")",
")",
"{",
"if",
"(",
"schema",
"get",
"format",
"(",
")",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"no",
"format",
"defined",
"return",
"\"",
"number",
"\"",
";",
"}",
"else",
"if",
"(",
"model",
"utils",
"is",
"float",
"schema",
"(",
"schema",
")",
")",
"{",
"return",
"schema",
"type",
"util",
"float",
"format",
";",
"}",
"else",
"if",
"(",
"model",
"utils",
"is",
"double",
"schema",
"(",
"schema",
")",
")",
"{",
"return",
"schema",
"type",
"util",
"double",
"format",
";",
"}",
"else",
"{",
"logger",
"warn",
"(",
"\"",
"unknown",
"`",
"format",
"`",
"{",
"}",
"detected",
"for",
"type",
"`",
"number",
"`",
"defaulting",
"to",
"`",
"number",
"`",
"\"",
",",
"schema",
"get",
"format",
"(",
")",
")",
";",
"return",
"\"",
"number",
"\"",
";",
"}",
"}",
"else",
"if",
"(",
"model",
"utils",
"is",
"integer",
"schema",
"(",
"schema",
")",
")",
"{",
"if",
"(",
"model",
"utils",
"is",
"long",
"schema",
"(",
"schema",
")",
")",
"{",
"return",
"\"",
"long",
"\"",
";",
"}",
"else",
"{",
"return",
"schema",
"get",
"type",
"(",
")",
";",
"/",
"/",
"integer",
"}",
"}",
"else",
"if",
"(",
"model",
"utils",
"is",
"map",
"schema",
"(",
"schema",
")",
")",
"{",
"return",
"\"",
"map",
"\"",
";",
"}",
"else",
"if",
"(",
"model",
"utils",
"is",
"array",
"schema",
"(",
"schema",
")",
")",
"{",
"if",
"(",
"model",
"utils",
"is",
"set",
"(",
"schema",
")",
")",
"{",
"return",
"\"",
"set",
"\"",
";",
"}",
"else",
"{",
"return",
"\"",
"array",
"\"",
";",
"}",
"}",
"else",
"if",
"(",
"model",
"utils",
"is",
"u",
"u",
"i",
"d",
"schema",
"(",
"schema",
")",
")",
"{",
"return",
"\"",
"uuid",
"\"",
";",
"}",
"else",
"if",
"(",
"model",
"utils",
"is",
"u",
"r",
"i",
"schema",
"(",
"schema",
")",
")",
"{",
"return",
"\"",
"uri",
"\"",
";",
"}",
"else",
"if",
"(",
"model",
"utils",
"is",
"string",
"schema",
"(",
"schema",
")",
")",
"{",
"if",
"(",
"type",
"mapping",
"contains",
"key",
"(",
"schema",
"get",
"format",
"(",
")",
")",
")",
"{",
"/",
"/",
"if",
"the",
"format",
"matches",
"a",
"type",
"mapping",
"(",
"supplied",
"with",
"the",
"-",
"-",
"type",
"mappings",
"flag",
")",
"/",
"/",
"then",
"treat",
"the",
"format",
"as",
"a",
"primitive",
"type",
"/",
"/",
"this",
"allows",
"the",
"type",
"mapping",
"flag",
"to",
"add",
"a",
"new",
"custom",
"type",
"which",
"can",
"then",
"/",
"/",
"be",
"used",
"in",
"the",
"format",
"field",
"return",
"schema",
"get",
"format",
"(",
")",
";",
"}",
"return",
"\"",
"string",
"\"",
";",
"}",
"else",
"if",
"(",
"is",
"free",
"form",
"object",
"(",
"schema",
")",
")",
"{",
"/",
"/",
"note",
":",
"the",
"value",
"of",
"a",
"free",
"-",
"form",
"object",
"cannot",
"be",
"an",
"arbitrary",
"type",
"per",
"oas",
"specification",
",",
"/",
"/",
"it",
"must",
"be",
"a",
"map",
"of",
"string",
"to",
"values",
"return",
"\"",
"object",
"\"",
";",
"}",
"else",
"if",
"(",
"schema",
"get",
"properties",
"(",
")",
"!",
"=",
"null",
"&",
"&",
"!",
"schema",
"get",
"properties",
"(",
")",
"is",
"empty",
"(",
")",
")",
"{",
"/",
"/",
"having",
"property",
"implies",
"it",
"'",
"s",
"a",
"model",
"return",
"\"",
"object",
"\"",
";",
"}",
"else",
"if",
"(",
"is",
"any",
"type",
"schema",
"(",
"schema",
")",
")",
"{",
"return",
"\"",
"any",
"type",
"\"",
";",
"}",
"else",
"if",
"(",
"string",
"utils",
"is",
"not",
"empty",
"(",
"schema",
"get",
"type",
"(",
")",
")",
")",
"{",
"if",
"(",
"!",
"import",
"mapping",
"contains",
"key",
"(",
"schema",
"get",
"type",
"(",
")",
")",
")",
"{",
"logger",
"warn",
"(",
"\"",
"unknown",
"type",
"found",
"in",
"the",
"schema",
":",
"\"",
"+",
"schema",
"get",
"type",
"(",
")",
")",
";",
"}",
"return",
"schema",
"get",
"type",
"(",
")",
";",
"}",
"/",
"/",
"the",
"'",
"type",
"'",
"attribute",
"has",
"not",
"been",
"set",
"in",
"the",
"oas",
"schema",
",",
"which",
"means",
"the",
"value",
"/",
"/",
"can",
"be",
"an",
"arbitrary",
"type",
",",
"e",
"g",
"integer",
",",
"string",
",",
"object",
",",
"array",
",",
"number",
"/",
"/",
"todo",
":",
"we",
"should",
"return",
"a",
"different",
"value",
"to",
"distinguish",
"between",
"free",
"-",
"form",
"object",
"/",
"/",
"and",
"arbitrary",
"type",
"return",
"\"",
"object",
"\"",
";",
"}"
] |
[
"creates",
"a",
"bitmap",
"from",
"encoded",
"bytes",
"supports",
"jpeg",
"but",
"callers",
"should",
"use",
"{",
"@",
"link",
"#",
"decode",
"j",
"p",
"e",
"g",
"from",
"encoded",
"image",
"}",
"for",
"partial",
"j",
"p",
"e",
"gs",
"in",
"addition",
",",
"a",
"region",
"to",
"decode",
"can",
"be",
"supplied",
"in",
"order",
"to",
"minimize",
"memory",
"usage",
"note",
":",
"not",
"all",
"platform",
"decoders",
"necessarily",
"support",
"supplying",
"specific",
"regions",
"note",
":",
"this",
"needs",
"to",
"be",
"kept",
"because",
"of",
"dependencies",
"issues"
] | [
"closeable",
"reference",
"<",
"bitmap",
">",
"decode",
"from",
"encoded",
"image",
"(",
"final",
"encoded",
"image",
"encoded",
"image",
",",
"bitmap",
"config",
"bitmap",
"config",
",",
"@",
"nullable",
"rect",
"region",
"to",
"decode",
")",
";"
] |
[
"params",
"for",
"setting",
"an",
"x",
"attr"
] | [
"public",
"static",
"string",
"set",
"x",
"attr",
"param",
"(",
"string",
"name",
",",
"byte",
"[",
"]",
"value",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"\"",
"xattr",
"name",
"=",
"\"",
"+",
"name",
"+",
"\"",
"&",
"xattr",
"value",
"=",
"\"",
"+",
"x",
"attr",
"codec",
"encode",
"value",
"(",
"value",
",",
"x",
"attr",
"codec",
"hex",
")",
"+",
"\"",
"&",
"encoding",
"=",
"hex",
"&",
"flag",
"=",
"create",
"\"",
";",
"}"
] |
[
"adds",
"the",
"fixup",
"address",
"to",
"the",
"contents",
"stored",
"at",
"address",
",",
"then",
"creates",
"a",
"pointer",
"at",
"address"
] | [
"public",
"void",
"fixup",
"memory",
"(",
"address",
"address",
",",
"address",
"fixup",
"address",
",",
"message",
"log",
"log",
")",
"{",
"relocate",
"memory",
"at",
"(",
"address",
",",
"(",
"int",
")",
"fixup",
"address",
"get",
"offset",
"(",
")",
",",
"log",
")",
";",
"try",
"{",
"program",
"get",
"listing",
"(",
")",
"create",
"data",
"(",
"address",
",",
"new",
"pointer",
"data",
"type",
"(",
")",
",",
"4",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"log",
"append",
"exception",
"(",
"e",
")",
";",
"}",
"}"
] |
[
"data",
"store",
"id",
"of",
"this",
"record"
] | [
"public",
"string",
"get",
"id",
"(",
")",
"{",
"return",
"build",
"id",
"(",
"job",
"id",
",",
"timestamp",
",",
"bucket",
"span",
",",
"detector",
"index",
",",
"by",
"field",
"value",
",",
"over",
"field",
"value",
",",
"partition",
"field",
"value",
")",
";",
"}"
] |
[
"get",
"the",
"complete",
"list",
"of",
"the",
"problems",
"reported"
] | [
"public",
"list",
"<",
"i",
"o",
"exception",
">",
"get",
"problems",
"(",
")",
"{",
"return",
"problems",
";",
"}"
] |
[
"similar",
"to",
"{",
"@",
"link",
"runtime",
"service",
"#",
"start",
"process",
"instance",
"by",
"message",
"(",
"string",
",",
"string",
")",
"}",
",",
"but",
"with",
"tenant",
"context"
] | [
"process",
"instance",
"start",
"process",
"instance",
"by",
"message",
"and",
"tenant",
"id",
"(",
"string",
"message",
"name",
",",
"string",
"business",
"key",
",",
"string",
"tenant",
"id",
")",
";"
] |
[
"links",
"a",
"{",
"@",
"link",
"dynamic",
"value",
"}",
"object",
"to",
"the",
"scale",
"x",
"value",
"for",
"this",
"component"
] | [
"public",
"t",
"scale",
"x",
"(",
"dynamic",
"value",
"<",
"float",
">",
"value",
")",
"{",
"m",
"component",
"get",
"or",
"create",
"common",
"dynamic",
"props",
"(",
")",
"put",
"(",
"key",
"scale",
"x",
",",
"value",
")",
";",
"return",
"get",
"this",
"(",
")",
";",
"}"
] |
[
"returns",
"a",
"buffered",
"reader",
"for",
"reading",
"this",
"file",
"as",
"characters",
"@",
"throw",
"gdx",
"runtime",
"exception",
"if",
"the",
"file",
"handle",
"represents",
"a",
"directory",
",",
"doesn",
"'",
"t",
"exist",
",",
"or",
"could",
"not",
"be",
"read"
] | [
"public",
"buffered",
"reader",
"reader",
"(",
"int",
"buffer",
"size",
",",
"string",
"charset",
")",
"{",
"return",
"new",
"buffered",
"reader",
"(",
"reader",
"(",
"charset",
")",
",",
"buffer",
"size",
")",
";",
"}"
] |
[
"parse",
"the",
"log",
"filedirectory"
] | [
"public",
"final",
"void",
"parse",
"log",
"(",
"final",
"string",
"log",
"file",
")",
"throws",
"skyline",
"store",
"exception",
",",
"i",
"o",
"exception",
",",
"resource",
"estimator",
"exception",
"{",
"if",
"(",
"log",
"parser",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"resource",
"estimator",
"exception",
"(",
"\"",
"the",
"log",
"parser",
"is",
"not",
"initialized",
",",
"\"",
"+",
"\"",
"please",
"try",
"again",
"after",
"initializing",
"\"",
")",
";",
"}",
"input",
"stream",
"input",
"stream",
"=",
"null",
";",
"try",
"{",
"input",
"stream",
"=",
"new",
"file",
"input",
"stream",
"(",
"log",
"file",
")",
";",
"log",
"parser",
"parse",
"stream",
"(",
"input",
"stream",
")",
";",
"}",
"finally",
"{",
"if",
"(",
"input",
"stream",
"!",
"=",
"null",
")",
"{",
"input",
"stream",
"close",
"(",
")",
";",
"}",
"}",
"}"
] |
[
"shows",
"options",
"dialog",
"with",
"the",
"node",
"denoted",
"by",
"\"",
"category",
"\"",
"being",
"displayed",
"the",
"value",
"is",
"expected",
"to",
"be",
"the",
"name",
"of",
"a",
"node",
"in",
"the",
"options",
"tree",
",",
"residing",
"under",
"the",
"root",
"node",
"you",
"may",
"also",
"provide",
"the",
"name",
"of",
"such",
"a",
"node",
",",
"followed",
"by",
"the",
"options",
"delimiter",
",",
"followed",
"by",
"the",
"name",
"of",
"a",
"child",
"node",
"under",
"that",
"node",
"for",
"example",
",",
"suppose",
"in",
"the",
"options",
"tree",
"exists",
"a",
"node",
"{",
"@",
"literal",
"root",
"-",
">",
"foo",
"}",
"you",
"may",
"pass",
"the",
"value",
"\"",
"foo",
"\"",
"to",
"get",
"that",
"node",
"or",
",",
"suppose",
"in",
"the",
"options",
"tree",
"exists",
"a",
"node",
"{",
"@",
"literal",
"root",
"-",
">",
"foo",
"-",
">",
"child",
"node",
"1",
"}",
"in",
"this",
"case",
",",
"you",
"may",
"pass",
"the",
"value",
"\"",
"foo",
"child",
"node",
"1",
"\"",
",",
"where",
"the",
"'",
"'",
"character",
"is",
"the",
"delimiter",
"of",
"the",
"{",
"@",
"link",
"tool",
"options",
"}",
"class",
"(",
"this",
"is",
"the",
"value",
"at",
"the",
"time",
"of",
"writing",
"this",
"documentation",
")",
"the",
"filter",
"text",
"parameter",
"is",
"used",
"to",
"set",
"the",
"contents",
"filter",
"text",
"of",
"the",
"options",
"you",
"may",
"use",
"this",
"parameter",
"to",
"filter",
"the",
"tree",
";",
"for",
"example",
",",
"to",
"show",
"only",
"the",
"node",
"in",
"the",
"tree",
"that",
"you",
"want",
"the",
"user",
"to",
"see"
] | [
"public",
"void",
"show",
"options",
"dialog",
"(",
"string",
"category",
",",
"string",
"filter",
"text",
")",
";"
] |
[
"get",
"capital",
"snake"
] | [
"public",
"string",
"get",
"capital",
"snake",
"(",
")",
"{",
"return",
"capital",
"snake",
";",
"}"
] |
[
"move",
"to",
"queue",
"will",
"invoke",
"scheduler",
"api",
"to",
"perform",
"move",
"queue",
"operation"
] | [
"public",
"void",
"move",
"application",
"across",
"queue",
"(",
"application",
"id",
"application",
"id",
",",
"string",
"target",
"queue",
")",
"throws",
"yarn",
"exception",
"{",
"r",
"m",
"app",
"app",
"=",
"this",
"rm",
"context",
"get",
"r",
"m",
"apps",
"(",
")",
"get",
"(",
"application",
"id",
")",
";",
"/",
"/",
"capacity",
"scheduler",
"will",
"directly",
"follow",
"below",
"approach",
"/",
"/",
"1",
"do",
"a",
"pre",
"-",
"validate",
"check",
"to",
"ensure",
"that",
"changes",
"are",
"fine",
"/",
"/",
"2",
"update",
"this",
"information",
"to",
"state",
"-",
"store",
"/",
"/",
"3",
"perform",
"real",
"move",
"operation",
"and",
"update",
"in",
"-",
"memory",
"data",
"structures",
"synchronized",
"(",
"application",
"id",
")",
"{",
"if",
"(",
"app",
"=",
"=",
"null",
"|",
"|",
"app",
"is",
"app",
"in",
"completed",
"states",
"(",
")",
")",
"{",
"return",
";",
"}",
"string",
"source",
"queue",
"=",
"app",
"get",
"queue",
"(",
")",
";",
"/",
"/",
"1",
"pre",
"-",
"validate",
"move",
"application",
"request",
"to",
"check",
"for",
"any",
"access",
"/",
"/",
"violations",
"or",
"other",
"errors",
"if",
"there",
"are",
"any",
"violations",
",",
"yarn",
"exception",
"/",
"/",
"will",
"be",
"thrown",
"rm",
"context",
"get",
"scheduler",
"(",
")",
"pre",
"validate",
"move",
"application",
"(",
"application",
"id",
",",
"target",
"queue",
")",
";",
"/",
"/",
"2",
"update",
"to",
"state",
"store",
"with",
"new",
"queue",
"and",
"throw",
"exception",
"is",
"failed",
"update",
"app",
"data",
"to",
"state",
"store",
"(",
"target",
"queue",
",",
"app",
",",
"false",
")",
";",
"/",
"/",
"3",
"perform",
"the",
"real",
"move",
"application",
"string",
"queue",
"=",
"\"",
"\"",
";",
"try",
"{",
"queue",
"=",
"rm",
"context",
"get",
"scheduler",
"(",
")",
"move",
"application",
"(",
"application",
"id",
",",
"target",
"queue",
")",
";",
"}",
"catch",
"(",
"yarn",
"exception",
"e",
")",
"{",
"/",
"/",
"revert",
"to",
"source",
"queue",
"since",
"in",
"-",
"memory",
"move",
"has",
"failed",
"chances",
"/",
"/",
"of",
"this",
"is",
"very",
"rare",
"as",
"we",
"have",
"already",
"done",
"the",
"pre",
"-",
"validation",
"update",
"app",
"data",
"to",
"state",
"store",
"(",
"source",
"queue",
",",
"app",
",",
"true",
")",
";",
"throw",
"e",
";",
"}",
"/",
"/",
"update",
"in",
"-",
"memory",
"if",
"(",
"queue",
"!",
"=",
"null",
"&",
"&",
"!",
"queue",
"is",
"empty",
"(",
")",
")",
"{",
"app",
"set",
"queue",
"(",
"queue",
")",
";",
"}",
"}",
"rm",
"context",
"get",
"system",
"metrics",
"publisher",
"(",
")",
"app",
"updated",
"(",
"app",
",",
"system",
"current",
"time",
"millis",
"(",
")",
")",
";",
"}"
] |
[
"verify",
"if",
"the",
"namespace",
"quota",
"is",
"violated",
"after",
"applying",
"delta"
] | [
"private",
"void",
"verify",
"namespace",
"quota",
"(",
"long",
"delta",
")",
"throws",
"n",
"s",
"quota",
"exceeded",
"exception",
"{",
"if",
"(",
"quota",
"is",
"violated",
"(",
"quota",
"get",
"name",
"space",
"(",
")",
",",
"usage",
"get",
"name",
"space",
"(",
")",
",",
"delta",
")",
")",
"{",
"throw",
"new",
"n",
"s",
"quota",
"exceeded",
"exception",
"(",
"quota",
"get",
"name",
"space",
"(",
")",
",",
"usage",
"get",
"name",
"space",
"(",
")",
"+",
"delta",
")",
";",
"}",
"}"
] |
[
"performed",
"a",
"non",
"-",
"recursive",
"audit",
"of",
"the",
"directory",
"-",
"require",
"the",
"directory",
"to",
"be",
"authoritative"
] | [
"private",
"void",
"expect",
"auth",
"non",
"recursive",
"(",
"path",
"path",
")",
"throws",
"exception",
"{",
"auditor",
"execute",
"audit",
"(",
"path",
",",
"true",
",",
"false",
")",
";",
"}"
] |
[
"revoke",
"the",
"provided",
"refresh",
"token",
"and",
"it",
"'",
"s",
"related",
"access",
"tokens"
] | [
"private",
"void",
"revoke",
"token",
"(",
"final",
"o",
"auth",
"2",
"0",
"refresh",
"token",
"token",
")",
"{",
"revoke",
"token",
"(",
"token",
"get",
"id",
"(",
")",
")",
";",
"token",
"get",
"access",
"tokens",
"(",
")",
"for",
"each",
"(",
"this",
":",
":",
"revoke",
"token",
")",
";",
"}"
] |
[
"create",
"a",
"new",
"set",
"of",
"test",
"entries",
"with",
"the",
"expected",
"result"
] | [
"public",
"stream",
"<",
"arguments",
">",
"expression",
"provider",
"(",
")",
"{",
"return",
"prepare",
"parameters",
"(",
"(",
"f",
",",
"s",
")",
"-",
">",
"f",
")",
";",
"}"
] |
[
"visits",
"the",
"end",
"of",
"the",
"field",
"this",
"method",
",",
"which",
"is",
"the",
"last",
"one",
"to",
"be",
"called",
",",
"is",
"used",
"to",
"inform",
"the",
"visitor",
"that",
"all",
"the",
"annotations",
"and",
"attributes",
"of",
"the",
"field",
"have",
"been",
"visited"
] | [
"public",
"void",
"visit",
"end",
"(",
")",
"{",
"if",
"(",
"fv",
"!",
"=",
"null",
")",
"{",
"fv",
"visit",
"end",
"(",
")",
";",
"}",
"}"
] |
[
"clears",
"the",
"current",
"tenant",
"identifier",
"settings"
] | [
"void",
"clear",
"current",
"tenant",
"id",
"(",
")",
";"
] |
[
"create",
"new",
"rejected",
"scheduling",
"request"
] | [
"public",
"static",
"rejected",
"scheduling",
"request",
"new",
"instance",
"(",
"rejection",
"reason",
"reason",
",",
"scheduling",
"request",
"request",
")",
"{",
"rejected",
"scheduling",
"request",
"instance",
"=",
"records",
"new",
"record",
"(",
"rejected",
"scheduling",
"request",
"class",
")",
";",
"instance",
"set",
"reason",
"(",
"reason",
")",
";",
"instance",
"set",
"request",
"(",
"request",
")",
";",
"return",
"instance",
";",
"}"
] |
[
"called",
"when",
"error",
"comes",
"from",
"rm",
"communications",
"as",
"well",
"as",
"from",
"errors",
"in",
"the",
"callback",
"itself",
"from",
"the",
"app",
"calling",
"stop",
"(",
")",
"is",
"the",
"recommended",
"action"
] | [
"void",
"on",
"error",
"(",
"throwable",
"e",
")",
";"
] |
[
"returns",
"the",
"second",
"program",
"being",
"compared",
"by",
"this",
"<",
"code",
">",
"program",
"diff",
"<",
"code",
">"
] | [
"public",
"program",
"get",
"program",
"two",
"(",
")",
"{",
"return",
"program",
"2",
";",
"}"
] |
[
"get",
"the",
"list",
"of",
"valid",
"cgroup",
"names"
] | [
"public",
"static",
"set",
"<",
"string",
">",
"get",
"valid",
"c",
"groups",
"(",
")",
"{",
"hash",
"set",
"<",
"string",
">",
"valid",
"cgroups",
"=",
"new",
"hash",
"set",
"<",
">",
"(",
")",
";",
"for",
"(",
"c",
"group",
"controller",
"controller",
":",
"c",
"group",
"controller",
"values",
"(",
")",
")",
"{",
"valid",
"cgroups",
"add",
"(",
"controller",
"get",
"name",
"(",
")",
")",
";",
"}",
"return",
"valid",
"cgroups",
";",
"}"
] |
[
"outputs",
"a",
"message",
"to",
"the",
"pdb",
"log",
"if",
"messaging",
"has",
"been",
"enable",
",",
"else",
"ignored",
"this",
"method",
"uses",
"a",
"format",
"string",
"and",
"a",
"variable",
"arguments",
"list",
"of",
"lambdas",
"to",
"allow",
"for",
"deferred",
"processing",
"of",
"the",
"message",
"to",
"output",
"thus",
",",
"when",
"message",
"output",
"is",
"disabled",
",",
"the",
"client",
"does",
"not",
"endure",
"as",
"much",
"cost",
"in",
"supplying",
"a",
"message",
"string",
"that",
"is",
"not",
"used"
] | [
"public",
"static",
"void",
"message",
"(",
"string",
"format",
",",
"supplier",
"<",
"string",
">",
"suppliers",
")",
"{",
"if",
"(",
"!",
"enabled",
")",
"{",
"return",
";",
"}",
"object",
"[",
"]",
"var",
"args",
"=",
"new",
"object",
"[",
"suppliers",
"length",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"suppliers",
"length",
";",
"i",
"+",
"+",
")",
"{",
"supplier",
"<",
"string",
">",
"supplier",
"=",
"suppliers",
"[",
"i",
"]",
";",
"string",
"var",
"=",
"supplier",
"get",
"(",
")",
"to",
"string",
"(",
")",
";",
"var",
"args",
"[",
"i",
"]",
"=",
"var",
";",
"}",
"try",
"{",
"writer",
"append",
"(",
"string",
"format",
"(",
"format",
",",
"var",
"args",
")",
")",
";",
"writer",
"append",
"(",
"\"",
"\\",
"n",
"\"",
")",
";",
"writer",
"flush",
"(",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"handle",
"i",
"o",
"exception",
"(",
"e",
")",
";",
"}",
"}"
] |
[
"checks",
"the",
"class",
"members",
"mentioned",
"in",
"the",
"given",
"class",
"member",
"specifications",
",",
"printing",
"notes",
"if",
"necessary"
] | [
"private",
"void",
"check",
"member",
"specifications",
"(",
"clazz",
"clazz",
",",
"list",
"member",
"specifications",
",",
"boolean",
"is",
"field",
")",
"{",
"if",
"(",
"member",
"specifications",
"!",
"=",
"null",
")",
"{",
"string",
"class",
"name",
"=",
"clazz",
"get",
"name",
"(",
")",
";",
"for",
"(",
"int",
"index",
"=",
"0",
";",
"index",
"<",
"member",
"specifications",
"size",
"(",
")",
";",
"index",
"+",
"+",
")",
"{",
"member",
"specification",
"member",
"specification",
"=",
"(",
"member",
"specification",
")",
"member",
"specifications",
"get",
"(",
"index",
")",
";",
"string",
"member",
"name",
"=",
"member",
"specification",
"name",
";",
"string",
"descriptor",
"=",
"member",
"specification",
"descriptor",
";",
"if",
"(",
"member",
"name",
"!",
"=",
"null",
"&",
"&",
"!",
"contains",
"wild",
"cards",
"(",
"member",
"name",
")",
"&",
"&",
"descriptor",
"!",
"=",
"null",
"&",
"&",
"!",
"contains",
"wild",
"cards",
"(",
"descriptor",
")",
")",
"{",
"if",
"(",
"is",
"field",
")",
"{",
"if",
"(",
"clazz",
"find",
"field",
"(",
"member",
"name",
",",
"descriptor",
")",
"=",
"=",
"null",
")",
"{",
"note",
"printer",
"print",
"(",
"class",
"name",
",",
"\"",
"note",
":",
"the",
"configuration",
"refers",
"to",
"the",
"unknown",
"field",
"'",
"\"",
"+",
"class",
"util",
"external",
"full",
"field",
"description",
"(",
"0",
",",
"member",
"name",
",",
"descriptor",
")",
"+",
"\"",
"'",
"in",
"class",
"'",
"\"",
"+",
"class",
"util",
"external",
"class",
"name",
"(",
"class",
"name",
")",
"+",
"\"",
"'",
"\"",
")",
";",
"}",
"}",
"else",
"{",
"if",
"(",
"clazz",
"find",
"method",
"(",
"member",
"name",
",",
"descriptor",
")",
"=",
"=",
"null",
")",
"{",
"note",
"printer",
"print",
"(",
"class",
"name",
",",
"\"",
"note",
":",
"the",
"configuration",
"refers",
"to",
"the",
"unknown",
"method",
"'",
"\"",
"+",
"class",
"util",
"external",
"full",
"method",
"description",
"(",
"class",
"name",
",",
"0",
",",
"member",
"name",
",",
"descriptor",
")",
"+",
"\"",
"'",
"in",
"class",
"'",
"\"",
"+",
"class",
"util",
"external",
"class",
"name",
"(",
"class",
"name",
")",
"+",
"\"",
"'",
"\"",
")",
";",
"}",
"}",
"}",
"}",
"}",
"}"
] |
[
"get",
"storeorder",
"{",
"order",
"id",
"}",
":",
"find",
"purchase",
"order",
"by",
"id",
"for",
"valid",
"response",
"try",
"integer",
"i",
"ds",
"with",
"value",
"&",
"lt",
";",
"&",
"#",
"x",
"3",
"d",
";",
"5",
"or",
"&",
"gt",
";",
"10",
"other",
"values",
"will",
"generated",
"exceptions"
] | [
"public",
"response",
"entity",
"<",
"order",
">",
"get",
"order",
"by",
"id",
"(",
"@",
"min",
"(",
"1l",
")",
"@",
"max",
"(",
"5l",
")",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"id",
"of",
"pet",
"that",
"needs",
"to",
"be",
"fetched",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"path",
"variable",
"(",
"\"",
"order",
"id",
"\"",
")",
"long",
"order",
"id",
")",
"{",
"return",
"delegate",
"get",
"order",
"by",
"id",
"(",
"order",
"id",
")",
";",
"}"
] |
[
"validates",
"the",
"required",
"and",
"optional",
"{",
"@",
"link",
"config",
"option",
"}",
"s",
"of",
"a",
"factory",
"note",
":",
"it",
"does",
"not",
"check",
"for",
"left",
"-",
"over",
"options"
] | [
"public",
"static",
"void",
"validate",
"factory",
"options",
"(",
"factory",
"factory",
",",
"readable",
"config",
"options",
")",
"{",
"validate",
"factory",
"options",
"(",
"factory",
"required",
"options",
"(",
")",
",",
"factory",
"optional",
"options",
"(",
")",
",",
"options",
")",
";",
"}"
] |
[
"calls",
"this",
"method",
",",
"which",
"must",
"have",
"{",
"@",
"code",
"struct",
"field",
"=",
"true",
"}"
] | [
"object",
"call",
"field",
"(",
"object",
"obj",
",",
"starlark",
"semantics",
"semantics",
",",
"@",
"nullable",
"mutability",
"mu",
")",
"throws",
"eval",
"exception",
",",
"interrupted",
"exception",
"{",
"if",
"(",
"!",
"struct",
"field",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"not",
"a",
"struct",
"field",
":",
"\"",
"+",
"name",
")",
";",
"}",
"object",
"[",
"]",
"args",
"=",
"use",
"starlark",
"semantics",
"?",
"new",
"object",
"[",
"]",
"{",
"semantics",
"}",
":",
"empty",
";",
"return",
"call",
"(",
"obj",
",",
"args",
",",
"mu",
")",
";",
"}"
] |
[
"sends",
"out",
"an",
"arbitrary",
"html",
"fragment"
] | [
"public",
"void",
"respond",
"(",
"string",
"html",
")",
"throws",
"i",
"o",
"exception",
",",
"servlet",
"exception",
"{",
"response",
"set",
"content",
"type",
"(",
"\"",
"text",
"/",
"html",
"\"",
")",
";",
"response",
"get",
"writer",
"(",
")",
"print",
"(",
"html",
")",
";",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.