docstring_tokens
list | code_tokens
list |
|---|---|
[
"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",
"\"",
")",
";",
"}"
] |
[
"returns",
"the",
"name",
"of",
"the",
"plugin",
"immediately",
"responsible",
"for",
"firing",
"this",
"event"
] |
[
"public",
"final",
"string",
"get",
"source",
"name",
"(",
")",
"{",
"return",
"source",
"name",
";",
"}"
] |
[
"the",
"settings",
"to",
"created",
"the",
"index",
"template",
"with"
] |
[
"public",
"put",
"index",
"template",
"request",
"builder",
"set",
"settings",
"(",
"settings",
"builder",
"settings",
")",
"{",
"request",
"settings",
"(",
"settings",
")",
";",
"return",
"this",
";",
"}"
] |
[
"gets",
"the",
"literal",
"value",
",",
"masked",
"to",
"be",
"a",
"byte",
"in",
"size",
"this",
"will",
"throw",
"if",
"the",
"value",
"is",
"out",
"of",
"the",
"range",
"of",
"a",
"signed",
"byte"
] |
[
"public",
"final",
"int",
"get",
"literal",
"byte",
"(",
")",
"{",
"if",
"(",
"literal",
"!",
"=",
"(",
"byte",
")",
"literal",
")",
"{",
"throw",
"new",
"dex",
"exception",
"(",
"\"",
"literal",
"out",
"of",
"range",
":",
"\"",
"+",
"hex",
"u",
"8",
"(",
"literal",
")",
")",
";",
"}",
"return",
"(",
"int",
")",
"literal",
"&",
"0xff",
";",
"}"
] |
[
"wraps",
"the",
"given",
"text",
"with",
"html",
"markup",
"for",
"each",
"attribute",
"and",
"color",
"defined",
"by",
"this",
"class",
"the",
"returned",
"result",
"will",
"<",
"b",
">",
"not",
"<",
"b",
">",
"be",
"prepended",
"with",
"<",
"code",
">",
"&",
"lt",
";",
"html",
"&",
"gt",
";",
"<",
"code",
">"
] |
[
"public",
"string",
"to",
"html",
"(",
"string",
"text",
")",
"{",
"string",
"html",
"=",
"text",
";",
"if",
"(",
"is",
"bold",
"(",
")",
")",
"{",
"html",
"=",
"h",
"t",
"m",
"l",
"utilities",
"bold",
"(",
"html",
")",
";",
"}",
"if",
"(",
"is",
"italic",
"(",
")",
")",
"{",
"html",
"=",
"h",
"t",
"m",
"l",
"utilities",
"italic",
"(",
"html",
")",
";",
"}",
"if",
"(",
"color",
"!",
"=",
"null",
")",
"{",
"html",
"=",
"h",
"t",
"m",
"l",
"utilities",
"color",
"string",
"(",
"color",
",",
"html",
")",
";",
"}",
"return",
"html",
";",
"}"
] |
[
"writes",
"four",
"code",
"units",
"to",
"the",
"given",
"output",
"destination",
",",
"where",
"the",
"second",
"and",
"third",
"are",
"represented",
"as",
"single",
"<",
"code",
">",
"int",
"<",
"code",
">",
"and",
"emitted",
"in",
"little",
"-",
"endian",
"order"
] |
[
"protected",
"static",
"void",
"write",
"(",
"annotated",
"output",
"out",
",",
"short",
"c",
"0",
",",
"int",
"c",
"1c",
"2",
",",
"short",
"c",
"3",
")",
"{",
"write",
"(",
"out",
",",
"c",
"0",
",",
"(",
"short",
")",
"c",
"1c",
"2",
",",
"(",
"short",
")",
"(",
"c",
"1c",
"2",
">",
">",
"16",
")",
",",
"c",
"3",
")",
";",
"}"
] |
[
"positive",
"test",
"to",
"verify",
"create",
"access",
"check",
"the",
"file",
"is",
"created",
"directly",
"under",
"an",
"existing",
"folder",
"no",
"intermediate",
"folders",
"need",
"to",
"be",
"created"
] |
[
"public",
"void",
"test",
"create",
"access",
"without",
"create",
"intermediate",
"folders",
"check",
"positive",
"(",
")",
"throws",
"throwable",
"{",
"path",
"parent",
"dir",
"=",
"new",
"path",
"(",
"\"",
"/",
"\"",
")",
";",
"path",
"test",
"path",
"=",
"new",
"path",
"(",
"parent",
"dir",
",",
"\"",
"test",
"dat",
"\"",
")",
";",
"authorizer",
"add",
"auth",
"rule",
"for",
"owner",
"(",
"\"",
"/",
"\"",
",",
"write",
",",
"true",
")",
";",
"fs",
"update",
"wasb",
"authorizer",
"(",
"authorizer",
")",
";",
"try",
"{",
"fs",
"create",
"(",
"test",
"path",
")",
";",
"contract",
"test",
"utils",
"assert",
"path",
"exists",
"(",
"fs",
",",
"\"",
"test",
"path",
"was",
"not",
"created",
"\"",
",",
"test",
"path",
")",
";",
"}",
"finally",
"{",
"fs",
"delete",
"(",
"test",
"path",
",",
"false",
")",
";",
"}",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] |
[
"public",
"void",
"execute",
"(",
"runnable",
"command",
")",
"{",
"try",
"{",
"command",
"run",
"(",
")",
";",
"}",
"catch",
"(",
"exception",
"t",
")",
"{",
"logger",
"factory",
"get",
"logger",
"(",
"pool",
"base",
"class",
")",
"debug",
"(",
"\"",
"failed",
"to",
"execute",
":",
"{",
"}",
"\"",
",",
"command",
",",
"t",
")",
";",
"}",
"}"
] |
[
"run",
"a",
"located",
"file",
"status",
"fetcher",
"against",
"the",
"directory",
"tree"
] |
[
"public",
"void",
"check",
"located",
"file",
"status",
"scan",
"file",
"(",
")",
"throws",
"throwable",
"{",
"/",
"/",
"pass",
"in",
"a",
"file",
"as",
"the",
"base",
"of",
"the",
"scan",
"describe",
"(",
"\"",
"located",
"file",
"status",
"fetcher",
"with",
"file",
"%",
"s",
"\"",
",",
"subdir",
"file",
")",
";",
"role",
"config",
"set",
"int",
"(",
"list",
"status",
"num",
"threads",
",",
"16",
")",
";",
"located",
"file",
"status",
"fetcher",
"fetcher",
"=",
"new",
"located",
"file",
"status",
"fetcher",
"(",
"role",
"config",
",",
"new",
"path",
"[",
"]",
"{",
"subdir",
"file",
"}",
",",
"true",
",",
"text",
"file",
",",
"true",
")",
";",
"access",
"denied",
"if",
"(",
"!",
"guarded",
"in",
"auth",
"mode",
",",
"(",
")",
"-",
">",
"fetcher",
"get",
"file",
"statuses",
"(",
")",
")",
"if",
"present",
"(",
"stats",
"-",
">",
"{",
"assertions",
"assert",
"that",
"(",
"stats",
")",
"described",
"as",
"(",
"\"",
"result",
"of",
"located",
"scan",
"\"",
")",
"is",
"not",
"null",
"(",
")",
"flat",
"extracting",
"(",
"file",
"status",
":",
":",
"get",
"path",
")",
"contains",
"exactly",
"(",
"subdir",
"file",
")",
";",
"}",
")",
";",
"}"
] |
[
"build",
"csv",
"output",
"for",
"a",
"request"
] |
[
"public",
"output",
"serialization",
"build",
"c",
"s",
"v",
"output",
"(",
"final",
"configuration",
"owner",
"conf",
",",
"final",
"configuration",
"builder",
"options",
")",
"throws",
"illegal",
"argument",
"exception",
",",
"i",
"o",
"exception",
"{",
"string",
"field",
"delimiter",
"=",
"xopt",
"(",
"builder",
"options",
",",
"owner",
"conf",
",",
"csv",
"output",
"field",
"delimiter",
",",
"csv",
"output",
"field",
"delimiter",
"default",
")",
";",
"string",
"record",
"delimiter",
"=",
"xopt",
"(",
"builder",
"options",
",",
"owner",
"conf",
",",
"csv",
"output",
"record",
"delimiter",
",",
"csv",
"output",
"record",
"delimiter",
"default",
")",
";",
"string",
"quote",
"character",
"=",
"xopt",
"(",
"builder",
"options",
",",
"owner",
"conf",
",",
"csv",
"output",
"quote",
"character",
",",
"csv",
"output",
"quote",
"character",
"default",
")",
";",
"string",
"quote",
"escape",
"character",
"=",
"xopt",
"(",
"builder",
"options",
",",
"owner",
"conf",
",",
"csv",
"output",
"quote",
"escape",
"character",
",",
"csv",
"output",
"quote",
"escape",
"character",
"default",
")",
";",
"string",
"quote",
"fields",
"=",
"xopt",
"(",
"builder",
"options",
",",
"owner",
"conf",
",",
"csv",
"output",
"quote",
"fields",
",",
"csv",
"output",
"quote",
"fields",
"always",
")",
"to",
"upper",
"case",
"(",
"locale",
"english",
")",
";",
"/",
"/",
"output",
"is",
"csv",
",",
"always",
"output",
"serialization",
"output",
"serialization",
"=",
"new",
"output",
"serialization",
"(",
")",
";",
"c",
"s",
"v",
"output",
"csv",
"out",
"=",
"new",
"c",
"s",
"v",
"output",
"(",
")",
";",
"csv",
"out",
"set",
"quote",
"character",
"(",
"quote",
"character",
")",
";",
"csv",
"out",
"set",
"quote",
"fields",
"(",
"quote",
"fields",
"from",
"value",
"(",
"quote",
"fields",
")",
")",
";",
"csv",
"out",
"set",
"field",
"delimiter",
"(",
"field",
"delimiter",
")",
";",
"csv",
"out",
"set",
"record",
"delimiter",
"(",
"record",
"delimiter",
")",
";",
"if",
"(",
"!",
"quote",
"escape",
"character",
"is",
"empty",
"(",
")",
")",
"{",
"csv",
"out",
"set",
"quote",
"escape",
"character",
"(",
"quote",
"escape",
"character",
")",
";",
"}",
"output",
"serialization",
"set",
"csv",
"(",
"csv",
"out",
")",
";",
"return",
"output",
"serialization",
";",
"}"
] |
[
"launches",
"the",
"given",
"java",
"project",
"in",
"the",
"given",
"mode",
"with",
"a",
"ghidra",
"launcher"
] |
[
"private",
"void",
"launch",
"(",
"i",
"java",
"project",
"java",
"project",
",",
"string",
"mode",
")",
"{",
"i",
"launch",
"manager",
"launch",
"manager",
"=",
"debug",
"plugin",
"get",
"default",
"(",
")",
"get",
"launch",
"manager",
"(",
")",
";",
"i",
"launch",
"configuration",
"type",
"launch",
"type",
"=",
"launch",
"manager",
"get",
"launch",
"configuration",
"type",
"(",
"launch",
"config",
"type",
"id",
")",
";",
"string",
"launch",
"config",
"name",
"=",
"java",
"project",
"get",
"project",
"(",
")",
"get",
"name",
"(",
")",
"+",
"launch",
"config",
"name",
"suffix",
";",
"try",
"{",
"i",
"launch",
"configuration",
"lc",
"=",
"ghidra",
"launch",
"utils",
"get",
"launch",
"config",
"(",
"launch",
"config",
"name",
")",
";",
"i",
"launch",
"configuration",
"working",
"copy",
"wc",
"=",
"null",
";",
"if",
"(",
"lc",
"=",
"=",
"null",
")",
"{",
"wc",
"=",
"ghidra",
"launch",
"utils",
"create",
"launch",
"config",
"(",
"java",
"project",
",",
"launch",
"config",
"type",
"id",
",",
"launch",
"config",
"name",
",",
"null",
")",
";",
"}",
"else",
"if",
"(",
"lc",
"get",
"type",
"(",
")",
"equals",
"(",
"launch",
"type",
")",
")",
"{",
"wc",
"=",
"lc",
"get",
"working",
"copy",
"(",
")",
";",
"}",
"else",
"{",
"throw",
"new",
"core",
"exception",
"(",
"new",
"status",
"(",
"i",
"status",
"error",
",",
"activator",
"plugin",
"id",
",",
"i",
"status",
"error",
",",
"\"",
"failed",
"to",
"launch",
"run",
"configuration",
"with",
"name",
"\\",
"\"",
"\"",
"+",
"launch",
"config",
"name",
"+",
"\"",
"\\",
"\"",
"already",
"exists",
"\"",
",",
"null",
")",
")",
";",
"}",
"wc",
"do",
"save",
"(",
")",
"launch",
"(",
"mode",
",",
"null",
")",
";",
"}",
"catch",
"(",
"core",
"exception",
"e",
")",
"{",
"eclipse",
"message",
"utils",
"show",
"error",
"dialog",
"(",
"e",
"get",
"message",
"(",
")",
")",
";",
"}",
"}"
] |
[
"returns",
"a",
"type",
"that",
"represents",
"an",
"unknown",
"type",
"that",
"extends",
"{",
"@",
"code",
"bound",
"}",
"for",
"example",
",",
"if",
"{",
"@",
"code",
"bound",
"}",
"is",
"{",
"@",
"code",
"char",
"sequence",
"class",
"}",
",",
"this",
"returns",
"{",
"@",
"code",
"?",
"extends",
"char",
"sequence",
"}",
"if",
"{",
"@",
"code",
"bound",
"}",
"is",
"{",
"@",
"code",
"object",
"class",
"}",
",",
"this",
"returns",
"{",
"@",
"code",
"?",
"}",
",",
"which",
"is",
"shorthand",
"for",
"{",
"@",
"code",
"?",
"extends",
"object",
"}"
] |
[
"public",
"static",
"wildcard",
"type",
"subtype",
"of",
"(",
"type",
"bound",
")",
"{",
"type",
"[",
"]",
"upper",
"bounds",
";",
"if",
"(",
"bound",
"instanceof",
"wildcard",
"type",
")",
"{",
"upper",
"bounds",
"=",
"(",
"(",
"wildcard",
"type",
")",
"bound",
")",
"get",
"upper",
"bounds",
"(",
")",
";",
"}",
"else",
"{",
"upper",
"bounds",
"=",
"new",
"type",
"[",
"]",
"{",
"bound",
"}",
";",
"}",
"return",
"new",
"wildcard",
"type",
"impl",
"(",
"upper",
"bounds",
",",
"empty",
"type",
"array",
")",
";",
"}"
] |
[
"gets",
"the",
"serializer",
"from",
"this",
"plan",
"node"
] |
[
"public",
"type",
"serializer",
"factory",
"<",
"?",
">",
"get",
"serializer",
"(",
")",
"{",
"return",
"serializer",
";",
"}"
] |
[
"ensures",
"all",
"buffered",
"data",
"is",
"written",
"to",
"the",
"underlying",
"{",
"@",
"link",
"sink",
"}",
"and",
"flushes",
"that",
"writer"
] |
[
"public",
"void",
"flush",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"stack",
"size",
"=",
"=",
"0",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"json",
"writer",
"is",
"closed",
"\"",
")",
";",
"}",
"sink",
"flush",
"(",
")",
";",
"}"
] |
[
"this",
"implementation",
"returns",
"{",
"@",
"code",
"to",
"string",
"(",
")",
"}",
"'",
"s",
"hash",
"code"
] |
[
"public",
"int",
"hash",
"code",
"(",
")",
"{",
"return",
"to",
"string",
"(",
")",
"hash",
"code",
"(",
")",
";",
"}"
] |
[
"guaranteed",
"to",
"throw",
"an",
"exception",
"and",
"leave",
"the",
"multimap",
"unmodified"
] |
[
"public",
"boolean",
"put",
"all",
"(",
"multimap",
"<",
"?",
"extends",
"k",
",",
"?",
"extends",
"v",
">",
"multimap",
")",
"{",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
")",
";",
"}"
] |
[
"returns",
"the",
"explanation",
"string",
",",
"fully",
"formatted",
"only",
"formats",
"the",
"string",
"once"
] |
[
"public",
"string",
"get",
"explanation",
"(",
")",
"{",
"return",
"this",
"explanation",
"string",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] |
[
"public",
"void",
"set",
"idle",
"timeout",
"(",
"long",
"idle",
"timeout",
"ms",
")",
"{",
"if",
"(",
"idle",
"timeout",
"ms",
"<",
"0",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"idle",
"timeout",
"cannot",
"be",
"negative",
"\"",
")",
";",
"}",
"this",
"idle",
"timeout",
"=",
"idle",
"timeout",
"ms",
";",
"}"
] |
[
"returns",
"whether",
"any",
"of",
"the",
"visited",
"line",
"numbers",
"has",
"a",
"non",
"-",
"null",
"source"
] |
[
"public",
"boolean",
"has",
"source",
"(",
")",
"{",
"return",
"has",
"source",
";",
"}"
] |
[
"a",
"convenience",
"wrapper",
"for",
"{",
"@",
"link",
"#",
"from",
"templates",
"(",
"iterable",
")",
"}"
] |
[
"public",
"static",
"safe",
"implicit",
"outputs",
"function",
"from",
"templates",
"(",
"string",
"templates",
")",
"{",
"return",
"from",
"templates",
"(",
"arrays",
"as",
"list",
"(",
"templates",
")",
")",
";",
"}"
] |
[
"writes",
"an",
"input",
"stream",
"from",
"a",
"network",
"response",
"to",
"a",
"temporary",
"file",
"if",
"the",
"file",
"successfully",
"parses",
"to",
"an",
"composition",
",",
"{",
"@",
"link",
"#",
"rename",
"temp",
"file",
"(",
"file",
"extension",
")",
"}",
"should",
"be",
"called",
"to",
"move",
"the",
"file",
"to",
"its",
"final",
"location",
"for",
"future",
"cache",
"hits"
] |
[
"file",
"write",
"temp",
"cache",
"file",
"(",
"string",
"url",
",",
"input",
"stream",
"stream",
",",
"file",
"extension",
"extension",
")",
"throws",
"i",
"o",
"exception",
"{",
"string",
"file",
"name",
"=",
"filename",
"for",
"url",
"(",
"url",
",",
"extension",
",",
"true",
")",
";",
"file",
"file",
"=",
"new",
"file",
"(",
"parent",
"dir",
"(",
")",
",",
"file",
"name",
")",
";",
"try",
"{",
"output",
"stream",
"output",
"=",
"new",
"file",
"output",
"stream",
"(",
"file",
")",
";",
"/",
"/",
"noinspection",
"try",
"finally",
"can",
"be",
"try",
"with",
"resources",
"try",
"{",
"byte",
"[",
"]",
"buffer",
"=",
"new",
"byte",
"[",
"1024",
"]",
";",
"int",
"read",
";",
"while",
"(",
"(",
"read",
"=",
"stream",
"read",
"(",
"buffer",
")",
")",
"!",
"=",
"-",
"1",
")",
"{",
"output",
"write",
"(",
"buffer",
",",
"0",
",",
"read",
")",
";",
"}",
"output",
"flush",
"(",
")",
";",
"}",
"finally",
"{",
"output",
"close",
"(",
")",
";",
"}",
"}",
"finally",
"{",
"stream",
"close",
"(",
")",
";",
"}",
"return",
"file",
";",
"}"
] |
[
"json",
"representation",
"of",
"the",
"async",
"caller",
"thread",
"pool"
] |
[
"public",
"string",
"get",
"async",
"caller",
"pool",
"json",
"(",
")",
"{",
"final",
"map",
"<",
"string",
",",
"integer",
">",
"info",
"=",
"new",
"linked",
"hash",
"map",
"<",
">",
"(",
")",
";",
"info",
"put",
"(",
"\"",
"active",
"\"",
",",
"executor",
"service",
"get",
"active",
"count",
"(",
")",
")",
";",
"info",
"put",
"(",
"\"",
"total",
"\"",
",",
"executor",
"service",
"get",
"pool",
"size",
"(",
")",
")",
";",
"info",
"put",
"(",
"\"",
"max",
"\"",
",",
"executor",
"service",
"get",
"maximum",
"pool",
"size",
"(",
")",
")",
";",
"return",
"json",
"to",
"string",
"(",
"info",
")",
";",
"}"
] |
[
"implementation",
"of",
"completing",
"a",
"task",
"either",
"{",
"@",
"code",
"v",
"}",
"or",
"{",
"@",
"code",
"t",
"}",
"will",
"be",
"set",
"but",
"not",
"both",
"the",
"{",
"@",
"code",
"final",
"state",
"}",
"is",
"the",
"state",
"to",
"change",
"to",
"from",
"{",
"@",
"link",
"#",
"running",
"}",
"if",
"the",
"state",
"is",
"not",
"in",
"the",
"running",
"state",
"we",
"return",
"{",
"@",
"code",
"false",
"}",
"after",
"waiting",
"for",
"the",
"state",
"to",
"be",
"set",
"to",
"a",
"valid",
"final",
"state",
"(",
"{",
"@",
"link",
"#",
"completed",
"}",
",",
"{",
"@",
"link",
"#",
"cancelled",
"}",
",",
"or",
"{",
"@",
"link",
"#",
"interrupted",
"}",
")"
] |
[
"private",
"boolean",
"complete",
"(",
"@",
"nullable",
"decl",
"v",
"v",
",",
"@",
"nullable",
"decl",
"throwable",
"t",
",",
"int",
"final",
"state",
")",
"{",
"boolean",
"do",
"completion",
"=",
"compare",
"and",
"set",
"state",
"(",
"running",
",",
"completing",
")",
";",
"if",
"(",
"do",
"completion",
")",
"{",
"/",
"/",
"if",
"this",
"thread",
"successfully",
"transitioned",
"to",
"completing",
",",
"set",
"the",
"value",
"/",
"/",
"and",
"exception",
"and",
"then",
"release",
"to",
"the",
"final",
"state",
"this",
"value",
"=",
"v",
";",
"/",
"/",
"don",
"'",
"t",
"actually",
"construct",
"a",
"cancellation",
"exception",
"until",
"necessary",
"this",
"exception",
"=",
"(",
"(",
"final",
"state",
"&",
"(",
"cancelled",
"|",
"interrupted",
")",
")",
"!",
"=",
"0",
")",
"?",
"new",
"cancellation",
"exception",
"(",
"\"",
"future",
"cancel",
"(",
")",
"was",
"called",
"\"",
")",
":",
"t",
";",
"release",
"shared",
"(",
"final",
"state",
")",
";",
"}",
"else",
"if",
"(",
"get",
"state",
"(",
")",
"=",
"=",
"completing",
")",
"{",
"/",
"/",
"if",
"some",
"other",
"thread",
"is",
"currently",
"completing",
"the",
"future",
",",
"block",
"until",
"/",
"/",
"they",
"are",
"done",
"so",
"we",
"can",
"guarantee",
"completion",
"acquire",
"shared",
"(",
"-",
"1",
")",
";",
"}",
"return",
"do",
"completion",
";",
"}"
] |
[
"usually",
"returns",
"{",
"@",
"code",
"null",
"}",
"but",
",",
"if",
"this",
"{",
"@",
"code",
"future",
"}",
"has",
"failed",
",",
"may",
"optionally",
"return",
"the",
"cause",
"of",
"the",
"failure",
"\"",
"failure",
"\"",
"means",
"specifically",
"\"",
"completed",
"with",
"an",
"exception",
"\"",
";",
"it",
"does",
"not",
"include",
"\"",
"was",
"cancelled",
"\"",
"to",
"be",
"explicit",
":",
"if",
"this",
"method",
"returns",
"a",
"non",
"-",
"null",
"value",
",",
"then",
":",
"{",
"@",
"code",
"is",
"done",
"(",
")",
"}",
"must",
"return",
"{",
"@",
"code",
"true",
"}",
"{",
"@",
"code",
"is",
"cancelled",
"(",
")",
"}",
"must",
"return",
"{",
"@",
"code",
"false",
"}",
"{",
"@",
"code",
"get",
"(",
")",
"}",
"must",
"not",
"block",
",",
"and",
"it",
"must",
"throw",
"an",
"{",
"@",
"code",
"execution",
"exception",
"}",
"with",
"the",
"return",
"value",
"of",
"this",
"method",
"as",
"its",
"cause",
"this",
"method",
"is",
"{",
"@",
"code",
"protected",
"}",
"so",
"that",
"classes",
"like",
"{",
"@",
"code",
"com",
"google",
"common",
"util",
"concurrent",
"settable",
"future",
"}",
"do",
"not",
"expose",
"it",
"to",
"their",
"users",
"as",
"an",
"instance",
"method",
"in",
"the",
"unlikely",
"event",
"that",
"you",
"need",
"to",
"call",
"this",
"method",
",",
"call",
"{",
"@",
"link",
"internal",
"futures",
"#",
"try",
"internal",
"fast",
"path",
"get",
"failure",
"(",
"internal",
"future",
"failure",
"access",
")",
"}"
] |
[
"protected",
"abstract",
"throwable",
"try",
"internal",
"fast",
"path",
"get",
"failure",
"(",
")",
";"
] |
[
"replaces",
"all",
"items",
"in",
"the",
"{",
"@",
"link",
"recycler",
"binder",
"}",
"with",
"the",
"provided",
"{",
"@",
"link",
"render",
"info",
"}",
"s"
] |
[
"public",
"final",
"void",
"replace",
"all",
"(",
"list",
"<",
"render",
"info",
">",
"render",
"infos",
")",
"{",
"final",
"list",
"<",
"component",
"tree",
"holder",
">",
"to",
"release",
";",
"synchronized",
"(",
"this",
")",
"{",
"if",
"(",
"m",
"has",
"async",
"operations",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"trying",
"to",
"do",
"a",
"sync",
"replace",
"all",
"when",
"using",
"asynchronous",
"mutations",
"!",
"\"",
")",
";",
"}",
"to",
"release",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"m",
"component",
"tree",
"holders",
")",
";",
"m",
"component",
"tree",
"holders",
"clear",
"(",
")",
";",
"for",
"(",
"render",
"info",
"render",
"info",
":",
"render",
"infos",
")",
"{",
"m",
"component",
"tree",
"holders",
"add",
"(",
"create",
"component",
"tree",
"holder",
"(",
"render",
"info",
")",
")",
";",
"}",
"}",
"m",
"internal",
"adapter",
"notify",
"data",
"set",
"changed",
"(",
")",
";",
"m",
"viewport",
"manager",
"set",
"should",
"update",
"(",
"true",
")",
";",
"/",
"/",
"when",
"items",
"are",
"removed",
",",
"the",
"corresponding",
"views",
"might",
"want",
"to",
"disappear",
"with",
"animations",
",",
"/",
"/",
"therefore",
"we",
"post",
"a",
"runnable",
"to",
"release",
"the",
"component",
"trees",
"later",
"post",
"release",
"component",
"tree",
"holders",
"(",
"to",
"release",
")",
";",
"}"
] |
[
"extract",
"headers",
"from",
"rest",
"call",
"and",
"add",
"to",
"client",
"request"
] |
[
"private",
"static",
"void",
"add",
"headers",
"to",
"request",
"(",
"http",
"headers",
"headers",
",",
"request",
"req",
")",
"{",
"if",
"(",
"headers",
"!",
"=",
"null",
")",
"{",
"string",
"credential",
"authorization",
"=",
"headers",
"get",
"header",
"string",
"(",
"http",
"headers",
"authorization",
")",
";",
"if",
"(",
"credential",
"authorization",
"!",
"=",
"null",
")",
"{",
"req",
"header",
"(",
"http",
"headers",
"authorization",
",",
"credential",
"authorization",
")",
";",
"}",
"}",
"}"
] |
[
"adds",
"the",
"result",
"from",
"expansion",
"of",
"negative",
"target",
"pattern",
"(",
"eg",
",",
"\"",
"-",
"foo",
":",
"all",
"\"",
")"
] |
[
"void",
"add",
"labels",
"of",
"positive",
"pattern",
"(",
"resolved",
"targets",
"<",
"label",
">",
"labels",
")",
"{",
"preconditions",
"check",
"argument",
"(",
"labels",
"get",
"filtered",
"targets",
"(",
")",
"is",
"empty",
"(",
")",
")",
";",
"resolved",
"labels",
"builder",
"add",
"all",
"(",
"labels",
"get",
"targets",
"(",
")",
")",
";",
"}"
] |
[
"verify",
"that",
"the",
"bucket",
"exists",
"this",
"does",
"not",
"check",
"permissions",
",",
"not",
"even",
"read",
"access"
] |
[
"static",
"void",
"verify",
"bucket",
"exists",
"(",
"final",
"o",
"b",
"s",
"file",
"system",
"owner",
")",
"throws",
"file",
"not",
"found",
"exception",
",",
"i",
"o",
"exception",
"{",
"int",
"retry",
"time",
"=",
"1",
";",
"while",
"(",
"true",
")",
"{",
"try",
"{",
"if",
"(",
"!",
"owner",
"get",
"obs",
"client",
"(",
")",
"head",
"bucket",
"(",
"owner",
"get",
"bucket",
"(",
")",
")",
")",
"{",
"throw",
"new",
"file",
"not",
"found",
"exception",
"(",
"\"",
"bucket",
"\"",
"+",
"owner",
"get",
"bucket",
"(",
")",
"+",
"\"",
"does",
"not",
"exist",
"\"",
")",
";",
"}",
"return",
";",
"}",
"catch",
"(",
"obs",
"exception",
"e",
")",
"{",
"log",
"warn",
"(",
"\"",
"failed",
"to",
"head",
"bucket",
"for",
"[",
"{",
"}",
"]",
",",
"retry",
"time",
"[",
"{",
"}",
"]",
",",
"\"",
"+",
"\"",
"exception",
"[",
"{",
"}",
"]",
"\"",
",",
"owner",
"get",
"bucket",
"(",
")",
",",
"retry",
"time",
",",
"translate",
"exception",
"(",
"\"",
"does",
"bucket",
"exist",
"\"",
",",
"owner",
"get",
"bucket",
"(",
")",
",",
"e",
")",
")",
";",
"if",
"(",
"max",
"retry",
"time",
"=",
"=",
"retry",
"time",
")",
"{",
"throw",
"translate",
"exception",
"(",
"\"",
"does",
"bucket",
"exist",
"\"",
",",
"owner",
"get",
"bucket",
"(",
")",
",",
"e",
")",
";",
"}",
"try",
"{",
"thread",
"sleep",
"(",
"delay",
"time",
")",
";",
"}",
"catch",
"(",
"interrupted",
"exception",
"ie",
")",
"{",
"throw",
"e",
";",
"}",
"}",
"retry",
"time",
"+",
"+",
";",
"}",
"}"
] |
[
"test",
"the",
"property",
"'",
"name",
"'"
] |
[
"public",
"void",
"name",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"name",
"}"
] |
[
"this",
"method",
"differs",
"from",
"{",
"@",
"link",
"blocking",
"queue",
"#",
"offer",
"(",
"object",
")",
"}",
"in",
"that",
"it",
"will",
"remove",
"the",
"oldest",
"queued",
"element",
"(",
"the",
"element",
"at",
"the",
"front",
"of",
"the",
"queue",
")",
"in",
"order",
"to",
"make",
"room",
"for",
"any",
"new",
"elements",
"if",
"the",
"queue",
"is",
"full"
] |
[
"public",
"boolean",
"offer",
"(",
"e",
"e",
")",
"{",
"objects",
"require",
"non",
"null",
"(",
"e",
")",
";",
"final",
"reentrant",
"lock",
"lock",
"=",
"this",
"lock",
";",
"lock",
"lock",
"(",
")",
";",
"try",
"{",
"if",
"(",
"this",
"queue",
"size",
"(",
")",
"=",
"=",
"this",
"max",
"size",
")",
"{",
"final",
"e",
"discard",
"=",
"this",
"queue",
"remove",
"(",
")",
";",
"this",
"dropped",
"count",
"+",
"+",
";",
"log",
"debug",
"(",
"\"",
"queue",
"is",
"full",
"discarding",
"oldest",
"element",
"[",
"count",
"=",
"{",
"}",
"]",
":",
"{",
"}",
"\"",
",",
"this",
"dropped",
"count",
",",
"discard",
")",
";",
"}",
"this",
"queue",
"add",
"(",
"e",
")",
";",
"this",
"not",
"empty",
"signal",
"(",
")",
";",
"}",
"finally",
"{",
"lock",
"unlock",
"(",
")",
";",
"}",
"return",
"true",
";",
"}"
] |
[
"return",
"whether",
"using",
"mobile",
"data",
"must",
"hold",
"{",
"@",
"code",
"<",
"uses",
"-",
"permission",
"android",
":",
"name",
"=",
"\"",
"android",
"permission",
"access",
"network",
"state",
"\"",
">",
"}"
] |
[
"public",
"static",
"boolean",
"is",
"mobile",
"data",
"(",
")",
"{",
"network",
"info",
"info",
"=",
"get",
"active",
"network",
"info",
"(",
")",
";",
"return",
"null",
"!",
"=",
"info",
"&",
"&",
"info",
"is",
"available",
"(",
")",
"&",
"&",
"info",
"get",
"type",
"(",
")",
"=",
"=",
"connectivity",
"manager",
"type",
"mobile",
";",
"}"
] |
[
"add",
"a",
"part",
"{",
"@",
"link",
"http",
"message",
"writer",
"}",
"for",
"writers",
"of",
"type",
"{",
"@",
"link",
"encoder",
"http",
"message",
"writer",
"}",
"consider",
"using",
"the",
"shortcut",
"{",
"@",
"link",
"#",
"encoder",
"(",
"encoder",
")",
"}",
"instead"
] |
[
"multipart",
"codecs",
"writer",
"(",
"http",
"message",
"writer",
"<",
"?",
">",
"writer",
")",
";"
] |
[
"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",
"abstract",
"epoxy",
"model",
"with",
"view",
"on",
"bind",
"(",
"on",
"model",
"bound",
"listener",
"<",
"abstract",
"epoxy",
"model",
"with",
"view",
",",
"view",
">",
"listener",
")",
"{",
"on",
"mutation",
"(",
")",
";",
"this",
"on",
"model",
"bound",
"listener",
"epoxy",
"generated",
"model",
"=",
"listener",
";",
"return",
"this",
";",
"}"
] |
[
"invalid",
"username",
"supplied"
] |
[
"public",
"void",
"should",
"see",
"4",
"0",
"0",
"after",
"get",
"user",
"by",
"name",
"(",
")",
"{",
"string",
"username",
"=",
"null",
";",
"api",
"get",
"user",
"by",
"name",
"(",
")",
"username",
"path",
"(",
"username",
")",
"execute",
"(",
"r",
"-",
">",
"r",
"pretty",
"peek",
"(",
")",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
] |
[
"build",
"call",
"for",
"fake",
"outer",
"boolean",
"serialize"
] |
[
"public",
"okhttp",
"3",
"call",
"fake",
"outer",
"boolean",
"serialize",
"call",
"(",
"boolean",
"body",
",",
"final",
"api",
"callback",
"callback",
")",
"throws",
"api",
"exception",
"{",
"object",
"local",
"var",
"post",
"body",
"=",
"body",
";",
"/",
"/",
"create",
"path",
"and",
"map",
"variables",
"api",
"operation",
"api",
"operation",
"=",
"local",
"var",
"api",
"client",
"get",
"operation",
"lookup",
"map",
"(",
")",
"get",
"(",
"\"",
"fake",
"outer",
"boolean",
"serialize",
"\"",
")",
";",
"if",
"(",
"api",
"operation",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"api",
"exception",
"(",
"\"",
"operation",
"not",
"found",
"in",
"oas",
"\"",
")",
";",
"}",
"operation",
"operation",
"=",
"api",
"operation",
"get",
"operation",
"(",
")",
";",
"string",
"local",
"var",
"path",
"=",
"api",
"operation",
"get",
"path",
"(",
")",
";",
"map",
"<",
"string",
",",
"object",
">",
"param",
"map",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"list",
"<",
"pair",
">",
"local",
"var",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
"pair",
">",
"(",
")",
";",
"list",
"<",
"pair",
">",
"local",
"var",
"collection",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
"pair",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"header",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"cookie",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"object",
">",
"local",
"var",
"form",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"object",
">",
"(",
")",
";",
"local",
"var",
"path",
"=",
"local",
"var",
"api",
"client",
"fill",
"parameters",
"from",
"operation",
"(",
"operation",
",",
"param",
"map",
",",
"local",
"var",
"path",
",",
"local",
"var",
"query",
"params",
",",
"local",
"var",
"collection",
"query",
"params",
",",
"local",
"var",
"header",
"params",
",",
"local",
"var",
"cookie",
"params",
")",
";",
"final",
"string",
"[",
"]",
"local",
"var",
"accepts",
"=",
"{",
"\"",
"*",
"/",
"*",
"\"",
"}",
";",
"final",
"string",
"local",
"var",
"accept",
"=",
"local",
"var",
"api",
"client",
"select",
"header",
"accept",
"(",
"local",
"var",
"accepts",
")",
";",
"if",
"(",
"local",
"var",
"accept",
"!",
"=",
"null",
")",
"{",
"local",
"var",
"header",
"params",
"put",
"(",
"\"",
"accept",
"\"",
",",
"local",
"var",
"accept",
")",
";",
"}",
"final",
"string",
"[",
"]",
"local",
"var",
"content",
"types",
"=",
"{",
"}",
";",
"final",
"string",
"local",
"var",
"content",
"type",
"=",
"local",
"var",
"api",
"client",
"select",
"header",
"content",
"type",
"(",
"local",
"var",
"content",
"types",
")",
";",
"local",
"var",
"header",
"params",
"put",
"(",
"\"",
"content",
"-",
"type",
"\"",
",",
"local",
"var",
"content",
"type",
")",
";",
"string",
"[",
"]",
"local",
"var",
"auth",
"names",
"=",
"new",
"string",
"[",
"]",
"{",
"}",
";",
"return",
"local",
"var",
"api",
"client",
"build",
"call",
"(",
"local",
"var",
"path",
",",
"api",
"operation",
"get",
"method",
"(",
")",
",",
"local",
"var",
"query",
"params",
",",
"local",
"var",
"collection",
"query",
"params",
",",
"local",
"var",
"post",
"body",
",",
"local",
"var",
"header",
"params",
",",
"local",
"var",
"cookie",
"params",
",",
"local",
"var",
"form",
"params",
",",
"local",
"var",
"auth",
"names",
",",
"callback",
")",
";",
"}"
] |
[
"all",
"registered",
"instances",
"of",
"{",
"@",
"link",
"hystrix",
"thread",
"pool",
"metrics",
"}"
] |
[
"public",
"static",
"collection",
"<",
"hystrix",
"thread",
"pool",
"metrics",
">",
"get",
"instances",
"(",
")",
"{",
"list",
"<",
"hystrix",
"thread",
"pool",
"metrics",
">",
"thread",
"pool",
"metrics",
"=",
"new",
"array",
"list",
"<",
"hystrix",
"thread",
"pool",
"metrics",
">",
"(",
")",
";",
"for",
"(",
"hystrix",
"thread",
"pool",
"metrics",
"tpm",
":",
"metrics",
"values",
"(",
")",
")",
"{",
"if",
"(",
"has",
"executed",
"commands",
"on",
"thread",
"(",
"tpm",
")",
")",
"{",
"thread",
"pool",
"metrics",
"add",
"(",
"tpm",
")",
";",
"}",
"}",
"return",
"collections",
"unmodifiable",
"collection",
"(",
"thread",
"pool",
"metrics",
")",
";",
"}"
] |
[
"returns",
"a",
"rooted",
"path",
"representing",
"{",
"@",
"code",
"path",
"}",
"under",
"the",
"root",
"{",
"@",
"code",
"root",
"}"
] |
[
"public",
"static",
"rooted",
"path",
"to",
"rooted",
"path",
"(",
"root",
"root",
",",
"path",
"path",
")",
"{",
"preconditions",
"check",
"state",
"(",
"root",
"contains",
"(",
"path",
")",
",",
"\"",
"path",
":",
"%",
"s",
"root",
":",
"%",
"s",
"\"",
",",
"path",
",",
"root",
")",
";",
"return",
"to",
"rooted",
"path",
"(",
"root",
",",
"path",
"as",
"fragment",
"(",
")",
")",
";",
"}"
] |
[
"returns",
"the",
"last",
"metadata",
"entry",
"added",
"with",
"the",
"name",
"'",
"name",
"'",
"parsed",
"as",
"t"
] |
[
"public",
"<",
"t",
">",
"t",
"get",
"(",
"key",
"<",
"t",
">",
"key",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"size",
"-",
"1",
";",
"i",
">",
"=",
"0",
";",
"i",
"-",
"-",
")",
"{",
"if",
"(",
"bytes",
"equal",
"(",
"key",
"ascii",
"name",
"(",
")",
",",
"name",
"(",
"i",
")",
")",
")",
"{",
"return",
"value",
"as",
"t",
"(",
"i",
",",
"key",
")",
";",
"}",
"}",
"return",
"null",
";",
"}"
] |
[
"returns",
"the",
"current",
"value",
"being",
"referenced",
",",
"or",
"{",
"@",
"code",
"null",
"}",
"if",
"there",
"is",
"none",
"(",
"e",
"g",
"because",
"either",
"it",
"got",
"collected",
",",
"or",
"{",
"@",
"link",
"#",
"clear",
"}",
"was",
"called",
",",
"or",
"it",
"wasn",
"'",
"t",
"set",
"in",
"the",
"first",
"place",
")"
] |
[
"v",
"get",
"(",
")",
";"
] |
[
"used",
"for",
"iterating",
"through",
"the",
"attributes"
] |
[
"public",
"final",
"iterator",
"<",
"attribute",
">",
"iterator",
"(",
")",
"{",
"return",
"attributes",
"iterator",
"(",
")",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"enum",
"string",
"'"
] |
[
"public",
"void",
"enum",
"string",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"enum",
"string",
"}"
] |
[
"determine",
"service",
"response",
"url",
"and",
"provide",
"url"
] |
[
"protected",
"string",
"determine",
"service",
"response",
"url",
"(",
"final",
"web",
"application",
"service",
"service",
")",
"{",
"val",
"registered",
"service",
"=",
"this",
"services",
"manager",
"find",
"service",
"by",
"(",
"service",
")",
";",
"if",
"(",
"registered",
"service",
"!",
"=",
"null",
"&",
"&",
"string",
"utils",
"is",
"not",
"blank",
"(",
"registered",
"service",
"get",
"redirect",
"url",
"(",
")",
")",
")",
"{",
"return",
"registered",
"service",
"get",
"redirect",
"url",
"(",
")",
";",
"}",
"return",
"service",
"get",
"original",
"url",
"(",
")",
";",
"}"
] |
[
"sets",
"the",
"type",
"of",
"versioning",
"to",
"use",
"defaults",
"to",
"{",
"@",
"link",
"version",
"type",
"#",
"internal",
"}"
] |
[
"public",
"delete",
"request",
"builder",
"set",
"version",
"type",
"(",
"version",
"type",
"version",
"type",
")",
"{",
"request",
"version",
"type",
"(",
"version",
"type",
")",
";",
"return",
"this",
";",
"}"
] |
[
"reap",
"the",
"docker",
"container"
] |
[
"public",
"void",
"reap",
"container",
"(",
"container",
"runtime",
"context",
"ctx",
")",
"throws",
"container",
"execution",
"exception",
"{",
"/",
"/",
"clean",
"up",
"the",
"docker",
"container",
"handle",
"container",
"remove",
"(",
"ctx",
"get",
"container",
"(",
")",
"get",
"container",
"id",
"(",
")",
"to",
"string",
"(",
")",
",",
"ctx",
"get",
"container",
"(",
")",
"get",
"launch",
"context",
"(",
")",
"get",
"environment",
"(",
")",
")",
";",
"/",
"/",
"cleanup",
"volumes",
"when",
"needed",
"if",
"(",
"nm",
"context",
"!",
"=",
"null",
"&",
"&",
"nm",
"context",
"get",
"resource",
"plugin",
"manager",
"(",
")",
"get",
"name",
"to",
"plugins",
"(",
")",
"!",
"=",
"null",
")",
"{",
"for",
"(",
"resource",
"plugin",
"plugin",
":",
"nm",
"context",
"get",
"resource",
"plugin",
"manager",
"(",
")",
"get",
"name",
"to",
"plugins",
"(",
")",
"values",
"(",
")",
")",
"{",
"docker",
"command",
"plugin",
"docker",
"command",
"plugin",
"=",
"plugin",
"get",
"docker",
"command",
"plugin",
"instance",
"(",
")",
";",
"if",
"(",
"docker",
"command",
"plugin",
"!",
"=",
"null",
")",
"{",
"docker",
"volume",
"command",
"docker",
"volume",
"command",
"=",
"docker",
"command",
"plugin",
"get",
"cleanup",
"docker",
"volumes",
"command",
"(",
"ctx",
"get",
"container",
"(",
")",
")",
";",
"if",
"(",
"docker",
"volume",
"command",
"!",
"=",
"null",
")",
"{",
"run",
"docker",
"volume",
"command",
"(",
"docker",
"volume",
"command",
",",
"ctx",
"get",
"container",
"(",
")",
")",
";",
"}",
"}",
"}",
"}",
"}"
] |
[
"gets",
"the",
"permission",
"object",
"that",
"represents",
"the",
"permission",
"(",
"against",
"{",
"@",
"link",
"#",
"get",
"a",
"c",
"l",
"}",
")",
"to",
"perform",
"this",
"task",
"generally",
"your",
"implementation",
"of",
"{",
"@",
"link",
"#",
"get",
"icon",
"file",
"name",
"}",
"should",
"return",
"null",
"if",
"{",
"@",
"code",
"!",
"get",
"a",
"c",
"l",
"(",
")",
"has",
"permission",
"2",
"(",
"get",
"permission",
"(",
")",
")",
"}"
] |
[
"protected",
"abstract",
"permission",
"get",
"permission",
"(",
")",
";"
] |
[
"tests",
"the",
"write",
"and",
"read",
"contents",
"with",
"nfly",
"mount",
"link"
] |
[
"public",
"void",
"test",
"nfly",
"write",
"read",
"(",
")",
"throws",
"exception",
"{",
"final",
"path",
"hdfs",
"target",
"path",
"1",
"=",
"new",
"path",
"(",
"default",
"f",
"s",
"u",
"r",
"i",
"+",
"hdfs",
"user",
"folder",
")",
";",
"final",
"path",
"hdfs",
"target",
"path",
"2",
"=",
"new",
"path",
"(",
"default",
"f",
"s",
"u",
"r",
"i",
"+",
"hdfs",
"user",
"folder",
"+",
"1",
")",
";",
"final",
"uri",
"uri",
"1",
"=",
"hdfs",
"target",
"path",
"1",
"to",
"uri",
"(",
")",
";",
"final",
"uri",
"uri",
"2",
"=",
"hdfs",
"target",
"path",
"2",
"to",
"uri",
"(",
")",
";",
"final",
"path",
"nfly",
"root",
"=",
"new",
"path",
"(",
"\"",
"/",
"nflyroot",
"\"",
")",
";",
"final",
"string",
"nfly",
"link",
"key",
"=",
"constants",
"config",
"viewfs",
"link",
"nfly",
"+",
"\"",
"min",
"replication",
"=",
"2",
"\"",
"+",
"nfly",
"root",
"to",
"string",
"(",
")",
";",
"add",
"mount",
"links",
"(",
"default",
"f",
"s",
"u",
"r",
"i",
"get",
"authority",
"(",
")",
",",
"new",
"string",
"[",
"]",
"{",
"nfly",
"link",
"key",
"}",
",",
"new",
"string",
"[",
"]",
"{",
"uri",
"1",
"to",
"string",
"(",
")",
"+",
"\"",
",",
"\"",
"+",
"uri",
"2",
"to",
"string",
"(",
")",
"}",
",",
"conf",
")",
";",
"final",
"file",
"system",
"nfly",
"=",
"file",
"system",
"get",
"(",
"default",
"f",
"s",
"u",
"r",
"i",
",",
"conf",
")",
";",
"final",
"path",
"test",
"file",
"=",
"new",
"path",
"(",
"\"",
"/",
"nflyroot",
"/",
"test",
"txt",
"\"",
")",
";",
"write",
"string",
"(",
"nfly",
",",
"test",
"string",
",",
"test",
"file",
")",
";",
"final",
"uri",
"[",
"]",
"test",
"uris",
"=",
"new",
"uri",
"[",
"]",
"{",
"uri",
"1",
",",
"uri",
"2",
"}",
";",
"for",
"(",
"final",
"uri",
"test",
"uri",
":",
"test",
"uris",
")",
"{",
"try",
"(",
"file",
"system",
"fs",
"=",
"file",
"system",
"get",
"(",
"test",
"uri",
",",
"conf",
")",
")",
"{",
"read",
"string",
"(",
"fs",
",",
"test",
"file",
",",
"test",
"string",
",",
"test",
"uri",
")",
";",
"}",
"}",
"}"
] |
[
"gets",
"the",
"timestamp",
"associated",
"with",
"this",
"facet",
"the",
"rendering",
"of",
"facets",
"are",
"sorted",
"by",
"their",
"chronological",
"order"
] |
[
"public",
"long",
"get",
"timestamp",
"(",
")",
"{",
"return",
"timestamp",
";",
"}"
] |
[
"create",
"empty",
"edits",
"logs",
"file"
] |
[
"public",
"void",
"create",
"(",
"int",
"layout",
"version",
")",
"throws",
"i",
"o",
"exception",
"{",
"fc",
"truncate",
"(",
"0",
")",
";",
"fc",
"position",
"(",
"0",
")",
";",
"write",
"header",
"(",
"layout",
"version",
",",
"double",
"buf",
"get",
"current",
"buf",
"(",
")",
")",
";",
"set",
"ready",
"to",
"flush",
"(",
")",
";",
"flush",
"(",
")",
";",
"set",
"current",
"log",
"version",
"(",
"layout",
"version",
")",
";",
"}"
] |
[
"set",
"the",
"style",
"to",
"use",
"for",
"date",
"and",
"time",
"types"
] |
[
"public",
"void",
"set",
"date",
"time",
"style",
"(",
"format",
"style",
"date",
"time",
"style",
")",
"{",
"this",
"date",
"style",
"=",
"date",
"time",
"style",
";",
"this",
"time",
"style",
"=",
"date",
"time",
"style",
";",
"}"
] |
[
"get",
"number",
"minimum",
":",
"32",
"1",
"maximum",
":",
"543",
"2"
] |
[
"public",
"big",
"decimal",
"get",
"number",
"(",
")",
"{",
"return",
"number",
";",
"}"
] |
[
"returns",
"number",
"of",
"blocks",
"with",
"corrupt",
"replicas"
] |
[
"public",
"long",
"get",
"corrupt",
"replica",
"blocks",
"(",
")",
"{",
"return",
"block",
"manager",
"get",
"corrupt",
"replica",
"blocks",
"count",
"(",
")",
";",
"}"
] |
[
"@",
"inherit",
"doc"
] |
[
"public",
"int",
"get",
"register",
"count",
"(",
")",
"{",
"return",
"1",
";",
"}"
] |
[
"sets",
"the",
"next",
"record",
"of",
"a",
"sequence",
"this",
"increments",
"the",
"{",
"@",
"code",
"record",
"skip",
"count",
"}",
"by",
"one"
] |
[
"public",
"void",
"set",
"next",
"(",
"e",
"record",
")",
"{",
"this",
"record",
"=",
"record",
";",
"this",
"record",
"skip",
"count",
"+",
"+",
";",
"}"
] |
[
"convert",
"the",
"source",
"record",
"into",
"a",
"producer",
"record"
] |
[
"private",
"producer",
"record",
"<",
"byte",
"[",
"]",
",",
"byte",
"[",
"]",
">",
"convert",
"transformed",
"record",
"(",
"source",
"record",
"record",
")",
"{",
"if",
"(",
"record",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"record",
"headers",
"headers",
"=",
"retry",
"with",
"tolerance",
"operator",
"execute",
"(",
"(",
")",
"-",
">",
"convert",
"header",
"for",
"(",
"record",
")",
",",
"stage",
"header",
"converter",
",",
"header",
"converter",
"get",
"class",
"(",
")",
")",
";",
"byte",
"[",
"]",
"key",
"=",
"retry",
"with",
"tolerance",
"operator",
"execute",
"(",
"(",
")",
"-",
">",
"key",
"converter",
"from",
"connect",
"data",
"(",
"record",
"topic",
"(",
")",
",",
"headers",
",",
"record",
"key",
"schema",
"(",
")",
",",
"record",
"key",
"(",
")",
")",
",",
"stage",
"key",
"converter",
",",
"key",
"converter",
"get",
"class",
"(",
")",
")",
";",
"byte",
"[",
"]",
"value",
"=",
"retry",
"with",
"tolerance",
"operator",
"execute",
"(",
"(",
")",
"-",
">",
"value",
"converter",
"from",
"connect",
"data",
"(",
"record",
"topic",
"(",
")",
",",
"headers",
",",
"record",
"value",
"schema",
"(",
")",
",",
"record",
"value",
"(",
")",
")",
",",
"stage",
"value",
"converter",
",",
"value",
"converter",
"get",
"class",
"(",
")",
")",
";",
"if",
"(",
"retry",
"with",
"tolerance",
"operator",
"failed",
"(",
")",
")",
"{",
"return",
"null",
";",
"}",
"return",
"new",
"producer",
"record",
"<",
">",
"(",
"record",
"topic",
"(",
")",
",",
"record",
"kafka",
"partition",
"(",
")",
",",
"connect",
"utils",
"check",
"and",
"convert",
"timestamp",
"(",
"record",
"timestamp",
"(",
")",
")",
",",
"key",
",",
"value",
",",
"headers",
")",
";",
"}"
] |
[
"required",
"the",
"hosts",
"associated",
"with",
"the",
"service",
"entry",
"could",
"be",
"a",
"dns",
"name",
"with",
"wildcard",
"prefix",
"1",
"the",
"hosts",
"field",
"is",
"used",
"to",
"select",
"matching",
"hosts",
"in",
"virtual",
"services",
"and",
"destination",
"rules",
"2",
"for",
"http",
"traffic",
"the",
"http",
"host",
"authority",
"header",
"will",
"be",
"matched",
"against",
"the",
"hosts",
"field",
"3",
"for",
"h",
"t",
"t",
"ps",
"or",
"tls",
"traffic",
"containing",
"server",
"name",
"indication",
"(",
"sni",
")",
",",
"the",
"sni",
"value",
"will",
"be",
"matched",
"against",
"the",
"hosts",
"field",
"note",
"that",
"when",
"resolution",
"is",
"set",
"to",
"type",
"dns",
"and",
"no",
"endpoints",
"are",
"specified",
",",
"the",
"host",
"field",
"will",
"be",
"used",
"as",
"the",
"dns",
"name",
"of",
"the",
"endpoint",
"to",
"route",
"traffic",
"to",
"<",
"code",
">",
"repeated",
"string",
"hosts",
"=",
"1",
";",
"<",
"code",
">"
] |
[
"public",
"com",
"google",
"protobuf",
"byte",
"string",
"get",
"hosts",
"bytes",
"(",
"int",
"index",
")",
"{",
"return",
"hosts",
"get",
"byte",
"string",
"(",
"index",
")",
";",
"}"
] |
[
"sets",
"the",
"empty",
"subscription",
"instance",
"on",
"the",
"subscriber",
"and",
"then",
"calls",
"on",
"complete",
"make",
"sure",
"this",
"is",
"only",
"called",
"if",
"the",
"subscriber",
"hasn",
"'",
"t",
"received",
"a",
"subscription",
"already",
"(",
"there",
"is",
"no",
"way",
"of",
"telling",
"this",
")"
] |
[
"public",
"static",
"void",
"complete",
"(",
"subscriber",
"<",
"?",
">",
"s",
")",
"{",
"s",
"on",
"subscribe",
"(",
"instance",
")",
";",
"s",
"on",
"complete",
"(",
")",
";",
"}"
] |
[
"remove",
"and",
"dispose",
"specified",
"subfolder",
"data",
"and",
"notify",
"listener",
"of",
"removal",
"if",
"this",
"folder",
"has",
"been",
"visited"
] |
[
"void",
"folder",
"removed",
"(",
"string",
"folder",
"name",
")",
"{",
"synchronized",
"(",
"file",
"system",
")",
"{",
"ghidra",
"folder",
"data",
"folder",
"data",
"=",
"folder",
"data",
"cache",
"remove",
"(",
"folder",
"name",
")",
";",
"if",
"(",
"folder",
"data",
"!",
"=",
"null",
")",
"{",
"folder",
"data",
"dispose",
"(",
")",
";",
"}",
"if",
"(",
"visited",
"&",
"&",
"folder",
"list",
"remove",
"(",
"folder",
"name",
")",
")",
"{",
"listener",
"domain",
"folder",
"removed",
"(",
"get",
"domain",
"folder",
"(",
")",
",",
"folder",
"name",
")",
";",
"}",
"}",
"}"
] |
[
"declaring",
"the",
"offset",
"of",
"rows",
"returned",
"by",
"the",
"query",
"this",
"method",
"must",
"be",
"used",
"with",
"{",
"@",
"link",
"#",
"limit",
"(",
"int",
")",
"}",
",",
"or",
"nothing",
"will",
"return",
"lite",
"pal",
"limit",
"(",
"1",
")",
"offset",
"(",
"2",
")",
"find",
"(",
"person",
"class",
")",
";",
"this",
"will",
"find",
"the",
"third",
"row",
"in",
"person",
"table"
] |
[
"public",
"fluent",
"query",
"offset",
"(",
"int",
"value",
")",
"{",
"m",
"offset",
"=",
"string",
"value",
"of",
"(",
"value",
")",
";",
"return",
"this",
";",
"}"
] |
[
"the",
"time",
"that",
"the",
"datafeed",
"should",
"begin",
"this",
"value",
"is",
"inclusive",
"if",
"you",
"specify",
"a",
"start",
"value",
"that",
"is",
"earlier",
"than",
"the",
"timestamp",
"of",
"the",
"latest",
"processed",
"record",
",",
"the",
"datafeed",
"continues",
"from",
"1",
"millisecond",
"after",
"the",
"timestamp",
"of",
"the",
"latest",
"processed",
"record",
"if",
"you",
"do",
"not",
"specify",
"a",
"start",
"time",
"and",
"the",
"datafeed",
"is",
"associated",
"with",
"a",
"new",
"job",
",",
"the",
"analysis",
"starts",
"from",
"the",
"earliest",
"time",
"for",
"which",
"data",
"is",
"available"
] |
[
"public",
"void",
"set",
"start",
"(",
"string",
"start",
")",
"{",
"this",
"start",
"=",
"start",
";",
"}"
] |
[
"fetches",
"the",
"current",
"selected",
"ip",
"address",
"for",
"this",
"node",
",",
"resolving",
"{",
"@",
"link",
"#",
"host",
"(",
")",
"}",
"if",
"necessary"
] |
[
"private",
"inet",
"address",
"current",
"address",
"(",
")",
"throws",
"unknown",
"host",
"exception",
"{",
"if",
"(",
"addresses",
"is",
"empty",
"(",
")",
")",
"{",
"/",
"/",
"(",
"re",
"-",
")",
"initialize",
"list",
"addresses",
"=",
"client",
"utils",
"resolve",
"(",
"host",
",",
"client",
"dns",
"lookup",
")",
";",
"address",
"index",
"=",
"0",
";",
"}",
"return",
"addresses",
"get",
"(",
"address",
"index",
")",
";",
"}"
] |
[
"return",
"the",
"code",
"of",
"this",
"resource"
] |
[
"public",
"byte",
"code",
"(",
")",
"{",
"return",
"code",
";",
"}"
] |
[
"parses",
"the",
"format",
"info",
"from",
"a",
"'",
"format",
":",
"'",
"line",
"in",
"the",
"[",
"v4",
"+",
"styles",
"]",
"section"
] |
[
"public",
"static",
"format",
"from",
"format",
"line",
"(",
"string",
"style",
"format",
"line",
")",
"{",
"int",
"name",
"index",
"=",
"c",
"index",
"unset",
";",
"int",
"alignment",
"index",
"=",
"c",
"index",
"unset",
";",
"string",
"[",
"]",
"keys",
"=",
"text",
"utils",
"split",
"(",
"style",
"format",
"line",
"substring",
"(",
"ssa",
"decoder",
"format",
"line",
"prefix",
"length",
"(",
")",
")",
",",
"\"",
",",
"\"",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"keys",
"length",
";",
"i",
"+",
"+",
")",
"{",
"switch",
"(",
"util",
"to",
"lower",
"invariant",
"(",
"keys",
"[",
"i",
"]",
"trim",
"(",
")",
")",
")",
"{",
"case",
"\"",
"name",
"\"",
":",
"name",
"index",
"=",
"i",
";",
"break",
";",
"case",
"\"",
"alignment",
"\"",
":",
"alignment",
"index",
"=",
"i",
";",
"break",
";",
"}",
"}",
"return",
"name",
"index",
"!",
"=",
"c",
"index",
"unset",
"?",
"new",
"format",
"(",
"name",
"index",
",",
"alignment",
"index",
",",
"keys",
"length",
")",
":",
"null",
";",
"}"
] |
[
"specify",
"multiple",
"property",
"editor",
"registrars",
"to",
"be",
"applied",
"to",
"every",
"data",
"binder"
] |
[
"public",
"final",
"void",
"set",
"property",
"editor",
"registrars",
"(",
"@",
"nullable",
"property",
"editor",
"registrar",
"[",
"]",
"property",
"editor",
"registrars",
")",
"{",
"this",
"property",
"editor",
"registrars",
"=",
"property",
"editor",
"registrars",
";",
"}"
] |
[
"schedules",
"a",
"task",
"to",
"occur",
"once",
"as",
"soon",
"as",
"possible",
",",
"but",
"not",
"sooner",
"than",
"the",
"start",
"of",
"the",
"next",
"frame"
] |
[
"public",
"task",
"post",
"task",
"(",
"task",
"task",
")",
"{",
"return",
"schedule",
"task",
"(",
"task",
",",
"0",
",",
"0",
",",
"0",
")",
";",
"}"
] |
[
"handle",
"the",
"given",
"exception",
"that",
"arose",
"during",
"listener",
"execution",
"the",
"default",
"implementation",
"logs",
"the",
"exception",
"at",
"error",
"level",
"this",
"method",
"only",
"applies",
"when",
"used",
"as",
"standard",
"jms",
"{",
"@",
"link",
"message",
"listener",
"}",
"in",
"case",
"of",
"the",
"spring",
"{",
"@",
"link",
"session",
"aware",
"message",
"listener",
"}",
"mechanism",
",",
"exceptions",
"get",
"handled",
"by",
"the",
"caller",
"instead"
] |
[
"protected",
"void",
"handle",
"listener",
"exception",
"(",
"throwable",
"ex",
")",
"{",
"logger",
"error",
"(",
"\"",
"listener",
"execution",
"failed",
"\"",
",",
"ex",
")",
";",
"}"
] |
[
"return",
"a",
"recycler",
"based",
"on",
"a",
"deque"
] |
[
"public",
"static",
"<",
"t",
">",
"recycler",
"factory",
"<",
"t",
">",
"deque",
"factory",
"(",
"final",
"recycler",
"c",
"<",
"t",
">",
"c",
",",
"final",
"int",
"limit",
")",
"{",
"return",
"(",
")",
"-",
">",
"deque",
"(",
"c",
",",
"limit",
")",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}",
"the",
"default",
"implementation",
"does",
"nothing"
] |
[
"@",
"override",
"public",
"void",
"exit",
"join",
"(",
"eql",
"base",
"parser",
"join",
"context",
"ctx",
")",
"{",
"}"
] |
[
"opens",
"the",
"fid",
"d",
"b",
"for",
"this",
"fid",
"file"
] |
[
"public",
"synchronized",
"fid",
"d",
"b",
"get",
"fid",
"d",
"b",
"(",
"boolean",
"open",
"for",
"update",
")",
"throws",
"version",
"exception",
",",
"i",
"o",
"exception",
"{",
"if",
"(",
"open",
"for",
"update",
"&",
"&",
"open",
"updateable",
"fid",
"d",
"b",
"!",
"=",
"null",
")",
"{",
"open",
"updateable",
"fid",
"d",
"b",
"increment",
"open",
"count",
"(",
")",
";",
"return",
"open",
"updateable",
"fid",
"d",
"b",
";",
"}",
"fid",
"d",
"b",
"fid",
"d",
"b",
"=",
"new",
"fid",
"d",
"b",
"(",
"this",
",",
"open",
"for",
"update",
")",
";",
"if",
"(",
"open",
"for",
"update",
")",
"{",
"open",
"updateable",
"fid",
"d",
"b",
"=",
"fid",
"d",
"b",
";",
"}",
"if",
"(",
"supported",
"languages",
"=",
"=",
"null",
")",
"{",
"supported",
"languages",
"=",
"get",
"supported",
"languages",
"(",
"fid",
"d",
"b",
")",
";",
"}",
"return",
"fid",
"d",
"b",
";",
"}"
] |
[
"check",
"that",
"the",
"scoring",
"increases",
"for",
"a",
"particular",
"match",
"as",
"we",
"add",
"more",
"references"
] |
[
"public",
"void",
"test",
"combined",
"reference",
"correlator",
"decrease",
"scores",
"(",
")",
"throws",
"exception",
"{",
"/",
"*",
"*",
"define",
"the",
"test",
"match",
"for",
"which",
"we",
"will",
"test",
"increasing",
"scores",
"*",
"/",
"address",
"src",
"addr",
"=",
"addr",
"(",
"src",
"prog",
",",
"\"",
"0",
"0",
"4",
"1",
"3",
"4e",
"0",
"\"",
")",
";",
"address",
"dest",
"addr",
"=",
"addr",
"(",
"dest",
"prog",
",",
"\"",
"0",
"0",
"4",
"1",
"3",
"4c",
"0",
"\"",
")",
";",
"v",
"t",
"match",
"set",
"test",
"match",
"set",
";",
"/",
"*",
"*",
"create",
"associated",
"matches",
"for",
"the",
"reference",
"correlator",
"to",
"work",
"with",
"*",
"/",
"list",
"<",
"v",
"t",
"association",
"pair",
">",
"associations",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"/",
"*",
"*",
"the",
"defined",
"test",
"match",
"references",
"the",
"following",
"3",
"items",
":",
"*",
"*",
"function",
"thunk",
"fun",
"0",
"0",
"4",
"1",
"1da",
"0",
"thunk",
"fun",
"0",
"0",
"4",
"1",
"1d",
"8",
"0",
"00411023",
"00411023",
"implied",
"match",
"*",
"data",
"dat",
"00418000",
"dat",
"00418000",
"00418000",
"00418000",
"implied",
"match",
"*",
"function",
"except",
"handler",
"4",
"common",
"except",
"handler",
"4",
"common",
"0",
"0",
"4",
"1",
"1",
"1db",
"0",
"0",
"4",
"1",
"1",
"1d",
"6",
"implied",
"match",
"*",
"*",
"/"
] |
[
"returns",
"true",
"if",
"the",
"analyzer",
"is",
"a",
"prototype"
] |
[
"public",
"boolean",
"is",
"prototype",
"(",
")",
"{",
"return",
"is",
"prototype",
";",
"}"
] |
[
"checks",
"if",
"cluster",
"state",
"matches",
"internal",
"state",
"of",
"indices",
"cluster",
"state",
"service",
"instance"
] |
[
"public",
"void",
"assert",
"cluster",
"state",
"matches",
"node",
"state",
"(",
"cluster",
"state",
"state",
",",
"indices",
"cluster",
"state",
"service",
"indices",
"cluster",
"state",
"service",
")",
"{",
"mock",
"indices",
"service",
"indices",
"service",
"=",
"(",
"mock",
"indices",
"service",
")",
"indices",
"cluster",
"state",
"service",
"indices",
"service",
";",
"concurrent",
"map",
"<",
"shard",
"id",
",",
"shard",
"routing",
">",
"failed",
"shards",
"cache",
"=",
"indices",
"cluster",
"state",
"service",
"failed",
"shards",
"cache",
";",
"routing",
"node",
"local",
"routing",
"node",
"=",
"state",
"get",
"routing",
"nodes",
"(",
")",
"node",
"(",
"state",
"get",
"nodes",
"(",
")",
"get",
"local",
"node",
"id",
"(",
")",
")",
";",
"if",
"(",
"local",
"routing",
"node",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"enable",
"random",
"failures",
"=",
"=",
"false",
")",
"{",
"/",
"/",
"initializing",
"a",
"shard",
"should",
"succeed",
"when",
"enable",
"random",
"failures",
"is",
"disabled",
"/",
"/",
"active",
"shards",
"can",
"be",
"failed",
"if",
"state",
"persistence",
"was",
"disabled",
"in",
"an",
"earlier",
"cs",
"update",
"if",
"(",
"failed",
"shards",
"cache",
"values",
"(",
")",
"stream",
"(",
")",
"any",
"match",
"(",
"shard",
"routing",
":",
":",
"initializing",
")",
")",
"{",
"fail",
"(",
"\"",
"failed",
"shard",
"cache",
"should",
"not",
"contain",
"initializing",
"shard",
"routing",
":",
"\"",
"+",
"failed",
"shards",
"cache",
"values",
"(",
")",
")",
";",
"}",
"}",
"/",
"/",
"check",
"that",
"all",
"shards",
"in",
"local",
"routing",
"nodes",
"have",
"been",
"allocated",
"for",
"(",
"shard",
"routing",
"shard",
"routing",
":",
"local",
"routing",
"node",
")",
"{",
"index",
"index",
"=",
"shard",
"routing",
"index",
"(",
")",
";",
"index",
"metadata",
"index",
"metadata",
"=",
"state",
"metadata",
"(",
")",
"get",
"index",
"safe",
"(",
"index",
")",
";",
"mock",
"index",
"shard",
"shard",
"=",
"indices",
"service",
"get",
"shard",
"or",
"null",
"(",
"shard",
"routing",
"shard",
"id",
"(",
")",
")",
";",
"shard",
"routing",
"failed",
"shard",
"=",
"failed",
"shards",
"cache",
"get",
"(",
"shard",
"routing",
"shard",
"id",
"(",
")",
")",
";",
"if",
"(",
"state",
"blocks",
"(",
")",
"disable",
"state",
"persistence",
"(",
")",
")",
"{",
"if",
"(",
"shard",
"!",
"=",
"null",
")",
"{",
"fail",
"(",
"\"",
"shard",
"with",
"id",
"\"",
"+",
"shard",
"routing",
"+",
"\"",
"should",
"be",
"removed",
"from",
"indices",
"service",
"due",
"to",
"disabled",
"state",
"persistence",
"\"",
")",
";",
"}",
"}",
"else",
"{",
"if",
"(",
"failed",
"shard",
"!",
"=",
"null",
"&",
"&",
"failed",
"shard",
"is",
"same",
"allocation",
"(",
"shard",
"routing",
")",
"=",
"=",
"false",
")",
"{",
"fail",
"(",
"\"",
"shard",
"cache",
"has",
"not",
"been",
"properly",
"cleaned",
"for",
"\"",
"+",
"failed",
"shard",
")",
";",
"}",
"if",
"(",
"shard",
"=",
"=",
"null",
"&",
"&",
"failed",
"shard",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"shard",
"must",
"either",
"be",
"there",
"or",
"there",
"must",
"be",
"a",
"failure",
"fail",
"(",
"\"",
"shard",
"with",
"id",
"\"",
"+",
"shard",
"routing",
"+",
"\"",
"expected",
"but",
"missing",
"in",
"indices",
"service",
"and",
"failed",
"shards",
"cache",
"\"",
")",
";",
"}",
"if",
"(",
"enable",
"random",
"failures",
"=",
"=",
"false",
")",
"{",
"if",
"(",
"shard",
"=",
"=",
"null",
"&",
"&",
"shard",
"routing",
"initializing",
"(",
")",
"&",
"&",
"failed",
"shard",
"=",
"=",
"shard",
"routing",
")",
"{",
"/",
"/",
"initializing",
"a",
"shard",
"should",
"succeed",
"when",
"enable",
"random",
"failures",
"is",
"disabled",
"fail",
"(",
"\"",
"shard",
"with",
"id",
"\"",
"+",
"shard",
"routing",
"+",
"\"",
"expected",
"but",
"missing",
"in",
"indices",
"service",
"\"",
"+",
"failed",
"shard",
")",
";",
"}",
"}",
"if",
"(",
"shard",
"!",
"=",
"null",
")",
"{",
"allocated",
"index",
"<",
"?",
"extends",
"shard",
">",
"index",
"service",
"=",
"indices",
"service",
"index",
"service",
"(",
"index",
")",
";",
"assert",
"true",
"(",
"\"",
"index",
"\"",
"+",
"index",
"+",
"\"",
"expected",
"but",
"missing",
"in",
"indices",
"service",
"\"",
",",
"index",
"service",
"!",
"=",
"null",
")",
";",
"/",
"/",
"index",
"metadata",
"has",
"been",
"updated",
"assert",
"that",
"(",
"index",
"service",
"get",
"index",
"settings",
"(",
")",
"get",
"index",
"metadata",
"(",
")",
",",
"equal",
"to",
"(",
"index",
"metadata",
")",
")",
";",
"/",
"/",
"shard",
"has",
"been",
"created",
"if",
"(",
"enable",
"random",
"failures",
"=",
"=",
"false",
"|",
"|",
"failed",
"shard",
"=",
"=",
"null",
")",
"{",
"assert",
"true",
"(",
"\"",
"shard",
"with",
"id",
"\"",
"+",
"shard",
"routing",
"+",
"\"",
"expected",
"but",
"missing",
"in",
"index",
"service",
"\"",
",",
"shard",
"!",
"=",
"null",
")",
";",
"/",
"/",
"shard",
"has",
"latest",
"shard",
"routing",
"assert",
"that",
"(",
"shard",
"routing",
"entry",
"(",
")",
",",
"equal",
"to",
"(",
"shard",
"routing",
")",
")",
";",
"}",
"if",
"(",
"shard",
"routing",
"entry",
"(",
")",
"primary",
"(",
")",
"&",
"&",
"shard",
"routing",
"entry",
"(",
")",
"active",
"(",
")",
")",
"{",
"index",
"shard",
"routing",
"table",
"shard",
"routing",
"table",
"=",
"state",
"routing",
"table",
"(",
")",
"shard",
"routing",
"table",
"(",
"shard",
"shard",
"id",
"(",
")",
")",
";",
"set",
"<",
"string",
">",
"in",
"sync",
"ids",
"=",
"state",
"metadata",
"(",
")",
"index",
"(",
"shard",
"shard",
"id",
"(",
")",
"get",
"index",
"(",
")",
")",
"in",
"sync",
"allocation",
"ids",
"(",
"shard",
"shard",
"id",
"(",
")",
"id",
"(",
")",
")",
";",
"assert",
"that",
"(",
"shard",
"routing",
"entry",
"(",
")",
"+",
"\"",
"isn",
"'",
"t",
"updated",
"with",
"in",
"-",
"sync",
"a",
"i",
"ds",
"\"",
",",
"shard",
"in",
"sync",
"allocation",
"ids",
",",
"equal",
"to",
"(",
"in",
"sync",
"ids",
")",
")",
";",
"assert",
"that",
"(",
"shard",
"routing",
"entry",
"(",
")",
"+",
"\"",
"isn",
"'",
"t",
"updated",
"with",
"routing",
"table",
"\"",
",",
"shard",
"routing",
"table",
",",
"equal",
"to",
"(",
"shard",
"routing",
"table",
")",
")",
";",
"}",
"}",
"}",
"}",
"}",
"/",
"/",
"all",
"other",
"shards",
"/",
"indices",
"have",
"been",
"cleaned",
"up",
"for",
"(",
"allocated",
"index",
"<",
"?",
"extends",
"shard",
">",
"index",
"service",
":",
"indices",
"service",
")",
"{",
"if",
"(",
"state",
"blocks",
"(",
")",
"disable",
"state",
"persistence",
"(",
")",
")",
"{",
"fail",
"(",
"\"",
"index",
"service",
"\"",
"+",
"index",
"service",
"index",
"(",
")",
"+",
"\"",
"should",
"be",
"removed",
"from",
"indices",
"service",
"due",
"to",
"disabled",
"state",
"persistence",
"\"",
")",
";",
"}",
"assert",
"true",
"(",
"state",
"metadata",
"(",
")",
"get",
"index",
"safe",
"(",
"index",
"service",
"index",
"(",
")",
")",
"!",
"=",
"null",
")",
";",
"boolean",
"shards",
"found",
"=",
"false",
";",
"for",
"(",
"shard",
"shard",
":",
"index",
"service",
")",
"{",
"shards",
"found",
"=",
"true",
";",
"shard",
"routing",
"persisted",
"shard",
"routing",
"=",
"shard",
"routing",
"entry",
"(",
")",
";",
"shard",
"routing",
"shard",
"routing",
"=",
"local",
"routing",
"node",
"get",
"by",
"shard",
"id",
"(",
"persisted",
"shard",
"routing",
"shard",
"id",
"(",
")",
")",
";",
"if",
"(",
"shard",
"routing",
"=",
"=",
"null",
")",
"{",
"fail",
"(",
"\"",
"shard",
"with",
"id",
"\"",
"+",
"persisted",
"shard",
"routing",
"+",
"\"",
"locally",
"exists",
"but",
"missing",
"in",
"routing",
"table",
"\"",
")",
";",
"}",
"if",
"(",
"shard",
"routing",
"equals",
"(",
"persisted",
"shard",
"routing",
")",
"=",
"=",
"false",
")",
"{",
"fail",
"(",
"\"",
"local",
"shard",
"\"",
"+",
"persisted",
"shard",
"routing",
"+",
"\"",
"has",
"stale",
"routing",
"\"",
"+",
"shard",
"routing",
")",
";",
"}",
"}",
"if",
"(",
"shards",
"found",
"=",
"=",
"false",
")",
"{",
"/",
"/",
"check",
"if",
"we",
"have",
"shards",
"of",
"that",
"index",
"in",
"failed",
"shards",
"cache",
"/",
"/",
"if",
"yes",
",",
"we",
"might",
"not",
"have",
"cleaned",
"the",
"index",
"as",
"failed",
"shards",
"cache",
"can",
"be",
"populated",
"by",
"another",
"thread",
"assert",
"false",
"(",
"failed",
"shards",
"cache",
"key",
"set",
"(",
")",
"stream",
"(",
")",
"none",
"match",
"(",
"shard",
"id",
"-",
">",
"shard",
"id",
"get",
"index",
"(",
")",
"equals",
"(",
"index",
"service",
"index",
"(",
")",
")",
")",
")",
";",
"}",
"}",
"}"
] |
[
"gets",
"the",
"address",
",",
"if",
"there",
"is",
"one",
",",
"of",
"the",
"component",
"with",
"the",
"type",
"descriptor",
"address",
"in",
"the",
"handler",
"type",
"entry",
"indicated",
"by",
"the",
"ordinal",
"otherwise",
",",
"this",
"returns",
"null"
] |
[
"public",
"address",
"get",
"component",
"address",
"of",
"type",
"descriptor",
"address",
"(",
"int",
"catch",
"handler",
"ordinal",
")",
"throws",
"invalid",
"data",
"type",
"exception",
"{",
"check",
"validity",
"(",
"catch",
"handler",
"ordinal",
")",
";",
"data",
"type",
"catch",
"handler",
"dt",
"=",
"get",
"data",
"type",
"(",
")",
";",
"mem",
"buffer",
"specific",
"mem",
"buffer",
"=",
"get",
"specific",
"mem",
"buffer",
"(",
"catch",
"handler",
"ordinal",
",",
"catch",
"handler",
"dt",
")",
";",
"/",
"/",
"component",
"1",
"is",
"action",
"pointer",
"or",
"displacement",
"return",
"e",
"h",
"data",
"type",
"utilities",
"get",
"component",
"address",
"(",
"catch",
"handler",
"dt",
",",
"type",
"descriptor",
"ordinal",
",",
"specific",
"mem",
"buffer",
")",
";",
"}"
] |
[
"closes",
"the",
"stream",
"and",
"blocks",
"until",
"all",
"pending",
"writes",
"are",
"completed",
"throws",
"an",
"exception",
"if",
"any",
"of",
"the",
"writes",
"or",
"the",
"close",
"itself",
"have",
"failed"
] |
[
"public",
"void",
"close",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"try",
"{",
"close",
"async",
"(",
")",
"get",
"(",
")",
";",
"}",
"catch",
"(",
"interrupted",
"exception",
"e",
")",
"{",
"thread",
"current",
"thread",
"(",
")",
"interrupt",
"(",
")",
";",
"}",
"catch",
"(",
"execution",
"exception",
"e",
")",
"{",
"throwables",
"throw",
"if",
"instance",
"of",
"(",
"e",
"get",
"cause",
"(",
")",
",",
"i",
"o",
"exception",
"class",
")",
";",
"throwables",
"throw",
"if",
"instance",
"of",
"(",
"e",
"get",
"cause",
"(",
")",
",",
"runtime",
"exception",
"class",
")",
";",
"throw",
"new",
"runtime",
"exception",
"(",
"e",
"get",
"cause",
"(",
")",
")",
";",
"}",
"}"
] |
[
"get",
"the",
"arguments",
"as",
"an",
"array",
"object",
"it",
"is",
"possible",
"to",
"change",
"element",
"values",
"within",
"this",
"array",
"to",
"change",
"the",
"arguments"
] |
[
"object",
"[",
"]",
"get",
"arguments",
"(",
")",
";"
] |
[
"check",
"whether",
"a",
"connector",
"'",
"s",
"set",
"of",
"active",
"topics",
"matches",
"the",
"given",
"collection",
"of",
"topic",
"names"
] |
[
"protected",
"optional",
"<",
"boolean",
">",
"check",
"connector",
"active",
"topics",
"(",
"string",
"connector",
"name",
",",
"collection",
"<",
"string",
">",
"topics",
")",
"{",
"try",
"{",
"active",
"topics",
"info",
"info",
"=",
"connect",
"connector",
"topics",
"(",
"connector",
"name",
")",
";",
"boolean",
"result",
"=",
"info",
"!",
"=",
"null",
"&",
"&",
"topics",
"size",
"(",
")",
"=",
"=",
"info",
"topics",
"(",
")",
"size",
"(",
")",
"&",
"&",
"topics",
"contains",
"all",
"(",
"info",
"topics",
"(",
")",
")",
";",
"log",
"debug",
"(",
"\"",
"found",
"connector",
"{",
"}",
"using",
"topics",
":",
"{",
"}",
"\"",
",",
"connector",
"name",
",",
"info",
"topics",
"(",
")",
")",
";",
"return",
"optional",
"of",
"(",
"result",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"log",
"error",
"(",
"\"",
"could",
"not",
"check",
"connector",
"{",
"}",
"state",
"info",
"\"",
",",
"connector",
"name",
",",
"e",
")",
";",
"return",
"optional",
"empty",
"(",
")",
";",
"}",
"}"
] |
[
"set",
"the",
"entity",
"id"
] |
[
"public",
"void",
"set",
"entity",
"id",
"(",
"string",
"entity",
"id",
")",
"{",
"this",
"entity",
"id",
"=",
"entity",
"id",
";",
"}"
] |
[
"this",
"test",
"validates",
"the",
"correctness",
"of",
"get",
"application",
"report",
"in",
"case",
"the",
"application",
"does",
"not",
"exist",
"in",
"state",
"store"
] |
[
"public",
"void",
"test",
"get",
"application",
"not",
"exists",
"(",
")",
"throws",
"yarn",
"exception",
",",
"i",
"o",
"exception",
",",
"interrupted",
"exception",
"{",
"log",
"info",
"(",
"\"",
"test",
"application",
"client",
"protocol",
":",
"get",
"application",
"report",
"-",
"not",
"exists",
"\"",
")",
";",
"application",
"id",
"app",
"id",
"=",
"application",
"id",
"new",
"instance",
"(",
"system",
"current",
"time",
"millis",
"(",
")",
",",
"1",
")",
";",
"get",
"application",
"report",
"request",
"request",
"get",
"=",
"get",
"application",
"report",
"request",
"new",
"instance",
"(",
"app",
"id",
")",
";",
"try",
"{",
"interceptor",
"get",
"application",
"report",
"(",
"request",
"get",
")",
";",
"assert",
"fail",
"(",
")",
";",
"}",
"catch",
"(",
"yarn",
"exception",
"e",
")",
"{",
"assert",
"assert",
"true",
"(",
"e",
"get",
"message",
"(",
")",
"equals",
"(",
"\"",
"application",
"\"",
"+",
"app",
"id",
"+",
"\"",
"does",
"not",
"exist",
"in",
"federation",
"state",
"store",
"\"",
")",
")",
";",
"}",
"}"
] |
[
"sets",
"the",
"attribute",
"value"
] |
[
"start",
"tag",
"set",
"to",
"(",
"string",
"value",
")",
";"
] |
[
"update",
"the",
"last",
"-",
"modified",
"time",
"of",
"the",
"parent",
"folder",
"of",
"the",
"file",
"identified",
"by",
"key"
] |
[
"private",
"void",
"update",
"parent",
"folder",
"last",
"modified",
"time",
"(",
"string",
"key",
")",
"throws",
"i",
"o",
"exception",
"{",
"path",
"parent",
"=",
"make",
"absolute",
"(",
"key",
"to",
"path",
"(",
"key",
")",
")",
"get",
"parent",
"(",
")",
";",
"if",
"(",
"parent",
"!",
"=",
"null",
"&",
"&",
"parent",
"get",
"parent",
"(",
")",
"!",
"=",
"null",
")",
"{",
"/",
"/",
"not",
"root",
"string",
"parent",
"key",
"=",
"path",
"to",
"key",
"(",
"parent",
")",
";",
"/",
"/",
"ensure",
"the",
"parent",
"is",
"a",
"materialized",
"folder",
"file",
"metadata",
"parent",
"metadata",
"=",
"store",
"retrieve",
"metadata",
"(",
"parent",
"key",
")",
";",
"/",
"/",
"the",
"metadata",
"could",
"be",
"null",
"if",
"the",
"implicit",
"folder",
"only",
"contains",
"a",
"/",
"/",
"single",
"file",
"in",
"this",
"case",
",",
"the",
"parent",
"folder",
"no",
"longer",
"exists",
"if",
"the",
"/",
"/",
"file",
"is",
"renamed",
";",
"so",
"we",
"can",
"safely",
"ignore",
"the",
"null",
"pointer",
"case",
"if",
"(",
"parent",
"metadata",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"parent",
"metadata",
"is",
"directory",
"(",
")",
"&",
"&",
"parent",
"metadata",
"get",
"blob",
"materialization",
"(",
")",
"=",
"=",
"blob",
"materialization",
"implicit",
")",
"{",
"store",
"store",
"empty",
"folder",
"(",
"parent",
"key",
",",
"create",
"permission",
"status",
"(",
"fs",
"permission",
"get",
"default",
"(",
")",
")",
")",
";",
"}",
"if",
"(",
"store",
"is",
"atomic",
"rename",
"key",
"(",
"parent",
"key",
")",
")",
"{",
"self",
"renewing",
"lease",
"lease",
"=",
"null",
";",
"try",
"{",
"lease",
"=",
"lease",
"source",
"folder",
"(",
"parent",
"key",
")",
";",
"store",
"update",
"folder",
"last",
"modified",
"time",
"(",
"parent",
"key",
",",
"lease",
")",
";",
"}",
"catch",
"(",
"azure",
"exception",
"e",
")",
"{",
"string",
"error",
"code",
"=",
"\"",
"\"",
";",
"try",
"{",
"storage",
"exception",
"e",
"2",
"=",
"(",
"storage",
"exception",
")",
"e",
"get",
"cause",
"(",
")",
";",
"error",
"code",
"=",
"e",
"2",
"get",
"error",
"code",
"(",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
"3",
")",
"{",
"/",
"/",
"do",
"nothing",
"if",
"cast",
"fails",
"}",
"if",
"(",
"error",
"code",
"equals",
"(",
"\"",
"blob",
"not",
"found",
"\"",
")",
")",
"{",
"throw",
"new",
"file",
"not",
"found",
"exception",
"(",
"\"",
"folder",
"does",
"not",
"exist",
":",
"\"",
"+",
"parent",
"key",
")",
";",
"}",
"log",
"warn",
"(",
"\"",
"got",
"unexpected",
"exception",
"trying",
"to",
"get",
"lease",
"on",
"{",
"}",
"{",
"}",
"\"",
",",
"parent",
"key",
",",
"e",
"get",
"message",
"(",
")",
")",
";",
"throw",
"e",
";",
"}",
"finally",
"{",
"try",
"{",
"if",
"(",
"lease",
"!",
"=",
"null",
")",
"{",
"lease",
"free",
"(",
")",
";",
"}",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"log",
"error",
"(",
"\"",
"unable",
"to",
"free",
"lease",
"on",
"{",
"}",
"\"",
",",
"parent",
"key",
",",
"e",
")",
";",
"}",
"}",
"}",
"else",
"{",
"store",
"update",
"folder",
"last",
"modified",
"time",
"(",
"parent",
"key",
",",
"null",
")",
";",
"}",
"}",
"}",
"}"
] |
[
"interrupts",
"the",
"current",
"thread",
"after",
"sleeping",
"for",
"the",
"specified",
"delay"
] |
[
"static",
"void",
"request",
"interrupt",
"in",
"(",
"final",
"long",
"time",
",",
"final",
"time",
"unit",
"unit",
")",
"{",
"check",
"not",
"null",
"(",
"unit",
")",
";",
"final",
"thread",
"interruptee",
"=",
"thread",
"current",
"thread",
"(",
")",
";",
"new",
"thread",
"(",
"new",
"runnable",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"run",
"(",
")",
"{",
"try",
"{",
"unit",
"sleep",
"(",
"time",
")",
";",
"}",
"catch",
"(",
"interrupted",
"exception",
"wont",
"happen",
")",
"{",
"throw",
"new",
"assertion",
"error",
"(",
"wont",
"happen",
")",
";",
"}",
"interruptee",
"interrupt",
"(",
")",
";",
"}",
"}",
")",
"start",
"(",
")",
";",
"}"
] |
[
"splits",
"files",
"returned",
"by",
"{",
"@",
"link",
"#",
"list",
"status",
"(",
"job",
"conf",
")",
"}",
"when",
"they",
"'",
"re",
"too",
"big"
] |
[
"public",
"input",
"split",
"[",
"]",
"get",
"splits",
"(",
"job",
"conf",
"job",
",",
"int",
"num",
"splits",
")",
"throws",
"i",
"o",
"exception",
"{",
"stop",
"watch",
"sw",
"=",
"new",
"stop",
"watch",
"(",
")",
"start",
"(",
")",
";",
"file",
"status",
"[",
"]",
"stats",
"=",
"list",
"status",
"(",
"job",
")",
";",
"/",
"/",
"save",
"the",
"number",
"of",
"input",
"files",
"for",
"metrics",
"/",
"loadgen",
"job",
"set",
"long",
"(",
"num",
"input",
"files",
",",
"stats",
"length",
")",
";",
"long",
"total",
"size",
"=",
"0",
";",
"/",
"/",
"compute",
"total",
"size",
"boolean",
"ignore",
"dirs",
"=",
"!",
"job",
"get",
"boolean",
"(",
"input",
"dir",
"recursive",
",",
"false",
")",
"&",
"&",
"job",
"get",
"boolean",
"(",
"input",
"dir",
"nonrecursive",
"ignore",
"subdirs",
",",
"false",
")",
";",
"list",
"<",
"file",
"status",
">",
"files",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"stats",
"length",
")",
";",
"for",
"(",
"file",
"status",
"file",
":",
"stats",
")",
"{",
"/",
"/",
"check",
"we",
"have",
"valid",
"files",
"if",
"(",
"file",
"is",
"directory",
"(",
")",
")",
"{",
"if",
"(",
"!",
"ignore",
"dirs",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"not",
"a",
"file",
":",
"\"",
"+",
"file",
"get",
"path",
"(",
")",
")",
";",
"}",
"}",
"else",
"{",
"files",
"add",
"(",
"file",
")",
";",
"total",
"size",
"+",
"=",
"file",
"get",
"len",
"(",
")",
";",
"}",
"}",
"long",
"goal",
"size",
"=",
"total",
"size",
"/",
"(",
"num",
"splits",
"=",
"=",
"0",
"?",
"1",
":",
"num",
"splits",
")",
";",
"long",
"min",
"size",
"=",
"math",
"max",
"(",
"job",
"get",
"long",
"(",
"org",
"apache",
"hadoop",
"mapreduce",
"lib",
"input",
"file",
"input",
"format",
"split",
"minsize",
",",
"1",
")",
",",
"min",
"split",
"size",
")",
";",
"/",
"/",
"generate",
"splits",
"array",
"list",
"<",
"file",
"split",
">",
"splits",
"=",
"new",
"array",
"list",
"<",
"file",
"split",
">",
"(",
"num",
"splits",
")",
";",
"network",
"topology",
"cluster",
"map",
"=",
"new",
"network",
"topology",
"(",
")",
";",
"for",
"(",
"file",
"status",
"file",
":",
"files",
")",
"{",
"path",
"path",
"=",
"file",
"get",
"path",
"(",
")",
";",
"long",
"length",
"=",
"file",
"get",
"len",
"(",
")",
";",
"if",
"(",
"length",
"!",
"=",
"0",
")",
"{",
"file",
"system",
"fs",
"=",
"path",
"get",
"file",
"system",
"(",
"job",
")",
";",
"block",
"location",
"[",
"]",
"blk",
"locations",
";",
"if",
"(",
"file",
"instanceof",
"located",
"file",
"status",
")",
"{",
"blk",
"locations",
"=",
"(",
"(",
"located",
"file",
"status",
")",
"file",
")",
"get",
"block",
"locations",
"(",
")",
";",
"}",
"else",
"{",
"blk",
"locations",
"=",
"fs",
"get",
"file",
"block",
"locations",
"(",
"file",
",",
"0",
",",
"length",
")",
";",
"}",
"if",
"(",
"is",
"splitable",
"(",
"fs",
",",
"path",
")",
")",
"{",
"long",
"block",
"size",
"=",
"file",
"get",
"block",
"size",
"(",
")",
";",
"long",
"split",
"size",
"=",
"compute",
"split",
"size",
"(",
"goal",
"size",
",",
"min",
"size",
",",
"block",
"size",
")",
";",
"long",
"bytes",
"remaining",
"=",
"length",
";",
"while",
"(",
"(",
"(",
"double",
")",
"bytes",
"remaining",
")",
"/",
"split",
"size",
">",
"split",
"slop",
")",
"{",
"string",
"[",
"]",
"[",
"]",
"split",
"hosts",
"=",
"get",
"split",
"hosts",
"and",
"cached",
"hosts",
"(",
"blk",
"locations",
",",
"length",
"-",
"bytes",
"remaining",
",",
"split",
"size",
",",
"cluster",
"map",
")",
";",
"splits",
"add",
"(",
"make",
"split",
"(",
"path",
",",
"length",
"-",
"bytes",
"remaining",
",",
"split",
"size",
",",
"split",
"hosts",
"[",
"0",
"]",
",",
"split",
"hosts",
"[",
"1",
"]",
")",
")",
";",
"bytes",
"remaining",
"-",
"=",
"split",
"size",
";",
"}",
"if",
"(",
"bytes",
"remaining",
"!",
"=",
"0",
")",
"{",
"string",
"[",
"]",
"[",
"]",
"split",
"hosts",
"=",
"get",
"split",
"hosts",
"and",
"cached",
"hosts",
"(",
"blk",
"locations",
",",
"length",
"-",
"bytes",
"remaining",
",",
"bytes",
"remaining",
",",
"cluster",
"map",
")",
";",
"splits",
"add",
"(",
"make",
"split",
"(",
"path",
",",
"length",
"-",
"bytes",
"remaining",
",",
"bytes",
"remaining",
",",
"split",
"hosts",
"[",
"0",
"]",
",",
"split",
"hosts",
"[",
"1",
"]",
")",
")",
";",
"}",
"}",
"else",
"{",
"if",
"(",
"log",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"/",
"/",
"log",
"only",
"if",
"the",
"file",
"is",
"big",
"enough",
"to",
"be",
"splitted",
"if",
"(",
"length",
">",
"math",
"min",
"(",
"file",
"get",
"block",
"size",
"(",
")",
",",
"min",
"size",
")",
")",
"{",
"log",
"debug",
"(",
"\"",
"file",
"is",
"not",
"splittable",
"so",
"no",
"parallelization",
"\"",
"+",
"\"",
"is",
"possible",
":",
"\"",
"+",
"file",
"get",
"path",
"(",
")",
")",
";",
"}",
"}",
"string",
"[",
"]",
"[",
"]",
"split",
"hosts",
"=",
"get",
"split",
"hosts",
"and",
"cached",
"hosts",
"(",
"blk",
"locations",
",",
"0",
",",
"length",
",",
"cluster",
"map",
")",
";",
"splits",
"add",
"(",
"make",
"split",
"(",
"path",
",",
"0",
",",
"length",
",",
"split",
"hosts",
"[",
"0",
"]",
",",
"split",
"hosts",
"[",
"1",
"]",
")",
")",
";",
"}",
"}",
"else",
"{",
"/",
"/",
"create",
"empty",
"hosts",
"array",
"for",
"zero",
"length",
"files",
"splits",
"add",
"(",
"make",
"split",
"(",
"path",
",",
"0",
",",
"length",
",",
"new",
"string",
"[",
"0",
"]",
")",
")",
";",
"}",
"}",
"sw",
"stop",
"(",
")",
";",
"if",
"(",
"log",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"log",
"debug",
"(",
"\"",
"total",
"#",
"of",
"splits",
"generated",
"by",
"get",
"splits",
":",
"\"",
"+",
"splits",
"size",
"(",
")",
"+",
"\"",
",",
"time",
"taken",
":",
"\"",
"+",
"sw",
"now",
"(",
"time",
"unit",
"milliseconds",
")",
")",
";",
"}",
"return",
"splits",
"to",
"array",
"(",
"new",
"file",
"split",
"[",
"splits",
"size",
"(",
")",
"]",
")",
";",
"}"
] |
[
"the",
"response",
"resources",
"wrapped",
"in",
"the",
"common",
"mcp",
"resource",
"message",
"these",
"are",
"typed",
"resources",
"that",
"match",
"the",
"type",
"url",
"in",
"the",
"incremental",
"mesh",
"config",
"request",
"<",
"code",
">",
"repeated",
"istio",
"mcp",
"v",
"1alpha",
"1",
"resource",
"resources",
"=",
"2",
";",
"<",
"code",
">"
] |
[
"public",
"builder",
"remove",
"resources",
"(",
"int",
"index",
")",
"{",
"if",
"(",
"resources",
"builder",
"=",
"=",
"null",
")",
"{",
"ensure",
"resources",
"is",
"mutable",
"(",
")",
";",
"resources",
"remove",
"(",
"index",
")",
";",
"on",
"changed",
"(",
")",
";",
"}",
"else",
"{",
"resources",
"builder",
"remove",
"(",
"index",
")",
";",
"}",
"return",
"this",
";",
"}"
] |
[
"compute",
"a",
"reduce",
"transformation",
"over",
"the",
"neighbors",
"'",
"vertex",
"values",
"of",
"each",
"vertex",
"for",
"each",
"vertex",
",",
"the",
"transformation",
"consecutively",
"calls",
"a",
"{",
"@",
"link",
"reduce",
"neighbors",
"function",
"}",
"until",
"only",
"a",
"single",
"value",
"for",
"each",
"vertex",
"remains",
"the",
"{",
"@",
"link",
"reduce",
"neighbors",
"function",
"}",
"combines",
"a",
"pair",
"of",
"neighbor",
"vertex",
"values",
"into",
"one",
"new",
"value",
"of",
"the",
"same",
"type"
] |
[
"public",
"data",
"set",
"<",
"tuple",
"2",
"<",
"k",
",",
"vv",
">",
">",
"reduce",
"on",
"neighbors",
"(",
"reduce",
"neighbors",
"function",
"<",
"vv",
">",
"reduce",
"neighbors",
"function",
",",
"edge",
"direction",
"direction",
")",
"throws",
"illegal",
"argument",
"exception",
"{",
"switch",
"(",
"direction",
")",
"{",
"case",
"in",
":",
"/",
"/",
"create",
"<",
"vertex",
"-",
"source",
"value",
">",
"pairs",
"final",
"data",
"set",
"<",
"tuple",
"2",
"<",
"k",
",",
"vv",
">",
">",
"vertices",
"with",
"source",
"neighbor",
"values",
"=",
"edges",
"join",
"(",
"this",
"vertices",
")",
"where",
"(",
"0",
")",
"equal",
"to",
"(",
"0",
")",
"with",
"(",
"new",
"project",
"vertex",
"with",
"neighbor",
"value",
"join",
"<",
">",
"(",
"1",
")",
")",
"with",
"forwarded",
"fields",
"first",
"(",
"\"",
"f",
"1",
"-",
">",
"f",
"0",
"\"",
")",
"name",
"(",
"\"",
"vertex",
"with",
"in",
"-",
"neighbor",
"value",
"\"",
")",
";",
"return",
"vertices",
"with",
"source",
"neighbor",
"values",
"group",
"by",
"(",
"0",
")",
"reduce",
"(",
"new",
"apply",
"neighbor",
"reduce",
"function",
"<",
">",
"(",
"reduce",
"neighbors",
"function",
")",
")",
"name",
"(",
"\"",
"neighbors",
"function",
"\"",
")",
";",
"case",
"out",
":",
"/",
"/",
"create",
"<",
"vertex",
"-",
"target",
"value",
">",
"pairs",
"data",
"set",
"<",
"tuple",
"2",
"<",
"k",
",",
"vv",
">",
">",
"vertices",
"with",
"target",
"neighbor",
"values",
"=",
"edges",
"join",
"(",
"this",
"vertices",
")",
"where",
"(",
"1",
")",
"equal",
"to",
"(",
"0",
")",
"with",
"(",
"new",
"project",
"vertex",
"with",
"neighbor",
"value",
"join",
"<",
">",
"(",
"0",
")",
")",
"with",
"forwarded",
"fields",
"first",
"(",
"\"",
"f",
"0",
"\"",
")",
"name",
"(",
"\"",
"vertex",
"with",
"out",
"-",
"neighbor",
"value",
"\"",
")",
";",
"return",
"vertices",
"with",
"target",
"neighbor",
"values",
"group",
"by",
"(",
"0",
")",
"reduce",
"(",
"new",
"apply",
"neighbor",
"reduce",
"function",
"<",
">",
"(",
"reduce",
"neighbors",
"function",
")",
")",
"name",
"(",
"\"",
"neighbors",
"function",
"\"",
")",
";",
"case",
"all",
":",
"/",
"/",
"create",
"<",
"vertex",
"-",
"neighbor",
"value",
">",
"pairs",
"data",
"set",
"<",
"tuple",
"2",
"<",
"k",
",",
"vv",
">",
">",
"vertices",
"with",
"neighbor",
"values",
"=",
"edges",
"flat",
"map",
"(",
"new",
"emit",
"one",
"edge",
"with",
"neighbor",
"per",
"node",
"<",
">",
"(",
")",
")",
"join",
"(",
"this",
"vertices",
")",
"where",
"(",
"1",
")",
"equal",
"to",
"(",
"0",
")",
"with",
"(",
"new",
"project",
"neighbor",
"value",
"<",
">",
"(",
")",
")",
"name",
"(",
"\"",
"vertex",
"with",
"neighbor",
"value",
"\"",
")",
";",
"return",
"vertices",
"with",
"neighbor",
"values",
"group",
"by",
"(",
"0",
")",
"reduce",
"(",
"new",
"apply",
"neighbor",
"reduce",
"function",
"<",
">",
"(",
"reduce",
"neighbors",
"function",
")",
")",
"name",
"(",
"\"",
"neighbors",
"function",
"\"",
")",
";",
"default",
":",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"illegal",
"edge",
"direction",
"\"",
")",
";",
"}",
"}"
] |
[
"add",
"a",
"new",
"byte",
"attribute",
"as",
"decimal"
] |
[
"public",
"void",
"add",
"attribute",
"(",
"string",
"name",
",",
"byte",
"value",
")",
"{",
"add",
"attribute",
"(",
"name",
",",
"value",
",",
"false",
")",
";",
"}"
] |
[
"allocate",
"a",
"new",
"{",
"@",
"link",
"float",
"array",
"}"
] |
[
"public",
"float",
"array",
"new",
"float",
"array",
"(",
"long",
"size",
",",
"boolean",
"clear",
"on",
"resize",
")",
"{",
"if",
"(",
"size",
">",
"page",
"cache",
"recycler",
"int",
"page",
"size",
")",
"{",
"/",
"/",
"when",
"allocating",
"big",
"arrays",
",",
"we",
"want",
"to",
"first",
"ensure",
"we",
"have",
"the",
"capacity",
"by",
"/",
"/",
"checking",
"with",
"the",
"circuit",
"breaker",
"before",
"attempting",
"to",
"allocate",
"adjust",
"breaker",
"(",
"big",
"float",
"array",
"estimate",
"ram",
"bytes",
"(",
"size",
")",
",",
"false",
")",
";",
"return",
"new",
"big",
"float",
"array",
"(",
"size",
",",
"this",
",",
"clear",
"on",
"resize",
")",
";",
"}",
"else",
"if",
"(",
"size",
">",
"=",
"page",
"cache",
"recycler",
"int",
"page",
"size",
"/",
"2",
"&",
"&",
"recycler",
"!",
"=",
"null",
")",
"{",
"final",
"recycler",
"v",
"<",
"int",
"[",
"]",
">",
"page",
"=",
"recycler",
"int",
"page",
"(",
"clear",
"on",
"resize",
")",
";",
"return",
"validate",
"(",
"new",
"float",
"array",
"wrapper",
"(",
"this",
",",
"page",
"v",
"(",
")",
",",
"size",
",",
"page",
",",
"clear",
"on",
"resize",
")",
")",
";",
"}",
"else",
"{",
"return",
"validate",
"(",
"new",
"float",
"array",
"wrapper",
"(",
"this",
",",
"new",
"int",
"[",
"(",
"int",
")",
"size",
"]",
",",
"size",
",",
"null",
",",
"clear",
"on",
"resize",
")",
")",
";",
"}",
"}"
] |
[
"getter",
"method",
"for",
"abfs",
"output",
"stream",
"statistics"
] |
[
"public",
"abfs",
"output",
"stream",
"statistics",
"get",
"output",
"stream",
"statistics",
"(",
")",
"{",
"return",
"output",
"stream",
"statistics",
";",
"}"
] |
[
"returns",
"whether",
"the",
"timeline",
"service",
"is",
"enabled",
"via",
"configuration"
] |
[
"public",
"static",
"boolean",
"timeline",
"service",
"enabled",
"(",
"configuration",
"conf",
")",
"{",
"return",
"conf",
"get",
"boolean",
"(",
"yarn",
"configuration",
"timeline",
"service",
"enabled",
",",
"yarn",
"configuration",
"default",
"timeline",
"service",
"enabled",
")",
";",
"}"
] |
[
"build",
"the",
"completion",
"window",
",",
"parented",
"to",
"the",
"attached",
"field",
"that",
"last",
"had",
"focus"
] |
[
"protected",
"void",
"build",
"completion",
"window",
"(",
")",
"{",
"completion",
"window",
"=",
"new",
"j",
"window",
"(",
"window",
"utilities",
"window",
"for",
"component",
"(",
"focus",
")",
")",
";",
"completion",
"window",
"add",
"(",
"content",
")",
";",
"content",
"set",
"visible",
"(",
"true",
")",
";",
"list",
"set",
"visible",
"(",
"true",
")",
";",
"dimension",
"size",
"=",
"get",
"default",
"completion",
"window",
"dimension",
"(",
")",
";",
"if",
"(",
"-",
"1",
"=",
"=",
"size",
"height",
")",
"{",
"size",
"height",
"=",
"default",
"height",
";",
"}",
"if",
"(",
"-",
"1",
"=",
"=",
"size",
"width",
")",
"{",
"size",
"width",
"=",
"default",
"width",
";",
"}",
"completion",
"window",
"set",
"size",
"(",
"size",
")",
";",
"}"
] |
[
"returns",
"a",
"{",
"@",
"code",
"top",
"k",
"selector",
"}",
"that",
"collects",
"the",
"lowest",
"{",
"@",
"code",
"k",
"}",
"elements",
"added",
"to",
"it",
",",
"relative",
"to",
"the",
"natural",
"ordering",
"of",
"the",
"elements",
",",
"and",
"returns",
"them",
"via",
"{",
"@",
"link",
"#",
"top",
"k",
"}",
"in",
"ascending",
"order"
] |
[
"public",
"static",
"<",
"t",
"extends",
"comparable",
"<",
"?",
"super",
"t",
">",
">",
"top",
"k",
"selector",
"<",
"t",
">",
"least",
"(",
"int",
"k",
")",
"{",
"return",
"least",
"(",
"k",
",",
"ordering",
"natural",
"(",
")",
")",
";",
"}"
] |
[
"decorates",
"the",
"remapping",
"function",
"to",
"record",
"statistics",
"if",
"enabled"
] |
[
"default",
"<",
"t",
",",
"u",
",",
"r",
">",
"bi",
"function",
"<",
"?",
"super",
"t",
",",
"?",
"super",
"u",
",",
"?",
"extends",
"r",
">",
"stats",
"aware",
"(",
"bi",
"function",
"<",
"?",
"super",
"t",
",",
"?",
"super",
"u",
",",
"?",
"extends",
"r",
">",
"remapping",
"function",
")",
"{",
"return",
"stats",
"aware",
"(",
"remapping",
"function",
",",
"/",
"*",
"record",
"miss",
"*",
"/",
"true",
",",
"/",
"*",
"record",
"load",
"*",
"/",
"true",
",",
"/",
"*",
"record",
"load",
"failure",
"*",
"/",
"true",
")",
";",
"}"
] |
[
"finds",
"the",
"child",
"with",
"the",
"specified",
"name",
"and",
"returns",
"it",
"as",
"an",
"int"
] |
[
"public",
"int",
"get",
"int",
"(",
"string",
"name",
")",
"{",
"json",
"value",
"child",
"=",
"get",
"(",
"name",
")",
";",
"if",
"(",
"child",
"=",
"=",
"null",
")",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"named",
"value",
"not",
"found",
":",
"\"",
"+",
"name",
")",
";",
"return",
"child",
"as",
"int",
"(",
")",
";",
"}"
] |
[
"test",
"the",
"snapshot",
"limit",
"of",
"a",
"single",
"snapshottable",
"directory"
] |
[
"public",
"void",
"test",
"snapshot",
"limit",
"(",
")",
"throws",
"exception",
"{",
"final",
"int",
"step",
"=",
"1000",
";",
"final",
"string",
"dir",
"str",
"=",
"\"",
"/",
"test",
"snapshot",
"limit",
"/",
"dir",
"\"",
";",
"final",
"path",
"dir",
"=",
"new",
"path",
"(",
"dir",
"str",
")",
";",
"hdfs",
"mkdirs",
"(",
"dir",
",",
"new",
"fs",
"permission",
"(",
"(",
"short",
")",
"0777",
")",
")",
";",
"hdfs",
"allow",
"snapshot",
"(",
"dir",
")",
";",
"int",
"s",
"=",
"0",
";",
"for",
"(",
";",
"s",
"<",
"snapshot",
"quota",
"default",
";",
"s",
"+",
"+",
")",
"{",
"final",
"string",
"snapshot",
"name",
"=",
"\"",
"s",
"\"",
"+",
"s",
";",
"hdfs",
"create",
"snapshot",
"(",
"dir",
",",
"snapshot",
"name",
")",
";",
"/",
"/",
"create",
"a",
"file",
"occasionally",
"if",
"(",
"s",
"%",
"step",
"=",
"=",
"0",
")",
"{",
"final",
"path",
"file",
"=",
"new",
"path",
"(",
"dir",
"str",
",",
"\"",
"f",
"\"",
"+",
"s",
")",
";",
"d",
"f",
"s",
"test",
"util",
"create",
"file",
"(",
"hdfs",
",",
"file",
",",
"blocksize",
",",
"replication",
",",
"seed",
")",
";",
"}",
"}",
"try",
"{",
"hdfs",
"create",
"snapshot",
"(",
"dir",
",",
"\"",
"s",
"\"",
"+",
"s",
")",
";",
"assert",
"fail",
"(",
"\"",
"expected",
"to",
"fail",
"to",
"create",
"snapshot",
",",
"but",
"didn",
"'",
"t",
"\"",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"ioe",
")",
"{",
"snapshot",
"test",
"helper",
"log",
"info",
"(",
"\"",
"the",
"exception",
"is",
"expected",
"\"",
",",
"ioe",
")",
";",
"}",
"for",
"(",
"int",
"f",
"=",
"0",
";",
"f",
"<",
"snapshot",
"quota",
"default",
";",
"f",
"+",
"=",
"step",
")",
"{",
"final",
"string",
"file",
"=",
"\"",
"f",
"\"",
"+",
"f",
";",
"s",
"=",
"random",
"next",
"int",
"(",
"step",
")",
";",
"for",
"(",
";",
"s",
"<",
"snapshot",
"quota",
"default",
";",
"s",
"+",
"=",
"random",
"next",
"int",
"(",
"step",
")",
")",
"{",
"final",
"path",
"p",
"=",
"snapshot",
"test",
"helper",
"get",
"snapshot",
"path",
"(",
"dir",
",",
"\"",
"s",
"\"",
"+",
"s",
",",
"file",
")",
";",
"/",
"/",
"the",
"file",
"#",
"f",
"exists",
"in",
"snapshot",
"#",
"s",
"iff",
"s",
">",
"f",
"assert",
"assert",
"equals",
"(",
"s",
">",
"f",
",",
"hdfs",
"exists",
"(",
"p",
")",
")",
";",
"}",
"}",
"}"
] |
[
"retrieves",
"the",
"collected",
"artifacts",
"since",
"this",
"method",
"was",
"last",
"called",
"and",
"clears",
"the",
"list"
] |
[
"immutable",
"list",
"<",
"artifact",
"derived",
"artifact",
">",
"get",
"and",
"reset",
"extra",
"artifacts",
"(",
")",
"{",
"immutable",
"list",
"<",
"artifact",
"derived",
"artifact",
">",
"collected",
"=",
"immutable",
"list",
"copy",
"of",
"(",
"extra",
"artifacts",
")",
";",
"extra",
"artifacts",
"clear",
"(",
")",
";",
"return",
"collected",
";",
"}"
] |
[
"get",
"the",
"sequence",
"of",
"bytes"
] |
[
"public",
"string",
"get",
"sequence",
"(",
")",
"{",
"return",
"byte",
"sequence",
";",
"}"
] |
[
"checks",
"if",
"a",
"user",
"-",
"defined",
"function",
"can",
"be",
"easily",
"instantiated"
] |
[
"private",
"static",
"void",
"validate",
"instantiation",
"(",
"class",
"<",
"?",
">",
"clazz",
",",
"boolean",
"requires",
"default",
"constructor",
")",
"{",
"if",
"(",
"!",
"instantiation",
"util",
"is",
"public",
"(",
"clazz",
")",
")",
"{",
"throw",
"new",
"validation",
"exception",
"(",
"string",
"format",
"(",
"\"",
"function",
"class",
"'",
"%",
"s",
"'",
"is",
"not",
"public",
"\"",
",",
"clazz",
"get",
"name",
"(",
")",
")",
")",
";",
"}",
"else",
"if",
"(",
"!",
"instantiation",
"util",
"is",
"proper",
"class",
"(",
"clazz",
")",
")",
"{",
"throw",
"new",
"validation",
"exception",
"(",
"string",
"format",
"(",
"\"",
"function",
"class",
"'",
"%",
"s",
"'",
"is",
"not",
"a",
"proper",
"class",
"it",
"is",
"either",
"abstract",
",",
"an",
"interface",
",",
"or",
"a",
"primitive",
"type",
"\"",
",",
"clazz",
"get",
"name",
"(",
")",
")",
")",
";",
"}",
"else",
"if",
"(",
"requires",
"default",
"constructor",
"&",
"&",
"!",
"instantiation",
"util",
"has",
"public",
"nullary",
"constructor",
"(",
"clazz",
")",
")",
"{",
"throw",
"new",
"validation",
"exception",
"(",
"string",
"format",
"(",
"\"",
"function",
"class",
"'",
"%",
"s",
"'",
"must",
"have",
"a",
"public",
"default",
"constructor",
"\"",
",",
"clazz",
"get",
"name",
"(",
")",
")",
")",
";",
"}",
"}"
] |
[
"retrieve",
"a",
"{",
"@",
"link",
"bean",
"info",
"}",
"descriptor",
"for",
"the",
"given",
"target",
"class"
] |
[
"private",
"static",
"bean",
"info",
"get",
"bean",
"info",
"(",
"class",
"<",
"?",
">",
"bean",
"class",
")",
"throws",
"introspection",
"exception",
"{",
"for",
"(",
"bean",
"info",
"factory",
"bean",
"info",
"factory",
":",
"bean",
"info",
"factories",
")",
"{",
"bean",
"info",
"bean",
"info",
"=",
"bean",
"info",
"factory",
"get",
"bean",
"info",
"(",
"bean",
"class",
")",
";",
"if",
"(",
"bean",
"info",
"!",
"=",
"null",
")",
"{",
"return",
"bean",
"info",
";",
"}",
"}",
"return",
"(",
"should",
"introspector",
"ignore",
"beaninfo",
"classes",
"?",
"introspector",
"get",
"bean",
"info",
"(",
"bean",
"class",
",",
"introspector",
"ignore",
"all",
"beaninfo",
")",
":",
"introspector",
"get",
"bean",
"info",
"(",
"bean",
"class",
")",
")",
";",
"}"
] |
[
"the",
"error",
"code",
"for",
"the",
"exception"
] |
[
"public",
"short",
"code",
"(",
")",
"{",
"return",
"this",
"code",
";",
"}"
] |
[
"return",
"the",
"jsf",
"external",
"context",
"that",
"this",
"adapter",
"operates",
"on"
] |
[
"protected",
"final",
"external",
"context",
"get",
"external",
"context",
"(",
")",
"{",
"return",
"get",
"faces",
"context",
"(",
")",
"get",
"external",
"context",
"(",
")",
";",
"}"
] |
[
"activate",
"the",
"new",
"master",
"-",
"key"
] |
[
"public",
"void",
"activate",
"next",
"master",
"key",
"(",
")",
"{",
"super",
"write",
"lock",
"lock",
"(",
")",
";",
"try",
"{",
"log",
"info",
"(",
"\"",
"activating",
"next",
"master",
"key",
"with",
"id",
":",
"\"",
"+",
"this",
"next",
"master",
"key",
"get",
"master",
"key",
"(",
")",
"get",
"key",
"id",
"(",
")",
")",
";",
"this",
"current",
"master",
"key",
"=",
"this",
"next",
"master",
"key",
";",
"this",
"next",
"master",
"key",
"=",
"null",
";",
"}",
"finally",
"{",
"super",
"write",
"lock",
"unlock",
"(",
")",
";",
"}",
"}"
] |
[
"return",
"all",
"pcode",
"ops",
"(",
"alive",
"or",
"dead",
")",
"ordered",
"by",
"sequence",
"number"
] |
[
"public",
"iterator",
"<",
"pcode",
"op",
"a",
"s",
"t",
">",
"get",
"pcode",
"ops",
"(",
")",
"{",
"return",
"opbank",
"all",
"ordered",
"(",
")",
";",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.