docstring_tokens
sequence | code_tokens
sequence |
|---|---|
[
"checks",
"that",
"the",
"elements",
"of",
"the",
"iterable",
"are",
"calculated",
"on",
"the",
"fly",
"concretely",
",",
"that",
"means",
"that",
"{",
"@",
"link",
"successors",
"function",
"#",
"successors",
"(",
"object",
")",
"}",
"can",
"only",
"be",
"called",
"for",
"a",
"subset",
"of",
"all",
"nodes"
] | [
"public",
"void",
"for",
"graph",
"breadth",
"first",
"iterable",
"empty",
"graph",
"(",
")",
"{",
"assert",
"equal",
"char",
"nodes",
"(",
"traverser",
"for",
"graph",
"(",
"create",
"directed",
"graph",
"(",
")",
")",
"breadth",
"first",
"(",
"characters",
"of",
"(",
"\"",
"\"",
")",
")",
",",
"\"",
"\"",
")",
";",
"try",
"{",
"traverser",
"for",
"graph",
"(",
"create",
"directed",
"graph",
"(",
")",
")",
"breadth",
"first",
"(",
"characters",
"of",
"(",
"\"",
"a",
"\"",
")",
")",
";",
"fail",
"(",
"\"",
"expected",
"illegal",
"argument",
"exception",
"\"",
")",
";",
"}",
"catch",
"(",
"illegal",
"argument",
"exception",
"expected",
")",
"{",
"}",
"}"
] |
[
"parse",
"the",
"expected",
"and",
"actual",
"strings",
"as",
"json",
"and",
"assert",
"the",
"two",
"are",
"\"",
"similar",
"\"",
"-",
"i",
"e",
"they",
"contain",
"the",
"same",
"attribute",
"-",
"value",
"pairs",
"regardless",
"of",
"formatting",
"with",
"a",
"lenient",
"checking",
"(",
"extensible",
",",
"and",
"non",
"-",
"strict",
"array",
"ordering",
")"
] | [
"public",
"result",
"matcher",
"json",
"(",
"string",
"json",
"content",
")",
"{",
"return",
"json",
"(",
"json",
"content",
",",
"false",
")",
";",
"}"
] |
[
"this",
"bridge",
"method",
"is",
"to",
"maintain",
"binary",
"compatibility",
"with",
"{",
"@",
"link",
"top",
"level",
"item",
"#",
"get",
"parent",
"(",
")",
"}"
] | [
"@",
"override",
"public",
"@",
"non",
"null",
"item",
"group",
"get",
"parent",
"(",
")",
"{",
"if",
"(",
"parent",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"no",
"parent",
"set",
"on",
"\"",
"+",
"get",
"class",
"(",
")",
"get",
"name",
"(",
")",
"+",
"\"",
"[",
"\"",
"+",
"name",
"+",
"\"",
"]",
"\"",
")",
";",
"}",
"return",
"parent",
";",
"}"
] |
[
"gets",
"symbol",
"id",
"groups",
"for",
"each",
"library",
"symbol",
"that",
"is",
"new",
"in",
"the",
"my",
"program",
"(",
"symbol",
"wasn",
"'",
"t",
"in",
"the",
"original",
"program",
")",
"<",
"br",
">",
"note",
":",
"this",
"method",
"excludes",
"any",
"new",
"library",
"symbols",
"in",
"original",
"whose",
"matching",
"result",
"id",
"has",
"already",
"been",
"placed",
"in",
"the",
"result",
"i",
"ds",
"in",
"a",
"group",
"set",
"otherwise",
",",
"each",
"id",
"group",
"that",
"has",
"a",
"result",
"id",
"will",
"add",
"it",
"to",
"the",
"result",
"i",
"ds",
"in",
"a",
"group",
"set"
] | [
"private",
"list",
"<",
"i",
"d",
"group",
">",
"get",
"groups",
"for",
"my",
"new",
"libs",
"(",
")",
"{",
"list",
"<",
"i",
"d",
"group",
">",
"id",
"groups",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"string",
"[",
"]",
"my",
"names",
"=",
"my",
"ext",
"mgr",
"get",
"external",
"library",
"names",
"(",
")",
";",
"symbol",
"table",
"original",
"symbol",
"table",
"=",
"original",
"pgm",
"get",
"symbol",
"table",
"(",
")",
";",
"symbol",
"table",
"my",
"symbol",
"table",
"=",
"my",
"pgm",
"get",
"symbol",
"table",
"(",
")",
";",
"for",
"(",
"string",
"my",
"name",
":",
"my",
"names",
")",
"{",
"symbol",
"my",
"library",
"symbol",
"=",
"my",
"symbol",
"table",
"get",
"library",
"symbol",
"(",
"my",
"name",
")",
";",
"long",
"my",
"i",
"d",
"=",
"my",
"library",
"symbol",
"get",
"i",
"d",
"(",
")",
";",
"if",
"(",
"original",
"symbol",
"table",
"get",
"symbol",
"(",
"my",
"i",
"d",
")",
"!",
"=",
"null",
")",
"{",
"continue",
";",
"/",
"/",
"get",
"groups",
"for",
"original",
"libs",
"already",
"got",
"this",
"}",
"long",
"result",
"i",
"d",
";",
"try",
"{",
"result",
"i",
"d",
"=",
"get",
"result",
"i",
"d",
"from",
"my",
"i",
"d",
"(",
"my",
"i",
"d",
")",
";",
"}",
"catch",
"(",
"no",
"value",
"exception",
"e",
")",
"{",
"result",
"i",
"d",
"=",
"my",
"i",
"d",
";",
"}",
"/",
"/",
"get",
"original",
"and",
"latest",
"for",
"this",
"my",
"'",
"s",
"matching",
"result",
"id",
"long",
"original",
"i",
"d",
"=",
"get",
"original",
"i",
"d",
"for",
"result",
"i",
"d",
"(",
"result",
"i",
"d",
")",
";",
"long",
"latest",
"i",
"d",
"=",
"get",
"latest",
"i",
"d",
"for",
"result",
"i",
"d",
"(",
"result",
"i",
"d",
")",
";",
"if",
"(",
"result",
"i",
"ds",
"in",
"a",
"group",
"contains",
"(",
"result",
"i",
"d",
")",
")",
"{",
"continue",
";",
"/",
"/",
"already",
"have",
"this",
"result",
"as",
"an",
"i",
"d",
"group",
"}",
"id",
"groups",
"add",
"(",
"new",
"i",
"d",
"group",
"(",
"result",
"i",
"d",
",",
"original",
"i",
"d",
",",
"latest",
"i",
"d",
",",
"my",
"i",
"d",
")",
")",
";",
"if",
"(",
"result",
"i",
"d",
"!",
"=",
"-",
"1",
")",
"{",
"result",
"i",
"ds",
"in",
"a",
"group",
"add",
"(",
"result",
"i",
"d",
")",
";",
"}",
"}",
"return",
"id",
"groups",
";",
"}"
] |
[
"returns",
"{",
"@",
"link",
"invokable",
"}",
"of",
"{",
"@",
"code",
"method",
"}"
] | [
"public",
"static",
"invokable",
"<",
"?",
",",
"object",
">",
"from",
"(",
"method",
"method",
")",
"{",
"return",
"new",
"method",
"invokable",
"<",
">",
"(",
"method",
")",
";",
"}"
] |
[
"starts",
"loading",
"a",
"{",
"@",
"link",
"loadable",
"}",
"the",
"calling",
"thread",
"must",
"be",
"a",
"{",
"@",
"link",
"looper",
"}",
"thread",
",",
"which",
"is",
"the",
"thread",
"on",
"which",
"the",
"{",
"@",
"link",
"callback",
"}",
"will",
"be",
"called"
] | [
"public",
"<",
"t",
"extends",
"loadable",
">",
"long",
"start",
"loading",
"(",
"t",
"loadable",
",",
"callback",
"<",
"t",
">",
"callback",
",",
"int",
"default",
"min",
"retry",
"count",
")",
"{",
"looper",
"looper",
"=",
"assertions",
"check",
"state",
"not",
"null",
"(",
"looper",
"my",
"looper",
"(",
")",
")",
";",
"fatal",
"error",
"=",
"null",
";",
"long",
"start",
"time",
"ms",
"=",
"system",
"clock",
"elapsed",
"realtime",
"(",
")",
";",
"new",
"load",
"task",
"<",
">",
"(",
"looper",
",",
"loadable",
",",
"callback",
",",
"default",
"min",
"retry",
"count",
",",
"start",
"time",
"ms",
")",
"start",
"(",
"0",
")",
";",
"return",
"start",
"time",
"ms",
";",
"}"
] |
[
"the",
"replication",
"factor",
"for",
"the",
"new",
"topic",
"or",
"-",
"1",
"if",
"a",
"replica",
"assignment",
"has",
"been",
"specified"
] | [
"public",
"short",
"replication",
"factor",
"(",
")",
"{",
"return",
"replication",
"factor",
"or",
"else",
"(",
"create",
"topics",
"request",
"no",
"replication",
"factor",
")",
";",
"}"
] |
[
"returns",
"restore",
"information",
"if",
"snapshot",
"was",
"completed",
"before",
"this",
"method",
"returned",
",",
"null",
"otherwise"
] | [
"public",
"restore",
"info",
"get",
"restore",
"info",
"(",
")",
"{",
"return",
"restore",
"info",
";",
"}"
] |
[
"generate",
"the",
"bytecode",
"for",
"this",
"node",
"into",
"the",
"supplied",
"visitor",
"context",
"info",
"about",
"the",
"current",
"expression",
"being",
"compiled",
"is",
"available",
"in",
"the",
"codeflow",
"object",
",",
"e",
"g",
"including",
"information",
"about",
"the",
"type",
"of",
"the",
"object",
"currently",
"on",
"the",
"stack"
] | [
"public",
"void",
"generate",
"code",
"(",
"method",
"visitor",
"mv",
",",
"code",
"flow",
"cf",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"get",
"class",
"(",
")",
"get",
"name",
"(",
")",
"+",
"\"",
"has",
"no",
"generate",
"code",
"(",
")",
"method",
"\"",
")",
";",
"}"
] |
[
"returns",
"a",
"view",
"of",
"{",
"@",
"code",
"network",
"}",
"with",
"the",
"direction",
"(",
"if",
"any",
")",
"of",
"every",
"edge",
"reversed",
"all",
"other",
"properties",
"remain",
"intact",
",",
"and",
"further",
"updates",
"to",
"{",
"@",
"code",
"network",
"}",
"will",
"be",
"reflected",
"in",
"the",
"view"
] | [
"public",
"static",
"<",
"n",
",",
"e",
">",
"network",
"<",
"n",
",",
"e",
">",
"transpose",
"(",
"network",
"<",
"n",
",",
"e",
">",
"network",
")",
"{",
"if",
"(",
"!",
"network",
"is",
"directed",
"(",
")",
")",
"{",
"return",
"network",
";",
"/",
"/",
"the",
"transpose",
"of",
"an",
"undirected",
"network",
"is",
"an",
"identical",
"network",
"}",
"if",
"(",
"network",
"instanceof",
"transposed",
"network",
")",
"{",
"return",
"(",
"(",
"transposed",
"network",
"<",
"n",
",",
"e",
">",
")",
"network",
")",
"network",
";",
"}",
"return",
"new",
"transposed",
"network",
"<",
">",
"(",
"network",
")",
";",
"}"
] |
[
"check",
"if",
"act",
"as",
"restful",
"destroy",
"method"
] | [
"public",
"boolean",
"is",
"restful",
"destroy",
"(",
")",
"{",
"return",
"\"",
"delete",
"\"",
"equals",
"ignore",
"case",
"(",
"http",
"method",
")",
"&",
"&",
"is",
"member",
"path",
"(",
")",
";",
"}"
] |
[
"model",
"tests",
"for",
"capitalization"
] | [
"public",
"void",
"test",
"capitalization",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"capitalization",
"}"
] |
[
"writes",
"all",
"the",
"remaining",
"ints",
"of",
"the",
"{",
"@",
"code",
"src",
"}",
"int",
"buffer",
"to",
"this",
"buffer",
"'",
"s",
"current",
"position",
",",
"and",
"increases",
"both",
"buffers",
"'",
"position",
"by",
"the",
"number",
"of",
"ints",
"copied"
] | [
"public",
"int",
"buffer",
"put",
"(",
"int",
"buffer",
"src",
")",
"{",
"if",
"(",
"src",
"=",
"=",
"this",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
")",
";",
"}",
"if",
"(",
"src",
"remaining",
"(",
")",
">",
"remaining",
"(",
")",
")",
"{",
"throw",
"new",
"buffer",
"overflow",
"exception",
"(",
")",
";",
"}",
"int",
"[",
"]",
"contents",
"=",
"new",
"int",
"[",
"src",
"remaining",
"(",
")",
"]",
";",
"src",
"get",
"(",
"contents",
")",
";",
"put",
"(",
"contents",
")",
";",
"return",
"this",
";",
"}"
] |
[
"<",
"code",
">",
"optional",
"aapt",
"pb",
"raw",
"string",
"raw",
"str",
"=",
"3",
";",
"<",
"code",
">"
] | [
"private",
"void",
"clear",
"raw",
"str",
"(",
")",
"{",
"raw",
"str",
"=",
"null",
";",
"bit",
"field",
"0",
"=",
"(",
"bit",
"field",
"0",
"&",
"~",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"4",
")",
";",
"}"
] |
[
"returns",
"the",
"default",
"settings",
"for",
"the",
"cluster",
"(",
"only",
"if",
"{",
"@",
"code",
"include",
"defaults",
"}",
"was",
"set",
"to",
"true",
"in",
"the",
"request",
")"
] | [
"public",
"settings",
"get",
"default",
"settings",
"(",
")",
"{",
"return",
"default",
"settings",
";",
"}"
] |
[
"overridden",
"so",
"that",
"our",
"text",
"area",
"will",
"properly",
"consume",
"key",
"events",
"for",
"registered",
"actions",
"by",
"default",
"the",
"j",
"components",
"will",
"not",
"process",
"a",
"keystroke",
"with",
"an",
"assigned",
"keybinding",
"if",
"the",
"assigned",
"action",
"is",
"not",
"enabled",
"we",
"want",
"to",
"always",
"process",
"registered",
"keystrokes",
"so",
"that",
"they",
"do",
"not",
"get",
"handled",
"elsewhere",
"in",
"ghidra",
"accidentally",
"for",
"example",
",",
"ctrl",
"-",
"s",
"is",
"bound",
"to",
"save",
"for",
"this",
"text",
"area",
"if",
"there",
"have",
"been",
"no",
"changes",
"in",
"the",
"data",
",",
"then",
"the",
"save",
"action",
"is",
"not",
"enabled",
"so",
",",
"when",
"the",
"user",
"presses",
"ctrl",
"-",
"s",
"in",
"this",
"window",
",",
"then",
",",
"by",
"default",
",",
"the",
"text",
"area",
"will",
"not",
"consume",
"the",
"event",
"and",
"the",
"event",
"will",
"end",
"up",
"moving",
"up",
"to",
"the",
"tool",
"level",
"and",
"executing",
"a",
"save",
"there",
",",
"which",
"is",
"clearly",
"not",
"the",
"intended",
"effect",
"in",
"this",
"example",
"we",
"really",
"just",
"want",
"this",
"window",
"to",
"do",
"nothing",
"if",
"the",
"save",
"is",
"not",
"enabled"
] | [
"protected",
"boolean",
"process",
"key",
"binding",
"(",
"key",
"stroke",
"ks",
",",
"key",
"event",
"e",
",",
"int",
"condition",
",",
"boolean",
"pressed",
")",
"{",
"input",
"map",
"map",
"=",
"get",
"input",
"map",
"(",
"condition",
")",
";",
"action",
"map",
"am",
"=",
"get",
"action",
"map",
"(",
")",
";",
"if",
"(",
"map",
"!",
"=",
"null",
"&",
"&",
"am",
"!",
"=",
"null",
"&",
"&",
"is",
"enabled",
"(",
")",
")",
"{",
"object",
"binding",
"=",
"map",
"get",
"(",
"ks",
")",
";",
"action",
"action",
"=",
"(",
"binding",
"=",
"=",
"null",
")",
"?",
"null",
":",
"am",
"get",
"(",
"binding",
")",
";",
"if",
"(",
"action",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"!",
"action",
"is",
"enabled",
"(",
")",
")",
"{",
"/",
"/",
"we",
"want",
"to",
"consume",
"the",
"event",
"here",
",",
"so",
"ghidra",
"doesn",
"'",
"t",
"get",
"to",
"/",
"/",
"process",
"it",
"when",
"the",
"actions",
"are",
"disabled",
"e",
"consume",
"(",
")",
";",
"return",
"true",
";",
"}",
"return",
"swing",
"utilities",
"notify",
"action",
"(",
"action",
",",
"ks",
",",
"e",
",",
"this",
",",
"e",
"get",
"modifiers",
"ex",
"(",
")",
")",
";",
"}",
"}",
"return",
"false",
";",
"}"
] |
[
"called",
"when",
"there",
"is",
"a",
"state",
"change",
"in",
"the",
"connection"
] | [
"void",
"state",
"changed",
"(",
"client",
"client",
",",
"int",
"new",
"state",
")",
";"
] |
[
"returns",
"the",
"regular",
"expressions",
"for",
"exclusion",
"matching"
] | [
"public",
"string",
"[",
"]",
"get",
"excluded",
"patterns",
"(",
")",
"{",
"return",
"this",
"excluded",
"patterns",
";",
"}"
] |
[
"return",
"the",
"files",
"'",
"path",
"in",
"zip",
"file"
] | [
"public",
"static",
"list",
"<",
"string",
">",
"get",
"files",
"path",
"(",
"final",
"file",
"zip",
"file",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"zip",
"file",
"=",
"=",
"null",
")",
"return",
"null",
";",
"list",
"<",
"string",
">",
"paths",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"zip",
"file",
"zip",
"=",
"new",
"zip",
"file",
"(",
"zip",
"file",
")",
";",
"enumeration",
"<",
"?",
">",
"entries",
"=",
"zip",
"entries",
"(",
")",
";",
"while",
"(",
"entries",
"has",
"more",
"elements",
"(",
")",
")",
"{",
"string",
"entry",
"name",
"=",
"(",
"(",
"zip",
"entry",
")",
"entries",
"next",
"element",
"(",
")",
")",
"get",
"name",
"(",
")",
"replace",
"(",
"\"",
"\\",
"\\",
"\"",
",",
"\"",
"/",
"\"",
")",
";",
"if",
"(",
"entry",
"name",
"contains",
"(",
"\"",
"/",
"\"",
")",
")",
"{",
"log",
"e",
"(",
"\"",
"zip",
"utils",
"\"",
",",
"\"",
"entry",
"name",
":",
"\"",
"+",
"entry",
"name",
"+",
"\"",
"is",
"dangerous",
"!",
"\"",
")",
";",
"paths",
"add",
"(",
"entry",
"name",
")",
";",
"}",
"else",
"{",
"paths",
"add",
"(",
"entry",
"name",
")",
";",
"}",
"}",
"zip",
"close",
"(",
")",
";",
"return",
"paths",
";",
"}"
] |
[
"set",
"optional",
"message",
"arguments",
"for",
"this",
"tag",
",",
"as",
"a",
"comma",
"-",
"delimited",
"string",
"(",
"each",
"string",
"argument",
"can",
"contain",
"jsp",
"el",
")",
",",
"an",
"object",
"array",
"(",
"used",
"as",
"argument",
"array",
")",
",",
"or",
"a",
"single",
"object",
"(",
"used",
"as",
"single",
"argument",
")"
] | [
"public",
"void",
"set",
"arguments",
"(",
"object",
"arguments",
")",
"{",
"this",
"arguments",
"=",
"arguments",
";",
"}"
] |
[
"add",
"a",
"bdo",
"(",
"bidirectional",
"override",
")",
"element"
] | [
"special",
"bdo",
"(",
"dir",
"dir",
",",
"string",
"cdata",
")",
";"
] |
[
"test",
"to",
"reconfigure",
"enabledisable",
"ipc",
"backoff"
] | [
"public",
"void",
"test",
"reconfigure",
"i",
"p",
"c",
"backoff",
"(",
")",
"throws",
"reconfiguration",
"exception",
"{",
"final",
"name",
"node",
"name",
"node",
"=",
"cluster",
"get",
"name",
"node",
"(",
")",
";",
"name",
"node",
"rpc",
"server",
"nnrs",
"=",
"(",
"name",
"node",
"rpc",
"server",
")",
"name",
"node",
"get",
"rpc",
"server",
"(",
")",
";",
"string",
"ipc",
"client",
"r",
"p",
"c",
"backoff",
"enable",
"=",
"name",
"node",
"build",
"backoff",
"enable",
"key",
"(",
"nnrs",
"get",
"client",
"rpc",
"server",
"(",
")",
"get",
"port",
"(",
")",
")",
";",
"/",
"/",
"try",
"invalid",
"values",
"verify",
"reconfigure",
"i",
"p",
"c",
"backoff",
"(",
"name",
"node",
",",
"nnrs",
",",
"ipc",
"client",
"r",
"p",
"c",
"backoff",
"enable",
",",
"false",
")",
";",
"/",
"/",
"enable",
"ipc",
"client",
"rpc",
"backoff",
"name",
"node",
"reconfigure",
"property",
"(",
"ipc",
"client",
"r",
"p",
"c",
"backoff",
"enable",
",",
"\"",
"true",
"\"",
")",
";",
"verify",
"reconfigure",
"i",
"p",
"c",
"backoff",
"(",
"name",
"node",
",",
"nnrs",
",",
"ipc",
"client",
"r",
"p",
"c",
"backoff",
"enable",
",",
"true",
")",
";",
"/",
"/",
"disable",
"ipc",
"client",
"rpc",
"backoff",
"name",
"node",
"reconfigure",
"property",
"(",
"ipc",
"client",
"r",
"p",
"c",
"backoff",
"enable",
",",
"\"",
"false",
"\"",
")",
";",
"verify",
"reconfigure",
"i",
"p",
"c",
"backoff",
"(",
"name",
"node",
",",
"nnrs",
",",
"ipc",
"client",
"r",
"p",
"c",
"backoff",
"enable",
",",
"false",
")",
";",
"/",
"/",
"revert",
"to",
"default",
"name",
"node",
"reconfigure",
"property",
"(",
"ipc",
"client",
"r",
"p",
"c",
"backoff",
"enable",
",",
"null",
")",
";",
"assert",
"equals",
"(",
"ipc",
"client",
"r",
"p",
"c",
"backoff",
"enable",
"+",
"\"",
"has",
"wrong",
"value",
"\"",
",",
"false",
",",
"nnrs",
"get",
"client",
"rpc",
"server",
"(",
")",
"is",
"client",
"backoff",
"enabled",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"ipc",
"client",
"r",
"p",
"c",
"backoff",
"enable",
"+",
"\"",
"has",
"wrong",
"value",
"\"",
",",
"null",
",",
"name",
"node",
"get",
"conf",
"(",
")",
"get",
"(",
"ipc",
"client",
"r",
"p",
"c",
"backoff",
"enable",
")",
")",
";",
"}"
] |
[
"create",
"a",
"new",
"index",
"on",
"the",
"singleton",
"node",
"with",
"the",
"provided",
"index",
"settings"
] | [
"protected",
"index",
"service",
"create",
"index",
"(",
"string",
"index",
",",
"settings",
"settings",
")",
"{",
"return",
"create",
"index",
"(",
"index",
",",
"settings",
",",
"null",
")",
";",
"}"
] |
[
"helper",
"method",
"to",
"get",
"field",
"mapped",
"to",
"this",
"field",
"pattern"
] | [
"private",
"static",
"collection",
"<",
"string",
">",
"get",
"mapped",
"field",
"(",
"query",
"shard",
"context",
"context",
",",
"string",
"field",
"pattern",
")",
"{",
"if",
"(",
"context",
"is",
"field",
"mapped",
"(",
"field",
"names",
"field",
"mapper",
"name",
")",
"=",
"=",
"false",
")",
"{",
"/",
"/",
"can",
"only",
"happen",
"when",
"no",
"types",
"exist",
",",
"so",
"no",
"docs",
"exist",
"either",
"return",
"collections",
"empty",
"set",
"(",
")",
";",
"}",
"final",
"collection",
"<",
"string",
">",
"fields",
";",
"if",
"(",
"context",
"get",
"object",
"mapper",
"(",
"field",
"pattern",
")",
"!",
"=",
"null",
")",
"{",
"/",
"/",
"the",
"field",
"names",
"field",
"also",
"indexes",
"objects",
",",
"so",
"we",
"don",
"'",
"t",
"have",
"to",
"/",
"/",
"do",
"any",
"more",
"work",
"to",
"support",
"exists",
"queries",
"on",
"whole",
"objects",
"fields",
"=",
"collections",
"singleton",
"(",
"field",
"pattern",
")",
";",
"}",
"else",
"{",
"fields",
"=",
"context",
"simple",
"match",
"to",
"index",
"names",
"(",
"field",
"pattern",
")",
";",
"}",
"if",
"(",
"fields",
"size",
"(",
")",
"=",
"=",
"1",
")",
"{",
"string",
"field",
"=",
"fields",
"iterator",
"(",
")",
"next",
"(",
")",
";",
"if",
"(",
"context",
"is",
"field",
"mapped",
"(",
"field",
")",
"=",
"=",
"false",
")",
"{",
"/",
"/",
"the",
"field",
"does",
"not",
"exist",
"as",
"a",
"leaf",
"but",
"could",
"be",
"an",
"object",
"so",
"/",
"/",
"check",
"for",
"an",
"object",
"mapper",
"if",
"(",
"context",
"get",
"object",
"mapper",
"(",
"field",
")",
"=",
"=",
"null",
")",
"{",
"return",
"collections",
"empty",
"set",
"(",
")",
";",
"}",
"}",
"}",
"return",
"fields",
";",
"}"
] |
[
"add",
"access",
"to",
"path",
"with",
"direct",
"andor",
"recursive",
"access",
"this",
"also",
"creates",
"the",
"directory",
"if",
"it",
"does",
"not",
"exist"
] | [
"public",
"static",
"void",
"add",
"directory",
"path",
"(",
"permissions",
"policy",
",",
"string",
"configuration",
"name",
",",
"path",
"path",
",",
"string",
"permissions",
",",
"boolean",
"recursive",
"access",
"only",
")",
"throws",
"i",
"o",
"exception",
"{",
"/",
"/",
"paths",
"may",
"not",
"exist",
"yet",
",",
"this",
"also",
"checks",
"accessibility",
"try",
"{",
"security",
"ensure",
"directory",
"exists",
"(",
"path",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"unable",
"to",
"access",
"'",
"\"",
"+",
"configuration",
"name",
"+",
"\"",
"'",
"(",
"\"",
"+",
"path",
"+",
"\"",
")",
"\"",
",",
"e",
")",
";",
"}",
"/",
"/",
"for",
"some",
"file",
"permissions",
"(",
"data",
"path",
")",
"we",
"create",
"a",
"permissions",
"object",
"that",
"only",
"checks",
"the",
"concrete",
"/",
"/",
"path",
"adding",
"the",
"directory",
"would",
"only",
"create",
"more",
"overhead",
"for",
"this",
"fast",
"path",
"if",
"(",
"recursive",
"access",
"only",
"=",
"=",
"false",
")",
"{",
"/",
"/",
"add",
"access",
"for",
"path",
"itself",
"policy",
"add",
"(",
"new",
"file",
"permission",
"(",
"path",
"to",
"string",
"(",
")",
",",
"permissions",
")",
")",
";",
"}",
"policy",
"add",
"(",
"new",
"file",
"permission",
"(",
"path",
"to",
"string",
"(",
")",
"+",
"path",
"get",
"file",
"system",
"(",
")",
"get",
"separator",
"(",
")",
"+",
"\"",
"-",
"\"",
",",
"permissions",
")",
")",
";",
"/",
"*",
"*",
"the",
"file",
"permission",
"model",
"since",
"jdk",
"9",
"requires",
"this",
"due",
"to",
"the",
"removal",
"of",
"pathname",
"canonicalization",
"see",
"also",
"*",
"https",
":",
"/",
"/",
"github",
"com",
"/",
"elastic",
"/",
"elasticsearch",
"/",
"issues",
"/",
"21534",
"*",
"/",
"final",
"path",
"real",
"path",
"=",
"path",
"to",
"real",
"path",
"(",
")",
";",
"if",
"(",
"path",
"to",
"string",
"(",
")",
"equals",
"(",
"real",
"path",
"to",
"string",
"(",
")",
")",
"=",
"=",
"false",
")",
"{",
"if",
"(",
"recursive",
"access",
"only",
"=",
"=",
"false",
")",
"{",
"/",
"/",
"add",
"access",
"for",
"path",
"itself",
"policy",
"add",
"(",
"new",
"file",
"permission",
"(",
"real",
"path",
"to",
"string",
"(",
")",
",",
"permissions",
")",
")",
";",
"}",
"/",
"/",
"add",
"access",
"for",
"files",
"underneath",
"policy",
"add",
"(",
"new",
"file",
"permission",
"(",
"real",
"path",
"to",
"string",
"(",
")",
"+",
"real",
"path",
"get",
"file",
"system",
"(",
")",
"get",
"separator",
"(",
")",
"+",
"\"",
"-",
"\"",
",",
"permissions",
")",
")",
";",
"}",
"}"
] |
[
"return",
"the",
"original",
"consumer",
"record",
"that",
"this",
"sink",
"record",
"represents"
] | [
"public",
"consumer",
"record",
"<",
"byte",
"[",
"]",
",",
"byte",
"[",
"]",
">",
"original",
"record",
"(",
")",
"{",
"return",
"original",
"record",
";",
"}"
] |
[
"specify",
"the",
"desired",
"number",
"of",
"partitions",
"for",
"the",
"topic"
] | [
"public",
"new",
"topic",
"builder",
"partitions",
"(",
"int",
"num",
"partitions",
")",
"{",
"this",
"num",
"partitions",
"=",
"num",
"partitions",
";",
"return",
"this",
";",
"}"
] |
[
"invoked",
"when",
"computation",
"produces",
"its",
"potentially",
"null",
"value",
"successfully",
"when",
"this",
"is",
"called",
",",
"{",
"@",
"link",
"#",
"on",
"error",
"}",
"won",
"'",
"t",
"be"
] | [
"void",
"on",
"success",
"(",
"@",
"nullable",
"v",
"value",
")",
";"
] |
[
"quick",
"validation",
"on",
"the",
"input",
"to",
"check",
"some",
"obvious",
"fail",
"conditions",
"(",
"fail",
"fast",
")",
"check",
"if",
"the",
"provided",
"{",
"@",
"link",
"sub",
"cluster",
"register",
"request",
"}",
"for",
"registration",
"a",
"new",
"subcluster",
"is",
"valid",
"or",
"not"
] | [
"public",
"static",
"void",
"validate",
"(",
"sub",
"cluster",
"register",
"request",
"request",
")",
"throws",
"federation",
"state",
"store",
"invalid",
"input",
"exception",
"{",
"/",
"/",
"check",
"if",
"the",
"request",
"is",
"present",
"if",
"(",
"request",
"=",
"=",
"null",
")",
"{",
"string",
"message",
"=",
"\"",
"missing",
"sub",
"cluster",
"register",
"request",
"\"",
"+",
"\"",
"please",
"try",
"again",
"by",
"specifying",
"a",
"\"",
"+",
"\"",
"sub",
"cluster",
"register",
"information",
"\"",
";",
"log",
"warn",
"(",
"message",
")",
";",
"throw",
"new",
"federation",
"state",
"store",
"invalid",
"input",
"exception",
"(",
"message",
")",
";",
"}",
"/",
"/",
"validate",
"subcluster",
"info",
"check",
"sub",
"cluster",
"info",
"(",
"request",
"get",
"sub",
"cluster",
"info",
"(",
")",
")",
";",
"}"
] |
[
"write",
"configuration",
"to",
"a",
"site",
"file",
"under",
"hadoop",
"configuration",
"dir"
] | [
"private",
"void",
"write",
"conf",
"(",
"configuration",
"conf",
",",
"string",
"sitename",
")",
"throws",
"exception",
"{",
"file",
"home",
"dir",
"=",
"test",
"dir",
"helper",
"get",
"test",
"dir",
"(",
")",
";",
"/",
"/",
"hdfs",
"configuration",
"file",
"hadoop",
"conf",
"dir",
"=",
"new",
"file",
"(",
"new",
"file",
"(",
"home",
"dir",
",",
"\"",
"conf",
"\"",
")",
",",
"\"",
"hadoop",
"-",
"conf",
"\"",
")",
";",
"assert",
"assert",
"true",
"(",
"hadoop",
"conf",
"dir",
"exists",
"(",
")",
")",
";",
"file",
"site",
"file",
"=",
"new",
"file",
"(",
"hadoop",
"conf",
"dir",
",",
"sitename",
")",
";",
"output",
"stream",
"os",
"=",
"new",
"file",
"output",
"stream",
"(",
"site",
"file",
")",
";",
"conf",
"write",
"xml",
"(",
"os",
")",
";",
"os",
"close",
"(",
")",
";",
"}"
] |
[
"this",
"test",
"triggers",
"two",
"checkpoints",
"and",
"then",
"sends",
"a",
"decline",
"message",
"from",
"one",
"of",
"the",
"tasks",
"for",
"the",
"first",
"checkpoint",
"this",
"should",
"discard",
"the",
"first",
"checkpoint",
"while",
"not",
"triggering",
"a",
"new",
"checkpoint",
"because",
"a",
"later",
"checkpoint",
"is",
"already",
"in",
"progress"
] | [
"public",
"void",
"test",
"trigger",
"and",
"decline",
"checkpoint",
"complex",
"(",
")",
"{",
"try",
"{",
"final",
"job",
"i",
"d",
"job",
"id",
"=",
"new",
"job",
"i",
"d",
"(",
")",
";",
"/",
"/",
"create",
"some",
"mock",
"execution",
"vertices",
"that",
"receive",
"the",
"checkpoint",
"trigger",
"messages",
"final",
"execution",
"attempt",
"i",
"d",
"attempt",
"i",
"d",
"1",
"=",
"new",
"execution",
"attempt",
"i",
"d",
"(",
")",
";",
"final",
"execution",
"attempt",
"i",
"d",
"attempt",
"i",
"d",
"2",
"=",
"new",
"execution",
"attempt",
"i",
"d",
"(",
")",
";",
"execution",
"vertex",
"vertex",
"1",
"=",
"mock",
"execution",
"vertex",
"(",
"attempt",
"i",
"d",
"1",
")",
";",
"execution",
"vertex",
"vertex",
"2",
"=",
"mock",
"execution",
"vertex",
"(",
"attempt",
"i",
"d",
"2",
")",
";",
"/",
"/",
"set",
"up",
"the",
"coordinator",
"and",
"validate",
"the",
"initial",
"state",
"checkpoint",
"coordinator",
"checkpoint",
"coordinator",
"=",
"get",
"checkpoint",
"coordinator",
"(",
"job",
"id",
",",
"vertex",
"1",
",",
"vertex",
"2",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"checkpoint",
"coordinator",
"get",
"number",
"of",
"pending",
"checkpoints",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"checkpoint",
"coordinator",
"get",
"number",
"of",
"retained",
"successful",
"checkpoints",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"manually",
"triggered",
"scheduled",
"executor",
"get",
"scheduled",
"tasks",
"(",
")",
"size",
"(",
")",
")",
";",
"/",
"/",
"trigger",
"the",
"first",
"checkpoint",
"this",
"should",
"succeed",
"final",
"completable",
"future",
"<",
"completed",
"checkpoint",
">",
"checkpoint",
"future",
"1",
"=",
"checkpoint",
"coordinator",
"trigger",
"checkpoint",
"(",
"false",
")",
";",
"manually",
"triggered",
"scheduled",
"executor",
"trigger",
"all",
"(",
")",
";",
"future",
"utils",
"throw",
"if",
"completed",
"exceptionally",
"(",
"checkpoint",
"future",
"1",
")",
";",
"/",
"/",
"trigger",
"second",
"checkpoint",
",",
"should",
"also",
"succeed",
"final",
"completable",
"future",
"<",
"completed",
"checkpoint",
">",
"checkpoint",
"future",
"2",
"=",
"checkpoint",
"coordinator",
"trigger",
"checkpoint",
"(",
"false",
")",
";",
"manually",
"triggered",
"scheduled",
"executor",
"trigger",
"all",
"(",
")",
";",
"future",
"utils",
"throw",
"if",
"completed",
"exceptionally",
"(",
"checkpoint",
"future",
"2",
")",
";",
"/",
"/",
"validate",
"that",
"we",
"have",
"a",
"pending",
"checkpoint",
"assert",
"equals",
"(",
"2",
",",
"checkpoint",
"coordinator",
"get",
"number",
"of",
"pending",
"checkpoints",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"checkpoint",
"coordinator",
"get",
"number",
"of",
"retained",
"successful",
"checkpoints",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"2",
",",
"manually",
"triggered",
"scheduled",
"executor",
"get",
"scheduled",
"tasks",
"(",
")",
"size",
"(",
")",
")",
";",
"iterator",
"<",
"map",
"entry",
"<",
"long",
",",
"pending",
"checkpoint",
">",
">",
"it",
"=",
"checkpoint",
"coordinator",
"get",
"pending",
"checkpoints",
"(",
")",
"entry",
"set",
"(",
")",
"iterator",
"(",
")",
";",
"long",
"checkpoint",
"1",
"id",
"=",
"it",
"next",
"(",
")",
"get",
"key",
"(",
")",
";",
"long",
"checkpoint",
"2",
"id",
"=",
"it",
"next",
"(",
")",
"get",
"key",
"(",
")",
";",
"pending",
"checkpoint",
"checkpoint",
"1",
"=",
"checkpoint",
"coordinator",
"get",
"pending",
"checkpoints",
"(",
")",
"get",
"(",
"checkpoint",
"1",
"id",
")",
";",
"pending",
"checkpoint",
"checkpoint",
"2",
"=",
"checkpoint",
"coordinator",
"get",
"pending",
"checkpoints",
"(",
")",
"get",
"(",
"checkpoint",
"2",
"id",
")",
";",
"assert",
"not",
"null",
"(",
"checkpoint",
"1",
")",
";",
"assert",
"equals",
"(",
"checkpoint",
"1",
"id",
",",
"checkpoint",
"1",
"get",
"checkpoint",
"id",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"job",
"id",
",",
"checkpoint",
"1",
"get",
"job",
"id",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"2",
",",
"checkpoint",
"1",
"get",
"number",
"of",
"non",
"acknowledged",
"tasks",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"checkpoint",
"1",
"get",
"number",
"of",
"acknowledged",
"tasks",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"checkpoint",
"1",
"get",
"operator",
"states",
"(",
")",
"size",
"(",
")",
")",
";",
"assert",
"false",
"(",
"checkpoint",
"1",
"is",
"disposed",
"(",
")",
")",
";",
"assert",
"false",
"(",
"checkpoint",
"1",
"are",
"tasks",
"fully",
"acknowledged",
"(",
")",
")",
";",
"assert",
"not",
"null",
"(",
"checkpoint",
"2",
")",
";",
"assert",
"equals",
"(",
"checkpoint",
"2",
"id",
",",
"checkpoint",
"2",
"get",
"checkpoint",
"id",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"job",
"id",
",",
"checkpoint",
"2",
"get",
"job",
"id",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"2",
",",
"checkpoint",
"2",
"get",
"number",
"of",
"non",
"acknowledged",
"tasks",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"checkpoint",
"2",
"get",
"number",
"of",
"acknowledged",
"tasks",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"checkpoint",
"2",
"get",
"operator",
"states",
"(",
")",
"size",
"(",
")",
")",
";",
"assert",
"false",
"(",
"checkpoint",
"2",
"is",
"disposed",
"(",
")",
")",
";",
"assert",
"false",
"(",
"checkpoint",
"2",
"are",
"tasks",
"fully",
"acknowledged",
"(",
")",
")",
";",
"/",
"/",
"check",
"that",
"the",
"vertices",
"received",
"the",
"trigger",
"checkpoint",
"message",
"{",
"verify",
"(",
"vertex",
"1",
"get",
"current",
"execution",
"attempt",
"(",
")",
",",
"times",
"(",
"1",
")",
")",
"trigger",
"checkpoint",
"(",
"eq",
"(",
"checkpoint",
"1",
"id",
")",
",",
"any",
"(",
"long",
"class",
")",
",",
"any",
"(",
"checkpoint",
"options",
"class",
")",
")",
";",
"verify",
"(",
"vertex",
"2",
"get",
"current",
"execution",
"attempt",
"(",
")",
",",
"times",
"(",
"1",
")",
")",
"trigger",
"checkpoint",
"(",
"eq",
"(",
"checkpoint",
"1",
"id",
")",
",",
"any",
"(",
"long",
"class",
")",
",",
"any",
"(",
"checkpoint",
"options",
"class",
")",
")",
";",
"}",
"/",
"/",
"check",
"that",
"the",
"vertices",
"received",
"the",
"trigger",
"checkpoint",
"message",
"for",
"the",
"second",
"/",
"/",
"checkpoint",
"{",
"verify",
"(",
"vertex",
"1",
"get",
"current",
"execution",
"attempt",
"(",
")",
",",
"times",
"(",
"1",
")",
")",
"trigger",
"checkpoint",
"(",
"eq",
"(",
"checkpoint",
"2",
"id",
")",
",",
"any",
"(",
"long",
"class",
")",
",",
"any",
"(",
"checkpoint",
"options",
"class",
")",
")",
";",
"verify",
"(",
"vertex",
"2",
"get",
"current",
"execution",
"attempt",
"(",
")",
",",
"times",
"(",
"1",
")",
")",
"trigger",
"checkpoint",
"(",
"eq",
"(",
"checkpoint",
"2",
"id",
")",
",",
"any",
"(",
"long",
"class",
")",
",",
"any",
"(",
"checkpoint",
"options",
"class",
")",
")",
";",
"}",
"/",
"/",
"decline",
"checkpoint",
"from",
"one",
"of",
"the",
"tasks",
",",
"this",
"should",
"cancel",
"the",
"checkpoint",
"checkpoint",
"coordinator",
"receive",
"decline",
"message",
"(",
"new",
"decline",
"checkpoint",
"(",
"job",
"id",
",",
"attempt",
"i",
"d",
"1",
",",
"checkpoint",
"1",
"id",
")",
",",
"task",
"manager",
"location",
"info",
")",
";",
"verify",
"(",
"vertex",
"1",
"get",
"current",
"execution",
"attempt",
"(",
")",
",",
"times",
"(",
"1",
")",
")",
"notify",
"checkpoint",
"aborted",
"(",
"eq",
"(",
"checkpoint",
"1",
"id",
")",
",",
"any",
"(",
"long",
"class",
")",
")",
";",
"verify",
"(",
"vertex",
"2",
"get",
"current",
"execution",
"attempt",
"(",
")",
",",
"times",
"(",
"1",
")",
")",
"notify",
"checkpoint",
"aborted",
"(",
"eq",
"(",
"checkpoint",
"1",
"id",
")",
",",
"any",
"(",
"long",
"class",
")",
")",
";",
"assert",
"true",
"(",
"checkpoint",
"1",
"is",
"disposed",
"(",
")",
")",
";",
"/",
"/",
"validate",
"that",
"we",
"have",
"only",
"one",
"pending",
"checkpoint",
"left",
"assert",
"equals",
"(",
"1",
",",
"checkpoint",
"coordinator",
"get",
"number",
"of",
"pending",
"checkpoints",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"checkpoint",
"coordinator",
"get",
"number",
"of",
"retained",
"successful",
"checkpoints",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"1",
",",
"manually",
"triggered",
"scheduled",
"executor",
"get",
"scheduled",
"tasks",
"(",
")",
"size",
"(",
")",
")",
";",
"/",
"/",
"validate",
"that",
"it",
"is",
"the",
"same",
"second",
"checkpoint",
"from",
"earlier",
"long",
"checkpoint",
"id",
"new",
"=",
"checkpoint",
"coordinator",
"get",
"pending",
"checkpoints",
"(",
")",
"entry",
"set",
"(",
")",
"iterator",
"(",
")",
"next",
"(",
")",
"get",
"key",
"(",
")",
";",
"pending",
"checkpoint",
"checkpoint",
"new",
"=",
"checkpoint",
"coordinator",
"get",
"pending",
"checkpoints",
"(",
")",
"get",
"(",
"checkpoint",
"id",
"new",
")",
";",
"assert",
"equals",
"(",
"checkpoint",
"2",
"id",
",",
"checkpoint",
"id",
"new",
")",
";",
"assert",
"not",
"null",
"(",
"checkpoint",
"new",
")",
";",
"assert",
"equals",
"(",
"checkpoint",
"id",
"new",
",",
"checkpoint",
"new",
"get",
"checkpoint",
"id",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"job",
"id",
",",
"checkpoint",
"new",
"get",
"job",
"id",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"2",
",",
"checkpoint",
"new",
"get",
"number",
"of",
"non",
"acknowledged",
"tasks",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"checkpoint",
"new",
"get",
"number",
"of",
"acknowledged",
"tasks",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"checkpoint",
"new",
"get",
"operator",
"states",
"(",
")",
"size",
"(",
")",
")",
";",
"assert",
"false",
"(",
"checkpoint",
"new",
"is",
"disposed",
"(",
")",
")",
";",
"assert",
"false",
"(",
"checkpoint",
"new",
"are",
"tasks",
"fully",
"acknowledged",
"(",
")",
")",
";",
"assert",
"not",
"equals",
"(",
"checkpoint",
"1",
"get",
"checkpoint",
"id",
"(",
")",
",",
"checkpoint",
"new",
"get",
"checkpoint",
"id",
"(",
")",
")",
";",
"/",
"/",
"decline",
"again",
",",
"nothing",
"should",
"happen",
"/",
"/",
"decline",
"from",
"the",
"other",
"task",
",",
"nothing",
"should",
"happen",
"checkpoint",
"coordinator",
"receive",
"decline",
"message",
"(",
"new",
"decline",
"checkpoint",
"(",
"job",
"id",
",",
"attempt",
"i",
"d",
"1",
",",
"checkpoint",
"1",
"id",
")",
",",
"task",
"manager",
"location",
"info",
")",
";",
"checkpoint",
"coordinator",
"receive",
"decline",
"message",
"(",
"new",
"decline",
"checkpoint",
"(",
"job",
"id",
",",
"attempt",
"i",
"d",
"2",
",",
"checkpoint",
"1",
"id",
")",
",",
"task",
"manager",
"location",
"info",
")",
";",
"assert",
"true",
"(",
"checkpoint",
"1",
"is",
"disposed",
"(",
")",
")",
";",
"/",
"/",
"will",
"not",
"notify",
"abort",
"message",
"again",
"verify",
"(",
"vertex",
"1",
"get",
"current",
"execution",
"attempt",
"(",
")",
",",
"times",
"(",
"1",
")",
")",
"notify",
"checkpoint",
"aborted",
"(",
"eq",
"(",
"checkpoint",
"1",
"id",
")",
",",
"any",
"(",
"long",
"class",
")",
")",
";",
"verify",
"(",
"vertex",
"2",
"get",
"current",
"execution",
"attempt",
"(",
")",
",",
"times",
"(",
"1",
")",
")",
"notify",
"checkpoint",
"aborted",
"(",
"eq",
"(",
"checkpoint",
"1",
"id",
")",
",",
"any",
"(",
"long",
"class",
")",
")",
";",
"checkpoint",
"coordinator",
"shutdown",
"(",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"e",
"print",
"stack",
"trace",
"(",
")",
";",
"fail",
"(",
"e",
"get",
"message",
"(",
")",
")",
";",
"}",
"}"
] |
[
"enters",
"the",
"username",
"into",
"the",
"username",
"input",
"text",
"field"
] | [
"public",
"login",
"page",
"enter",
"username",
"(",
"string",
"username",
")",
"{",
"var",
"username",
"input",
"text",
"field",
"=",
"(",
"html",
"text",
"input",
")",
"page",
"get",
"element",
"by",
"id",
"(",
"\"",
"username",
"\"",
")",
";",
"username",
"input",
"text",
"field",
"set",
"text",
"(",
"username",
")",
";",
"return",
"this",
";",
"}"
] |
[
"controls",
"whether",
"the",
"first",
"action",
"added",
"will",
"automatically",
"fire",
"an",
"event",
"or",
"not"
] | [
"public",
"multi",
"state",
"action",
"builder",
"<",
"t",
">",
"fire",
"first",
"action",
"(",
"boolean",
"fire",
"first",
"action",
")",
"{",
"this",
"fire",
"first",
"action",
"=",
"fire",
"first",
"action",
";",
"return",
"self",
"(",
")",
";",
"}"
] |
[
"checks",
"that",
"a",
"certain",
"event",
"sequence",
"is",
"recognized"
] | [
"public",
"void",
"test",
"simple",
"pattern",
"c",
"e",
"p",
"(",
")",
"throws",
"exception",
"{",
"stream",
"execution",
"environment",
"env",
"=",
"stream",
"execution",
"environment",
"get",
"execution",
"environment",
"(",
")",
";",
"data",
"stream",
"<",
"event",
">",
"input",
"=",
"env",
"from",
"elements",
"(",
"new",
"event",
"(",
"1",
",",
"\"",
"barfoo",
"\"",
",",
"1",
"0",
")",
",",
"new",
"event",
"(",
"2",
",",
"\"",
"start",
"\"",
",",
"2",
"0",
")",
",",
"new",
"event",
"(",
"3",
",",
"\"",
"foobar",
"\"",
",",
"3",
"0",
")",
",",
"new",
"sub",
"event",
"(",
"4",
",",
"\"",
"foo",
"\"",
",",
"4",
"0",
",",
"1",
"0",
")",
",",
"new",
"event",
"(",
"5",
",",
"\"",
"middle",
"\"",
",",
"5",
"0",
")",
",",
"new",
"sub",
"event",
"(",
"6",
",",
"\"",
"middle",
"\"",
",",
"6",
"0",
",",
"2",
"0",
")",
",",
"new",
"sub",
"event",
"(",
"7",
",",
"\"",
"bar",
"\"",
",",
"3",
"0",
",",
"3",
"0",
")",
",",
"new",
"event",
"(",
"42",
",",
"\"",
"42",
"\"",
",",
"42",
"0",
")",
",",
"new",
"event",
"(",
"8",
",",
"\"",
"end",
"\"",
",",
"1",
"0",
")",
")",
";",
"pattern",
"<",
"event",
",",
"?",
">",
"pattern",
"=",
"pattern",
"<",
"event",
">",
"begin",
"(",
"\"",
"start",
"\"",
")",
"where",
"(",
"new",
"simple",
"condition",
"<",
"event",
">",
"(",
")",
"{",
"@",
"override",
"public",
"boolean",
"filter",
"(",
"event",
"value",
")",
"throws",
"exception",
"{",
"return",
"value",
"get",
"name",
"(",
")",
"equals",
"(",
"\"",
"start",
"\"",
")",
";",
"}",
"}",
")",
"followed",
"by",
"any",
"(",
"\"",
"middle",
"\"",
")",
"subtype",
"(",
"sub",
"event",
"class",
")",
"where",
"(",
"new",
"simple",
"condition",
"<",
"sub",
"event",
">",
"(",
")",
"{",
"@",
"override",
"public",
"boolean",
"filter",
"(",
"sub",
"event",
"value",
")",
"throws",
"exception",
"{",
"return",
"value",
"get",
"name",
"(",
")",
"equals",
"(",
"\"",
"middle",
"\"",
")",
";",
"}",
"}",
")",
"followed",
"by",
"any",
"(",
"\"",
"end",
"\"",
")",
"where",
"(",
"new",
"simple",
"condition",
"<",
"event",
">",
"(",
")",
"{",
"@",
"override",
"public",
"boolean",
"filter",
"(",
"event",
"value",
")",
"throws",
"exception",
"{",
"return",
"value",
"get",
"name",
"(",
")",
"equals",
"(",
"\"",
"end",
"\"",
")",
";",
"}",
"}",
")",
";",
"data",
"stream",
"<",
"string",
">",
"result",
"=",
"cep",
"pattern",
"(",
"input",
",",
"pattern",
")",
"in",
"processing",
"time",
"(",
")",
"flat",
"select",
"(",
"(",
"p",
",",
"o",
")",
"-",
">",
"{",
"string",
"builder",
"builder",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"builder",
"append",
"(",
"p",
"get",
"(",
"\"",
"start",
"\"",
")",
"get",
"(",
"0",
")",
"get",
"id",
"(",
")",
")",
"append",
"(",
"\"",
",",
"\"",
")",
"append",
"(",
"p",
"get",
"(",
"\"",
"middle",
"\"",
")",
"get",
"(",
"0",
")",
"get",
"id",
"(",
")",
")",
"append",
"(",
"\"",
",",
"\"",
")",
"append",
"(",
"p",
"get",
"(",
"\"",
"end",
"\"",
")",
"get",
"(",
"0",
")",
"get",
"id",
"(",
")",
")",
";",
"o",
"collect",
"(",
"builder",
"to",
"string",
"(",
")",
")",
";",
"}",
",",
"types",
"string",
")",
";",
"list",
"<",
"string",
">",
"result",
"list",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"data",
"stream",
"utils",
"collect",
"(",
"result",
")",
"for",
"each",
"remaining",
"(",
"result",
"list",
":",
":",
"add",
")",
";",
"assert",
"equals",
"(",
"arrays",
"as",
"list",
"(",
"\"",
"2",
",",
"6",
",",
"8",
"\"",
")",
",",
"result",
"list",
")",
";",
"}"
] |
[
"execute",
"test",
"group",
"parameters",
"request"
] | [
"public",
"void",
"execute",
"(",
")",
"throws",
"api",
"exception",
"{",
"test",
"group",
"parameters",
"with",
"http",
"info",
"(",
"required",
"string",
"group",
",",
"required",
"boolean",
"group",
",",
"required",
"int",
"6",
"4",
"group",
",",
"string",
"group",
",",
"boolean",
"group",
",",
"int",
"6",
"4",
"group",
")",
";",
"}"
] |
[
"check",
"if",
"a",
"pair",
"(",
"server",
"id",
",",
"zxid",
")",
"succeeds",
"our",
"current",
"vote"
] | [
"protected",
"boolean",
"total",
"order",
"predicate",
"(",
"long",
"new",
"id",
",",
"long",
"new",
"zxid",
",",
"long",
"new",
"epoch",
",",
"long",
"cur",
"id",
",",
"long",
"cur",
"zxid",
",",
"long",
"cur",
"epoch",
")",
"{",
"log",
"debug",
"(",
"\"",
"id",
":",
"{",
"}",
",",
"proposed",
"id",
":",
"{",
"}",
",",
"zxid",
":",
"0x",
"{",
"}",
",",
"proposed",
"zxid",
":",
"0x",
"{",
"}",
"\"",
",",
"new",
"id",
",",
"cur",
"id",
",",
"long",
"to",
"hex",
"string",
"(",
"new",
"zxid",
")",
",",
"long",
"to",
"hex",
"string",
"(",
"cur",
"zxid",
")",
")",
";",
"if",
"(",
"self",
"get",
"quorum",
"verifier",
"(",
")",
"get",
"weight",
"(",
"new",
"id",
")",
"=",
"=",
"0",
")",
"{",
"return",
"false",
";",
"}",
"/",
"*",
"*",
"we",
"return",
"true",
"if",
"one",
"of",
"the",
"following",
"three",
"cases",
"hold",
":",
"*",
"1",
"-",
"new",
"epoch",
"is",
"higher",
"*",
"2",
"-",
"new",
"epoch",
"is",
"the",
"same",
"as",
"current",
"epoch",
",",
"but",
"new",
"zxid",
"is",
"higher",
"*",
"3",
"-",
"new",
"epoch",
"is",
"the",
"same",
"as",
"current",
"epoch",
",",
"new",
"zxid",
"is",
"the",
"same",
"*",
"as",
"current",
"zxid",
",",
"but",
"server",
"id",
"is",
"higher",
"*",
"/",
"return",
"(",
"(",
"new",
"epoch",
">",
"cur",
"epoch",
")",
"|",
"|",
"(",
"(",
"new",
"epoch",
"=",
"=",
"cur",
"epoch",
")",
"&",
"&",
"(",
"(",
"new",
"zxid",
">",
"cur",
"zxid",
")",
"|",
"|",
"(",
"(",
"new",
"zxid",
"=",
"=",
"cur",
"zxid",
")",
"&",
"&",
"(",
"new",
"id",
">",
"cur",
"id",
")",
")",
")",
")",
")",
";",
"}"
] |
[
"the",
"minimum",
"length",
"a",
"suggest",
"text",
"term",
"must",
"have",
"in",
"order",
"to",
"be",
"corrected",
"defaults",
"to",
"{",
"@",
"code",
"4",
"}"
] | [
"public",
"direct",
"candidate",
"generator",
"builder",
"min",
"word",
"length",
"(",
"int",
"min",
"word",
"length",
")",
"{",
"this",
"min",
"word",
"length",
"=",
"min",
"word",
"length",
";",
"return",
"this",
";",
"}"
] |
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
] | [
"private",
"string",
"to",
"indented",
"string",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
] |
[
"get",
"enum",
"integer"
] | [
"public",
"enum",
"integer",
"enum",
"get",
"enum",
"integer",
"(",
")",
"{",
"return",
"enum",
"integer",
";",
"}"
] |
[
"asserts",
"that",
"the",
"specified",
"download",
"is",
"removed"
] | [
"public",
"void",
"assert",
"removed",
"(",
"string",
"id",
")",
"{",
"assert",
"state",
"internal",
"(",
"id",
",",
"state",
"removed",
")",
";",
"}"
] |
[
"returns",
"the",
"name"
] | [
"public",
"string",
"get",
"name",
"(",
")",
"{",
"return",
"name",
";",
"}"
] |
[
"check",
"whether",
"the",
"given",
"block",
"is",
"under",
"recovery"
] | [
"synchronized",
"boolean",
"is",
"under",
"recovery",
"(",
"block",
"info",
"b",
")",
"{",
"block",
"recovery",
"attempt",
"recovery",
"attempt",
"=",
"recovery",
"timeouts",
"get",
"element",
"(",
"new",
"block",
"recovery",
"attempt",
"(",
"b",
")",
")",
";",
"return",
"recovery",
"attempt",
"!",
"=",
"null",
";",
"}"
] |
[
"returns",
"the",
"index",
"of",
"the",
"first",
"appearance",
"of",
"the",
"value",
"{",
"@",
"code",
"target",
"}",
"in",
"{",
"@",
"code",
"array",
"}"
] | [
"public",
"static",
"int",
"index",
"of",
"(",
"byte",
"[",
"]",
"array",
",",
"byte",
"target",
")",
"{",
"return",
"index",
"of",
"(",
"array",
",",
"target",
",",
"0",
",",
"array",
"length",
")",
";",
"}"
] |
[
"the",
"set",
"menu",
"path",
"method",
"should",
"fail",
"to",
"set",
"an",
"invalid",
"(",
"empty",
")",
"menu",
"path"
] | [
"public",
"void",
"test",
"break",
"menu",
"path",
"(",
")",
"{",
"menu",
"data",
"menu",
"data",
"=",
"new",
"menu",
"data",
"(",
"new",
"string",
"[",
"]",
"{",
"\"",
"one",
"\"",
",",
"\"",
"two",
"\"",
",",
"\"",
"three",
"\"",
"}",
")",
";",
"menu",
"data",
"set",
"menu",
"path",
"(",
"new",
"string",
"[",
"0",
"]",
")",
";",
"}"
] |
[
"sets",
"the",
"value",
"of",
"the",
"given",
"{",
"@",
"code",
"entry",
"}"
] | [
"void",
"set",
"value",
"(",
"e",
"entry",
",",
"v",
"value",
")",
"{",
"this",
"map",
"entry",
"helper",
"set",
"value",
"(",
"self",
"(",
")",
",",
"entry",
",",
"value",
")",
";",
"}"
] |
[
"returns",
"whether",
"{",
"@",
"code",
"cache",
"folder",
"}",
"is",
"locked",
"by",
"a",
"{",
"@",
"link",
"simple",
"cache",
"}",
"instance",
"to",
"unlock",
"the",
"folder",
"the",
"{",
"@",
"link",
"simple",
"cache",
"}",
"instance",
"should",
"be",
"released"
] | [
"public",
"static",
"synchronized",
"boolean",
"is",
"cache",
"folder",
"locked",
"(",
"file",
"cache",
"folder",
")",
"{",
"return",
"locked",
"cache",
"dirs",
"contains",
"(",
"cache",
"folder",
"get",
"absolute",
"file",
"(",
")",
")",
";",
"}"
] |
[
"intended",
"for",
"use",
"by",
"{",
"@",
"link",
"com",
"google",
"devtools",
"build",
"lib",
"skyframe",
"package",
"function",
"}",
"only"
] | [
"public",
"package",
"finish",
"build",
"(",
")",
"{",
"if",
"(",
"already",
"built",
")",
"{",
"return",
"pkg",
";",
"}",
"/",
"/",
"freeze",
"targets",
"and",
"distributions",
"for",
"(",
"target",
"t",
":",
"targets",
"values",
"(",
")",
")",
"{",
"if",
"(",
"t",
"instanceof",
"rule",
")",
"{",
"(",
"(",
"rule",
")",
"t",
")",
"freeze",
"(",
")",
";",
"}",
"}",
"targets",
"=",
"maps",
"unmodifiable",
"bi",
"map",
"(",
"targets",
")",
";",
"default",
"distribution",
"set",
"=",
"collections",
"unmodifiable",
"set",
"(",
"default",
"distribution",
"set",
")",
";",
"/",
"/",
"now",
"all",
"targets",
"have",
"been",
"loaded",
",",
"so",
"we",
"validate",
"the",
"group",
"'",
"s",
"member",
"environments",
"for",
"(",
"environment",
"group",
"env",
"group",
":",
"immutable",
"set",
"copy",
"of",
"(",
"environment",
"groups",
"values",
"(",
")",
")",
")",
"{",
"collection",
"<",
"event",
">",
"errors",
"=",
"env",
"group",
"process",
"member",
"environments",
"(",
"targets",
")",
";",
"if",
"(",
"!",
"errors",
"is",
"empty",
"(",
")",
")",
"{",
"add",
"events",
"(",
"errors",
")",
";",
"set",
"contains",
"errors",
"(",
")",
";",
"}",
"}",
"/",
"/",
"build",
"the",
"package",
"pkg",
"finish",
"init",
"(",
"this",
")",
";",
"already",
"built",
"=",
"true",
";",
"return",
"pkg",
";",
"}"
] |
[
"get",
"integer",
"minimum",
":",
"10",
"maximum",
":",
"100"
] | [
"public",
"integer",
"get",
"integer",
"(",
")",
"{",
"return",
"integer",
";",
"}"
] |
[
"recursively",
"expand",
"the",
"path",
"into",
"the",
"supplied",
"string",
"builder",
",",
"increasing",
"the",
"indentation",
"by",
"{",
"@",
"link",
"#",
"indent",
"}",
"as",
"it",
"proceeds",
"(",
"depth",
"first",
")",
"down",
"the",
"tree"
] | [
"private",
"void",
"expand",
"(",
"string",
"builder",
"builder",
",",
"string",
"path",
",",
"int",
"indent",
")",
"{",
"try",
"{",
"get",
"children",
"builder",
"children",
"builder",
"=",
"curator",
"get",
"children",
"(",
")",
";",
"list",
"<",
"string",
">",
"children",
"=",
"children",
"builder",
"for",
"path",
"(",
"path",
")",
";",
"for",
"(",
"string",
"child",
":",
"children",
")",
"{",
"string",
"child",
"path",
"=",
"path",
"+",
"\"",
"/",
"\"",
"+",
"child",
";",
"string",
"body",
";",
"stat",
"stat",
"=",
"curator",
"check",
"exists",
"(",
")",
"for",
"path",
"(",
"child",
"path",
")",
";",
"string",
"builder",
"body",
"builder",
"=",
"new",
"string",
"builder",
"(",
"256",
")",
";",
"body",
"builder",
"append",
"(",
"\"",
"[",
"\"",
")",
"append",
"(",
"stat",
"get",
"data",
"length",
"(",
")",
")",
"append",
"(",
"\"",
"]",
"\"",
")",
";",
"if",
"(",
"stat",
"get",
"ephemeral",
"owner",
"(",
")",
">",
"0",
")",
"{",
"body",
"builder",
"append",
"(",
"\"",
"*",
"\"",
")",
";",
"}",
"if",
"(",
"verbose",
")",
"{",
"/",
"/",
"verbose",
":",
"extract",
"a",
"c",
"ls",
"builder",
"append",
"(",
"\"",
"-",
"-",
"\"",
")",
";",
"list",
"<",
"acl",
">",
"acls",
"=",
"curator",
"get",
"a",
"c",
"l",
"(",
")",
"for",
"path",
"(",
"child",
"path",
")",
";",
"for",
"(",
"acl",
"acl",
":",
"acls",
")",
"{",
"builder",
"append",
"(",
"registry",
"security",
"acl",
"to",
"string",
"(",
"acl",
")",
")",
";",
"builder",
"append",
"(",
"\"",
"\"",
")",
";",
"}",
"}",
"body",
"=",
"body",
"builder",
"to",
"string",
"(",
")",
";",
"/",
"/",
"print",
"each",
"child",
"append",
"(",
"builder",
",",
"indent",
",",
"'",
"'",
")",
";",
"builder",
"append",
"(",
"'",
"/",
"'",
")",
"append",
"(",
"child",
")",
";",
"builder",
"append",
"(",
"body",
")",
";",
"builder",
"append",
"(",
"'",
"\\",
"n",
"'",
")",
";",
"/",
"/",
"recurse",
"expand",
"(",
"builder",
",",
"child",
"path",
",",
"indent",
"+",
"indent",
")",
";",
"}",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"builder",
"append",
"(",
"e",
"to",
"string",
"(",
")",
")",
"append",
"(",
"\"",
"\\",
"n",
"\"",
")",
";",
"}",
"}"
] |
[
"implements",
"{",
"@",
"link",
"#",
"convert",
"(",
"string",
")",
"}"
] | [
"public",
"t",
"convert",
"(",
"string",
"input",
")",
"throws",
"options",
"parsing",
"exception",
"{",
"for",
"(",
"t",
"value",
":",
"enum",
"type",
"get",
"enum",
"constants",
"(",
")",
")",
"{",
"if",
"(",
"value",
"to",
"string",
"(",
")",
"equals",
"ignore",
"case",
"(",
"input",
")",
")",
"{",
"return",
"value",
";",
"}",
"}",
"throw",
"new",
"options",
"parsing",
"exception",
"(",
"\"",
"not",
"a",
"valid",
"\"",
"+",
"type",
"name",
"+",
"\"",
":",
"'",
"\"",
"+",
"input",
"+",
"\"",
"'",
"(",
"should",
"be",
"\"",
"+",
"get",
"type",
"description",
"(",
")",
"+",
"\"",
")",
"\"",
")",
";",
"}"
] |
[
"get",
"the",
"server",
"name"
] | [
"public",
"string",
"get",
"server",
"name",
"(",
")",
"{",
"return",
"name",
"field",
"get",
"text",
"(",
")",
";",
"}"
] |
[
"reads",
"a",
"template",
"file",
"and",
"substitutes",
"variables",
"of",
"the",
"format",
"$",
"{",
"foo",
"}"
] | [
"public",
"static",
"string",
"read",
"template",
"contents",
"(",
"string",
"template",
"file",
"path",
",",
"final",
"map",
"<",
"string",
",",
"string",
">",
"variables",
")",
"throws",
"build",
"encyclopedia",
"doc",
"exception",
",",
"i",
"o",
"exception",
"{",
"final",
"string",
"builder",
"sb",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"read",
"text",
"file",
"(",
"template",
"file",
"path",
",",
"new",
"read",
"action",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"read",
"line",
"impl",
"(",
"string",
"line",
")",
"{",
"sb",
"append",
"(",
"expand",
"variables",
"(",
"line",
",",
"variables",
")",
")",
"append",
"(",
"ls",
")",
";",
"}",
"}",
")",
";",
"return",
"sb",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"just",
"test",
"for",
"replace",
"fastjson",
"with",
"jackson"
] | [
"public",
"void",
"test",
"login",
"(",
")",
"{",
"string",
"example",
"=",
"\"",
"{",
"\\",
"\"",
"access",
"token",
"\\",
"\"",
":",
"\\",
"\"",
"ttttttttttttttttt",
"\\",
"\"",
",",
"\\",
"\"",
"token",
"ttl",
"\\",
"\"",
":",
"1000",
"}",
"\"",
";",
"json",
"node",
"obj",
"=",
"jackson",
"utils",
"to",
"obj",
"(",
"example",
")",
";",
"if",
"(",
"obj",
"has",
"(",
"constants",
"access",
"token",
")",
")",
"{",
"if",
"(",
"obj",
"has",
"(",
"constants",
"access",
"token",
")",
")",
"{",
"assert",
"equals",
"(",
"\"",
"ttttttttttttttttt",
"\"",
",",
"obj",
"get",
"(",
"constants",
"access",
"token",
")",
"as",
"text",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"1000",
",",
"obj",
"get",
"(",
"constants",
"token",
"ttl",
")",
"as",
"int",
"(",
")",
")",
";",
"}",
"}",
"}"
] |
[
"return",
"the",
"bazel",
"information",
"associated",
"with",
"the",
"specified",
"starlark",
"thread"
] | [
"public",
"static",
"bazel",
"starlark",
"context",
"from",
"(",
"starlark",
"thread",
"thread",
")",
"{",
"return",
"thread",
"get",
"thread",
"local",
"(",
"bazel",
"starlark",
"context",
"class",
")",
";",
"}"
] |
[
"test",
"if",
"the",
"router",
"client",
"r",
"m",
"forwards",
"all",
"the",
"requests",
"to",
"the",
"mock",
"r",
"m",
"and",
"get",
"back",
"the",
"responses"
] | [
"public",
"void",
"test",
"router",
"client",
"r",
"m",
"service",
"e",
"2",
"e",
"(",
")",
"throws",
"exception",
"{",
"string",
"user",
"=",
"\"",
"test",
"1",
"\"",
";",
"log",
"info",
"(",
"\"",
"test",
"router",
"client",
"r",
"m",
"service",
"e",
"2",
"e",
"-",
"get",
"new",
"application",
"\"",
")",
";",
"get",
"new",
"application",
"response",
"response",
"get",
"new",
"app",
"=",
"get",
"new",
"application",
"(",
"user",
")",
";",
"assert",
"assert",
"not",
"null",
"(",
"response",
"get",
"new",
"app",
")",
";",
"log",
"info",
"(",
"\"",
"test",
"router",
"client",
"r",
"m",
"service",
"e",
"2",
"e",
"-",
"submit",
"application",
"\"",
")",
";",
"submit",
"application",
"response",
"response",
"submit",
"app",
"=",
"submit",
"application",
"(",
"response",
"get",
"new",
"app",
"get",
"application",
"id",
"(",
")",
",",
"user",
")",
";",
"assert",
"assert",
"not",
"null",
"(",
"response",
"submit",
"app",
")",
";",
"log",
"info",
"(",
"\"",
"test",
"router",
"client",
"r",
"m",
"service",
"e",
"2",
"e",
"-",
"get",
"cluster",
"metrics",
"\"",
")",
";",
"get",
"cluster",
"metrics",
"response",
"response",
"get",
"cluster",
"metrics",
"=",
"get",
"cluster",
"metrics",
"(",
"user",
")",
";",
"assert",
"assert",
"not",
"null",
"(",
"response",
"get",
"cluster",
"metrics",
")",
";",
"log",
"info",
"(",
"\"",
"test",
"router",
"client",
"r",
"m",
"service",
"e",
"2",
"e",
"-",
"get",
"cluster",
"nodes",
"\"",
")",
";",
"get",
"cluster",
"nodes",
"response",
"response",
"get",
"cluster",
"nodes",
"=",
"get",
"cluster",
"nodes",
"(",
"user",
")",
";",
"assert",
"assert",
"not",
"null",
"(",
"response",
"get",
"cluster",
"nodes",
")",
";",
"log",
"info",
"(",
"\"",
"test",
"router",
"client",
"r",
"m",
"service",
"e",
"2",
"e",
"-",
"get",
"queue",
"info",
"\"",
")",
";",
"get",
"queue",
"info",
"response",
"response",
"get",
"queue",
"info",
"=",
"get",
"queue",
"info",
"(",
"user",
")",
";",
"assert",
"assert",
"not",
"null",
"(",
"response",
"get",
"queue",
"info",
")",
";",
"log",
"info",
"(",
"\"",
"test",
"router",
"client",
"r",
"m",
"service",
"e",
"2",
"e",
"-",
"get",
"queue",
"user",
"\"",
")",
";",
"get",
"queue",
"user",
"acls",
"info",
"response",
"response",
"get",
"queue",
"user",
"=",
"get",
"queue",
"user",
"acls",
"(",
"user",
")",
";",
"assert",
"assert",
"not",
"null",
"(",
"response",
"get",
"queue",
"user",
")",
";",
"log",
"info",
"(",
"\"",
"test",
"router",
"client",
"r",
"m",
"service",
"e",
"2",
"e",
"-",
"get",
"cluster",
"node",
"\"",
")",
";",
"get",
"cluster",
"node",
"labels",
"response",
"response",
"get",
"cluster",
"node",
"=",
"get",
"cluster",
"node",
"labels",
"(",
"user",
")",
";",
"assert",
"assert",
"not",
"null",
"(",
"response",
"get",
"cluster",
"node",
")",
";",
"log",
"info",
"(",
"\"",
"test",
"router",
"client",
"r",
"m",
"service",
"e",
"2",
"e",
"-",
"move",
"application",
"across",
"queues",
"\"",
")",
";",
"move",
"application",
"across",
"queues",
"response",
"response",
"move",
"app",
"=",
"move",
"application",
"across",
"queues",
"(",
"user",
",",
"response",
"get",
"new",
"app",
"get",
"application",
"id",
"(",
")",
")",
";",
"assert",
"assert",
"not",
"null",
"(",
"response",
"move",
"app",
")",
";",
"log",
"info",
"(",
"\"",
"test",
"router",
"client",
"r",
"m",
"service",
"e",
"2",
"e",
"-",
"get",
"new",
"reservation",
"\"",
")",
";",
"get",
"new",
"reservation",
"response",
"get",
"new",
"reservation",
"response",
"=",
"get",
"new",
"reservation",
"(",
"user",
")",
";",
"log",
"info",
"(",
"\"",
"test",
"router",
"client",
"r",
"m",
"service",
"e",
"2",
"e",
"-",
"submit",
"reservation",
"\"",
")",
";",
"reservation",
"submission",
"response",
"response",
"submit",
"reser",
"=",
"submit",
"reservation",
"(",
"user",
",",
"get",
"new",
"reservation",
"response",
"get",
"reservation",
"id",
"(",
")",
")",
";",
"assert",
"assert",
"not",
"null",
"(",
"response",
"submit",
"reser",
")",
";",
"log",
"info",
"(",
"\"",
"test",
"router",
"client",
"r",
"m",
"service",
"e",
"2",
"e",
"-",
"update",
"reservation",
"\"",
")",
";",
"reservation",
"update",
"response",
"response",
"update",
"reser",
"=",
"update",
"reservation",
"(",
"user",
",",
"get",
"new",
"reservation",
"response",
"get",
"reservation",
"id",
"(",
")",
")",
";",
"assert",
"assert",
"not",
"null",
"(",
"response",
"update",
"reser",
")",
";",
"log",
"info",
"(",
"\"",
"test",
"router",
"client",
"r",
"m",
"service",
"e",
"2",
"e",
"-",
"delete",
"reservation",
"\"",
")",
";",
"reservation",
"delete",
"response",
"response",
"delete",
"reser",
"=",
"delete",
"reservation",
"(",
"user",
",",
"get",
"new",
"reservation",
"response",
"get",
"reservation",
"id",
"(",
")",
")",
";",
"assert",
"assert",
"not",
"null",
"(",
"response",
"delete",
"reser",
")",
";",
"log",
"info",
"(",
"\"",
"test",
"router",
"client",
"r",
"m",
"service",
"e",
"2",
"e",
"-",
"kill",
"application",
"\"",
")",
";",
"kill",
"application",
"response",
"response",
"kill",
"app",
"=",
"force",
"kill",
"application",
"(",
"response",
"get",
"new",
"app",
"get",
"application",
"id",
"(",
")",
",",
"user",
")",
";",
"assert",
"assert",
"not",
"null",
"(",
"response",
"kill",
"app",
")",
";",
"}"
] |
[
"this",
"method",
"will",
"signal",
"to",
"the",
"users",
"if",
"a",
"filter",
"is",
"currently",
"applied",
"(",
"has",
"text",
")",
"for",
"example",
",",
"the",
"default",
"implementation",
"will",
"'",
"flash",
"'",
"the",
"filter",
"by",
"changing",
"its",
"background",
"color",
"multiple",
"times",
"note",
":",
"this",
"method",
"will",
"not",
"perform",
"the",
"alert",
"if",
"the",
"minimum",
"time",
"between",
"alerts",
"has",
"not",
"passed",
"to",
"force",
"the",
"alter",
"to",
"take",
"place",
",",
"call",
"{",
"@",
"link",
"#",
"alert",
"(",
"boolean",
")",
"}",
"with",
"a",
"value",
"of",
"<",
"code",
">",
"true",
"<",
"code",
">"
] | [
"public",
"void",
"alert",
"(",
")",
"{",
"alert",
"(",
"false",
")",
";",
"}"
] |
[
"returns",
"the",
"{",
"@",
"link",
"com",
"google",
"gson",
"stream",
"json",
"token",
"#",
"number",
"int",
"}",
"value",
"of",
"the",
"next",
"token",
",",
"consuming",
"it",
"if",
"the",
"next",
"token",
"is",
"a",
"string",
",",
"this",
"method",
"will",
"attempt",
"to",
"parse",
"it",
"as",
"an",
"int",
"if",
"the",
"next",
"token",
"'",
"s",
"numeric",
"value",
"cannot",
"be",
"exactly",
"represented",
"by",
"a",
"java",
"{",
"@",
"code",
"int",
"}",
",",
"this",
"method",
"throws"
] | [
"public",
"int",
"next",
"int",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"int",
"p",
"=",
"peeked",
";",
"if",
"(",
"p",
"=",
"=",
"peeked",
"none",
")",
"{",
"p",
"=",
"do",
"peek",
"(",
")",
";",
"}",
"int",
"result",
";",
"if",
"(",
"p",
"=",
"=",
"peeked",
"long",
")",
"{",
"result",
"=",
"(",
"int",
")",
"peeked",
"long",
";",
"if",
"(",
"peeked",
"long",
"!",
"=",
"result",
")",
"{",
"/",
"/",
"make",
"sure",
"no",
"precision",
"was",
"lost",
"casting",
"to",
"'",
"int",
"'",
"throw",
"new",
"number",
"format",
"exception",
"(",
"\"",
"expected",
"an",
"int",
"but",
"was",
"\"",
"+",
"peeked",
"long",
"+",
"location",
"string",
"(",
")",
")",
";",
"}",
"peeked",
"=",
"peeked",
"none",
";",
"path",
"indices",
"[",
"stack",
"size",
"-",
"1",
"]",
"+",
"+",
";",
"return",
"result",
";",
"}",
"if",
"(",
"p",
"=",
"=",
"peeked",
"number",
")",
"{",
"peeked",
"string",
"=",
"new",
"string",
"(",
"buffer",
",",
"pos",
",",
"peeked",
"number",
"length",
")",
";",
"pos",
"+",
"=",
"peeked",
"number",
"length",
";",
"}",
"else",
"if",
"(",
"p",
"=",
"=",
"peeked",
"single",
"quoted",
"|",
"|",
"p",
"=",
"=",
"peeked",
"double",
"quoted",
"|",
"|",
"p",
"=",
"=",
"peeked",
"unquoted",
")",
"{",
"if",
"(",
"p",
"=",
"=",
"peeked",
"unquoted",
")",
"{",
"peeked",
"string",
"=",
"next",
"unquoted",
"value",
"(",
")",
";",
"}",
"else",
"{",
"peeked",
"string",
"=",
"next",
"quoted",
"value",
"(",
"p",
"=",
"=",
"peeked",
"single",
"quoted",
"?",
"'",
"\\",
"'",
"'",
":",
"'",
"\"",
"'",
")",
";",
"}",
"try",
"{",
"result",
"=",
"integer",
"parse",
"int",
"(",
"peeked",
"string",
")",
";",
"peeked",
"=",
"peeked",
"none",
";",
"path",
"indices",
"[",
"stack",
"size",
"-",
"1",
"]",
"+",
"+",
";",
"return",
"result",
";",
"}",
"catch",
"(",
"number",
"format",
"exception",
"ignored",
")",
"{",
"/",
"/",
"fall",
"back",
"to",
"parse",
"as",
"a",
"double",
"below",
"}",
"}",
"else",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"expected",
"an",
"int",
"but",
"was",
"\"",
"+",
"peek",
"(",
")",
"+",
"location",
"string",
"(",
")",
")",
";",
"}",
"peeked",
"=",
"peeked",
"buffered",
";",
"double",
"as",
"double",
"=",
"double",
"parse",
"double",
"(",
"peeked",
"string",
")",
";",
"/",
"/",
"don",
"'",
"t",
"catch",
"this",
"number",
"format",
"exception",
"result",
"=",
"(",
"int",
")",
"as",
"double",
";",
"if",
"(",
"result",
"!",
"=",
"as",
"double",
")",
"{",
"/",
"/",
"make",
"sure",
"no",
"precision",
"was",
"lost",
"casting",
"to",
"'",
"int",
"'",
"throw",
"new",
"number",
"format",
"exception",
"(",
"\"",
"expected",
"an",
"int",
"but",
"was",
"\"",
"+",
"peeked",
"string",
"+",
"location",
"string",
"(",
")",
")",
";",
"}",
"peeked",
"string",
"=",
"null",
";",
"peeked",
"=",
"peeked",
"none",
";",
"path",
"indices",
"[",
"stack",
"size",
"-",
"1",
"]",
"+",
"+",
";",
"return",
"result",
";",
"}"
] |
[
"get",
"class",
"name"
] | [
"public",
"string",
"get",
"class",
"name",
"(",
")",
"{",
"return",
"class",
"name",
";",
"}"
] |
[
"closes",
"this",
"cache",
"stored",
"values",
"will",
"remain",
"on",
"the",
"filesystem"
] | [
"public",
"synchronized",
"void",
"close",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"journal",
"writer",
"=",
"=",
"null",
")",
"{",
"return",
";",
"/",
"/",
"already",
"closed",
"}",
"for",
"(",
"entry",
"entry",
":",
"new",
"array",
"list",
"<",
"entry",
">",
"(",
"lru",
"entries",
"values",
"(",
")",
")",
")",
"{",
"if",
"(",
"entry",
"current",
"editor",
"!",
"=",
"null",
")",
"{",
"entry",
"current",
"editor",
"abort",
"(",
")",
";",
"}",
"}",
"trim",
"to",
"size",
"(",
")",
";",
"trim",
"to",
"file",
"count",
"(",
")",
";",
"journal",
"writer",
"close",
"(",
")",
";",
"journal",
"writer",
"=",
"null",
";",
"}"
] |
[
"returns",
"the",
"job",
"name",
"for",
"the",
"execution",
"graph"
] | [
"string",
"get",
"job",
"name",
"(",
")",
";"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"category",
"'"
] | [
"public",
"void",
"category",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"category",
"}"
] |
[
"returns",
"the",
"defined",
"data",
"after",
"the",
"specified",
"data",
"or",
"null",
"if",
"no",
"data",
"exists"
] | [
"public",
"final",
"data",
"get",
"data",
"after",
"(",
"data",
"data",
")",
"{",
"return",
"get",
"data",
"after",
"(",
"data",
"get",
"max",
"address",
"(",
")",
")",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"int",
"3",
"2",
"'"
] | [
"public",
"void",
"int",
"3",
"2",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"int",
"3",
"2",
"}"
] |
[
"get",
"the",
"lookup",
"to",
"use",
"during",
"the",
"search"
] | [
"public",
"search",
"lookup",
"lookup",
"(",
")",
"{",
"if",
"(",
"this",
"lookup",
"=",
"=",
"null",
")",
"{",
"this",
"lookup",
"=",
"new",
"search",
"lookup",
"(",
"this",
":",
":",
"get",
"field",
"type",
",",
"(",
"field",
"type",
",",
"search",
"lookup",
")",
"-",
">",
"index",
"field",
"data",
"service",
"apply",
"(",
"field",
"type",
",",
"fully",
"qualified",
"index",
"get",
"name",
"(",
")",
",",
"search",
"lookup",
")",
")",
";",
"}",
"return",
"this",
"lookup",
";",
"}"
] |
[
"convert",
"an",
"extended",
"block",
"to",
"a",
"json",
"map"
] | [
"private",
"static",
"map",
"<",
"string",
",",
"object",
">",
"to",
"json",
"map",
"(",
"final",
"extended",
"block",
"extendedblock",
")",
"{",
"if",
"(",
"extendedblock",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"final",
"map",
"<",
"string",
",",
"object",
">",
"m",
"=",
"new",
"tree",
"map",
"<",
"string",
",",
"object",
">",
"(",
")",
";",
"m",
"put",
"(",
"\"",
"block",
"pool",
"id",
"\"",
",",
"extendedblock",
"get",
"block",
"pool",
"id",
"(",
")",
")",
";",
"m",
"put",
"(",
"\"",
"block",
"id",
"\"",
",",
"extendedblock",
"get",
"block",
"id",
"(",
")",
")",
";",
"m",
"put",
"(",
"\"",
"num",
"bytes",
"\"",
",",
"extendedblock",
"get",
"num",
"bytes",
"(",
")",
")",
";",
"m",
"put",
"(",
"\"",
"generation",
"stamp",
"\"",
",",
"extendedblock",
"get",
"generation",
"stamp",
"(",
")",
")",
";",
"return",
"m",
";",
"}"
] |
[
"implementors",
"should",
"return",
"a",
"list",
"of",
"{",
"@",
"link",
"values",
"source",
"type",
"}",
"that",
"the",
"aggregator",
"supports",
"this",
"is",
"used",
"to",
"test",
"the",
"matrix",
"of",
"supportedunsupported",
"field",
"types",
"against",
"the",
"aggregator",
"and",
"verify",
"it",
"works",
"(",
"or",
"doesn",
"'",
"t",
")",
"as",
"expected",
"if",
"this",
"method",
"is",
"implemented",
",",
"{",
"@",
"link",
"aggregator",
"test",
"case",
"#",
"create",
"agg",
"builder",
"for",
"type",
"test",
"(",
"mapped",
"field",
"type",
",",
"string",
")",
"}",
"should",
"be",
"implemented",
"as",
"well"
] | [
"protected",
"list",
"<",
"values",
"source",
"type",
">",
"get",
"supported",
"values",
"source",
"types",
"(",
")",
"{",
"/",
"/",
"if",
"aggs",
"don",
"'",
"t",
"override",
"this",
"method",
",",
"an",
"empty",
"list",
"allows",
"the",
"test",
"to",
"be",
"skipped",
"/",
"/",
"once",
"all",
"aggs",
"implement",
"this",
"method",
"we",
"should",
"make",
"it",
"abstract",
"and",
"not",
"allow",
"skipping",
"return",
"collections",
"empty",
"list",
"(",
")",
";",
"}"
] |
[
"returns",
"an",
"immutable",
"array",
"containing",
"the",
"given",
"values",
",",
"in",
"order",
"the",
"array",
"{",
"@",
"code",
"rest",
"}",
"must",
"not",
"be",
"longer",
"than",
"{",
"@",
"code",
"integer",
"max",
"value",
"-",
"1",
"}"
] | [
"public",
"static",
"immutable",
"int",
"array",
"of",
"(",
"int",
"first",
",",
"int",
"rest",
")",
"{",
"check",
"argument",
"(",
"rest",
"length",
"<",
"=",
"integer",
"max",
"value",
"-",
"1",
",",
"\"",
"the",
"total",
"number",
"of",
"elements",
"must",
"fit",
"in",
"an",
"int",
"\"",
")",
";",
"int",
"[",
"]",
"array",
"=",
"new",
"int",
"[",
"rest",
"length",
"+",
"1",
"]",
";",
"array",
"[",
"0",
"]",
"=",
"first",
";",
"system",
"arraycopy",
"(",
"rest",
",",
"0",
",",
"array",
",",
"1",
",",
"rest",
"length",
")",
";",
"return",
"new",
"immutable",
"int",
"array",
"(",
"array",
")",
";",
"}"
] |
[
"get",
"$",
"special",
"property",
"name"
] | [
"public",
"long",
"get",
"$",
"special",
"property",
"name",
"(",
")",
"{",
"return",
"$",
"special",
"property",
"name",
";",
"}"
] |
[
"simulates",
"a",
"user",
"typing",
"a",
"single",
"key",
"this",
"method",
"should",
"used",
"for",
"the",
"special",
"keyboard",
"keys",
"(",
"arrow",
",",
"f1",
",",
"end",
",",
"etc",
")",
"and",
"alpha",
"keys",
"when",
"associated",
"with",
"actions"
] | [
"public",
"static",
"void",
"trigger",
"action",
"key",
"(",
"component",
"c",
",",
"int",
"modifiers",
",",
"int",
"key",
"code",
")",
"{",
"trigger",
"key",
"(",
"c",
",",
"modifiers",
",",
"key",
"code",
",",
"key",
"event",
"char",
"undefined",
")",
";",
"}"
] |
[
"return",
"whether",
"to",
"globally",
"mark",
"an",
"existing",
"transaction",
"as",
"rollback",
"-",
"only",
"after",
"a",
"participating",
"transaction",
"failed"
] | [
"public",
"final",
"boolean",
"is",
"global",
"rollback",
"on",
"participation",
"failure",
"(",
")",
"{",
"return",
"this",
"global",
"rollback",
"on",
"participation",
"failure",
";",
"}"
] |
[
"the",
"index",
"of",
"the",
"string",
"path",
"within",
"the",
"source",
"string",
"pool",
"of",
"a",
"resource",
"table",
"<",
"code",
">",
"optional",
"uint",
"3",
"2",
"path",
"idx",
"=",
"1",
";",
"<",
"code",
">"
] | [
"public",
"builder",
"clear",
"path",
"idx",
"(",
")",
"{",
"copy",
"on",
"write",
"(",
")",
";",
"instance",
"clear",
"path",
"idx",
"(",
")",
";",
"return",
"this",
";",
"}"
] |
[
"select",
"the",
"content",
"-",
"type",
"header",
"'",
"s",
"value",
"from",
"the",
"given",
"array",
":",
"if",
"json",
"exists",
"in",
"the",
"given",
"array",
",",
"use",
"it",
";",
"otherwise",
"use",
"the",
"first",
"one",
"of",
"the",
"array"
] | [
"public",
"string",
"select",
"header",
"content",
"type",
"(",
"string",
"[",
"]",
"content",
"types",
")",
"{",
"if",
"(",
"content",
"types",
"length",
"=",
"=",
"0",
"|",
"|",
"content",
"types",
"[",
"0",
"]",
"equals",
"(",
"\"",
"*",
"/",
"*",
"\"",
")",
")",
"{",
"return",
"\"",
"application",
"/",
"json",
"\"",
";",
"}",
"for",
"(",
"string",
"content",
"type",
":",
"content",
"types",
")",
"{",
"if",
"(",
"is",
"json",
"mime",
"(",
"content",
"type",
")",
")",
"{",
"return",
"content",
"type",
";",
"}",
"}",
"return",
"content",
"types",
"[",
"0",
"]",
";",
"}"
] |
[
"incrementing",
"integer",
"values"
] | [
"public",
"void",
"test",
"increment",
"int",
"(",
")",
"{",
"assert",
"equals",
"(",
"0",
",",
"exec",
"(",
"\"",
"int",
"x",
"=",
"0",
";",
"return",
"x",
"+",
"+",
";",
"\"",
")",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"exec",
"(",
"\"",
"int",
"x",
"=",
"0",
";",
"return",
"x",
"-",
"-",
";",
"\"",
")",
")",
";",
"assert",
"equals",
"(",
"1",
",",
"exec",
"(",
"\"",
"int",
"x",
"=",
"0",
";",
"return",
"+",
"+",
"x",
";",
"\"",
")",
")",
";",
"assert",
"equals",
"(",
"-",
"1",
",",
"exec",
"(",
"\"",
"int",
"x",
"=",
"0",
";",
"return",
"-",
"-",
"x",
";",
"\"",
")",
")",
";",
"}"
] |
[
"test",
"org",
"apache",
"hadoop",
"mapred",
"pipes",
"pipes",
"reducer",
"test",
"the",
"transfer",
"of",
"data",
":",
"key",
"and",
"value"
] | [
"public",
"void",
"test",
"pipes",
"reduser",
"(",
")",
"throws",
"exception",
"{",
"file",
"[",
"]",
"psw",
"=",
"clean",
"token",
"password",
"file",
"(",
")",
";",
"job",
"conf",
"conf",
"=",
"new",
"job",
"conf",
"(",
")",
";",
"try",
"{",
"token",
"<",
"a",
"m",
"r",
"m",
"token",
"identifier",
">",
"token",
"=",
"new",
"token",
"<",
"a",
"m",
"r",
"m",
"token",
"identifier",
">",
"(",
"\"",
"user",
"\"",
"get",
"bytes",
"(",
")",
",",
"\"",
"password",
"\"",
"get",
"bytes",
"(",
")",
",",
"new",
"text",
"(",
"\"",
"kind",
"\"",
")",
",",
"new",
"text",
"(",
"\"",
"service",
"\"",
")",
")",
";",
"token",
"cache",
"set",
"job",
"token",
"(",
"token",
",",
"conf",
"get",
"credentials",
"(",
")",
")",
";",
"file",
"f",
"command",
"=",
"get",
"file",
"command",
"(",
"\"",
"org",
"apache",
"hadoop",
"mapred",
"pipes",
"pipe",
"reducer",
"stub",
"\"",
")",
";",
"conf",
"set",
"(",
"m",
"r",
"job",
"config",
"cache",
"localfiles",
",",
"f",
"command",
"get",
"absolute",
"path",
"(",
")",
")",
";",
"pipes",
"reducer",
"<",
"boolean",
"writable",
",",
"text",
",",
"int",
"writable",
",",
"text",
">",
"reducer",
"=",
"new",
"pipes",
"reducer",
"<",
"boolean",
"writable",
",",
"text",
",",
"int",
"writable",
",",
"text",
">",
"(",
")",
";",
"reducer",
"configure",
"(",
"conf",
")",
";",
"boolean",
"writable",
"bw",
"=",
"new",
"boolean",
"writable",
"(",
"true",
")",
";",
"conf",
"set",
"(",
"m",
"r",
"job",
"config",
"task",
"attempt",
"id",
",",
"task",
"name",
")",
";",
"init",
"std",
"out",
"(",
"conf",
")",
";",
"conf",
"set",
"boolean",
"(",
"m",
"r",
"job",
"config",
"skip",
"records",
",",
"true",
")",
";",
"combine",
"output",
"collector",
"<",
"int",
"writable",
",",
"text",
">",
"output",
"=",
"new",
"combine",
"output",
"collector",
"<",
"int",
"writable",
",",
"text",
">",
"(",
"new",
"counters",
"counter",
"(",
")",
",",
"new",
"progress",
"(",
")",
")",
";",
"reporter",
"reporter",
"=",
"new",
"test",
"task",
"reporter",
"(",
")",
";",
"list",
"<",
"text",
">",
"texts",
"=",
"new",
"array",
"list",
"<",
"text",
">",
"(",
")",
";",
"texts",
"add",
"(",
"new",
"text",
"(",
"\"",
"first",
"\"",
")",
")",
";",
"texts",
"add",
"(",
"new",
"text",
"(",
"\"",
"second",
"\"",
")",
")",
";",
"texts",
"add",
"(",
"new",
"text",
"(",
"\"",
"third",
"\"",
")",
")",
";",
"reducer",
"reduce",
"(",
"bw",
",",
"texts",
"iterator",
"(",
")",
",",
"output",
",",
"reporter",
")",
";",
"reducer",
"close",
"(",
")",
";",
"string",
"std",
"out",
"=",
"read",
"std",
"out",
"(",
"conf",
")",
";",
"/",
"/",
"test",
"data",
":",
"key",
"assert",
"true",
"(",
"std",
"out",
"contains",
"(",
"\"",
"reducer",
"key",
":",
"true",
"\"",
")",
")",
";",
"/",
"/",
"and",
"values",
"assert",
"true",
"(",
"std",
"out",
"contains",
"(",
"\"",
"reduce",
"value",
":",
"first",
"\"",
")",
")",
";",
"assert",
"true",
"(",
"std",
"out",
"contains",
"(",
"\"",
"reduce",
"value",
":",
"second",
"\"",
")",
")",
";",
"assert",
"true",
"(",
"std",
"out",
"contains",
"(",
"\"",
"reduce",
"value",
":",
"third",
"\"",
")",
")",
";",
"}",
"finally",
"{",
"if",
"(",
"psw",
"!",
"=",
"null",
")",
"{",
"/",
"/",
"remove",
"password",
"files",
"for",
"(",
"file",
"file",
":",
"psw",
")",
"{",
"file",
"delete",
"(",
")",
";",
"}",
"}",
"}",
"}"
] |
[
"returns",
"a",
"{",
"@",
"link",
"query",
"task",
"future",
"}",
"representing",
"the",
"successful",
"computation",
"of",
"{",
"@",
"code",
"value",
"}",
"the",
"returned",
"{",
"@",
"link",
"query",
"task",
"future",
"}",
"is",
"considered",
"\"",
"successful",
"\"",
"for",
"purposes",
"of",
"{",
"@",
"link",
"#",
"when",
"succeeds",
"call",
"}",
",",
"{",
"@",
"link",
"#",
"when",
"all",
"succeed",
"}",
",",
"and",
"{",
"@",
"link",
"query",
"task",
"future",
"#",
"get",
"if",
"successful",
"}"
] | [
"abstract",
"<",
"r",
">",
"query",
"task",
"future",
"<",
"r",
">",
"immediate",
"successful",
"future",
"(",
"r",
"value",
")",
";"
] |
[
"main",
"(",
")",
"has",
"some",
"simple",
"utility",
"methods"
] | [
"public",
"static",
"void",
"main",
"(",
"string",
"argv",
"[",
"]",
")",
"throws",
"exception",
"{",
"fs",
"shell",
"shell",
"=",
"new",
"shell",
"instance",
"(",
")",
";",
"configuration",
"conf",
"=",
"new",
"configuration",
"(",
")",
";",
"conf",
"set",
"quiet",
"mode",
"(",
"false",
")",
";",
"shell",
"set",
"conf",
"(",
"conf",
")",
";",
"int",
"res",
";",
"try",
"{",
"res",
"=",
"tool",
"runner",
"run",
"(",
"shell",
",",
"argv",
")",
";",
"}",
"finally",
"{",
"shell",
"close",
"(",
")",
";",
"}",
"system",
"exit",
"(",
"res",
")",
";",
"}"
] |
[
"put",
"the",
"data",
"to",
"occupy",
"the",
"next",
"byte",
"sequence",
"in",
"the",
"byte",
"array"
] | [
"public",
"void",
"put",
"bytes",
"(",
"byte",
"[",
"]",
"bytes",
",",
"int",
"num",
")",
"{",
"output",
"stream",
"write",
"(",
"bytes",
",",
"0",
",",
"num",
")",
";",
"}"
] |
[
"if",
"this",
"storage",
"corresponds",
"to",
"a",
"auto",
"-",
"parameter",
",",
"return",
"the",
"type",
"associated",
"with",
"the",
"auto",
"-",
"parameter"
] | [
"public",
"auto",
"parameter",
"type",
"get",
"auto",
"parameter",
"type",
"(",
")",
"{",
"return",
"null",
";",
"}"
] |
[
"removes",
"a",
"listener",
"from",
"the",
"root"
] | [
"public",
"boolean",
"remove",
"capture",
"listener",
"(",
"event",
"listener",
"listener",
")",
"{",
"return",
"root",
"remove",
"capture",
"listener",
"(",
"listener",
")",
";",
"}"
] |
[
"fulfills",
"the",
"promise",
"with",
"the",
"provided",
"value"
] | [
"public",
"void",
"fulfill",
"(",
"t",
"value",
")",
"{",
"super",
"fulfill",
"(",
"value",
")",
";",
"post",
"fulfillment",
"(",
")",
";",
"}"
] |
[
"populates",
"auxiliary",
"data",
"structures",
"used",
"by",
"the",
"container",
"scheduler",
"on",
"recovery"
] | [
"public",
"void",
"recover",
"active",
"container",
"(",
"container",
"container",
",",
"recovered",
"container",
"state",
"rcs",
")",
"{",
"execution",
"type",
"exec",
"type",
"=",
"container",
"get",
"container",
"token",
"identifier",
"(",
")",
"get",
"execution",
"type",
"(",
")",
";",
"if",
"(",
"rcs",
"get",
"status",
"(",
")",
"=",
"=",
"recovered",
"container",
"status",
"queued",
"|",
"|",
"rcs",
"get",
"status",
"(",
")",
"=",
"=",
"recovered",
"container",
"status",
"paused",
")",
"{",
"if",
"(",
"exec",
"type",
"=",
"=",
"execution",
"type",
"guaranteed",
")",
"{",
"queued",
"guaranteed",
"containers",
"put",
"(",
"container",
"get",
"container",
"id",
"(",
")",
",",
"container",
")",
";",
"}",
"else",
"if",
"(",
"exec",
"type",
"=",
"=",
"execution",
"type",
"opportunistic",
")",
"{",
"queued",
"opportunistic",
"containers",
"put",
"(",
"container",
"get",
"container",
"id",
"(",
")",
",",
"container",
")",
";",
"}",
"else",
"{",
"log",
"error",
"(",
"\"",
"un",
"known",
"execution",
"type",
"received",
"\"",
"+",
"container",
"get",
"container",
"id",
"(",
")",
"+",
"\"",
",",
"exec",
"type",
"\"",
"+",
"exec",
"type",
")",
";",
"}",
"metrics",
"set",
"queued",
"containers",
"(",
"queued",
"opportunistic",
"containers",
"size",
"(",
")",
",",
"queued",
"guaranteed",
"containers",
"size",
"(",
")",
")",
";",
"}",
"else",
"if",
"(",
"rcs",
"get",
"status",
"(",
")",
"=",
"=",
"recovered",
"container",
"status",
"launched",
")",
"{",
"running",
"containers",
"put",
"(",
"container",
"get",
"container",
"id",
"(",
")",
",",
"container",
")",
";",
"utilization",
"tracker",
"add",
"container",
"resources",
"(",
"container",
")",
";",
"}",
"if",
"(",
"rcs",
"get",
"status",
"(",
")",
"!",
"=",
"recovered",
"container",
"status",
"completed",
"&",
"&",
"rcs",
"get",
"capability",
"(",
")",
"!",
"=",
"null",
")",
"{",
"metrics",
"launched",
"container",
"(",
")",
";",
"metrics",
"allocate",
"container",
"(",
"rcs",
"get",
"capability",
"(",
")",
")",
";",
"}",
"}"
] |
[
"allocate",
"a",
"heap",
"{",
"@",
"link",
"composite",
"byte",
"buf",
"}"
] | [
"composite",
"byte",
"buf",
"composite",
"heap",
"buffer",
"(",
")",
";"
] |
[
"sets",
"the",
"<",
"code",
">",
"anytype",
"3",
"<",
"code",
">",
"property"
] | [
"public",
"additional",
"properties",
"class",
"anytype",
"3",
"(",
"object",
"anytype",
"3",
")",
"{",
"this",
"anytype",
"3",
"=",
"anytype",
"3",
";",
"return",
"this",
";",
"}"
] |
[
"set",
"the",
"value",
"of",
"<",
"code",
">",
"name",
"<",
"code",
">",
"to",
"the",
"given",
"time",
"duration",
"this",
"is",
"equivalent",
"to",
"<",
"code",
">",
"set",
"(",
"&",
"lt",
";",
"name",
"&",
"gt",
";",
",",
"value",
"+",
"&",
"lt",
";",
"time",
"suffix",
"&",
"gt",
";",
")",
"<",
"code",
">"
] | [
"public",
"void",
"set",
"time",
"duration",
"(",
"string",
"name",
",",
"long",
"value",
",",
"time",
"unit",
"unit",
")",
"{",
"set",
"(",
"name",
",",
"value",
"+",
"parsed",
"time",
"duration",
"unit",
"for",
"(",
"unit",
")",
"suffix",
"(",
")",
")",
";",
"}"
] |
[
"returns",
"a",
"list",
"of",
"additional",
"settings",
"filter",
"for",
"this",
"plugin"
] | [
"public",
"list",
"<",
"string",
">",
"get",
"settings",
"filter",
"(",
")",
"{",
"return",
"collections",
"empty",
"list",
"(",
")",
";",
"}"
] |
[
"verifies",
"that",
"we",
"can",
"uninstall",
"an",
"extension"
] | [
"public",
"void",
"test",
"uninstall",
"extension",
"(",
")",
"throws",
"extension",
"exception",
",",
"i",
"o",
"exception",
"{",
"/",
"/",
"create",
"an",
"extension",
"and",
"install",
"it",
"resource",
"file",
"r",
"file",
"=",
"new",
"resource",
"file",
"(",
"create",
"extension",
"zip",
"(",
"default",
"ext",
"name",
")",
")",
";",
"extension",
"utils",
"install",
"(",
"r",
"file",
")",
";",
"check",
"dirty",
"install",
"(",
"default",
"ext",
"name",
")",
";",
"/",
"/",
"get",
"the",
"extension",
"object",
"that",
"we",
"need",
"to",
"uninstall",
"-",
"there",
"will",
"only",
"/",
"/",
"be",
"one",
"in",
"the",
"set",
"set",
"<",
"extension",
"details",
">",
"extensions",
"=",
"extension",
"utils",
"get",
"extensions",
"(",
")",
";",
"assert",
"true",
"(",
"extensions",
"size",
"(",
")",
"=",
"=",
"1",
")",
";",
"extension",
"details",
"ext",
"=",
"extensions",
"iterator",
"(",
")",
"next",
"(",
")",
";",
"/",
"/",
"now",
"uninstall",
"it",
"and",
"verify",
"we",
"have",
"a",
"clean",
"install",
"folder",
"extension",
"utils",
"uninstall",
"(",
"ext",
")",
";",
"check",
"clean",
"install",
"(",
")",
";",
"}"
] |
[
"get",
"direct",
"map"
] | [
"public",
"map",
"<",
"string",
",",
"boolean",
">",
"get",
"direct",
"map",
"(",
")",
"{",
"return",
"direct",
"map",
";",
"}"
] |
[
"serialize",
"the",
"attributes",
"of",
"this",
"session",
"into",
"an",
"object",
"that",
"can",
"be",
"turned",
"into",
"a",
"byte",
"array",
"with",
"standard",
"java",
"serialization"
] | [
"public",
"serializable",
"serialize",
"state",
"(",
")",
"{",
"hash",
"map",
"<",
"string",
",",
"serializable",
">",
"state",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"for",
"(",
"iterator",
"<",
"map",
"entry",
"<",
"string",
",",
"object",
">",
">",
"it",
"=",
"this",
"attributes",
"entry",
"set",
"(",
")",
"iterator",
"(",
")",
";",
"it",
"has",
"next",
"(",
")",
";",
")",
"{",
"map",
"entry",
"<",
"string",
",",
"object",
">",
"entry",
"=",
"it",
"next",
"(",
")",
";",
"string",
"name",
"=",
"entry",
"get",
"key",
"(",
")",
";",
"object",
"value",
"=",
"entry",
"get",
"value",
"(",
")",
";",
"it",
"remove",
"(",
")",
";",
"if",
"(",
"value",
"instanceof",
"serializable",
")",
"{",
"state",
"put",
"(",
"name",
",",
"(",
"serializable",
")",
"value",
")",
";",
"}",
"else",
"{",
"/",
"/",
"not",
"serializable",
"servlet",
"containers",
"usually",
"automatically",
"/",
"/",
"unbind",
"the",
"attribute",
"in",
"this",
"case",
"if",
"(",
"value",
"instanceof",
"http",
"session",
"binding",
"listener",
")",
"{",
"(",
"(",
"http",
"session",
"binding",
"listener",
")",
"value",
")",
"value",
"unbound",
"(",
"new",
"http",
"session",
"binding",
"event",
"(",
"this",
",",
"name",
",",
"value",
")",
")",
";",
"}",
"}",
"}",
"return",
"state",
";",
"}"
] |
[
"get",
"the",
"appropriate",
"decoder",
"for",
"the",
"given",
"decode",
"format",
"and",
"application",
"mode"
] | [
"public",
"static",
"dwarf",
"e",
"h",
"decoder",
"get",
"decoder",
"(",
"dwarf",
"e",
"h",
"data",
"decode",
"format",
"decode",
"format",
",",
"dwarf",
"e",
"h",
"data",
"application",
"mode",
"app",
"format",
",",
"boolean",
"is",
"indirect",
")",
"{",
"dwarf",
"e",
"h",
"decoder",
"decoder",
"=",
"decoder",
"map",
"get",
"(",
"decode",
"format",
")",
";",
"if",
"(",
"decoder",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"decoder",
"set",
"application",
"mode",
"(",
"app",
"format",
")",
";",
"decoder",
"set",
"indirect",
"(",
"is",
"indirect",
")",
";",
"return",
"decoder",
";",
"}"
] |
[
"quote",
"a",
"string",
"with",
"double",
"quotes"
] | [
"private",
"string",
"quote",
"(",
"string",
"string",
")",
"{",
"/",
"/",
"todo",
"(",
"bazel",
"-",
"team",
")",
":",
"this",
"is",
"doesn",
"'",
"t",
"really",
"work",
"if",
"the",
"string",
"contains",
"quotes",
"or",
"a",
"newline",
"/",
"/",
"or",
"a",
"backslash",
"or",
"anything",
"unusual",
",",
"really",
"return",
"\"",
"\\",
"\"",
"\"",
"+",
"string",
"+",
"\"",
"\\",
"\"",
"\"",
";",
"}"
] |
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
] | [
"private",
"static",
"string",
"to",
"indented",
"string",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
] |
[
"start",
"the",
"activity"
] | [
"public",
"static",
"void",
"start",
"activity",
"(",
"@",
"non",
"null",
"final",
"string",
"pkg",
",",
"@",
"non",
"null",
"final",
"string",
"cls",
")",
"{",
"start",
"activity",
"(",
"get",
"top",
"activity",
"or",
"app",
"(",
")",
",",
"null",
",",
"pkg",
",",
"cls",
",",
"null",
")",
";",
"}"
] |
[
"gets",
"called",
"by",
"{",
"@",
"code",
"jdbc",
"template",
"execute",
"}",
"with",
"an",
"active",
"jdbc",
"prepared",
"statement",
"does",
"not",
"need",
"to",
"care",
"about",
"closing",
"the",
"statement",
"or",
"the",
"connection",
",",
"or",
"about",
"handling",
"transactions",
":",
"this",
"will",
"all",
"be",
"handled",
"by",
"spring",
"'",
"s",
"jdbc",
"template",
"<",
"b",
">",
"note",
":",
"<",
"b",
">",
"any",
"result",
"sets",
"opened",
"should",
"be",
"closed",
"in",
"finally",
"blocks",
"within",
"the",
"callback",
"implementation",
"spring",
"will",
"close",
"the",
"statement",
"object",
"after",
"the",
"callback",
"returned",
",",
"but",
"this",
"does",
"not",
"necessarily",
"imply",
"that",
"the",
"result",
"set",
"resources",
"will",
"be",
"closed",
":",
"the",
"statement",
"objects",
"might",
"get",
"pooled",
"by",
"the",
"connection",
"pool",
",",
"with",
"{",
"@",
"code",
"close",
"}",
"calls",
"only",
"returning",
"the",
"object",
"to",
"the",
"pool",
"but",
"not",
"physically",
"closing",
"the",
"resources",
"if",
"called",
"without",
"a",
"thread",
"-",
"bound",
"jdbc",
"transaction",
"(",
"initiated",
"by",
"data",
"source",
"transaction",
"manager",
")",
",",
"the",
"code",
"will",
"simply",
"get",
"executed",
"on",
"the",
"jdbc",
"connection",
"with",
"its",
"transactional",
"semantics",
"if",
"jdbc",
"template",
"is",
"configured",
"to",
"use",
"a",
"jta",
"-",
"aware",
"data",
"source",
",",
"the",
"jdbc",
"connection",
"and",
"thus",
"the",
"callback",
"code",
"will",
"be",
"transactional",
"if",
"a",
"jta",
"transaction",
"is",
"active",
"allows",
"for",
"returning",
"a",
"result",
"object",
"created",
"within",
"the",
"callback",
",",
"i",
"e",
"a",
"domain",
"object",
"or",
"a",
"collection",
"of",
"domain",
"objects",
"note",
"that",
"there",
"'",
"s",
"special",
"support",
"for",
"single",
"step",
"actions",
":",
"see",
"jdbc",
"template",
"query",
"for",
"object",
"etc",
"a",
"thrown",
"runtime",
"exception",
"is",
"treated",
"as",
"application",
"exception",
",",
"it",
"gets",
"propagated",
"to",
"the",
"caller",
"of",
"the",
"template"
] | [
"t",
"do",
"in",
"prepared",
"statement",
"(",
"prepared",
"statement",
"ps",
")",
"throws",
"s",
"q",
"l",
"exception",
",",
"data",
"access",
"exception",
";"
] |
[
"get",
"my",
"string"
] | [
"public",
"string",
"get",
"my",
"string",
"(",
")",
"{",
"return",
"my",
"string",
";",
"}"
] |
[
"test",
"inline",
"additional",
"properties",
"<",
"b",
">",
"200",
"<",
"b",
">",
"-",
"successful",
"operation"
] | [
"public",
"void",
"test",
"inline",
"additional",
"properties",
"(",
"map",
"<",
"string",
",",
"string",
">",
"param",
")",
"throws",
"rest",
"client",
"exception",
"{",
"test",
"inline",
"additional",
"properties",
"with",
"http",
"info",
"(",
"param",
")",
";",
"}"
] |
[
"return",
"the",
"hash",
"code",
"of",
"objects"
] | [
"public",
"static",
"int",
"hash",
"codes",
"(",
"object",
"values",
")",
"{",
"return",
"arrays",
"hash",
"code",
"(",
"values",
")",
";",
"}"
] |
[
"write",
"a",
"json",
"representable",
"type",
"as",
"a",
"string",
",",
"optionally",
"pretty",
"print",
"it",
"by",
"spanning",
"multiple",
"lines",
"and",
"indenting"
] | [
"public",
"static",
"string",
"dump",
"(",
"object",
"data",
",",
"boolean",
"pretty",
")",
"throws",
"i",
"o",
"exception",
"{",
"x",
"content",
"builder",
"builder",
"=",
"json",
"x",
"content",
"content",
"builder",
"(",
")",
";",
"if",
"(",
"pretty",
")",
"{",
"builder",
"pretty",
"print",
"(",
")",
";",
"}",
"builder",
"value",
"(",
"data",
")",
";",
"builder",
"flush",
"(",
")",
";",
"return",
"builder",
"get",
"output",
"stream",
"(",
")",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"parses",
"the",
"query",
"provided",
"as",
"bytes",
"argument",
"and",
"compares",
"it",
"with",
"the",
"expected",
"result",
"provided",
"as",
"argument",
"as",
"a",
"{",
"@",
"link",
"query",
"builder",
"}"
] | [
"private",
"void",
"assert",
"parsed",
"query",
"(",
"x",
"content",
"parser",
"parser",
",",
"query",
"builder",
"expected",
"query",
")",
"throws",
"i",
"o",
"exception",
"{",
"query",
"builder",
"new",
"query",
"=",
"parse",
"query",
"(",
"parser",
")",
";",
"assert",
"not",
"same",
"(",
"new",
"query",
",",
"expected",
"query",
")",
";",
"assert",
"equals",
"(",
"expected",
"query",
",",
"new",
"query",
")",
";",
"assert",
"equals",
"(",
"expected",
"query",
"hash",
"code",
"(",
")",
",",
"new",
"query",
"hash",
"code",
"(",
")",
")",
";",
"}"
] |
[
"adds",
"mapping",
"that",
"will",
"be",
"added",
"when",
"the",
"index",
"gets",
"created"
] | [
"public",
"put",
"index",
"template",
"request",
"mapping",
"(",
"bytes",
"reference",
"source",
",",
"x",
"content",
"type",
"x",
"content",
"type",
")",
"{",
"objects",
"require",
"non",
"null",
"(",
"x",
"content",
"type",
")",
";",
"map",
"<",
"string",
",",
"object",
">",
"mapping",
"as",
"map",
"=",
"x",
"content",
"helper",
"convert",
"to",
"map",
"(",
"source",
",",
"false",
",",
"x",
"content",
"type",
")",
"v",
"2",
"(",
")",
";",
"return",
"mapping",
"(",
"mapping",
"as",
"map",
")",
";",
"}"
] |