docstring_tokens
list | code_tokens
list |
|---|---|
[
"creates",
"a",
"blocking",
"stub",
"for",
"csi",
"node",
"plugin",
"on",
"the",
"given",
"channel"
] | [
"public",
"node",
"grpc",
"node",
"blocking",
"stub",
"create",
"node",
"blocking",
"stub",
"(",
")",
"{",
"return",
"node",
"grpc",
"new",
"blocking",
"stub",
"(",
"channel",
")",
";",
"}"
] |
[
"stop",
"game",
"loop"
] | [
"public",
"void",
"stop",
"(",
")",
"{",
"logger",
"info",
"(",
"\"",
"stop",
"game",
"\"",
")",
";",
"is",
"running",
"=",
"false",
";",
"}"
] |
[
"add",
"a",
"filter",
"to",
"actions",
",",
"preventing",
"things",
"such",
"as",
"breaking",
"or",
"configuring",
"blocks"
] | [
"public",
"void",
"add",
"action",
"filter",
"(",
"action",
"filter",
"filter",
")",
"{",
"action",
"filters",
"add",
"(",
"filter",
")",
";",
"}"
] |
[
"called",
"whenever",
"image",
"request",
"fails",
",",
"that",
"is",
"whenever",
"failure",
"drawable",
"is",
"set"
] | [
"public",
"void",
"report",
"failure",
"(",
"long",
"wait",
"time",
")",
"{",
"m",
"sum",
"of",
"wait",
"time",
"+",
"=",
"wait",
"time",
";",
"m",
"failed",
"requests",
"+",
"+",
";",
"}"
] |
[
"finds",
"pets",
"by",
"status",
"multiple",
"status",
"values",
"can",
"be",
"provided",
"with",
"comma",
"separated",
"strings"
] | [
"public",
"list",
"<",
"pet",
">",
"find",
"pets",
"by",
"status",
"(",
"@",
"query",
"param",
"(",
"\"",
"status",
"\"",
")",
"list",
"<",
"string",
">",
"status",
")",
";"
] |
[
"asynchronously",
"gets",
"one",
"or",
"more",
"aliases",
"using",
"the",
"get",
"index",
"aliases",
"api",
"see",
"<",
"a",
"href",
"=",
"\"",
"https",
":",
"www",
"elastic",
"coguideenelasticsearchreferencecurrentindices",
"-",
"aliases",
"html",
"\"",
">",
"indices",
"aliases",
"api",
"on",
"elastic",
"co"
] | [
"public",
"cancellable",
"get",
"alias",
"async",
"(",
"get",
"aliases",
"request",
"get",
"aliases",
"request",
",",
"request",
"options",
"options",
",",
"action",
"listener",
"<",
"get",
"aliases",
"response",
">",
"listener",
")",
"{",
"return",
"rest",
"high",
"level",
"client",
"perform",
"request",
"async",
"and",
"parse",
"entity",
"(",
"get",
"aliases",
"request",
",",
"indices",
"request",
"converters",
":",
":",
"get",
"alias",
",",
"options",
",",
"get",
"aliases",
"response",
":",
":",
"from",
"x",
"content",
",",
"listener",
",",
"singleton",
"(",
"rest",
"status",
"not",
"found",
"get",
"status",
"(",
")",
")",
")",
";",
"}"
] |
[
"tests",
"context",
"set",
"status",
"method",
"todo",
"fix",
"testcase"
] | [
"public",
"void",
"test",
"context",
"status",
"(",
")",
"throws",
"i",
"o",
"exception",
",",
"interrupted",
"exception",
",",
"class",
"not",
"found",
"exception",
"{",
"path",
"test",
"=",
"new",
"path",
"(",
"test",
"root",
"temp",
"dir",
",",
"\"",
"test",
"context",
"status",
"\"",
")",
";",
"/",
"/",
"test",
"with",
"1",
"map",
"and",
"0",
"reducers",
"/",
"/",
"test",
"with",
"custom",
"task",
"status",
"int",
"num",
"maps",
"=",
"1",
";",
"job",
"job",
"=",
"map",
"reduce",
"test",
"util",
"create",
"job",
"(",
"create",
"job",
"conf",
"(",
")",
",",
"new",
"path",
"(",
"test",
",",
"\"",
"in",
"\"",
")",
",",
"new",
"path",
"(",
"test",
",",
"\"",
"out",
"\"",
")",
",",
"num",
"maps",
",",
"0",
")",
";",
"job",
"set",
"mapper",
"class",
"(",
"my",
"mapper",
"class",
")",
";",
"job",
"wait",
"for",
"completion",
"(",
"true",
")",
";",
"assert",
"true",
"(",
"\"",
"job",
"failed",
"\"",
",",
"job",
"is",
"successful",
"(",
")",
")",
";",
"task",
"report",
"[",
"]",
"reports",
"=",
"job",
"get",
"task",
"reports",
"(",
"task",
"type",
"map",
")",
";",
"assert",
"equals",
"(",
"num",
"maps",
",",
"reports",
"length",
")",
";",
"assert",
"equals",
"(",
"my",
"status",
",",
"reports",
"[",
"0",
"]",
"get",
"state",
"(",
")",
")",
";",
"/",
"/",
"test",
"with",
"1",
"map",
"and",
"1",
"reducer",
"/",
"/",
"test",
"with",
"default",
"task",
"status",
"int",
"num",
"reduces",
"=",
"1",
";",
"job",
"=",
"map",
"reduce",
"test",
"util",
"create",
"job",
"(",
"create",
"job",
"conf",
"(",
")",
",",
"new",
"path",
"(",
"test",
",",
"\"",
"in",
"\"",
")",
",",
"new",
"path",
"(",
"test",
",",
"\"",
"out",
"\"",
")",
",",
"num",
"maps",
",",
"num",
"reduces",
")",
";",
"job",
"set",
"mapper",
"class",
"(",
"data",
"copy",
"mapper",
"class",
")",
";",
"job",
"set",
"reducer",
"class",
"(",
"data",
"copy",
"reducer",
"class",
")",
";",
"job",
"set",
"map",
"output",
"key",
"class",
"(",
"text",
"class",
")",
";",
"job",
"set",
"map",
"output",
"value",
"class",
"(",
"text",
"class",
")",
";",
"job",
"set",
"output",
"key",
"class",
"(",
"text",
"class",
")",
";",
"job",
"set",
"output",
"value",
"class",
"(",
"text",
"class",
")",
";",
"/",
"/",
"fail",
"early",
"job",
"set",
"max",
"map",
"attempts",
"(",
"1",
")",
";",
"job",
"set",
"max",
"reduce",
"attempts",
"(",
"0",
")",
";",
"/",
"/",
"run",
"the",
"job",
"and",
"wait",
"for",
"completion",
"job",
"wait",
"for",
"completion",
"(",
"true",
")",
";",
"assert",
"true",
"(",
"\"",
"job",
"failed",
"\"",
",",
"job",
"is",
"successful",
"(",
")",
")",
";",
"/",
"/",
"check",
"map",
"task",
"reports",
"/",
"/",
"todo",
"fix",
"testcase",
"/",
"/",
"disabling",
"checks",
"for",
"now",
"to",
"get",
"builds",
"to",
"run",
"/",
"*",
"reports",
"=",
"job",
"get",
"task",
"reports",
"(",
"task",
"type",
"map",
")",
";",
"assert",
"equals",
"(",
"num",
"maps",
",",
"reports",
"length",
")",
";",
"assert",
"equals",
"(",
"\"",
"map",
">",
"sort",
"\"",
",",
"reports",
"[",
"0",
"]",
"get",
"state",
"(",
")",
")",
";",
"/",
"/",
"check",
"reduce",
"task",
"reports",
"reports",
"=",
"job",
"get",
"task",
"reports",
"(",
"task",
"type",
"reduce",
")",
";",
"assert",
"equals",
"(",
"num",
"reduces",
",",
"reports",
"length",
")",
";",
"assert",
"equals",
"(",
"\"",
"reduce",
">",
"reduce",
"\"",
",",
"reports",
"[",
"0",
"]",
"get",
"state",
"(",
")",
")",
";",
"*",
"/",
"}"
] |
[
"inserts",
"all",
"mappings",
"from",
"the",
"specified",
"map",
"to",
"this",
"map",
"view"
] | [
"public",
"void",
"put",
"all",
"(",
"map",
"<",
"k",
",",
"v",
">",
"map",
")",
"throws",
"exception",
"{",
"this",
"map",
"put",
"all",
"(",
"map",
")",
";",
"}"
] |
[
"returns",
"a",
"listener",
"that",
"should",
"be",
"called",
"on",
"engine",
"failure"
] | [
"public",
"engine",
"event",
"listener",
"get",
"event",
"listener",
"(",
")",
"{",
"return",
"event",
"listener",
";",
"}"
] |
[
"gracefully",
"close",
"this",
"client",
"we",
"will",
"send",
"all",
"existing",
"requests",
",",
"and",
"then",
"invoke",
"close",
"n",
"release",
"(",
")",
"method"
] | [
"public",
"synchronized",
"void",
"close",
"(",
")",
"{",
"if",
"(",
"!",
"being",
"closed",
"get",
"(",
")",
")",
"{",
"/",
"/",
"enqueue",
"a",
"close",
"message",
"so",
"that",
"shutdown",
"(",
")",
"will",
"be",
"invoked",
"try",
"{",
"message",
"queue",
"put",
"(",
"control",
"message",
"close",
"message",
")",
";",
"being",
"closed",
"set",
"(",
"true",
")",
";",
"}",
"catch",
"(",
"interrupted",
"exception",
"e",
")",
"{",
"close",
"n",
"release",
"(",
")",
";",
"}",
"}",
"}"
] |
[
"for",
"this",
"test",
",",
"the",
"body",
"for",
"this",
"request",
"much",
"reference",
"a",
"schema",
"named",
"&",
"#",
"x",
"6",
"0",
";",
"file",
"&",
"#",
"x",
"6",
"0",
";",
"<",
"b",
">",
"200",
"<",
"b",
">",
"-",
"success"
] | [
"public",
"void",
"test",
"body",
"with",
"file",
"schema",
"(",
"file",
"schema",
"test",
"class",
"body",
")",
"throws",
"i",
"o",
"exception",
"{",
"test",
"body",
"with",
"file",
"schema",
"for",
"http",
"response",
"(",
"body",
")",
";",
"}"
] |
[
"change",
"the",
"versioned",
"filesystem",
"associated",
"with",
"this",
"project",
"file",
"manager",
"this",
"method",
"is",
"provided",
"for",
"testing",
"care",
"should",
"be",
"taken",
"when",
"using",
"a",
"local",
"file",
"system",
"in",
"a",
"shared",
"capacity",
"since",
"locking",
"is",
"not",
"supported"
] | [
"void",
"set",
"versioned",
"file",
"system",
"(",
"file",
"system",
"fs",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"!",
"fs",
"is",
"versioned",
"(",
")",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"versioned",
"filesystem",
"required",
"\"",
")",
";",
"}",
"versioned",
"file",
"system",
"remove",
"file",
"system",
"listener",
"(",
"versioned",
"f",
"s",
"listener",
")",
";",
"versioned",
"file",
"system",
"=",
"fs",
";",
"versioned",
"file",
"system",
"add",
"file",
"system",
"listener",
"(",
"versioned",
"f",
"s",
"listener",
")",
";",
"root",
"folder",
"data",
"set",
"versioned",
"file",
"system",
"(",
"versioned",
"file",
"system",
")",
";",
"}"
] |
[
"returns",
"a",
"file",
"handle",
"to",
"the",
"file",
"associated",
"with",
"the",
"given",
"blob",
"key",
"on",
"the",
"blob",
"server"
] | [
"public",
"file",
"get",
"storage",
"location",
"(",
"@",
"nullable",
"job",
"i",
"d",
"job",
"id",
",",
"blob",
"key",
"key",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"blob",
"utils",
"get",
"storage",
"location",
"(",
"storage",
"dir",
",",
"job",
"id",
",",
"key",
")",
";",
"}"
] |
[
"add",
"a",
"default",
"header"
] | [
"public",
"api",
"client",
"add",
"default",
"header",
"(",
"string",
"key",
",",
"string",
"value",
")",
"{",
"default",
"header",
"map",
"put",
"(",
"key",
",",
"value",
")",
";",
"return",
"this",
";",
"}"
] |
[
"http",
":",
"gbiv",
"comprotocolsurirfcrfc",
"2",
"3",
"9",
"6",
"html",
"#",
"rfc",
"section",
"c",
"1"
] | [
"public",
"void",
"test",
"rfc",
"2",
"3",
"9",
"6",
"normal",
"(",
")",
"{",
"assert",
"equals",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"g",
"\"",
",",
"simplify",
"path",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"g",
"\"",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"g",
"\"",
",",
"simplify",
"path",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"/",
"g",
"\"",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"g",
"\"",
",",
"simplify",
"path",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"g",
"/",
"\"",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"g",
"?",
"y",
"\"",
",",
"simplify",
"path",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"g",
"?",
"y",
"\"",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"g",
"#",
"s",
"\"",
",",
"simplify",
"path",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"g",
"#",
"s",
"\"",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"g",
"?",
"y",
"#",
"s",
"\"",
",",
"simplify",
"path",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"g",
"?",
"y",
"#",
"s",
"\"",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
";",
"x",
"\"",
",",
"simplify",
"path",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
";",
"x",
"\"",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"g",
";",
"x",
"\"",
",",
"simplify",
"path",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"g",
";",
"x",
"\"",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"g",
";",
"x",
"?",
"y",
"#",
"s",
"\"",
",",
"simplify",
"path",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"g",
";",
"x",
"?",
"y",
"#",
"s",
"\"",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"\"",
",",
"simplify",
"path",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"\"",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"\"",
",",
"simplify",
"path",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"/",
"\"",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"/",
"a",
"/",
"b",
"\"",
",",
"simplify",
"path",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"\"",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"/",
"a",
"/",
"b",
"\"",
",",
"simplify",
"path",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"/",
"\"",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"g",
"\"",
",",
"simplify",
"path",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"/",
"g",
"\"",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"/",
"a",
"\"",
",",
"simplify",
"path",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"/",
"\"",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"/",
"a",
"\"",
",",
"simplify",
"path",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"/",
"/",
"\"",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"/",
"a",
"/",
"g",
"\"",
",",
"simplify",
"path",
"(",
"\"",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"/",
"/",
"g",
"\"",
")",
")",
";",
"}"
] |
[
"enables",
"the",
"accumulation",
"of",
"{",
"@",
"link",
"cache",
"stats",
"}",
"during",
"the",
"operation",
"of",
"the",
"cache",
"without",
"this",
"{",
"@",
"link",
"cache",
"#",
"stats",
"}",
"will",
"return",
"zero",
"for",
"all",
"statistics",
"note",
"that",
"recording",
"statistics",
"requires",
"bookkeeping",
"to",
"be",
"performed",
"with",
"each",
"operation",
",",
"and",
"thus",
"imposes",
"a",
"performance",
"penalty",
"on",
"cache",
"operation",
"any",
"exception",
"thrown",
"by",
"the",
"supplied",
"{",
"@",
"link",
"stats",
"counter",
"}",
"will",
"be",
"suppressed",
"and",
"logged"
] | [
"public",
"caffeine",
"<",
"k",
",",
"v",
">",
"record",
"stats",
"(",
"@",
"non",
"null",
"supplier",
"<",
"?",
"extends",
"stats",
"counter",
">",
"stats",
"counter",
"supplier",
")",
"{",
"require",
"state",
"(",
"this",
"stats",
"counter",
"supplier",
"=",
"=",
"null",
",",
"\"",
"statistics",
"recording",
"was",
"already",
"set",
"\"",
")",
";",
"require",
"non",
"null",
"(",
"stats",
"counter",
"supplier",
")",
";",
"this",
"stats",
"counter",
"supplier",
"=",
"(",
")",
"-",
">",
"stats",
"counter",
"guarded",
"stats",
"counter",
"(",
"stats",
"counter",
"supplier",
"get",
"(",
")",
")",
";",
"return",
"this",
";",
"}"
] |
[
"only",
"support",
"auto",
"load",
"libarmeabi",
"-",
"v",
"7a",
"library",
"from",
"patch",
"in",
"some",
"process",
",",
"you",
"may",
"not",
"want",
"to",
"install",
"tinker",
"and",
"you",
"can",
"load",
"patch",
"dex",
"and",
"library",
"without",
"install",
"tinker",
"!",
"}"
] | [
"public",
"static",
"void",
"load",
"arm",
"v",
"7a",
"library",
"(",
"application",
"like",
"application",
"like",
",",
"string",
"lib",
"name",
")",
"{",
"if",
"(",
"lib",
"name",
"=",
"=",
"null",
"|",
"|",
"lib",
"name",
"is",
"empty",
"(",
")",
"|",
"|",
"application",
"like",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"tinker",
"runtime",
"exception",
"(",
"\"",
"lib",
"name",
"or",
"context",
"is",
"null",
"!",
"\"",
")",
";",
"}",
"if",
"(",
"tinker",
"application",
"helper",
"is",
"tinker",
"enable",
"for",
"native",
"lib",
"(",
"application",
"like",
")",
")",
"{",
"if",
"(",
"tinker",
"application",
"helper",
"load",
"library",
"from",
"tinker",
"(",
"application",
"like",
",",
"\"",
"lib",
"/",
"armeabi",
"-",
"v",
"7a",
"\"",
",",
"lib",
"name",
")",
")",
"{",
"return",
";",
"}",
"}",
"system",
"load",
"library",
"(",
"lib",
"name",
")",
";",
"}"
] |
[
"filters",
"out",
"a",
"chat",
"message"
] | [
"public",
"@",
"nullable",
"string",
"filter",
"message",
"(",
"player",
"player",
",",
"string",
"message",
")",
"{",
"string",
"current",
"=",
"message",
";",
"for",
"(",
"chat",
"filter",
"f",
":",
"chat",
"filters",
")",
"{",
"current",
"=",
"f",
"filter",
"(",
"player",
",",
"current",
")",
";",
"if",
"(",
"current",
"=",
"=",
"null",
")",
"return",
"null",
";",
"}",
"return",
"current",
";",
"}"
] |
[
"retrieves",
"the",
"vertex",
"in",
"-",
"degree",
"(",
"number",
"of",
"in",
"-",
"coming",
"edges",
")"
] | [
"public",
"long",
"get",
"in",
"degree",
"(",
")",
"{",
"return",
"in",
"degree",
";",
"}"
] |
[
"returns",
"the",
"bootstrap",
"'",
"s",
"{",
"@",
"link",
"application",
"}"
] | [
"public",
"application",
"<",
"t",
">",
"get",
"application",
"(",
")",
"{",
"return",
"application",
";",
"}"
] |
[
"register",
"a",
"listener",
"that",
"will",
"be",
"called",
"when",
"this",
"model",
"visibility",
"has",
"changed",
"the",
"listener",
"will",
"contribute",
"to",
"this",
"model",
"'",
"s",
"hash",
"code",
"state",
"per",
"the",
"{",
"@",
"link",
"com",
"airbnb",
"epoxy",
"epoxy",
"attribute",
"option",
"#",
"do",
"not",
"hash",
"}",
"rules"
] | [
"public",
"epoxy",
"model",
"group",
"with",
"annotations",
"on",
"visibility",
"changed",
"(",
"on",
"model",
"visibility",
"changed",
"listener",
"<",
"epoxy",
"model",
"group",
"with",
"annotations",
",",
"model",
"group",
"holder",
">",
"listener",
")",
"{",
"on",
"mutation",
"(",
")",
";",
"this",
"on",
"model",
"visibility",
"changed",
"listener",
"epoxy",
"generated",
"model",
"=",
"listener",
";",
"return",
"this",
";",
"}"
] |
[
"determine",
"if",
"the",
"indicated",
"data",
"type",
"can",
"be",
"edited",
"(",
"i",
"e",
"it",
"has",
"an",
"editor",
"that",
"this",
"service",
"knows",
"how",
"to",
"invoke",
")"
] | [
"public",
"boolean",
"is",
"editable",
"(",
"data",
"type",
"dt",
")",
"{",
"if",
"(",
"(",
"dt",
"instanceof",
"enum",
")",
"|",
"|",
"(",
"dt",
"instanceof",
"union",
")",
"|",
"|",
"(",
"dt",
"instanceof",
"structure",
")",
")",
"{",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}"
] |
[
"register",
"a",
"listener",
"that",
"will",
"be",
"called",
"when",
"this",
"model",
"is",
"bound",
"to",
"a",
"view",
"the",
"listener",
"will",
"contribute",
"to",
"this",
"model",
"'",
"s",
"hash",
"code",
"state",
"per",
"the",
"{",
"@",
"link",
"com",
"airbnb",
"epoxy",
"epoxy",
"attribute",
"option",
"#",
"do",
"not",
"hash",
"}",
"rules",
"you",
"may",
"clear",
"the",
"listener",
"by",
"setting",
"a",
"null",
"value",
",",
"or",
"by",
"calling",
"{",
"@",
"link",
"#",
"reset",
"(",
")",
"}"
] | [
"public",
"model",
"with",
"type",
"<",
"t",
">",
"on",
"bind",
"(",
"on",
"model",
"bound",
"listener",
"<",
"model",
"with",
"type",
"<",
"t",
">",
",",
"object",
">",
"listener",
")",
"{",
"on",
"mutation",
"(",
")",
";",
"this",
"on",
"model",
"bound",
"listener",
"epoxy",
"generated",
"model",
"=",
"listener",
";",
"return",
"this",
";",
"}"
] |
[
"in",
"the",
"following",
"test",
",",
"we",
"verify",
"that",
"we",
"can",
"handle",
"the",
"case",
"that",
"we",
"got",
"a",
"commit",
"of",
"a",
"request",
"we",
"never",
"seen",
"since",
"the",
"session",
"that",
"we",
"just",
"established",
"this",
"can",
"happen",
"when",
"a",
"session",
"is",
"just",
"established",
"and",
"there",
"is",
"request",
"waiting",
"to",
"be",
"committed",
"in",
"the",
"session",
"queue",
"but",
"it",
"sees",
"a",
"commit",
"for",
"a",
"request",
"that",
"belongs",
"to",
"the",
"previous",
"connection"
] | [
"public",
"void",
"no",
"crash",
"on",
"committed",
"requests",
"of",
"unseen",
"request",
"test",
"(",
")",
"throws",
"exception",
"{",
"final",
"string",
"path",
"=",
"\"",
"/",
"no",
"crash",
"/",
"on",
"committed",
"requests",
"/",
"of",
"unseen",
"request",
"test",
"\"",
";",
"final",
"int",
"numberof",
"reads",
"=",
"10",
";",
"final",
"int",
"sessionid",
"=",
"0x",
"1",
"2",
"3",
"4",
"5",
"6",
";",
"final",
"int",
"first",
"c",
"xid",
"=",
"0x",
"1",
"0",
"0",
";",
"int",
"read",
"req",
"id",
"=",
"first",
"c",
"xid",
";",
"processor",
"stopped",
"main",
"loop",
"=",
"true",
";",
"hash",
"set",
"<",
"request",
">",
"local",
"requests",
"=",
"new",
"hash",
"set",
"<",
"request",
">",
"(",
")",
";",
"/",
"/",
"queue",
"the",
"blocking",
"write",
"request",
"to",
"queued",
"requests",
"request",
"first",
"committed",
"req",
"=",
"new",
"request",
"(",
"new",
"create",
"request",
"(",
"path",
",",
"new",
"byte",
"[",
"0",
"]",
",",
"ids",
"open",
"acl",
"unsafe",
",",
"create",
"mode",
"persistent",
"sequential",
"to",
"flag",
"(",
")",
")",
",",
"op",
"code",
"create",
",",
"sessionid",
",",
"read",
"req",
"id",
"+",
"+",
")",
";",
"processor",
"queued",
"requests",
"add",
"(",
"first",
"committed",
"req",
")",
";",
"processor",
"queued",
"write",
"requests",
"add",
"(",
"first",
"committed",
"req",
")",
";",
"local",
"requests",
"add",
"(",
"first",
"committed",
"req",
")",
";",
"/",
"/",
"queue",
"read",
"requests",
"to",
"queued",
"requests",
"for",
"(",
";",
"read",
"req",
"id",
"<",
"=",
"numberof",
"reads",
"+",
"first",
"c",
"xid",
";",
"+",
"+",
"read",
"req",
"id",
")",
"{",
"request",
"read",
"req",
"=",
"new",
"request",
"(",
"new",
"get",
"data",
"request",
"(",
"path",
",",
"false",
")",
",",
"op",
"code",
"get",
"data",
",",
"sessionid",
",",
"read",
"req",
"id",
")",
";",
"processor",
"queued",
"requests",
"add",
"(",
"read",
"req",
")",
";",
"local",
"requests",
"add",
"(",
"read",
"req",
")",
";",
"}",
"/",
"/",
"run",
"once",
"assert",
"true",
"(",
"processor",
"queued",
"requests",
"contains",
"all",
"(",
"local",
"requests",
")",
")",
";",
"processor",
"init",
"threads",
"(",
"default",
"size",
"of",
"thread",
"pool",
")",
";",
"processor",
"run",
"(",
")",
";",
"thread",
"sleep",
"(",
"1000",
")",
";",
"/",
"/",
"we",
"verify",
"that",
"the",
"processor",
"is",
"waiting",
"for",
"the",
"commit",
"assert",
"true",
"(",
"processed",
"requests",
"is",
"empty",
"(",
")",
")",
";",
"/",
"/",
"we",
"add",
"a",
"commit",
"that",
"belongs",
"to",
"the",
"same",
"session",
"but",
"with",
"smaller",
"cxid",
",",
"/",
"/",
"i",
"e",
",",
"commit",
"of",
"an",
"update",
"from",
"previous",
"connection",
"of",
"this",
"session",
"request",
"pre",
"session",
"committed",
"req",
"=",
"new",
"request",
"(",
"new",
"create",
"request",
"(",
"path",
",",
"new",
"byte",
"[",
"0",
"]",
",",
"ids",
"open",
"acl",
"unsafe",
",",
"create",
"mode",
"persistent",
"sequential",
"to",
"flag",
"(",
")",
")",
",",
"op",
"code",
"create",
",",
"sessionid",
",",
"first",
"c",
"xid",
"-",
"2",
")",
";",
"processor",
"committed",
"requests",
"add",
"(",
"pre",
"session",
"committed",
"req",
")",
";",
"processor",
"committed",
"requests",
"add",
"(",
"first",
"committed",
"req",
")",
";",
"processor",
"run",
"(",
")",
";",
"thread",
"sleep",
"(",
"1000",
")",
";",
"/",
"/",
"we",
"verify",
"that",
"the",
"commit",
"processor",
"processed",
"the",
"old",
"commit",
"prior",
"to",
"the",
"newer",
"messages",
"assert",
"true",
"(",
"processed",
"requests",
"peek",
"(",
")",
"=",
"=",
"pre",
"session",
"committed",
"req",
")",
";",
"processor",
"run",
"(",
")",
";",
"thread",
"sleep",
"(",
"1000",
")",
";",
"/",
"/",
"we",
"verify",
"that",
"the",
"commit",
"processor",
"handle",
"all",
"messages",
"assert",
"true",
"(",
"processed",
"requests",
"contains",
"all",
"(",
"local",
"requests",
")",
")",
";",
"}"
] |
[
"called",
"when",
"the",
"renderer",
"is",
"enabled",
"the",
"default",
"implementation",
"is",
"a",
"no",
"-",
"op"
] | [
"protected",
"void",
"on",
"enabled",
"(",
"boolean",
"joining",
")",
"throws",
"exo",
"playback",
"exception",
"{",
"/",
"/",
"do",
"nothing",
"}"
] |
[
"updated",
"user",
"this",
"can",
"only",
"be",
"done",
"by",
"the",
"logged",
"in",
"user"
] | [
"public",
"void",
"update",
"user",
"(",
"string",
"username",
",",
"user",
"body",
")",
"throws",
"api",
"exception",
"{",
"update",
"user",
"with",
"http",
"info",
"(",
"username",
",",
"body",
")",
";",
"}"
] |
[
"convert",
"read",
"operation",
"interface",
"or",
"write",
"operation",
"interface",
"to",
"the",
"implementation",
"class",
"get",
"the",
"method",
"name",
"and",
"filter",
"info"
] | [
"public",
"static",
"string",
"get",
"trace",
"param",
"(",
"object",
"obj",
")",
"{",
"if",
"(",
"obj",
"instanceof",
"count",
"operation",
")",
"{",
"bson",
"document",
"filter",
"=",
"(",
"(",
"count",
"operation",
")",
"obj",
")",
"get",
"filter",
"(",
")",
";",
"return",
"limit",
"filter",
"(",
"filter",
"to",
"string",
"(",
")",
")",
";",
"}",
"else",
"if",
"(",
"obj",
"instanceof",
"distinct",
"operation",
")",
"{",
"bson",
"document",
"filter",
"=",
"(",
"(",
"distinct",
"operation",
")",
"obj",
")",
"get",
"filter",
"(",
")",
";",
"return",
"limit",
"filter",
"(",
"filter",
"to",
"string",
"(",
")",
")",
";",
"}",
"else",
"if",
"(",
"obj",
"instanceof",
"find",
"operation",
")",
"{",
"bson",
"document",
"filter",
"=",
"(",
"(",
"find",
"operation",
")",
"obj",
")",
"get",
"filter",
"(",
")",
";",
"return",
"limit",
"filter",
"(",
"filter",
"to",
"string",
"(",
")",
")",
";",
"}",
"else",
"if",
"(",
"obj",
"instanceof",
"group",
"operation",
")",
"{",
"bson",
"document",
"filter",
"=",
"(",
"(",
"group",
"operation",
")",
"obj",
")",
"get",
"filter",
"(",
")",
";",
"return",
"limit",
"filter",
"(",
"filter",
"to",
"string",
"(",
")",
")",
";",
"}",
"else",
"if",
"(",
"obj",
"instanceof",
"list",
"collections",
"operation",
")",
"{",
"bson",
"document",
"filter",
"=",
"(",
"(",
"list",
"collections",
"operation",
")",
"obj",
")",
"get",
"filter",
"(",
")",
";",
"return",
"limit",
"filter",
"(",
"filter",
"to",
"string",
"(",
")",
")",
";",
"}",
"else",
"if",
"(",
"obj",
"instanceof",
"map",
"reduce",
"with",
"inline",
"results",
"operation",
")",
"{",
"bson",
"document",
"filter",
"=",
"(",
"(",
"map",
"reduce",
"with",
"inline",
"results",
"operation",
")",
"obj",
")",
"get",
"filter",
"(",
")",
";",
"return",
"limit",
"filter",
"(",
"filter",
"to",
"string",
"(",
")",
")",
";",
"}",
"else",
"if",
"(",
"obj",
"instanceof",
"delete",
"operation",
")",
"{",
"list",
"<",
"delete",
"request",
">",
"write",
"request",
"list",
"=",
"(",
"(",
"delete",
"operation",
")",
"obj",
")",
"get",
"delete",
"requests",
"(",
")",
";",
"return",
"get",
"filter",
"(",
"write",
"request",
"list",
")",
";",
"}",
"else",
"if",
"(",
"obj",
"instanceof",
"insert",
"operation",
")",
"{",
"list",
"<",
"insert",
"request",
">",
"write",
"request",
"list",
"=",
"(",
"(",
"insert",
"operation",
")",
"obj",
")",
"get",
"insert",
"requests",
"(",
")",
";",
"return",
"get",
"filter",
"(",
"write",
"request",
"list",
")",
";",
"}",
"else",
"if",
"(",
"obj",
"instanceof",
"update",
"operation",
")",
"{",
"list",
"<",
"update",
"request",
">",
"write",
"request",
"list",
"=",
"(",
"(",
"update",
"operation",
")",
"obj",
")",
"get",
"update",
"requests",
"(",
")",
";",
"return",
"get",
"filter",
"(",
"write",
"request",
"list",
")",
";",
"}",
"else",
"if",
"(",
"obj",
"instanceof",
"create",
"collection",
"operation",
")",
"{",
"string",
"filter",
"=",
"(",
"(",
"create",
"collection",
"operation",
")",
"obj",
")",
"get",
"collection",
"name",
"(",
")",
";",
"return",
"limit",
"filter",
"(",
"filter",
")",
";",
"}",
"else",
"if",
"(",
"obj",
"instanceof",
"create",
"indexes",
"operation",
")",
"{",
"list",
"<",
"string",
">",
"filter",
"=",
"(",
"(",
"create",
"indexes",
"operation",
")",
"obj",
")",
"get",
"index",
"names",
"(",
")",
";",
"return",
"limit",
"filter",
"(",
"filter",
"to",
"string",
"(",
")",
")",
";",
"}",
"else",
"if",
"(",
"obj",
"instanceof",
"create",
"view",
"operation",
")",
"{",
"string",
"filter",
"=",
"(",
"(",
"create",
"view",
"operation",
")",
"obj",
")",
"get",
"view",
"name",
"(",
")",
";",
"return",
"limit",
"filter",
"(",
"filter",
")",
";",
"}",
"else",
"if",
"(",
"obj",
"instanceof",
"find",
"and",
"delete",
"operation",
")",
"{",
"bson",
"document",
"filter",
"=",
"(",
"(",
"find",
"and",
"delete",
"operation",
")",
"obj",
")",
"get",
"filter",
"(",
")",
";",
"return",
"limit",
"filter",
"(",
"filter",
"to",
"string",
"(",
")",
")",
";",
"}",
"else",
"if",
"(",
"obj",
"instanceof",
"find",
"and",
"replace",
"operation",
")",
"{",
"bson",
"document",
"filter",
"=",
"(",
"(",
"find",
"and",
"replace",
"operation",
")",
"obj",
")",
"get",
"filter",
"(",
")",
";",
"return",
"limit",
"filter",
"(",
"filter",
"to",
"string",
"(",
")",
")",
";",
"}",
"else",
"if",
"(",
"obj",
"instanceof",
"find",
"and",
"update",
"operation",
")",
"{",
"bson",
"document",
"filter",
"=",
"(",
"(",
"find",
"and",
"update",
"operation",
")",
"obj",
")",
"get",
"filter",
"(",
")",
";",
"return",
"limit",
"filter",
"(",
"filter",
"to",
"string",
"(",
")",
")",
";",
"}",
"else",
"if",
"(",
"obj",
"instanceof",
"map",
"reduce",
"to",
"collection",
"operation",
")",
"{",
"bson",
"document",
"filter",
"=",
"(",
"(",
"map",
"reduce",
"to",
"collection",
"operation",
")",
"obj",
")",
"get",
"filter",
"(",
")",
";",
"return",
"limit",
"filter",
"(",
"filter",
"to",
"string",
"(",
")",
")",
";",
"}",
"else",
"if",
"(",
"obj",
"instanceof",
"mixed",
"bulk",
"write",
"operation",
")",
"{",
"list",
"<",
"?",
"extends",
"write",
"request",
">",
"write",
"request",
"list",
"=",
"(",
"(",
"mixed",
"bulk",
"write",
"operation",
")",
"obj",
")",
"get",
"write",
"requests",
"(",
")",
";",
"return",
"get",
"filter",
"(",
"write",
"request",
"list",
")",
";",
"}",
"else",
"{",
"return",
"mongo",
"constants",
"empty",
";",
"}",
"}"
] |
[
"this",
"method",
"is",
"visible",
"to",
"allow",
"sub",
"-",
"classes",
"to",
"override",
"the",
"initialization",
"behavior"
] | [
"protected",
"void",
"init",
"ideal",
"assignment",
"(",
"resource",
"tot",
"guarant",
",",
"temp",
"queue",
"per",
"partition",
"q",
",",
"resource",
"init",
"ideal",
"assigned",
")",
"{",
"q",
"ideal",
"assigned",
"=",
"init",
"ideal",
"assigned",
";",
"}"
] |
[
"returns",
"the",
"number",
"of",
"delete",
"operation",
"executed"
] | [
"public",
"long",
"get",
"delete",
"count",
"(",
")",
"{",
"return",
"delete",
"count",
";",
"}"
] |
[
"thrown",
"when",
"the",
"virtual",
"machine",
"notices",
"that",
"a",
"program",
"tries",
"to",
"reference",
",",
"on",
"a",
"class",
"or",
"object",
",",
"a",
"field",
"that",
"does",
"not",
"exist"
] | [
"public",
"static",
"string",
"no",
"such",
"field",
"exceptioin",
"(",
"string",
"class",
"name",
",",
"string",
"field",
"name",
")",
"{",
"return",
"\"",
"the",
"\"",
"+",
"field",
"name",
"+",
"\"",
"field",
"in",
"\"",
"+",
"class",
"name",
"+",
"\"",
"class",
"is",
"necessary",
"which",
"does",
"not",
"exist",
"\"",
";",
"}"
] |
[
"test",
"reading",
"various",
"maps",
"schemas",
"compatible",
"with",
"spec",
"https",
":",
"github",
"comapacheparquet",
"-",
"formatblobmaster",
"logical",
"types",
"md",
"#",
"maps"
] | [
"public",
"void",
"test",
"map",
"schemas",
"(",
")",
"throws",
"exception",
"{",
"iterable",
"<",
"map",
"<",
"string",
",",
"integer",
">",
">",
"values",
"=",
"create",
"test",
"maps",
"(",
"transform",
"(",
"ints",
"between",
"(",
"0",
",",
"100",
"000",
")",
",",
"object",
":",
":",
"to",
"string",
")",
",",
"ints",
"between",
"(",
"0",
",",
"10",
"000",
")",
")",
";",
"iterable",
"<",
"map",
"<",
"string",
",",
"integer",
">",
">",
"nullable",
"values",
"=",
"create",
"test",
"maps",
"(",
"transform",
"(",
"ints",
"between",
"(",
"0",
",",
"30",
"000",
")",
",",
"object",
":",
":",
"to",
"string",
")",
",",
"limit",
"(",
"cycle",
"(",
"as",
"list",
"(",
"1",
",",
"null",
",",
"3",
",",
"5",
",",
"null",
",",
"null",
",",
"null",
",",
"7",
",",
"11",
",",
"null",
",",
"13",
",",
"17",
")",
")",
",",
"30",
"000",
")",
")",
";",
"tester",
"test",
"round",
"trip",
"(",
"get",
"standard",
"map",
"object",
"inspector",
"(",
"java",
"string",
"object",
"inspector",
",",
"java",
"int",
"object",
"inspector",
")",
",",
"values",
",",
"values",
",",
"map",
"type",
"(",
"varchar",
",",
"integer",
")",
")",
";",
"/",
"/",
"map",
"<",
"string",
",",
"integer",
">",
"(",
"nullable",
"map",
",",
"non",
"-",
"null",
"values",
")",
"message",
"type",
"map",
"=",
"parse",
"message",
"type",
"(",
"\"",
"message",
"hive",
"schema",
"{",
"\"",
"+",
"\"",
"optional",
"group",
"my",
"map",
"(",
"map",
")",
"{",
"\"",
"+",
"\"",
"repeated",
"group",
"map",
"{",
"\"",
"+",
"\"",
"required",
"binary",
"str",
"(",
"utf8",
")",
";",
"\"",
"+",
"\"",
"required",
"int",
"3",
"2",
"num",
";",
"\"",
"+",
"\"",
"}",
"\"",
"+",
"\"",
"}",
"\"",
"+",
"\"",
"}",
"\"",
")",
";",
"tester",
"test",
"round",
"trip",
"(",
"get",
"standard",
"map",
"object",
"inspector",
"(",
"java",
"string",
"object",
"inspector",
",",
"java",
"int",
"object",
"inspector",
")",
",",
"values",
",",
"values",
",",
"\"",
"my",
"map",
"\"",
",",
"map",
"type",
"(",
"varchar",
",",
"integer",
")",
",",
"optional",
"of",
"(",
"map",
")",
")",
";",
"/",
"/",
"map",
"<",
"string",
",",
"integer",
">",
"(",
"nullable",
"map",
",",
"non",
"-",
"null",
"values",
")",
"map",
"=",
"parse",
"message",
"type",
"(",
"\"",
"message",
"hive",
"schema",
"{",
"\"",
"+",
"\"",
"optional",
"group",
"my",
"map",
"(",
"map",
"key",
"value",
")",
"{",
"\"",
"+",
"\"",
"repeated",
"group",
"map",
"{",
"\"",
"+",
"\"",
"required",
"binary",
"str",
"(",
"utf8",
")",
";",
"\"",
"+",
"\"",
"required",
"int",
"3",
"2",
"num",
";",
"\"",
"+",
"\"",
"}",
"\"",
"+",
"\"",
"}",
"\"",
"+",
"\"",
"}",
"\"",
")",
";",
"tester",
"test",
"round",
"trip",
"(",
"get",
"standard",
"map",
"object",
"inspector",
"(",
"java",
"string",
"object",
"inspector",
",",
"java",
"int",
"object",
"inspector",
")",
",",
"values",
",",
"values",
",",
"\"",
"my",
"map",
"\"",
",",
"map",
"type",
"(",
"varchar",
",",
"integer",
")",
",",
"optional",
"of",
"(",
"map",
")",
")",
";",
"/",
"/",
"map",
"<",
"string",
",",
"integer",
">",
"(",
"non",
"-",
"null",
"map",
",",
"nullable",
"values",
")",
"map",
"=",
"parse",
"message",
"type",
"(",
"\"",
"message",
"hive",
"schema",
"{",
"\"",
"+",
"\"",
"required",
"group",
"my",
"map",
"(",
"map",
")",
"{",
"\"",
"+",
"\"",
"repeated",
"group",
"map",
"{",
"\"",
"+",
"\"",
"required",
"binary",
"key",
"(",
"utf8",
")",
";",
"\"",
"+",
"\"",
"optional",
"int",
"3",
"2",
"value",
";",
"\"",
"+",
"\"",
"}",
"\"",
"+",
"\"",
"}",
"\"",
"+",
"\"",
"}",
"\"",
")",
";",
"tester",
"assert",
"round",
"trip",
"(",
"singleton",
"list",
"(",
"get",
"standard",
"map",
"object",
"inspector",
"(",
"java",
"string",
"object",
"inspector",
",",
"java",
"int",
"object",
"inspector",
")",
")",
",",
"new",
"iterable",
"<",
"?",
">",
"[",
"]",
"{",
"nullable",
"values",
"}",
",",
"new",
"iterable",
"<",
"?",
">",
"[",
"]",
"{",
"nullable",
"values",
"}",
",",
"singleton",
"list",
"(",
"\"",
"my",
"map",
"\"",
")",
",",
"singleton",
"list",
"(",
"map",
"type",
"(",
"varchar",
",",
"integer",
")",
")",
",",
"optional",
"of",
"(",
"map",
")",
")",
";",
"/",
"/",
"map",
"<",
"string",
",",
"integer",
">",
"(",
"non",
"-",
"null",
"map",
",",
"nullable",
"values",
")",
"map",
"=",
"parse",
"message",
"type",
"(",
"\"",
"message",
"hive",
"schema",
"{",
"\"",
"+",
"\"",
"required",
"group",
"my",
"map",
"(",
"map",
"key",
"value",
")",
"{",
"\"",
"+",
"\"",
"repeated",
"group",
"map",
"{",
"\"",
"+",
"\"",
"required",
"binary",
"key",
"(",
"utf8",
")",
";",
"\"",
"+",
"\"",
"optional",
"int",
"3",
"2",
"value",
";",
"\"",
"+",
"\"",
"}",
"\"",
"+",
"\"",
"}",
"\"",
"+",
"\"",
"}",
"\"",
")",
";",
"tester",
"assert",
"round",
"trip",
"(",
"singleton",
"list",
"(",
"get",
"standard",
"map",
"object",
"inspector",
"(",
"java",
"string",
"object",
"inspector",
",",
"java",
"int",
"object",
"inspector",
")",
")",
",",
"new",
"iterable",
"<",
"?",
">",
"[",
"]",
"{",
"nullable",
"values",
"}",
",",
"new",
"iterable",
"<",
"?",
">",
"[",
"]",
"{",
"nullable",
"values",
"}",
",",
"singleton",
"list",
"(",
"\"",
"my",
"map",
"\"",
")",
",",
"singleton",
"list",
"(",
"map",
"type",
"(",
"varchar",
",",
"integer",
")",
")",
",",
"optional",
"of",
"(",
"map",
")",
")",
";",
"/",
"/",
"map",
"<",
"string",
",",
"integer",
">",
"(",
"non",
"-",
"null",
"map",
",",
"nullable",
"values",
")",
"map",
"=",
"parse",
"message",
"type",
"(",
"\"",
"message",
"hive",
"schema",
"{",
"\"",
"+",
"\"",
"required",
"group",
"my",
"map",
"(",
"map",
")",
"{",
"\"",
"+",
"\"",
"repeated",
"group",
"map",
"{",
"\"",
"+",
"\"",
"required",
"binary",
"key",
"(",
"utf8",
")",
";",
"\"",
"+",
"\"",
"required",
"int",
"3",
"2",
"value",
";",
"\"",
"+",
"\"",
"}",
"\"",
"+",
"\"",
"}",
"\"",
"+",
"\"",
"}",
"\"",
")",
";",
"tester",
"assert",
"round",
"trip",
"(",
"singleton",
"list",
"(",
"get",
"standard",
"map",
"object",
"inspector",
"(",
"java",
"string",
"object",
"inspector",
",",
"java",
"int",
"object",
"inspector",
")",
")",
",",
"new",
"iterable",
"<",
"?",
">",
"[",
"]",
"{",
"values",
"}",
",",
"new",
"iterable",
"<",
"?",
">",
"[",
"]",
"{",
"values",
"}",
",",
"singleton",
"list",
"(",
"\"",
"my",
"map",
"\"",
")",
",",
"singleton",
"list",
"(",
"map",
"type",
"(",
"varchar",
",",
"integer",
")",
")",
",",
"optional",
"of",
"(",
"map",
")",
")",
";",
"/",
"/",
"map",
"<",
"string",
",",
"integer",
">",
"(",
"non",
"-",
"null",
"map",
",",
"nullable",
"values",
")",
"map",
"=",
"parse",
"message",
"type",
"(",
"\"",
"message",
"hive",
"schema",
"{",
"\"",
"+",
"\"",
"required",
"group",
"my",
"map",
"(",
"map",
"key",
"value",
")",
"{",
"\"",
"+",
"\"",
"repeated",
"group",
"map",
"{",
"\"",
"+",
"\"",
"required",
"binary",
"key",
"(",
"utf8",
")",
";",
"\"",
"+",
"\"",
"required",
"int",
"3",
"2",
"value",
";",
"\"",
"+",
"\"",
"}",
"\"",
"+",
"\"",
"}",
"\"",
"+",
"\"",
"}",
"\"",
")",
";",
"tester",
"assert",
"round",
"trip",
"(",
"singleton",
"list",
"(",
"get",
"standard",
"map",
"object",
"inspector",
"(",
"java",
"string",
"object",
"inspector",
",",
"java",
"int",
"object",
"inspector",
")",
")",
",",
"new",
"iterable",
"<",
"?",
">",
"[",
"]",
"{",
"values",
"}",
",",
"new",
"iterable",
"<",
"?",
">",
"[",
"]",
"{",
"values",
"}",
",",
"singleton",
"list",
"(",
"\"",
"my",
"map",
"\"",
")",
",",
"singleton",
"list",
"(",
"map",
"type",
"(",
"varchar",
",",
"integer",
")",
")",
",",
"optional",
"of",
"(",
"map",
")",
")",
";",
"/",
"/",
"map",
"<",
"string",
",",
"integer",
">",
"(",
"nullable",
"map",
",",
"nullable",
"values",
")",
"map",
"=",
"parse",
"message",
"type",
"(",
"\"",
"message",
"hive",
"schema",
"{",
"\"",
"+",
"\"",
"optional",
"group",
"my",
"map",
"(",
"map",
")",
"{",
"\"",
"+",
"\"",
"repeated",
"group",
"map",
"{",
"\"",
"+",
"\"",
"required",
"binary",
"key",
"(",
"utf8",
")",
";",
"\"",
"+",
"\"",
"optional",
"int",
"3",
"2",
"value",
";",
"\"",
"+",
"\"",
"}",
"\"",
"+",
"\"",
"}",
"\"",
"+",
"\"",
"}",
"\"",
")",
";",
"tester",
"test",
"round",
"trip",
"(",
"get",
"standard",
"map",
"object",
"inspector",
"(",
"java",
"string",
"object",
"inspector",
",",
"java",
"int",
"object",
"inspector",
")",
",",
"nullable",
"values",
",",
"nullable",
"values",
",",
"\"",
"my",
"map",
"\"",
",",
"map",
"type",
"(",
"varchar",
",",
"integer",
")",
",",
"optional",
"of",
"(",
"map",
")",
")",
";",
"/",
"/",
"map",
"<",
"string",
",",
"integer",
">",
"(",
"nullable",
"map",
",",
"nullable",
"values",
")",
"map",
"=",
"parse",
"message",
"type",
"(",
"\"",
"message",
"hive",
"schema",
"{",
"\"",
"+",
"\"",
"optional",
"group",
"my",
"map",
"(",
"map",
"key",
"value",
")",
"{",
"\"",
"+",
"\"",
"repeated",
"group",
"map",
"{",
"\"",
"+",
"\"",
"required",
"binary",
"key",
"(",
"utf8",
")",
";",
"\"",
"+",
"\"",
"optional",
"int",
"3",
"2",
"value",
";",
"\"",
"+",
"\"",
"}",
"\"",
"+",
"\"",
"}",
"\"",
"+",
"\"",
"}",
"\"",
")",
";",
"tester",
"test",
"round",
"trip",
"(",
"get",
"standard",
"map",
"object",
"inspector",
"(",
"java",
"string",
"object",
"inspector",
",",
"java",
"int",
"object",
"inspector",
")",
",",
"nullable",
"values",
",",
"nullable",
"values",
",",
"\"",
"my",
"map",
"\"",
",",
"map",
"type",
"(",
"varchar",
",",
"integer",
")",
",",
"optional",
"of",
"(",
"map",
")",
")",
";",
"}"
] |
[
"sends",
"out",
"an",
"arbitrary",
"html",
"fragment",
"as",
"the",
"output"
] | [
"public",
"static",
"form",
"fill",
"failure",
"respond",
"(",
"form",
"validation",
"kind",
"kind",
",",
"final",
"string",
"html",
")",
"{",
"return",
"new",
"form",
"fill",
"failure",
"(",
"kind",
")",
"{",
"public",
"string",
"render",
"html",
"(",
")",
"{",
"return",
"html",
";",
"}",
"@",
"override",
"public",
"string",
"to",
"string",
"(",
")",
"{",
"return",
"get",
"kind",
"(",
")",
"+",
"\"",
":",
"\"",
"+",
"html",
";",
"}",
"}",
";",
"}"
] |
[
"returns",
"an",
"array",
"containing",
"all",
"the",
"short",
"keys"
] | [
"public",
"short",
"[",
"]",
"get",
"keys",
"(",
")",
"{",
"return",
"indexer",
"get",
"keys",
"(",
")",
";",
"}"
] |
[
"set",
"the",
"random",
"text",
"data",
"generator",
"'",
"s",
"list",
"size"
] | [
"static",
"void",
"set",
"random",
"text",
"data",
"generator",
"list",
"size",
"(",
"configuration",
"conf",
",",
"int",
"list",
"size",
")",
"{",
"if",
"(",
"log",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"log",
"debug",
"(",
"\"",
"random",
"text",
"data",
"generator",
"is",
"configured",
"to",
"use",
"a",
"dictionary",
"\"",
"+",
"\"",
"with",
"\"",
"+",
"list",
"size",
"+",
"\"",
"words",
"\"",
")",
";",
"}",
"conf",
"set",
"int",
"(",
"gridmix",
"datagen",
"randomtext",
"listsize",
",",
"list",
"size",
")",
";",
"}"
] |
[
"returns",
"an",
"immutable",
"list",
"containing",
"the",
"given",
"elements",
",",
"in",
"order",
"the",
"array",
"{",
"@",
"code",
"others",
"}",
"must",
"not",
"be",
"longer",
"than",
"{",
"@",
"code",
"integer",
"max",
"value",
"-",
"12",
"}"
] | [
"public",
"static",
"<",
"e",
">",
"immutable",
"list",
"<",
"e",
">",
"of",
"(",
"e",
"e",
"1",
",",
"e",
"e",
"2",
",",
"e",
"e",
"3",
",",
"e",
"e",
"4",
",",
"e",
"e",
"5",
",",
"e",
"e",
"6",
",",
"e",
"e",
"7",
",",
"e",
"e",
"8",
",",
"e",
"e",
"9",
",",
"e",
"e",
"1",
"0",
",",
"e",
"e",
"1",
"1",
",",
"e",
"e",
"1",
"2",
",",
"e",
"others",
")",
"{",
"check",
"argument",
"(",
"others",
"length",
"<",
"=",
"integer",
"max",
"value",
"-",
"12",
",",
"\"",
"the",
"total",
"number",
"of",
"elements",
"must",
"fit",
"in",
"an",
"int",
"\"",
")",
";",
"object",
"[",
"]",
"array",
"=",
"new",
"object",
"[",
"12",
"+",
"others",
"length",
"]",
";",
"array",
"[",
"0",
"]",
"=",
"e",
"1",
";",
"array",
"[",
"1",
"]",
"=",
"e",
"2",
";",
"array",
"[",
"2",
"]",
"=",
"e",
"3",
";",
"array",
"[",
"3",
"]",
"=",
"e",
"4",
";",
"array",
"[",
"4",
"]",
"=",
"e",
"5",
";",
"array",
"[",
"5",
"]",
"=",
"e",
"6",
";",
"array",
"[",
"6",
"]",
"=",
"e",
"7",
";",
"array",
"[",
"7",
"]",
"=",
"e",
"8",
";",
"array",
"[",
"8",
"]",
"=",
"e",
"9",
";",
"array",
"[",
"9",
"]",
"=",
"e",
"1",
"0",
";",
"array",
"[",
"10",
"]",
"=",
"e",
"1",
"1",
";",
"array",
"[",
"11",
"]",
"=",
"e",
"1",
"2",
";",
"system",
"arraycopy",
"(",
"others",
",",
"0",
",",
"array",
",",
"12",
",",
"others",
"length",
")",
";",
"return",
"construct",
"(",
"array",
")",
";",
"}"
] |
[
"send",
"notification",
"that",
"the",
"equate",
"name",
"changed"
] | [
"void",
"equate",
"name",
"changed",
"(",
"string",
"old",
"name",
",",
"string",
"new",
"name",
")",
"{",
"program",
"set",
"changed",
"(",
"change",
"manager",
"docr",
"equate",
"renamed",
",",
"old",
"name",
",",
"new",
"name",
")",
";",
"}"
] |
[
"returns",
"the",
"name",
"of",
"the",
"\"",
"platform",
"\"",
"as",
"it",
"appears",
"in",
"the",
"plist",
"when",
"it",
"appears",
"in",
"all",
"-",
"lowercase"
] | [
"public",
"string",
"get",
"lower",
"case",
"name",
"in",
"plist",
"(",
")",
"{",
"return",
"name",
"in",
"plist",
"to",
"lower",
"case",
"(",
"locale",
"us",
")",
";",
"}"
] |
[
"parse",
"request",
"scopes",
"set"
] | [
"public",
"static",
"set",
"<",
"string",
">",
"parse",
"request",
"scopes",
"(",
"final",
"j",
"e",
"e",
"context",
"context",
")",
"{",
"return",
"parse",
"request",
"scopes",
"(",
"context",
"get",
"native",
"request",
"(",
")",
")",
";",
"}"
] |
[
"the",
"number",
"of",
"registers",
"used",
"by",
"this",
"code"
] | [
"public",
"short",
"get",
"registers",
"size",
"(",
")",
"{",
"return",
"registers",
"size",
";",
"}"
] |
[
"adds",
"a",
"service",
"programmatically",
"if",
"a",
"service",
"with",
"the",
"same",
"interface",
"exists",
",",
"it",
"will",
"be",
"destroyed",
"and",
"removed",
"before",
"the",
"given",
"one",
"is",
"initialized",
"and",
"added",
"if",
"an",
"exception",
"is",
"thrown",
"the",
"server",
"is",
"destroyed"
] | [
"public",
"void",
"set",
"service",
"(",
"class",
"<",
"?",
"extends",
"service",
">",
"klass",
")",
"throws",
"server",
"exception",
"{",
"ensure",
"operational",
"(",
")",
";",
"check",
"not",
"null",
"(",
"klass",
",",
"\"",
"service",
"klass",
"\"",
")",
";",
"if",
"(",
"get",
"status",
"(",
")",
"=",
"=",
"status",
"shutting",
"down",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"server",
"shutting",
"down",
"\"",
")",
";",
"}",
"try",
"{",
"service",
"new",
"service",
"=",
"klass",
"new",
"instance",
"(",
")",
";",
"service",
"old",
"service",
"=",
"services",
"get",
"(",
"new",
"service",
"get",
"interface",
"(",
")",
")",
";",
"if",
"(",
"old",
"service",
"!",
"=",
"null",
")",
"{",
"try",
"{",
"old",
"service",
"destroy",
"(",
")",
";",
"}",
"catch",
"(",
"throwable",
"ex",
")",
"{",
"log",
"error",
"(",
"\"",
"could",
"not",
"destroy",
"service",
"[",
"{",
"}",
"]",
",",
"{",
"}",
"\"",
",",
"new",
"object",
"[",
"]",
"{",
"old",
"service",
"get",
"interface",
"(",
")",
",",
"ex",
"get",
"message",
"(",
")",
",",
"ex",
"}",
")",
";",
"}",
"}",
"new",
"service",
"init",
"(",
"this",
")",
";",
"services",
"put",
"(",
"new",
"service",
"get",
"interface",
"(",
")",
",",
"new",
"service",
")",
";",
"}",
"catch",
"(",
"exception",
"ex",
")",
"{",
"log",
"error",
"(",
"\"",
"could",
"not",
"set",
"service",
"[",
"{",
"}",
"]",
"programmatically",
"-",
"server",
"shutting",
"down",
"-",
",",
"{",
"}",
"\"",
",",
"klass",
",",
"ex",
")",
";",
"destroy",
"(",
")",
";",
"throw",
"new",
"server",
"exception",
"(",
"server",
"exception",
"error",
"s09",
",",
"klass",
",",
"ex",
"get",
"message",
"(",
")",
",",
"ex",
")",
";",
"}",
"}"
] |
[
"get",
"attribute",
"number"
] | [
"public",
"big",
"decimal",
"get",
"attribute",
"number",
"(",
")",
"{",
"return",
"attribute",
"number",
";",
"}"
] |
[
"indicate",
"whether",
"dtd",
"parsing",
"should",
"be",
"supported",
"default",
"is",
"{",
"@",
"code",
"false",
"}",
"meaning",
"that",
"dtd",
"is",
"disabled"
] | [
"public",
"void",
"set",
"support",
"dtd",
"(",
"boolean",
"support",
"dtd",
")",
"{",
"this",
"support",
"dtd",
"=",
"support",
"dtd",
";",
"}"
] |
[
"returns",
"a",
"non",
"-",
"null",
"value",
"if",
"this",
"request",
"should",
"execute",
"using",
"a",
"specific",
"point",
"-",
"in",
"-",
"time",
"reader",
";",
"otherwise",
",",
"using",
"the",
"most",
"up",
"to",
"date",
"point",
"-",
"in",
"-",
"time",
"reader"
] | [
"public",
"shard",
"search",
"context",
"id",
"reader",
"id",
"(",
")",
"{",
"return",
"reader",
"id",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"number",
"'"
] | [
"public",
"void",
"number",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"number",
"}"
] |
[
"kick",
"to",
"repaint",
"when",
"the",
"colors",
"have",
"changed"
] | [
"public",
"void",
"update",
"colors",
"(",
")",
"{",
"repaint",
"(",
")",
";",
"}"
] |
[
"called",
"when",
"the",
"service",
"transitions",
"to",
"the",
"{",
"@",
"linkplain",
"state",
"#",
"terminated",
"terminated",
"}",
"state",
"the",
"{",
"@",
"linkplain",
"state",
"#",
"terminated",
"terminated",
"}",
"state",
"is",
"a",
"terminal",
"state",
"in",
"the",
"transition",
"diagram",
"therefore",
",",
"if",
"this",
"method",
"is",
"called",
",",
"no",
"other",
"methods",
"will",
"be",
"called",
"on",
"the",
"{",
"@",
"link",
"listener",
"}"
] | [
"public",
"void",
"terminated",
"(",
"state",
"from",
")",
"{",
"}"
] |
[
"gets",
"http",
"servlet",
"request",
"geo",
"location"
] | [
"public",
"static",
"geo",
"location",
"request",
"get",
"http",
"servlet",
"request",
"geo",
"location",
"(",
"final",
"http",
"servlet",
"request",
"request",
")",
"{",
"val",
"loc",
"=",
"new",
"geo",
"location",
"request",
"(",
")",
";",
"if",
"(",
"request",
"!",
"=",
"null",
")",
"{",
"val",
"geo",
"location",
"param",
"=",
"request",
"get",
"parameter",
"(",
"\"",
"geolocation",
"\"",
")",
";",
"return",
"get",
"http",
"servlet",
"request",
"geo",
"location",
"(",
"geo",
"location",
"param",
")",
";",
"}",
"return",
"loc",
";",
"}"
] |
[
"gives",
"access",
"to",
"a",
"deployed",
"process",
"model",
",",
"e",
"g",
",",
"a",
"bpmn",
"2",
"0",
"xml",
"file",
",",
"through",
"a",
"stream",
"of",
"bytes"
] | [
"input",
"stream",
"get",
"process",
"model",
"(",
"string",
"process",
"definition",
"id",
")",
";"
] |
[
"sets",
"the",
"number",
"of",
"maximum",
"visible",
"drawn",
"values",
"on",
"the",
"chart",
"only",
"active",
"when",
"set",
"draw",
"values",
"(",
")",
"is",
"enabled"
] | [
"public",
"void",
"set",
"max",
"visible",
"value",
"count",
"(",
"int",
"count",
")",
"{",
"this",
"m",
"max",
"visible",
"count",
"=",
"count",
";",
"}"
] |
[
"re",
"-",
"groups",
"the",
"records",
"of",
"this",
"{",
"@",
"code",
"k",
"table",
"}",
"using",
"the",
"provided",
"{",
"@",
"link",
"key",
"value",
"mapper",
"}",
"and",
"{",
"@",
"link",
"serde",
"}",
"s",
"as",
"specified",
"by",
"{",
"@",
"link",
"serialized",
"}",
"each",
"{",
"@",
"link",
"key",
"value",
"}",
"pair",
"of",
"this",
"{",
"@",
"code",
"k",
"table",
"}",
"is",
"mapped",
"to",
"a",
"new",
"{",
"@",
"link",
"key",
"value",
"}",
"pair",
"by",
"applying",
"the",
"provided",
"{",
"@",
"link",
"key",
"value",
"mapper",
"}",
"re",
"-",
"grouping",
"a",
"{",
"@",
"code",
"k",
"table",
"}",
"is",
"required",
"before",
"an",
"aggregation",
"operator",
"can",
"be",
"applied",
"to",
"the",
"data",
"(",
"cf",
"{",
"@",
"link",
"k",
"grouped",
"table",
"}",
")",
"the",
"{",
"@",
"link",
"key",
"value",
"mapper",
"}",
"selects",
"a",
"new",
"key",
"and",
"value",
"(",
"with",
"both",
"maybe",
"being",
"the",
"same",
"type",
"or",
"a",
"new",
"type",
")",
"if",
"the",
"new",
"record",
"key",
"is",
"{",
"@",
"code",
"null",
"}",
"the",
"record",
"will",
"not",
"be",
"included",
"in",
"the",
"resulting",
"{",
"@",
"link",
"k",
"grouped",
"table",
"}",
"because",
"a",
"new",
"key",
"is",
"selected",
",",
"an",
"internal",
"repartitioning",
"topic",
"will",
"be",
"created",
"in",
"kafka",
"this",
"topic",
"will",
"be",
"named",
"\"",
"$",
"{",
"application",
"id",
"}",
"-",
"&",
"lt",
";",
"name",
"&",
"gt",
";",
"-",
"repartition",
"\"",
",",
"where",
"\"",
"application",
"id",
"\"",
"is",
"user",
"-",
"specified",
"in",
"{",
"@",
"link",
"streams",
"config",
"}",
"via",
"parameter",
"{",
"@",
"link",
"streams",
"config",
"#",
"application",
"id",
"config",
"application",
"id",
"config",
"}",
",",
"\"",
"&",
"lt",
";",
"name",
"&",
"gt",
";",
"\"",
"is",
"an",
"internally",
"generated",
"name",
",",
"and",
"\"",
"-",
"repartition",
"\"",
"is",
"a",
"fixed",
"suffix",
"you",
"can",
"retrieve",
"all",
"generated",
"internal",
"topic",
"names",
"via",
"{",
"@",
"link",
"topology",
"#",
"describe",
"(",
")",
"}",
"all",
"data",
"of",
"this",
"{",
"@",
"code",
"k",
"table",
"}",
"will",
"be",
"redistributed",
"through",
"the",
"repartitioning",
"topic",
"by",
"writing",
"all",
"update",
"records",
"to",
"and",
"rereading",
"all",
"updated",
"records",
"from",
"it",
",",
"such",
"that",
"the",
"resulting",
"{",
"@",
"link",
"k",
"grouped",
"table",
"}",
"is",
"partitioned",
"on",
"the",
"new",
"key"
] | [
"<",
"kr",
",",
"vr",
">",
"k",
"grouped",
"table",
"<",
"kr",
",",
"vr",
">",
"group",
"by",
"(",
"final",
"key",
"value",
"mapper",
"<",
"?",
"super",
"k",
",",
"?",
"super",
"v",
",",
"key",
"value",
"<",
"kr",
",",
"vr",
">",
">",
"selector",
",",
"final",
"serialized",
"<",
"kr",
",",
"vr",
">",
"serialized",
")",
";"
] |
[
"ensures",
"that",
"the",
"given",
"directory",
"exists",
"(",
"if",
"not",
",",
"it",
"'",
"s",
"created",
",",
"including",
"all",
"the",
"parent",
"directories",
")"
] | [
"public",
"static",
"file",
"mkdirs",
"(",
"file",
"dir",
")",
"throws",
"i",
"o",
"exception",
"{",
"try",
"{",
"return",
"files",
"create",
"directories",
"(",
"file",
"to",
"path",
"(",
"dir",
")",
")",
"to",
"file",
"(",
")",
";",
"}",
"catch",
"(",
"unsupported",
"operation",
"exception",
"e",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"e",
")",
";",
"}",
"}"
] |
[
"returns",
"the",
"name",
"of",
"the",
"index",
"that",
"the",
"request",
"alias",
"was",
"pointing",
"to"
] | [
"public",
"string",
"get",
"old",
"index",
"(",
")",
"{",
"return",
"old",
"index",
";",
"}"
] |
[
"variant",
"of",
"{",
"@",
"link",
"#",
"from",
"multipart",
"async",
"data",
"(",
"string",
",",
"publisher",
",",
"class",
")",
"}",
"that",
"accepts",
"a",
"{",
"@",
"link",
"parameterized",
"type",
"reference",
"}",
"for",
"the",
"element",
"type",
",",
"which",
"allows",
"specifying",
"generic",
"type",
"information",
"note",
"that",
"you",
"can",
"also",
"build",
"the",
"multipart",
"data",
"externally",
"with",
"{",
"@",
"link",
"multipart",
"body",
"builder",
"}",
",",
"and",
"pass",
"the",
"resulting",
"map",
"directly",
"to",
"the",
"{",
"@",
"code",
"body",
"value",
"(",
"object",
")",
"}",
"shortcut",
"method",
"in",
"{",
"@",
"code",
"web",
"client",
"}"
] | [
"public",
"static",
"<",
"t",
",",
"p",
"extends",
"publisher",
"<",
"t",
">",
">",
"multipart",
"inserter",
"from",
"multipart",
"async",
"data",
"(",
"string",
"name",
",",
"p",
"publisher",
",",
"parameterized",
"type",
"reference",
"<",
"t",
">",
"type",
"reference",
")",
"{",
"return",
"new",
"default",
"multipart",
"inserter",
"(",
")",
"with",
"publisher",
"(",
"name",
",",
"publisher",
",",
"type",
"reference",
")",
";",
"}"
] |
[
"run",
"a",
"mover",
"in",
"command",
"line"
] | [
"public",
"static",
"void",
"main",
"(",
"string",
"[",
"]",
"args",
")",
"{",
"if",
"(",
"d",
"f",
"s",
"util",
"parse",
"help",
"argument",
"(",
"args",
",",
"cli",
"usage",
",",
"system",
"out",
",",
"true",
")",
")",
"{",
"system",
"exit",
"(",
"0",
")",
";",
"}",
"try",
"{",
"system",
"exit",
"(",
"tool",
"runner",
"run",
"(",
"new",
"hdfs",
"configuration",
"(",
")",
",",
"new",
"cli",
"(",
")",
",",
"args",
")",
")",
";",
"}",
"catch",
"(",
"throwable",
"e",
")",
"{",
"log",
"error",
"(",
"\"",
"exiting",
"\"",
"+",
"mover",
"class",
"get",
"simple",
"name",
"(",
")",
"+",
"\"",
"due",
"to",
"an",
"exception",
"\"",
",",
"e",
")",
";",
"system",
"exit",
"(",
"-",
"1",
")",
";",
"}",
"}"
] |
[
"method",
"to",
"ask",
"for",
"a",
"file",
"(",
"copied",
"from",
"ghidra",
"script",
")"
] | [
"private",
"file",
"ask",
"file",
"(",
"final",
"string",
"title",
",",
"final",
"string",
"approve",
"button",
"text",
")",
"{",
"final",
"ghidra",
"file",
"chooser",
"chooser",
"=",
"new",
"ghidra",
"file",
"chooser",
"(",
"tool",
"get",
"active",
"window",
"(",
")",
")",
";",
"chooser",
"set",
"approve",
"button",
"text",
"(",
"approve",
"button",
"text",
")",
";",
"chooser",
"set",
"title",
"(",
"title",
")",
";",
"chooser",
"set",
"file",
"selection",
"mode",
"(",
"ghidra",
"file",
"chooser",
"files",
"only",
")",
";",
"return",
"chooser",
"get",
"selected",
"file",
"(",
")",
";",
"}"
] |
[
"write",
"properties",
"to",
"the",
"version",
"file",
"in",
"the",
"given",
"storage",
"directory"
] | [
"public",
"void",
"write",
"properties",
"(",
"storage",
"directory",
"sd",
")",
"throws",
"i",
"o",
"exception",
"{",
"write",
"properties",
"(",
"sd",
"get",
"version",
"file",
"(",
")",
",",
"sd",
")",
";",
"}"
] |
[
"subclasses",
"need",
"to",
"implement",
"this",
"to",
"return",
"the",
"transaction",
"attribute",
"for",
"the",
"given",
"class",
",",
"if",
"any"
] | [
"protected",
"abstract",
"transaction",
"attribute",
"find",
"transaction",
"attribute",
"(",
"class",
"<",
"?",
">",
"clazz",
")",
";"
] |
[
"reads",
"the",
"raw",
"bytes",
"following",
"a",
"<",
"code",
">",
"type",
"float",
"<",
"code",
">",
"code"
] | [
"public",
"byte",
"[",
"]",
"read",
"raw",
"float",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"byte",
"[",
"]",
"bytes",
"=",
"new",
"byte",
"[",
"5",
"]",
";",
"bytes",
"[",
"0",
"]",
"=",
"(",
"byte",
")",
"type",
"float",
"code",
";",
"in",
"read",
"fully",
"(",
"bytes",
",",
"1",
",",
"4",
")",
";",
"return",
"bytes",
";",
"}"
] |
[
"create",
"simple",
"object"
] | [
"public",
"simple",
"object",
"create",
"(",
"@",
"parameter",
"layout",
"(",
"named",
"=",
"\"",
"name",
"\"",
")",
"final",
"string",
"name",
")",
"{",
"final",
"simple",
"object",
"obj",
"=",
"container",
"new",
"transient",
"instance",
"(",
"simple",
"object",
"class",
")",
";",
"obj",
"set",
"name",
"(",
"name",
")",
";",
"container",
"persist",
"if",
"not",
"already",
"(",
"obj",
")",
";",
"return",
"obj",
";",
"}"
] |
[
"staging",
"models",
"allows",
"them",
"to",
"be",
"implicitly",
"added",
"after",
"the",
"user",
"finishes",
"modifying",
"them",
"this",
"means",
"that",
"if",
"a",
"user",
"has",
"modified",
"a",
"model",
",",
"and",
"then",
"moves",
"on",
"to",
"modifying",
"a",
"different",
"model",
",",
"the",
"first",
"model",
"is",
"automatically",
"added",
"as",
"soon",
"as",
"the",
"second",
"model",
"is",
"modified",
"there",
"are",
"some",
"edge",
"cases",
"for",
"handling",
"models",
"that",
"are",
"added",
"without",
"modification",
",",
"or",
"models",
"that",
"are",
"modified",
"but",
"then",
"fail",
"an",
"`",
"add",
"if",
"`",
"check",
"this",
"only",
"works",
"for",
"auto",
"models",
",",
"and",
"only",
"if",
"implicitly",
"adding",
"is",
"enabled",
"in",
"configuration"
] | [
"void",
"set",
"staged",
"model",
"(",
"epoxy",
"model",
"<",
"?",
">",
"model",
")",
"{",
"if",
"(",
"model",
"!",
"=",
"staged",
"model",
")",
"{",
"add",
"currently",
"staged",
"model",
"if",
"exists",
"(",
")",
";",
"}",
"staged",
"model",
"=",
"model",
";",
"}"
] |
[
"accepts",
"the",
"update",
"to",
"the",
"node",
"configuration"
] | [
"public",
"void",
"do",
"config",
"submit",
"(",
"stapler",
"request",
"req",
",",
"stapler",
"response",
"rsp",
")",
"throws",
"i",
"o",
"exception",
",",
"servlet",
"exception",
",",
"form",
"exception",
"{",
"final",
"jenkins",
"app",
"=",
"jenkins",
"get",
"(",
")",
";",
"app",
"check",
"permission",
"(",
"jenkins",
"administer",
")",
";",
"if",
"(",
"is",
"invalid",
"name",
"(",
")",
")",
"{",
"throw",
"new",
"form",
"exception",
"(",
"\"",
"invalid",
"label",
"\"",
",",
"null",
")",
";",
"}",
"properties",
"rebuild",
"(",
"req",
",",
"req",
"get",
"submitted",
"form",
"(",
")",
",",
"get",
"applicable",
"property",
"descriptors",
"(",
")",
")",
";",
"this",
"description",
"=",
"req",
"get",
"submitted",
"form",
"(",
")",
"get",
"string",
"(",
"\"",
"description",
"\"",
")",
";",
"update",
"transient",
"actions",
"(",
")",
";",
"save",
"(",
")",
";",
"form",
"apply",
"success",
"(",
"\"",
"\"",
")",
"generate",
"response",
"(",
"req",
",",
"rsp",
",",
"null",
")",
";",
"}"
] |
[
"set",
"the",
"(",
"new",
")",
"values",
"of",
"the",
"{",
"@",
"code",
"if",
"-",
"none",
"-",
"match",
"}",
"header"
] | [
"public",
"void",
"set",
"if",
"none",
"match",
"(",
"list",
"<",
"string",
">",
"if",
"none",
"match",
"list",
")",
"{",
"set",
"(",
"if",
"none",
"match",
",",
"to",
"comma",
"delimited",
"string",
"(",
"if",
"none",
"match",
"list",
")",
")",
";",
"}"
] |
[
"gets",
"accounts",
"internal"
] | [
"protected",
"abstract",
"collection",
"<",
"?",
"extends",
"yubi",
"key",
"account",
">",
"get",
"accounts",
"internal",
"(",
")",
";"
] |
[
"returns",
"the",
"bzl",
"module"
] | [
"public",
"module",
"get",
"module",
"(",
")",
"{",
"return",
"module",
";",
"}"
] |
[
"gets",
"the",
"name",
"of",
"the",
"jython",
"interpreter",
"to",
"use"
] | [
"public",
"string",
"get",
"jython",
"interpreter",
"name",
"(",
")",
"{",
"if",
"(",
"enable",
"python",
"checkbox",
"button",
"get",
"selection",
"(",
")",
")",
"{",
"return",
"jython",
"combo",
"get",
"text",
"(",
")",
";",
"}",
"return",
"null",
";",
"}"
] |
[
"returns",
"the",
"immutable",
"list",
"of",
"include",
"directories",
"to",
"be",
"added",
"with",
"\"",
"-",
"i",
"\"",
"(",
"possibly",
"empty",
"but",
"never",
"null",
")",
"this",
"includes",
"the",
"include",
"dirs",
"from",
"the",
"transitive",
"deps",
"closure",
"of",
"the",
"target",
"this",
"list",
"does",
"not",
"contain",
"duplicates",
"all",
"fragments",
"are",
"either",
"absolute",
"or",
"relative",
"to",
"the",
"exec",
"root",
"(",
"see",
"{",
"@",
"link",
"com",
"google",
"devtools",
"build",
"lib",
"analysis",
"blaze",
"directories",
"#",
"get",
"exec",
"root",
"(",
"string",
")",
"}",
")"
] | [
"public",
"immutable",
"list",
"<",
"path",
"fragment",
">",
"get",
"include",
"dirs",
"(",
")",
"{",
"return",
"command",
"line",
"cc",
"compilation",
"context",
"include",
"dirs",
";",
"}"
] |
[
"checks",
"if",
"the",
"migration",
"tag",
"has",
"been",
"added",
"to",
"the",
"rules",
"list",
"of",
"tags",
"if",
"the",
"tag",
"is",
"missing",
",",
"the",
"user",
"is",
"accessing",
"the",
"rule",
"directly",
"in",
"a",
"build",
"file",
"or",
"through",
"a",
"macro",
"that",
"is",
"accessing",
"it",
"directly"
] | [
"default",
"void",
"check",
"for",
"migration",
"tag",
"(",
"rule",
"context",
"rule",
"context",
")",
"throws",
"rule",
"error",
"exception",
"{",
"if",
"(",
"!",
"android",
"common",
"get",
"android",
"config",
"(",
"rule",
"context",
")",
"check",
"for",
"migration",
"tag",
"(",
")",
")",
"{",
"return",
";",
"}",
"boolean",
"has",
"migration",
"tag",
"=",
"rule",
"context",
"attributes",
"(",
")",
"get",
"(",
"\"",
"tags",
"\"",
",",
"type",
"string",
"list",
")",
"contains",
"(",
"\"",
"android",
"rules",
"migration",
"\"",
")",
";",
"if",
"(",
"!",
"has",
"migration",
"tag",
")",
"{",
"register",
"migration",
"rule",
"error",
"(",
"rule",
"context",
")",
";",
"}",
"}"
] |
[
"tells",
"us",
"if",
"a",
"volume",
"is",
"transient"
] | [
"public",
"void",
"set",
"is",
"transient",
"(",
"boolean",
"transient",
"value",
")",
"{",
"this",
"is",
"transient",
"=",
"transient",
"value",
";",
"}"
] |
[
"hide",
"the",
"soft",
"input"
] | [
"public",
"static",
"void",
"hide",
"soft",
"input",
"by",
"toggle",
"(",
"final",
"activity",
"activity",
")",
"{",
"long",
"now",
"millis",
"=",
"system",
"clock",
"elapsed",
"realtime",
"(",
")",
";",
"long",
"delta",
"=",
"now",
"millis",
"-",
"millis",
";",
"if",
"(",
"math",
"abs",
"(",
"delta",
")",
">",
"500",
"&",
"&",
"keyboard",
"utils",
"is",
"soft",
"input",
"visible",
"(",
"activity",
")",
")",
"{",
"keyboard",
"utils",
"toggle",
"soft",
"input",
"(",
")",
";",
"}",
"millis",
"=",
"now",
"millis",
";",
"}"
] |
[
"creates",
"a",
"data",
"stream",
"containing",
"results",
"of",
"{",
"@",
"link",
"pattern",
"process",
"function",
"}",
"to",
"fully",
"matching",
"event",
"patterns"
] | [
"<",
"out",
",",
"k",
">",
"single",
"output",
"stream",
"operator",
"<",
"out",
">",
"build",
"(",
"final",
"type",
"information",
"<",
"out",
">",
"out",
"type",
"info",
",",
"final",
"pattern",
"process",
"function",
"<",
"in",
",",
"out",
">",
"process",
"function",
")",
"{",
"check",
"not",
"null",
"(",
"out",
"type",
"info",
")",
";",
"check",
"not",
"null",
"(",
"process",
"function",
")",
";",
"final",
"type",
"serializer",
"<",
"in",
">",
"input",
"serializer",
"=",
"input",
"stream",
"get",
"type",
"(",
")",
"create",
"serializer",
"(",
"input",
"stream",
"get",
"execution",
"config",
"(",
")",
")",
";",
"final",
"boolean",
"is",
"processing",
"time",
"=",
"time",
"behaviour",
"=",
"=",
"time",
"behaviour",
"processing",
"time",
";",
"final",
"boolean",
"timeout",
"handling",
"=",
"process",
"function",
"instanceof",
"timed",
"out",
"partial",
"match",
"handler",
";",
"final",
"n",
"f",
"a",
"compiler",
"n",
"f",
"a",
"factory",
"<",
"in",
">",
"nfa",
"factory",
"=",
"n",
"f",
"a",
"compiler",
"compile",
"factory",
"(",
"pattern",
",",
"timeout",
"handling",
")",
";",
"final",
"cep",
"operator",
"<",
"in",
",",
"k",
",",
"out",
">",
"operator",
"=",
"new",
"cep",
"operator",
"<",
">",
"(",
"input",
"serializer",
",",
"is",
"processing",
"time",
",",
"nfa",
"factory",
",",
"comparator",
",",
"pattern",
"get",
"after",
"match",
"skip",
"strategy",
"(",
")",
",",
"process",
"function",
",",
"late",
"data",
"output",
"tag",
")",
";",
"final",
"single",
"output",
"stream",
"operator",
"<",
"out",
">",
"pattern",
"stream",
";",
"if",
"(",
"input",
"stream",
"instanceof",
"keyed",
"stream",
")",
"{",
"keyed",
"stream",
"<",
"in",
",",
"k",
">",
"keyed",
"stream",
"=",
"(",
"keyed",
"stream",
"<",
"in",
",",
"k",
">",
")",
"input",
"stream",
";",
"pattern",
"stream",
"=",
"keyed",
"stream",
"transform",
"(",
"\"",
"cep",
"operator",
"\"",
",",
"out",
"type",
"info",
",",
"operator",
")",
";",
"}",
"else",
"{",
"key",
"selector",
"<",
"in",
",",
"byte",
">",
"key",
"selector",
"=",
"new",
"null",
"byte",
"key",
"selector",
"<",
">",
"(",
")",
";",
"pattern",
"stream",
"=",
"input",
"stream",
"key",
"by",
"(",
"key",
"selector",
")",
"transform",
"(",
"\"",
"global",
"cep",
"operator",
"\"",
",",
"out",
"type",
"info",
",",
"operator",
")",
"force",
"non",
"parallel",
"(",
")",
";",
"}",
"return",
"pattern",
"stream",
";",
"}"
] |
[
"whether",
"the",
"given",
"{",
"@",
"linkplain",
"method",
"parameter",
"method",
"return",
"type",
"}",
"is",
"supported",
"by",
"any",
"registered",
"{",
"@",
"link",
"handler",
"method",
"return",
"value",
"handler",
"}"
] | [
"public",
"boolean",
"supports",
"return",
"type",
"(",
"method",
"parameter",
"return",
"type",
")",
"{",
"return",
"get",
"return",
"value",
"handler",
"(",
"return",
"type",
")",
"!",
"=",
"null",
";",
"}"
] |
[
"a",
"visitation",
"over",
"all",
"the",
"nodes",
"in",
"the",
"graph",
"in",
"depth",
"-",
"first",
"order",
"see",
"dfs",
"constructor",
"for",
"meaning",
"of",
"'",
"order",
"'",
"and",
"'",
"transpose",
"'",
"parameters"
] | [
"public",
"void",
"visit",
"depth",
"first",
"(",
"graph",
"visitor",
"<",
"t",
">",
"visitor",
",",
"dfs",
"order",
"order",
",",
"boolean",
"transpose",
",",
"iterable",
"<",
"node",
"<",
"t",
">",
">",
"start",
"nodes",
")",
"{",
"dfs",
"<",
"t",
">",
"visitation",
"=",
"new",
"dfs",
"<",
">",
"(",
"order",
",",
"transpose",
")",
";",
"visitor",
"begin",
"visit",
"(",
")",
";",
"for",
"(",
"node",
"<",
"t",
">",
"node",
":",
"start",
"nodes",
")",
"{",
"visitation",
"visit",
"(",
"node",
",",
"visitor",
")",
";",
"}",
"visitor",
"end",
"visit",
"(",
")",
";",
"}"
] |
[
"add",
"a",
"file",
"path",
"to",
"the",
"current",
"set",
"of",
"classpath",
"entries",
"the",
"file",
"will",
"also",
"be",
"added",
"to",
"the",
"cache",
"if",
"{",
"@",
"code",
"add",
"to",
"cache",
"}",
"is",
"true",
"used",
"by",
"internal",
"distributed",
"cache",
"code"
] | [
"public",
"static",
"void",
"add",
"file",
"to",
"class",
"path",
"(",
"path",
"file",
",",
"configuration",
"conf",
",",
"file",
"system",
"fs",
",",
"boolean",
"add",
"to",
"cache",
")",
"{",
"string",
"classpath",
"=",
"conf",
"get",
"(",
"m",
"r",
"job",
"config",
"classpath",
"files",
")",
";",
"conf",
"set",
"(",
"m",
"r",
"job",
"config",
"classpath",
"files",
",",
"classpath",
"=",
"=",
"null",
"?",
"file",
"to",
"string",
"(",
")",
":",
"classpath",
"+",
"\"",
",",
"\"",
"+",
"file",
"to",
"string",
"(",
")",
")",
";",
"if",
"(",
"add",
"to",
"cache",
")",
"{",
"uri",
"uri",
"=",
"fs",
"make",
"qualified",
"(",
"file",
")",
"to",
"uri",
"(",
")",
";",
"add",
"cache",
"file",
"(",
"uri",
",",
"conf",
")",
";",
"}",
"}"
] |
[
"adds",
"the",
"given",
"method"
] | [
"public",
"void",
"add",
"method",
"(",
"method",
"method",
")",
"{",
"int",
"methods",
"count",
"=",
"target",
"class",
"u",
"2methods",
"count",
";",
"method",
"[",
"]",
"methods",
"=",
"target",
"class",
"methods",
";",
"/",
"/",
"make",
"sure",
"there",
"is",
"enough",
"space",
"for",
"the",
"new",
"method",
"if",
"(",
"methods",
"length",
"<",
"=",
"methods",
"count",
")",
"{",
"target",
"class",
"methods",
"=",
"new",
"program",
"method",
"[",
"methods",
"count",
"+",
"1",
"]",
";",
"system",
"arraycopy",
"(",
"methods",
",",
"0",
",",
"target",
"class",
"methods",
",",
"0",
",",
"methods",
"count",
")",
";",
"methods",
"=",
"target",
"class",
"methods",
";",
"}",
"if",
"(",
"debug",
")",
"{",
"system",
"out",
"println",
"(",
"target",
"class",
"get",
"name",
"(",
")",
"+",
"\"",
":",
"adding",
"method",
"[",
"\"",
"+",
"method",
"get",
"name",
"(",
"target",
"class",
")",
"+",
"method",
"get",
"descriptor",
"(",
"target",
"class",
")",
"+",
"\"",
"]",
"\"",
")",
";",
"}",
"/",
"/",
"add",
"the",
"method",
"methods",
"[",
"target",
"class",
"u",
"2methods",
"count",
"+",
"+",
"]",
"=",
"method",
";",
"}"
] |
[
"returns",
"the",
"fallback",
"action",
"to",
"be",
"taken",
"if",
"the",
"main",
"action",
"(",
"result",
"returned",
"by",
"the",
"execute",
"method",
")",
"fails",
"e",
"g",
"target",
"queue",
"does",
"not",
"exist",
",",
"or",
"reference",
"is",
"ambiguous"
] | [
"public",
"mapping",
"rule",
"result",
"get",
"fallback",
"(",
")",
"{",
"return",
"fallback",
";",
"}"
] |
[
"get",
"the",
"count",
"of",
"sequences",
"which",
"pass",
"through",
"this",
"node"
] | [
"public",
"int",
"get",
"count",
"(",
")",
"{",
"return",
"count",
";",
"}"
] |
[
"<",
"code",
">",
"optional",
"second",
"msg",
"blah",
"=",
"2",
";",
"<",
"code",
">"
] | [
"public",
"builder",
"merge",
"blah",
"(",
"org",
"springframework",
"protobuf",
"second",
"msg",
"value",
")",
"{",
"if",
"(",
"blah",
"builder",
"=",
"=",
"null",
")",
"{",
"if",
"(",
"(",
"(",
"bit",
"field",
"0",
"&",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"2",
")",
"=",
"=",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"2",
")",
"&",
"&",
"blah",
"!",
"=",
"org",
"springframework",
"protobuf",
"second",
"msg",
"get",
"default",
"instance",
"(",
")",
")",
"{",
"blah",
"=",
"org",
"springframework",
"protobuf",
"second",
"msg",
"new",
"builder",
"(",
"blah",
")",
"merge",
"from",
"(",
"value",
")",
"build",
"partial",
"(",
")",
";",
"}",
"else",
"{",
"blah",
"=",
"value",
";",
"}",
"on",
"changed",
"(",
")",
";",
"}",
"else",
"{",
"blah",
"builder",
"merge",
"from",
"(",
"value",
")",
";",
"}",
"bit",
"field",
"0",
"|",
"=",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"2",
";",
"return",
"this",
";",
"}"
] |
[
"reference",
"to",
"the",
"process",
"instance",
"on",
"which",
"this",
"comment",
"was",
"made"
] | [
"string",
"get",
"process",
"instance",
"id",
"(",
")",
";"
] |
[
"compared",
"to",
"the",
"original",
"method",
"we",
"adjust",
"the",
"nullability",
"of",
"the",
"nested",
"column",
"based",
"on",
"the",
"nullability",
"of",
"the",
"enclosing",
"type",
"if",
"the",
"fields",
"type",
"is",
"not",
"null",
",",
"but",
"the",
"enclosing",
"row",
"is",
"nullable",
"we",
"still",
"can",
"produce",
"nulls"
] | [
"public",
"rex",
"node",
"make",
"field",
"access",
"(",
"rex",
"node",
"expr",
",",
"string",
"field",
"name",
",",
"boolean",
"case",
"sensitive",
")",
"{",
"rex",
"node",
"field",
"=",
"super",
"make",
"field",
"access",
"(",
"expr",
",",
"field",
"name",
",",
"case",
"sensitive",
")",
";",
"if",
"(",
"expr",
"get",
"type",
"(",
")",
"is",
"nullable",
"(",
")",
"&",
"&",
"!",
"field",
"get",
"type",
"(",
")",
"is",
"nullable",
"(",
")",
")",
"{",
"return",
"make",
"cast",
"(",
"type",
"factory",
"create",
"type",
"with",
"nullability",
"(",
"field",
"get",
"type",
"(",
")",
",",
"true",
")",
",",
"field",
",",
"true",
")",
";",
"}",
"return",
"field",
";",
"}"
] |
[
"get",
"the",
"configured",
"operation",
"count"
] | [
"protected",
"long",
"get",
"operation",
"count",
"(",
")",
"{",
"return",
"get",
"conf",
"(",
")",
"get",
"long",
"(",
"key",
"operation",
"count",
",",
"default",
"operation",
"count",
")",
";",
"}"
] |
[
"creates",
"a",
"new",
"bitmap",
"font",
"cache",
"for",
"this",
"font",
"using",
"this",
"method",
"allows",
"the",
"font",
"to",
"provide",
"the",
"bitmap",
"font",
"cache",
"implementation",
"to",
"customize",
"rendering",
"note",
"this",
"method",
"is",
"called",
"by",
"the",
"bitmap",
"font",
"constructors",
"if",
"a",
"subclass",
"overrides",
"this",
"method",
",",
"it",
"will",
"be",
"called",
"before",
"the",
"subclass",
"constructors"
] | [
"public",
"bitmap",
"font",
"cache",
"new",
"font",
"cache",
"(",
")",
"{",
"return",
"new",
"bitmap",
"font",
"cache",
"(",
"this",
",",
"integer",
")",
";",
"}"
] |
[
"notifies",
"this",
"plugin",
"that",
"service",
"has",
"been",
"removed",
"from",
"the",
"plugin",
"tool"
] | [
"public",
"void",
"service",
"removed",
"(",
"class",
"<",
"?",
">",
"interface",
"class",
",",
"object",
"service",
")",
"{",
"if",
"(",
"interface",
"class",
"!",
"=",
"view",
"provider",
"service",
"class",
")",
"{",
"return",
";",
"}",
"view",
"provider",
"service",
"removed",
"(",
"(",
"view",
"provider",
"service",
")",
"service",
")",
";",
"}"
] |
[
"will",
"poke",
"parents",
"for",
"defaults"
] | [
"public",
"object",
"get",
"property",
"internal",
"(",
"string",
"key",
")",
"{",
"object",
"value",
"=",
"super",
"get",
"property",
"internal",
"(",
"key",
")",
";",
"if",
"(",
"value",
"=",
"=",
"null",
")",
"{",
"if",
"(",
"log",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"log",
"debug",
"(",
"\"",
"poking",
"parent",
"'",
"\"",
"+",
"get",
"parent",
"(",
")",
"get",
"class",
"(",
")",
"get",
"simple",
"name",
"(",
")",
"+",
"\"",
"'",
"for",
"key",
":",
"\"",
"+",
"key",
")",
";",
"}",
"return",
"get",
"parent",
"(",
")",
"get",
"property",
"(",
"key",
"starts",
"with",
"(",
"prefix",
"default",
")",
"?",
"key",
":",
"prefix",
"default",
"+",
"key",
")",
";",
"}",
"log",
"debug",
"(",
"\"",
"returning",
"'",
"{",
"}",
"'",
"for",
"key",
":",
"{",
"}",
"\"",
",",
"value",
",",
"key",
")",
";",
"return",
"value",
";",
"}"
] |
[
"return",
"the",
"hex",
"string",
"of",
"sha384",
"encryption"
] | [
"public",
"static",
"string",
"encrypt",
"s",
"h",
"a",
"3",
"8",
"4",
"to",
"string",
"(",
"final",
"byte",
"[",
"]",
"data",
")",
"{",
"return",
"utils",
"bridge",
"bytes",
"2",
"hex",
"string",
"(",
"encrypt",
"s",
"h",
"a",
"3",
"8",
"4",
"(",
"data",
")",
")",
";",
"}"
] |
[
"drops",
"underlying",
"database",
"table",
"using",
"d",
"a",
"os"
] | [
"public",
"static",
"void",
"drop",
"all",
"tables",
"(",
"database",
"db",
",",
"boolean",
"if",
"exists",
")",
"{",
"keep",
"entity",
"dao",
"drop",
"table",
"(",
"db",
",",
"if",
"exists",
")",
";",
"to",
"many",
"target",
"2",
"dao",
"drop",
"table",
"(",
"db",
",",
"if",
"exists",
")",
";",
"to",
"one",
"target",
"2",
"dao",
"drop",
"table",
"(",
"db",
",",
"if",
"exists",
")",
";",
"relation",
"source",
"2",
"dao",
"drop",
"table",
"(",
"db",
",",
"if",
"exists",
")",
";",
"}"
] |
[
"called",
"when",
"the",
"state",
"of",
"a",
"download",
"changes"
] | [
"default",
"void",
"on",
"download",
"changed",
"(",
"download",
"manager",
"download",
"manager",
",",
"download",
"download",
",",
"@",
"nullable",
"exception",
"final",
"exception",
")",
"{",
"}"
] |
[
"returns",
"a",
"regular",
"expression",
"representing",
"an",
"exclusive",
"filter",
"test",
"descriptions",
"that",
"match",
"this",
"regular",
"expression",
"should",
"not",
"be",
"run"
] | [
"public",
"string",
"get",
"test",
"exclude",
"filter",
"regexp",
"(",
")",
"{",
"return",
"test",
"exclude",
"filter",
"regexp",
";",
"}"
] |
[
"forces",
"the",
"scroll",
"pane",
"to",
"scroll",
"to",
"bottom",
"of",
"text",
"area"
] | [
"public",
"void",
"scroll",
"to",
"bottom",
"(",
")",
"{",
"set",
"caret",
"position",
"(",
"text",
"area",
"get",
"document",
"(",
")",
"get",
"length",
"(",
")",
")",
";",
"}"
] |
[
"set",
"the",
"matcher",
"for",
"the",
"size",
"of",
"the",
"failures",
"list",
"for",
"more",
"in",
"depth",
"matching",
"do",
"it",
"by",
"hand",
"the",
"type",
"signatures",
"required",
"to",
"match",
"the",
"actual",
"failures",
"list",
"here",
"just",
"don",
"'",
"t",
"work"
] | [
"public",
"bulk",
"index",
"by",
"scroll",
"response",
"matcher",
"failures",
"(",
"matcher",
"<",
"integer",
">",
"failures",
"matcher",
")",
"{",
"this",
"failures",
"matcher",
"=",
"failures",
"matcher",
";",
"return",
"this",
";",
"}"
] |
[
"get",
"the",
"service",
"on",
"which",
"the",
"token",
"is",
"supposed",
"to",
"be",
"used"
] | [
"public",
"text",
"get",
"service",
"(",
")",
"{",
"return",
"service",
";",
"}"
] |
[
"set",
"the",
"service",
"url",
"of",
"the",
"remote",
"{",
"@",
"code",
"m",
"bean",
"server",
"}"
] | [
"public",
"void",
"set",
"service",
"url",
"(",
"string",
"url",
")",
"throws",
"malformed",
"u",
"r",
"l",
"exception",
"{",
"this",
"service",
"url",
"=",
"new",
"j",
"m",
"x",
"service",
"u",
"r",
"l",
"(",
"url",
")",
";",
"}"
] |
[
"return",
"the",
"internal",
"lifecycle",
"processor",
"used",
"by",
"the",
"context"
] | [
"lifecycle",
"processor",
"get",
"lifecycle",
"processor",
"(",
")",
"throws",
"illegal",
"state",
"exception",
"{",
"if",
"(",
"this",
"lifecycle",
"processor",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"lifecycle",
"processor",
"not",
"initialized",
"-",
"\"",
"+",
"\"",
"call",
"'",
"refresh",
"'",
"before",
"invoking",
"lifecycle",
"methods",
"via",
"the",
"context",
":",
"\"",
"+",
"this",
")",
";",
"}",
"return",
"this",
"lifecycle",
"processor",
";",
"}"
] |
[
"inserts",
"or",
"replaces",
"the",
"given",
"instructions",
"at",
"the",
"given",
"offset"
] | [
"private",
"void",
"insert",
"instructions",
"(",
"int",
"offset",
",",
"boolean",
"replace",
",",
"boolean",
"before",
",",
"instruction",
"old",
"instruction",
",",
"int",
"new",
"opcodes",
")",
"{",
"/",
"/",
"is",
"it",
"a",
"suitable",
"(",
"extended",
")",
"opcode",
"?",
"if",
"(",
"new",
"opcodes",
"=",
"=",
"unsupported",
")",
"{",
"/",
"/",
"we",
"can",
"'",
"t",
"easily",
"emulate",
"some",
"constructs",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
"\"",
"can",
"'",
"t",
"handle",
"\"",
"+",
"old",
"instruction",
"to",
"string",
"(",
"offset",
")",
")",
";",
"}",
"/",
"/",
"mark",
"this",
"instruction",
"mark",
"instruction",
"(",
"offset",
")",
";",
"/",
"/",
"is",
"it",
"a",
"single",
"new",
"instruction",
"?",
"if",
"(",
"(",
"new",
"opcodes",
"&",
"~",
"0xff",
")",
"=",
"=",
"0",
")",
"{",
"/",
"/",
"insert",
"or",
"replace",
"the",
"single",
"instruction",
"insert",
"instruction",
"(",
"offset",
",",
"replace",
",",
"before",
",",
"old",
"instruction",
",",
"new",
"simple",
"instruction",
"(",
"(",
"byte",
")",
"new",
"opcodes",
")",
")",
";",
"}",
"else",
"{",
"/",
"/",
"count",
"the",
"number",
"of",
"instructions",
"int",
"count",
"=",
"0",
";",
"for",
"(",
"int",
"opcodes",
"=",
"new",
"opcodes",
";",
"opcodes",
"!",
"=",
"0",
";",
"opcodes",
">",
">",
">",
"=",
"8",
")",
"{",
"count",
"+",
"+",
";",
"}",
"instruction",
"[",
"]",
"new",
"instructions",
"=",
"new",
"instruction",
"[",
"count",
"]",
";",
"/",
"/",
"collect",
"the",
"instructions",
"count",
"=",
"0",
";",
"for",
"(",
"int",
"opcodes",
"=",
"new",
"opcodes",
";",
"opcodes",
"!",
"=",
"0",
";",
"opcodes",
">",
">",
">",
"=",
"8",
")",
"{",
"new",
"instructions",
"[",
"count",
"+",
"+",
"]",
"=",
"new",
"simple",
"instruction",
"(",
"(",
"byte",
")",
"opcodes",
")",
";",
"}",
"/",
"/",
"replace",
"or",
"insert",
"them",
"insert",
"instructions",
"(",
"offset",
",",
"replace",
",",
"before",
",",
"old",
"instruction",
",",
"new",
"instructions",
")",
";",
"}",
"}"
] |
[
"terminates",
"a",
"check",
"-",
"in",
"which",
"is",
"in",
"progress",
"or",
"has",
"been",
"completed"
] | [
"void",
"end",
"checkin",
"(",
"long",
"item",
"checkin",
"id",
")",
"{",
"synchronized",
"(",
"file",
"system",
")",
"{",
"if",
"(",
"this",
"checkin",
"id",
"=",
"=",
"item",
"checkin",
"id",
")",
"{",
"this",
"checkin",
"id",
"=",
"default",
"checkout",
"id",
";",
"/",
"/",
"log",
"put",
"(",
"\"",
"check",
"-",
"in",
"ended",
":",
"\"",
"+",
"checkin",
"id",
")",
";",
"}",
"}",
"}"
] |
[
"optional",
",",
"the",
"smallest",
"value",
"of",
"the",
"first",
"partition"
] | [
"public",
"builder",
"set",
"partition",
"lower",
"bound",
"(",
"long",
"partition",
"lower",
"bound",
")",
"{",
"this",
"partition",
"lower",
"bound",
"=",
"partition",
"lower",
"bound",
";",
"return",
"this",
";",
"}"
] |
[
"verifies",
"that",
"the",
"chain",
"startend",
"is",
"correctly",
"set"
] | [
"public",
"void",
"test",
"chain",
"start",
"end",
"setting",
"(",
")",
"throws",
"exception",
"{",
"stream",
"execution",
"environment",
"env",
"=",
"stream",
"execution",
"environment",
"get",
"execution",
"environment",
"(",
")",
";",
"/",
"/",
"set",
"parallelism",
"to",
"2",
"to",
"avoid",
"chaining",
"with",
"source",
"in",
"case",
"when",
"available",
"processors",
"is",
"/",
"/",
"1",
"env",
"set",
"parallelism",
"(",
"2",
")",
";",
"/",
"/",
"from",
"elements",
"-",
">",
"chain",
"(",
"map",
"-",
">",
"print",
")",
"env",
"from",
"elements",
"(",
"1",
",",
"2",
",",
"3",
")",
"map",
"(",
"new",
"map",
"function",
"<",
"integer",
",",
"integer",
">",
"(",
")",
"{",
"@",
"override",
"public",
"integer",
"map",
"(",
"integer",
"value",
")",
"throws",
"exception",
"{",
"return",
"value",
";",
"}",
"}",
")",
"print",
"(",
")",
";",
"job",
"graph",
"job",
"graph",
"=",
"streaming",
"job",
"graph",
"generator",
"create",
"job",
"graph",
"(",
"env",
"get",
"stream",
"graph",
"(",
")",
")",
";",
"list",
"<",
"job",
"vertex",
">",
"vertices",
"sorted",
"=",
"job",
"graph",
"get",
"vertices",
"sorted",
"topologically",
"from",
"sources",
"(",
")",
";",
"job",
"vertex",
"source",
"vertex",
"=",
"vertices",
"sorted",
"get",
"(",
"0",
")",
";",
"job",
"vertex",
"map",
"print",
"vertex",
"=",
"vertices",
"sorted",
"get",
"(",
"1",
")",
";",
"assert",
"equals",
"(",
"result",
"partition",
"type",
"pipelined",
"bounded",
",",
"source",
"vertex",
"get",
"produced",
"data",
"sets",
"(",
")",
"get",
"(",
"0",
")",
"get",
"result",
"type",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"result",
"partition",
"type",
"pipelined",
"bounded",
",",
"map",
"print",
"vertex",
"get",
"inputs",
"(",
")",
"get",
"(",
"0",
")",
"get",
"source",
"(",
")",
"get",
"result",
"type",
"(",
")",
")",
";",
"stream",
"config",
"source",
"config",
"=",
"new",
"stream",
"config",
"(",
"source",
"vertex",
"get",
"configuration",
"(",
")",
")",
";",
"stream",
"config",
"map",
"config",
"=",
"new",
"stream",
"config",
"(",
"map",
"print",
"vertex",
"get",
"configuration",
"(",
")",
")",
";",
"map",
"<",
"integer",
",",
"stream",
"config",
">",
"chained",
"configs",
"=",
"map",
"config",
"get",
"transitive",
"chained",
"task",
"configs",
"(",
"get",
"class",
"(",
")",
"get",
"class",
"loader",
"(",
")",
")",
";",
"stream",
"config",
"print",
"config",
"=",
"chained",
"configs",
"values",
"(",
")",
"iterator",
"(",
")",
"next",
"(",
")",
";",
"assert",
"true",
"(",
"source",
"config",
"is",
"chain",
"start",
"(",
")",
")",
";",
"assert",
"true",
"(",
"source",
"config",
"is",
"chain",
"end",
"(",
")",
")",
";",
"assert",
"true",
"(",
"map",
"config",
"is",
"chain",
"start",
"(",
")",
")",
";",
"assert",
"false",
"(",
"map",
"config",
"is",
"chain",
"end",
"(",
")",
")",
";",
"assert",
"false",
"(",
"print",
"config",
"is",
"chain",
"start",
"(",
")",
")",
";",
"assert",
"true",
"(",
"print",
"config",
"is",
"chain",
"end",
"(",
")",
")",
";",
"}"
] |
[
"this",
"operation",
"adds",
"all",
"inverse",
"-",
"direction",
"edges",
"to",
"the",
"graph"
] | [
"public",
"graph",
"<",
"k",
",",
"vv",
",",
"ev",
">",
"get",
"undirected",
"(",
")",
"{",
"data",
"set",
"<",
"edge",
"<",
"k",
",",
"ev",
">",
">",
"undirected",
"edges",
"=",
"edges",
"flat",
"map",
"(",
"new",
"regular",
"and",
"reversed",
"edges",
"map",
"<",
">",
"(",
")",
")",
"name",
"(",
"\"",
"to",
"undirected",
"graph",
"\"",
")",
";",
"return",
"new",
"graph",
"<",
">",
"(",
"vertices",
",",
"undirected",
"edges",
",",
"this",
"context",
")",
";",
"}"
] |
[
"sets",
"the",
"vote",
"count",
"for",
"this",
"association",
"which",
"should",
"be",
"used",
"to",
"indicate",
"the",
"number",
"of",
"supporting",
"facts",
"for",
"this",
"association"
] | [
"public",
"void",
"set",
"vote",
"count",
"(",
"int",
"vote",
"count",
")",
";"
] |
[
"test",
"the",
"property",
"'",
"prefix",
"boolean",
"'"
] | [
"public",
"void",
"prefix",
"boolean",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"prefix",
"boolean",
"}"
] |
[
"test",
"serialization",
"of",
"outer",
"boolean",
"types"
] | [
"public",
"void",
"fake",
"outer",
"boolean",
"serialize",
"test",
"(",
")",
"throws",
"api",
"exception",
"{",
"boolean",
"body",
"=",
"null",
";",
"boolean",
"response",
"=",
"api",
"fake",
"outer",
"boolean",
"serialize",
"(",
"body",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.