docstring_tokens
list | code_tokens
list |
|---|---|
[
"create",
"a",
"new",
"context",
"with",
"the",
"given",
"key",
"value",
"set",
"the",
"new",
"context",
"will",
"cascade",
"cancellation",
"from",
"its",
"parent"
]
| [
"public",
"<",
"v1",
",",
"v2",
",",
"v3",
">",
"context",
"with",
"values",
"(",
"key",
"<",
"v1",
">",
"k",
"1",
",",
"v1",
"v",
"1",
",",
"key",
"<",
"v2",
">",
"k",
"2",
",",
"v2",
"v",
"2",
",",
"key",
"<",
"v3",
">",
"k",
"3",
",",
"v3",
"v",
"3",
")",
"{",
"node",
"<",
"key",
"<",
"?",
">",
",",
"object",
">",
"new",
"key",
"value",
"entries",
"=",
"persistent",
"hash",
"array",
"mapped",
"trie",
"put",
"(",
"key",
"value",
"entries",
",",
"k",
"1",
",",
"v",
"1",
")",
";",
"new",
"key",
"value",
"entries",
"=",
"persistent",
"hash",
"array",
"mapped",
"trie",
"put",
"(",
"new",
"key",
"value",
"entries",
",",
"k",
"2",
",",
"v",
"2",
")",
";",
"new",
"key",
"value",
"entries",
"=",
"persistent",
"hash",
"array",
"mapped",
"trie",
"put",
"(",
"new",
"key",
"value",
"entries",
",",
"k",
"3",
",",
"v",
"3",
")",
";",
"return",
"new",
"context",
"(",
"this",
",",
"new",
"key",
"value",
"entries",
")",
";",
"}"
]
|
[
"gets",
"the",
"source",
"of",
"this",
"channel"
]
| [
"public",
"plan",
"node",
"get",
"source",
"(",
")",
"{",
"return",
"this",
"source",
";",
"}"
]
|
[
"determines",
"whether",
"the",
"given",
"cache",
"can",
"be",
"converted",
"to",
"a",
"local",
"cache",
"by",
"{",
"@",
"link",
"#",
"to",
"local",
"cache",
"}",
"without",
"throwing",
"an",
"exception"
]
| [
"static",
"boolean",
"has",
"local",
"cache",
"(",
"cache",
"<",
"?",
",",
"?",
">",
"cache",
")",
"{",
"return",
"(",
"check",
"not",
"null",
"(",
"cache",
")",
"instanceof",
"local",
"loading",
"cache",
")",
";",
"}"
]
|
[
"override",
"to",
"add",
"additional",
"pre",
"-",
"configured",
"{",
"@",
"link",
"analyzer",
"}",
"s"
]
| [
"default",
"list",
"<",
"pre",
"built",
"analyzer",
"provider",
"factory",
">",
"get",
"pre",
"built",
"analyzer",
"provider",
"factories",
"(",
")",
"{",
"return",
"empty",
"list",
"(",
")",
";",
"}"
]
|
[
"returns",
"the",
"last",
"modified",
"time",
"in",
"milliseconds",
"for",
"this",
"file",
"zero",
"is",
"returned",
"if",
"the",
"file",
"doesn",
"'",
"t",
"exist",
"zero",
"is",
"returned",
"for",
"{",
"@",
"link",
"file",
"type",
"#",
"classpath",
"}",
"files",
"on",
"android",
",",
"zero",
"is",
"returned",
"for",
"{",
"@",
"link",
"file",
"type",
"#",
"internal",
"}",
"files",
"on",
"the",
"desktop",
",",
"zero",
"is",
"returned",
"for",
"{",
"@",
"link",
"file",
"type",
"#",
"internal",
"}",
"files",
"on",
"the",
"classpath"
]
| [
"public",
"long",
"last",
"modified",
"(",
")",
"{",
"return",
"file",
"(",
")",
"last",
"modified",
"(",
")",
";",
"}"
]
|
[
"success",
"is",
"relative",
"with",
"bulk",
"responses",
"because",
"unless",
"it",
"'",
"s",
"rejected",
"outright",
",",
"it",
"returns",
"with",
"a",
"200",
"individual",
"documents",
"can",
"fail",
"and",
"since",
"we",
"know",
"how",
"we",
"'",
"re",
"making",
"them",
",",
"that",
"means",
"that"
]
| [
"public",
"void",
"on",
"success",
"(",
"final",
"response",
"response",
")",
"{",
"/",
"/",
"empty",
"is",
"safe",
"here",
"because",
"we",
"never",
"call",
"named",
"object",
"try",
"(",
"x",
"content",
"parser",
"parser",
"=",
"x",
"content",
"create",
"parser",
"(",
"named",
"x",
"content",
"registry",
"empty",
",",
"logging",
"deprecation",
"handler",
"instance",
",",
"response",
"get",
"entity",
"(",
")",
"get",
"content",
"(",
")",
")",
")",
"{",
"/",
"/",
"avoid",
"parsing",
"the",
"entire",
"payload",
"if",
"we",
"don",
"'",
"t",
"need",
"too",
"x",
"content",
"parser",
"token",
"token",
"=",
"parser",
"next",
"token",
"(",
")",
";",
"if",
"(",
"token",
"=",
"=",
"x",
"content",
"parser",
"token",
"start",
"object",
")",
"{",
"string",
"current",
"field",
"name",
"=",
"null",
";",
"while",
"(",
"(",
"token",
"=",
"parser",
"next",
"token",
"(",
")",
")",
"!",
"=",
"x",
"content",
"parser",
"token",
"end",
"object",
")",
"{",
"if",
"(",
"token",
"=",
"=",
"x",
"content",
"parser",
"token",
"field",
"name",
")",
"{",
"current",
"field",
"name",
"=",
"parser",
"current",
"name",
"(",
")",
";",
"}",
"else",
"if",
"(",
"token",
"is",
"value",
"(",
")",
")",
"{",
"if",
"(",
"\"",
"errors",
"\"",
"equals",
"(",
"current",
"field",
"name",
")",
")",
"{",
"/",
"/",
"no",
"errors",
"?",
"then",
"we",
"can",
"stop",
"looking",
"if",
"(",
"parser",
"boolean",
"value",
"(",
")",
"=",
"=",
"false",
")",
"{",
"return",
";",
"}",
"}",
"}",
"else",
"if",
"(",
"token",
"=",
"=",
"x",
"content",
"parser",
"token",
"start",
"array",
")",
"{",
"/",
"/",
"note",
":",
"this",
"assumes",
"that",
"\"",
"items",
"\"",
"is",
"the",
"only",
"array",
"portion",
"of",
"the",
"response",
"(",
"currently",
"true",
")",
"parse",
"errors",
"(",
"parser",
")",
";",
"return",
";",
"}",
"}",
"}",
"}",
"catch",
"(",
"i",
"o",
"exception",
"|",
"runtime",
"exception",
"e",
")",
"{",
"on",
"error",
"(",
"\"",
"unexpected",
"exception",
"while",
"verifying",
"bulk",
"response",
"\"",
",",
"e",
")",
";",
"}",
"}"
]
|
[
"load",
"bean",
"definitions",
"from",
"the",
"given",
"groovy",
"scripts",
"or",
"xml",
"files",
"note",
"that",
"\"",
"xml",
"\"",
"files",
"will",
"be",
"parsed",
"as",
"xml",
"content",
";",
"all",
"other",
"kinds",
"of",
"resources",
"will",
"be",
"parsed",
"as",
"groovy",
"scripts"
]
| [
"public",
"void",
"load",
"(",
"string",
"resource",
"locations",
")",
"{",
"this",
"reader",
"load",
"bean",
"definitions",
"(",
"resource",
"locations",
")",
";",
"}"
]
|
[
"register",
"a",
"newly",
"created",
"channel"
]
| [
"protected",
"void",
"add",
"channel",
"(",
"channel",
"channel",
")",
"{",
"all",
"channels",
"add",
"(",
"channel",
")",
";",
"}"
]
|
[
"creates",
"a",
"nested",
"set",
"from",
"a",
"given",
"list",
"of",
"items"
]
| [
"public",
"static",
"<",
"e",
">",
"nested",
"set",
"<",
"e",
">",
"wrap",
"(",
"order",
"order",
",",
"iterable",
"<",
"?",
"extends",
"e",
">",
"wrapped",
"items",
")",
"{",
"if",
"(",
"iterables",
"is",
"empty",
"(",
"wrapped",
"items",
")",
")",
"{",
"return",
"order",
"empty",
"set",
"(",
")",
";",
"}",
"else",
"if",
"(",
"order",
"=",
"=",
"order",
"stable",
"order",
"&",
"&",
"wrapped",
"items",
"instanceof",
"immutable",
"list",
")",
"{",
"immutable",
"list",
"<",
"e",
">",
"wrapped",
"list",
"=",
"(",
"immutable",
"list",
")",
"wrapped",
"items",
";",
"if",
"(",
"wrapped",
"list",
"size",
"(",
")",
">",
"1",
")",
"{",
"nested",
"set",
"<",
"?",
">",
"cached",
"=",
"immutable",
"list",
"cache",
"get",
"(",
"wrapped",
"list",
")",
";",
"if",
"(",
"cached",
"!",
"=",
"null",
")",
"{",
"return",
"(",
"nested",
"set",
"<",
"e",
">",
")",
"cached",
";",
"}",
"nested",
"set",
"<",
"e",
">",
"built",
"=",
"new",
"nested",
"set",
"builder",
"<",
"e",
">",
"(",
"order",
")",
"add",
"all",
"(",
"wrapped",
"list",
")",
"build",
"(",
")",
";",
"immutable",
"list",
"cache",
"put",
"if",
"absent",
"(",
"wrapped",
"list",
",",
"built",
")",
";",
"return",
"built",
";",
"}",
"}",
"return",
"new",
"nested",
"set",
"builder",
"<",
"e",
">",
"(",
"order",
")",
"add",
"all",
"(",
"wrapped",
"items",
")",
"build",
"(",
")",
";",
"}"
]
|
[
"delete",
"a",
"ticket",
"by",
"its",
"identifier",
"simple",
"call",
"to",
"the",
"super",
"method",
"to",
"force",
"a",
"transaction",
"to",
"be",
"started",
"in",
"case",
"of",
"a",
"direct",
"call"
]
| [
"public",
"int",
"delete",
"ticket",
"(",
"final",
"string",
"ticket",
"id",
")",
"{",
"return",
"super",
"delete",
"ticket",
"(",
"ticket",
"id",
")",
";",
"}"
]
|
[
"returns",
"true",
"iff",
"the",
"given",
"number",
"of",
"active",
"shards",
"is",
"enough",
"to",
"meet",
"the",
"required",
"shard",
"count",
"represented",
"by",
"this",
"instance",
"this",
"method",
"should",
"only",
"be",
"invoked",
"with",
"{",
"@",
"link",
"active",
"shard",
"count",
"}",
"objects",
"created",
"from",
"{",
"@",
"link",
"#",
"from",
"(",
"int",
")",
"}",
",",
"or",
"{",
"@",
"link",
"#",
"none",
"}",
"or",
"{",
"@",
"link",
"#",
"one",
"}"
]
| [
"public",
"boolean",
"enough",
"shards",
"active",
"(",
"final",
"int",
"active",
"shard",
"count",
")",
"{",
"if",
"(",
"this",
"value",
"<",
"0",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"not",
"enough",
"information",
"to",
"resolve",
"to",
"shard",
"count",
"\"",
")",
";",
"}",
"if",
"(",
"active",
"shard",
"count",
"<",
"0",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"active",
"shard",
"count",
"cannot",
"be",
"negative",
"\"",
")",
";",
"}",
"return",
"this",
"value",
"<",
"=",
"active",
"shard",
"count",
";",
"}"
]
|
[
"get",
"enum",
"string"
]
| [
"public",
"enum",
"string",
"enum",
"get",
"enum",
"string",
"(",
")",
"{",
"return",
"enum",
"string",
";",
"}"
]
|
[
"return",
"the",
"error",
"exception",
"during",
"the",
"job",
"execution",
"this",
"should",
"be",
"called",
"after",
"the",
"job",
"finishes"
]
| [
"public",
"exception",
"get",
"error",
"(",
")",
"{",
"return",
"error",
";",
"}"
]
|
[
"handle",
"deserialization",
"of",
"the",
"'",
"null",
"'",
"value"
]
| [
"public",
"gm",
"fruit",
"get",
"null",
"value",
"(",
"deserialization",
"context",
"ctxt",
")",
"throws",
"json",
"mapping",
"exception",
"{",
"throw",
"new",
"json",
"mapping",
"exception",
"(",
"ctxt",
"get",
"parser",
"(",
")",
",",
"\"",
"gm",
"fruit",
"cannot",
"be",
"null",
"\"",
")",
";",
"}"
]
|
[
"skip",
"buffers",
"from",
"the",
"given",
"{",
"@",
"link",
"publisher",
"}",
"until",
"the",
"total",
"{",
"@",
"linkplain",
"data",
"buffer",
"#",
"readable",
"byte",
"count",
"(",
")",
"byte",
"count",
"}",
"reaches",
"the",
"given",
"maximum",
"byte",
"count",
",",
"or",
"until",
"the",
"publisher",
"is",
"complete"
]
| [
"public",
"static",
"flux",
"<",
"data",
"buffer",
">",
"skip",
"until",
"byte",
"count",
"(",
"publisher",
"<",
"?",
"extends",
"data",
"buffer",
">",
"publisher",
",",
"long",
"max",
"byte",
"count",
")",
"{",
"assert",
"not",
"null",
"(",
"publisher",
",",
"\"",
"publisher",
"must",
"not",
"be",
"null",
"\"",
")",
";",
"assert",
"is",
"true",
"(",
"max",
"byte",
"count",
">",
"=",
"0",
",",
"\"",
"'",
"max",
"byte",
"count",
"'",
"must",
"be",
"a",
"positive",
"number",
"\"",
")",
";",
"return",
"flux",
"defer",
"(",
"(",
")",
"-",
">",
"{",
"atomic",
"long",
"count",
"down",
"=",
"new",
"atomic",
"long",
"(",
"max",
"byte",
"count",
")",
";",
"return",
"flux",
"from",
"(",
"publisher",
")",
"skip",
"until",
"(",
"buffer",
"-",
">",
"{",
"long",
"remainder",
"=",
"count",
"down",
"add",
"and",
"get",
"(",
"-",
"buffer",
"readable",
"byte",
"count",
"(",
")",
")",
";",
"return",
"remainder",
"<",
"0",
";",
"}",
")",
"map",
"(",
"buffer",
"-",
">",
"{",
"long",
"remainder",
"=",
"count",
"down",
"get",
"(",
")",
";",
"if",
"(",
"remainder",
"<",
"0",
")",
"{",
"count",
"down",
"set",
"(",
"0",
")",
";",
"int",
"start",
"=",
"buffer",
"readable",
"byte",
"count",
"(",
")",
"+",
"(",
"int",
")",
"remainder",
";",
"int",
"length",
"=",
"(",
"int",
")",
"-",
"remainder",
";",
"return",
"buffer",
"slice",
"(",
"start",
",",
"length",
")",
";",
"}",
"else",
"{",
"return",
"buffer",
";",
"}",
"}",
")",
";",
"}",
")",
"do",
"on",
"discard",
"(",
"pooled",
"data",
"buffer",
"class",
",",
"data",
"buffer",
"utils",
":",
":",
"release",
")",
";",
"}"
]
|
[
"test",
"the",
"default",
"behavior",
"when",
"the",
"textinputformat",
"record",
"delimiter",
"configuration",
"property",
"is",
"not",
"specified"
]
| [
"public",
"void",
"test",
"default",
"record",
"delimiters",
"(",
")",
"throws",
"i",
"o",
"exception",
",",
"interrupted",
"exception",
",",
"class",
"not",
"found",
"exception",
"{",
"configuration",
"conf",
"=",
"new",
"configuration",
"(",
")",
";",
"file",
"system",
"local",
"fs",
"=",
"file",
"system",
"get",
"local",
"(",
"conf",
")",
";",
"/",
"/",
"cleanup",
"local",
"fs",
"delete",
"(",
"work",
"dir",
",",
"true",
")",
";",
"/",
"/",
"creating",
"input",
"test",
"file",
"create",
"input",
"file",
"(",
"conf",
")",
";",
"create",
"and",
"run",
"job",
"(",
"conf",
")",
";",
"string",
"expected",
"=",
"\"",
"0",
"\\",
"tabc",
"\\",
"n",
"4",
"\\",
"tdef",
"\\",
"t",
"\\",
"n",
"9",
"\\",
"tghi",
"\\",
"n",
"1",
"3",
"\\",
"tjkl",
"\\",
"n",
"\"",
";",
"assert",
"equals",
"(",
"expected",
",",
"read",
"output",
"file",
"(",
"conf",
")",
")",
";",
"}"
]
|
[
"builds",
"the",
"default",
"request",
"handlers"
]
| [
"private",
"path",
"trie",
"<",
"request",
"handler",
">",
"default",
"handlers",
"(",
")",
"{",
"final",
"path",
"trie",
"<",
"request",
"handler",
">",
"handlers",
"=",
"new",
"path",
"trie",
"<",
">",
"(",
"rest",
"utils",
"rest",
"decoder",
")",
";",
"final",
"consumer",
"<",
"map",
"<",
"string",
",",
"string",
">",
">",
"common",
"header",
"consumer",
"=",
"headers",
"-",
">",
"headers",
"put",
"(",
"\"",
"metadata",
"-",
"flavor",
"\"",
",",
"\"",
"google",
"\"",
")",
";",
"final",
"function",
"<",
"string",
",",
"response",
">",
"simple",
"value",
"=",
"value",
"-",
">",
"{",
"final",
"map",
"<",
"string",
",",
"string",
">",
"headers",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
"text",
"plain",
"content",
"type",
")",
";",
"common",
"header",
"consumer",
"accept",
"(",
"headers",
")",
";",
"final",
"byte",
"[",
"]",
"response",
"as",
"bytes",
"=",
"value",
"get",
"bytes",
"(",
"standard",
"charsets",
"utf",
"8",
")",
";",
"return",
"new",
"response",
"(",
"rest",
"status",
"ok",
"get",
"status",
"(",
")",
",",
"headers",
",",
"response",
"as",
"bytes",
")",
";",
"}",
";",
"final",
"function",
"<",
"string",
",",
"response",
">",
"json",
"value",
"=",
"value",
"-",
">",
"{",
"final",
"map",
"<",
"string",
",",
"string",
">",
"headers",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
"json",
"content",
"type",
")",
";",
"common",
"header",
"consumer",
"accept",
"(",
"headers",
")",
";",
"final",
"byte",
"[",
"]",
"response",
"as",
"bytes",
"=",
"value",
"get",
"bytes",
"(",
"standard",
"charsets",
"utf",
"8",
")",
";",
"return",
"new",
"response",
"(",
"rest",
"status",
"ok",
"get",
"status",
"(",
")",
",",
"headers",
",",
"response",
"as",
"bytes",
")",
";",
"}",
";",
"/",
"/",
"https",
":",
"/",
"/",
"cloud",
"google",
"com",
"/",
"compute",
"/",
"docs",
"/",
"storing",
"-",
"retrieving",
"-",
"metadata",
"handlers",
"insert",
"(",
"non",
"auth",
"path",
"(",
"http",
"get",
"method",
"name",
",",
"\"",
"/",
"compute",
"metadata",
"/",
"v",
"1",
"/",
"project",
"/",
"project",
"-",
"id",
"\"",
")",
",",
"request",
"-",
">",
"simple",
"value",
"apply",
"(",
"project",
"id",
")",
")",
";",
"handlers",
"insert",
"(",
"non",
"auth",
"path",
"(",
"http",
"get",
"method",
"name",
",",
"\"",
"/",
"compute",
"metadata",
"/",
"v",
"1",
"/",
"project",
"/",
"attributes",
"/",
"google",
"-",
"compute",
"-",
"default",
"-",
"zone",
"\"",
")",
",",
"request",
"-",
">",
"simple",
"value",
"apply",
"(",
"zone",
")",
")",
";",
"/",
"/",
"https",
":",
"/",
"/",
"cloud",
"google",
"com",
"/",
"compute",
"/",
"docs",
"/",
"access",
"/",
"create",
"-",
"enable",
"-",
"service",
"-",
"accounts",
"-",
"for",
"-",
"instances",
"handlers",
"insert",
"(",
"non",
"auth",
"path",
"(",
"http",
"get",
"method",
"name",
",",
"\"",
"/",
"compute",
"metadata",
"/",
"v",
"1",
"/",
"instance",
"/",
"service",
"-",
"accounts",
"/",
"default",
"/",
"token",
"\"",
")",
",",
"request",
"-",
">",
"json",
"value",
"apply",
"(",
"strings",
"to",
"string",
"(",
"json",
"builder",
"(",
")",
"start",
"object",
"(",
")",
"field",
"(",
"\"",
"access",
"token",
"\"",
",",
"token",
")",
"field",
"(",
"\"",
"expires",
"in",
"\"",
",",
"time",
"unit",
"hours",
"to",
"seconds",
"(",
"1",
")",
")",
"field",
"(",
"\"",
"token",
"type",
"\"",
",",
"token",
"type",
")",
"end",
"object",
"(",
")",
")",
")",
")",
";",
"/",
"/",
"https",
":",
"/",
"/",
"cloud",
"google",
"com",
"/",
"compute",
"/",
"docs",
"/",
"reference",
"/",
"rest",
"/",
"v",
"1",
"/",
"instances",
"handlers",
"insert",
"(",
"auth",
"path",
"(",
"http",
"get",
"method",
"name",
",",
"\"",
"/",
"compute",
"/",
"v",
"1",
"/",
"projects",
"/",
"{",
"project",
"}",
"/",
"zones",
"/",
"{",
"zone",
"}",
"/",
"instances",
"\"",
")",
",",
"request",
"-",
">",
"{",
"final",
"var",
"items",
"=",
"new",
"array",
"list",
"<",
"map",
"<",
"string",
",",
"object",
">",
">",
"(",
")",
";",
"int",
"count",
"=",
"0",
";",
"for",
"(",
"string",
"address",
":",
"files",
"read",
"all",
"lines",
"(",
"nodes",
")",
")",
"{",
"count",
"+",
"+",
";",
"items",
"add",
"(",
"map",
"of",
"(",
"\"",
"id",
"\"",
",",
"long",
"to",
"string",
"(",
"9309873766405l",
"+",
"count",
")",
",",
"\"",
"description",
"\"",
",",
"\"",
"es",
"node",
"\"",
"+",
"count",
",",
"\"",
"name",
"\"",
",",
"\"",
"test",
"\"",
"+",
"count",
",",
"\"",
"kind",
"\"",
",",
"\"",
"compute",
"#",
"instance",
"\"",
",",
"\"",
"machine",
"type",
"\"",
",",
"\"",
"n",
"1",
"-",
"standard",
"-",
"1",
"\"",
",",
"\"",
"network",
"interfaces",
"\"",
",",
"list",
"of",
"(",
"map",
"of",
"(",
"\"",
"access",
"configs",
"\"",
",",
"collections",
"empty",
"list",
"(",
")",
",",
"\"",
"name",
"\"",
",",
"\"",
"nic",
"0",
"\"",
",",
"\"",
"network",
"\"",
",",
"\"",
"default",
"\"",
",",
"\"",
"network",
"i",
"p",
"\"",
",",
"address",
")",
")",
",",
"\"",
"status",
"\"",
",",
"\"",
"running",
"\"",
",",
"\"",
"zone",
"\"",
",",
"zone",
")",
")",
";",
"}",
"final",
"string",
"json",
"=",
"strings",
"to",
"string",
"(",
"json",
"builder",
"(",
")",
"start",
"object",
"(",
")",
"field",
"(",
"\"",
"id",
"\"",
",",
"\"",
"test",
"-",
"instances",
"\"",
")",
"field",
"(",
"\"",
"items",
"\"",
",",
"items",
")",
"end",
"object",
"(",
")",
")",
";",
"final",
"byte",
"[",
"]",
"response",
"as",
"bytes",
"=",
"json",
"get",
"bytes",
"(",
"standard",
"charsets",
"utf",
"8",
")",
";",
"final",
"map",
"<",
"string",
",",
"string",
">",
"headers",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
"json",
"content",
"type",
")",
";",
"common",
"header",
"consumer",
"accept",
"(",
"headers",
")",
";",
"return",
"new",
"response",
"(",
"rest",
"status",
"ok",
"get",
"status",
"(",
")",
",",
"headers",
",",
"response",
"as",
"bytes",
")",
";",
"}",
")",
";",
"return",
"handlers",
";",
"}"
]
|
[
"get",
"string",
"item"
]
| [
"public",
"string",
"get",
"string",
"item",
"(",
")",
"{",
"return",
"string",
"item",
";",
"}"
]
|
[
"abort",
"a",
"task",
"attempt",
"load",
"then",
"abort",
"all",
"pending",
"files",
",",
"then",
"try",
"to",
"delete",
"the",
"task",
"attempt",
"path",
"this",
"method",
"may",
"be",
"called",
"on",
"the",
"job",
"committer",
",",
"rather",
"than",
"the",
"task",
"one",
"(",
"such",
"as",
"in",
"the",
"map",
"reduce",
"am",
"after",
"a",
"task",
"container",
"failure",
")",
"it",
"must",
"extract",
"all",
"paths",
"and",
"state",
"from",
"the",
"passed",
"in",
"context"
]
| [
"public",
"void",
"abort",
"task",
"(",
"task",
"attempt",
"context",
"context",
")",
"throws",
"i",
"o",
"exception",
"{",
"path",
"attempt",
"path",
"=",
"get",
"task",
"attempt",
"path",
"(",
"context",
")",
";",
"try",
"(",
"duration",
"info",
"d",
"=",
"new",
"duration",
"info",
"(",
"log",
",",
"\"",
"abort",
"task",
"%",
"s",
"\"",
",",
"context",
"get",
"task",
"attempt",
"i",
"d",
"(",
")",
")",
")",
"{",
"get",
"commit",
"operations",
"(",
")",
"abort",
"all",
"single",
"pending",
"commits",
"(",
"attempt",
"path",
",",
"true",
")",
";",
"}",
"finally",
"{",
"delete",
"quietly",
"(",
"attempt",
"path",
"get",
"file",
"system",
"(",
"context",
"get",
"configuration",
"(",
")",
")",
",",
"attempt",
"path",
",",
"true",
")",
";",
"destroy",
"thread",
"pool",
"(",
")",
";",
"}",
"}"
]
|
[
"adds",
"multiple",
"starlark",
"options",
"to",
"the",
"builder",
"overrides",
"previous",
"instances",
"of",
"the",
"same",
"key"
]
| [
"public",
"builder",
"add",
"starlark",
"options",
"(",
"map",
"<",
"label",
",",
"object",
">",
"options",
")",
"{",
"starlark",
"options",
"put",
"all",
"(",
"options",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"get",
"the",
"address",
"of",
"the",
"codeunit",
"that",
"is",
"making",
"the",
"reference"
]
| [
"public",
"address",
"get",
"from",
"address",
"(",
")",
"{",
"return",
"from",
"addr",
";",
"}"
]
|
[
"get",
"job",
"status",
"for",
"all",
"jobs",
"in",
"the",
"cluster"
]
| [
"public",
"job",
"status",
"[",
"]",
"get",
"all",
"job",
"statuses",
"(",
")",
"throws",
"i",
"o",
"exception",
",",
"interrupted",
"exception",
"{",
"return",
"client",
"get",
"all",
"jobs",
"(",
")",
";",
"}"
]
|
[
"guaranteed",
"to",
"throw",
"an",
"exception",
"and",
"leave",
"the",
"set",
"unmodified"
]
| [
"public",
"final",
"e",
"poll",
"first",
"(",
")",
"{",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
")",
";",
"}"
]
|
[
"block",
"recovery",
"02",
"9",
"one",
"replica",
"is",
"finalized",
"and",
"another",
"is",
"rbw"
]
| [
"public",
"void",
"test",
"finalized",
"rbw",
"replicas",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"log",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"log",
"debug",
"(",
"\"",
"running",
"\"",
"+",
"generic",
"test",
"utils",
"get",
"method",
"name",
"(",
")",
")",
";",
"}",
"/",
"/",
"rbw",
"and",
"finalized",
"replicas",
"have",
"the",
"same",
"length",
"replica",
"recovery",
"info",
"replica",
"1",
"=",
"new",
"replica",
"recovery",
"info",
"(",
"block",
"id",
",",
"replica",
"len1",
",",
"gen",
"stamp",
"-",
"1",
",",
"replica",
"state",
"finalized",
")",
";",
"replica",
"recovery",
"info",
"replica",
"2",
"=",
"new",
"replica",
"recovery",
"info",
"(",
"block",
"id",
",",
"replica",
"len1",
",",
"gen",
"stamp",
"-",
"2",
",",
"replica",
"state",
"rbw",
")",
";",
"inter",
"datanode",
"protocol",
"dn",
"1",
"=",
"mock",
"(",
"inter",
"datanode",
"protocol",
"class",
")",
";",
"inter",
"datanode",
"protocol",
"dn",
"2",
"=",
"mock",
"(",
"inter",
"datanode",
"protocol",
"class",
")",
";",
"test",
"sync",
"replicas",
"(",
"replica",
"1",
",",
"replica",
"2",
",",
"dn",
"1",
",",
"dn",
"2",
",",
"replica",
"len1",
")",
";",
"verify",
"(",
"dn",
"1",
")",
"update",
"replica",
"under",
"recovery",
"(",
"block",
",",
"recovery",
"id",
",",
"block",
"id",
",",
"replica",
"len1",
")",
";",
"verify",
"(",
"dn",
"2",
")",
"update",
"replica",
"under",
"recovery",
"(",
"block",
",",
"recovery",
"id",
",",
"block",
"id",
",",
"replica",
"len1",
")",
";",
"/",
"/",
"rbw",
"replica",
"has",
"a",
"different",
"length",
"from",
"the",
"finalized",
"one",
"replica",
"1",
"=",
"new",
"replica",
"recovery",
"info",
"(",
"block",
"id",
",",
"replica",
"len1",
",",
"gen",
"stamp",
"-",
"1",
",",
"replica",
"state",
"finalized",
")",
";",
"replica",
"2",
"=",
"new",
"replica",
"recovery",
"info",
"(",
"block",
"id",
",",
"replica",
"len2",
",",
"gen",
"stamp",
"-",
"2",
",",
"replica",
"state",
"rbw",
")",
";",
"dn",
"1",
"=",
"mock",
"(",
"inter",
"datanode",
"protocol",
"class",
")",
";",
"dn",
"2",
"=",
"mock",
"(",
"inter",
"datanode",
"protocol",
"class",
")",
";",
"test",
"sync",
"replicas",
"(",
"replica",
"1",
",",
"replica",
"2",
",",
"dn",
"1",
",",
"dn",
"2",
",",
"replica",
"len1",
")",
";",
"verify",
"(",
"dn",
"1",
")",
"update",
"replica",
"under",
"recovery",
"(",
"block",
",",
"recovery",
"id",
",",
"block",
"id",
",",
"replica",
"len1",
")",
";",
"verify",
"(",
"dn",
"2",
",",
"never",
"(",
")",
")",
"update",
"replica",
"under",
"recovery",
"(",
"block",
",",
"recovery",
"id",
",",
"block",
"id",
",",
"replica",
"len1",
")",
";",
"}"
]
|
[
"requests",
"a",
"slot",
"with",
"the",
"respective",
"resource",
"profile"
]
| [
"public",
"boolean",
"register",
"slot",
"request",
"(",
"slot",
"request",
"slot",
"request",
")",
"throws",
"resource",
"manager",
"exception",
"{",
"check",
"init",
"(",
")",
";",
"if",
"(",
"check",
"duplicate",
"request",
"(",
"slot",
"request",
"get",
"allocation",
"id",
"(",
")",
")",
")",
"{",
"log",
"debug",
"(",
"\"",
"ignoring",
"a",
"duplicate",
"slot",
"request",
"with",
"allocation",
"id",
"{",
"}",
"\"",
",",
"slot",
"request",
"get",
"allocation",
"id",
"(",
")",
")",
";",
"return",
"false",
";",
"}",
"else",
"{",
"pending",
"slot",
"request",
"pending",
"slot",
"request",
"=",
"new",
"pending",
"slot",
"request",
"(",
"slot",
"request",
")",
";",
"pending",
"slot",
"requests",
"put",
"(",
"slot",
"request",
"get",
"allocation",
"id",
"(",
")",
",",
"pending",
"slot",
"request",
")",
";",
"try",
"{",
"internal",
"request",
"slot",
"(",
"pending",
"slot",
"request",
")",
";",
"}",
"catch",
"(",
"resource",
"manager",
"exception",
"e",
")",
"{",
"/",
"/",
"requesting",
"the",
"slot",
"failed",
"-",
"-",
">",
"remove",
"pending",
"slot",
"request",
"pending",
"slot",
"requests",
"remove",
"(",
"slot",
"request",
"get",
"allocation",
"id",
"(",
")",
")",
";",
"throw",
"new",
"resource",
"manager",
"exception",
"(",
"\"",
"could",
"not",
"fulfill",
"slot",
"request",
"\"",
"+",
"slot",
"request",
"get",
"allocation",
"id",
"(",
")",
"+",
"'",
"'",
",",
"e",
")",
";",
"}",
"return",
"true",
";",
"}",
"}"
]
|
[
"get",
"integer",
"item"
]
| [
"public",
"integer",
"get",
"integer",
"item",
"(",
")",
"{",
"return",
"integer",
"item",
";",
"}"
]
|
[
"makes",
"the",
"given",
"visitor",
"visit",
"the",
"jvms",
"class",
"file",
"structure",
"passed",
"to",
"the",
"constructor",
"of",
"this",
"{",
"@",
"link",
"class",
"reader",
"}"
]
| [
"public",
"void",
"accept",
"(",
"final",
"class",
"visitor",
"class",
"visitor",
",",
"final",
"int",
"parsing",
"options",
")",
"{",
"accept",
"(",
"class",
"visitor",
",",
"new",
"attribute",
"[",
"0",
"]",
",",
"parsing",
"options",
")",
";",
"}"
]
|
[
"is",
"the",
"exception",
"an",
"instance",
"of",
"a",
"throttling",
"exception",
"that",
"is",
"an",
"amazon",
"service",
"exception",
"with",
"a",
"503",
"response",
",",
"any",
"exception",
"from",
"dynamo",
"d",
"b",
"for",
"limits",
"exceeded",
",",
"an",
"{",
"@",
"link",
"a",
"w",
"s",
"service",
"throttled",
"exception",
"}",
",",
"or",
"anything",
"which",
"the",
"aws",
"sdk",
"'",
"s",
"retry",
"utils",
"considers",
"to",
"be",
"a",
"throttling",
"exception"
]
| [
"public",
"static",
"boolean",
"is",
"throttle",
"exception",
"(",
"exception",
"ex",
")",
"{",
"return",
"ex",
"instanceof",
"a",
"w",
"s",
"service",
"throttled",
"exception",
"|",
"|",
"ex",
"instanceof",
"provisioned",
"throughput",
"exceeded",
"exception",
"|",
"|",
"ex",
"instanceof",
"limit",
"exceeded",
"exception",
"|",
"|",
"(",
"ex",
"instanceof",
"amazon",
"service",
"exception",
"&",
"&",
"503",
"=",
"=",
"(",
"(",
"amazon",
"service",
"exception",
")",
"ex",
")",
"get",
"status",
"code",
"(",
")",
")",
"|",
"|",
"(",
"ex",
"instanceof",
"sdk",
"base",
"exception",
"&",
"&",
"retry",
"utils",
"is",
"throttling",
"exception",
"(",
"(",
"sdk",
"base",
"exception",
")",
"ex",
")",
")",
";",
"}"
]
|
[
"wraps",
"a",
"{",
"@",
"link",
"input",
"stream",
"}",
",",
"limiting",
"the",
"number",
"of",
"bytes",
"which",
"can",
"be",
"read"
]
| [
"public",
"static",
"input",
"stream",
"limit",
"(",
"input",
"stream",
"in",
",",
"long",
"limit",
")",
"{",
"return",
"new",
"limited",
"input",
"stream",
"(",
"in",
",",
"limit",
")",
";",
"}"
]
|
[
"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",
"\"",
")",
";",
"}"
]
|
[
"compute",
"the",
"crc32c",
"(",
"castagnoli",
")",
"of",
"the",
"segment",
"of",
"the",
"byte",
"array",
"given",
"by",
"the",
"specified",
"size",
"and",
"offset"
]
| [
"public",
"static",
"long",
"compute",
"(",
"byte",
"[",
"]",
"bytes",
",",
"int",
"offset",
",",
"int",
"size",
")",
"{",
"checksum",
"crc",
"=",
"create",
"(",
")",
";",
"crc",
"update",
"(",
"bytes",
",",
"offset",
",",
"size",
")",
";",
"return",
"crc",
"get",
"value",
"(",
")",
";",
"}"
]
|
[
"tests",
"the",
"annotated",
"element",
"is",
"annotated",
"the",
"specified",
"annotation",
"or",
"not"
]
| [
"static",
"boolean",
"is",
"annotation",
"present",
"(",
"class",
"<",
"?",
">",
"type",
",",
"class",
"<",
"?",
"extends",
"annotation",
">",
"annotation",
"type",
")",
"{",
"return",
"is",
"annotation",
"present",
"(",
"type",
",",
"true",
",",
"annotation",
"type",
")",
";",
"}"
]
|
[
"test",
"the",
"property",
"'",
"namespace",
"number",
"'"
]
| [
"public",
"void",
"namespace",
"number",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"namespace",
"number",
"}"
]
|
[
"validates",
"the",
"fields",
"on",
"the",
"page",
"and",
"updates",
"the",
"page",
"'",
"s",
"status",
"should",
"be",
"called",
"every",
"time",
"a",
"field",
"on",
"the",
"page",
"changes"
]
| [
"private",
"void",
"validate",
"(",
")",
"{",
"string",
"message",
"=",
"null",
";",
"string",
"project",
"name",
"=",
"project",
"combo",
"get",
"text",
"(",
")",
";",
"if",
"(",
"project",
"name",
"is",
"empty",
"(",
")",
")",
"{",
"message",
"=",
"\"",
"project",
"name",
"must",
"be",
"specified",
"\"",
";",
"}",
"set",
"error",
"message",
"(",
"message",
")",
";",
"set",
"page",
"complete",
"(",
"message",
"=",
"=",
"null",
")",
";",
"}"
]
|
[
"generate",
"a",
"unique",
"key",
"for",
"the",
"specified",
"addr",
"only",
"addresses",
"from",
"a",
"single",
"address",
"space",
"or",
"single",
"program",
"should",
"be",
"passed",
"to",
"this",
"method",
"only",
"limited",
"checking",
"is",
"not",
"performed",
"in",
"order",
"to",
"improve",
"performance"
]
| [
"public",
"synchronized",
"long",
"get",
"key",
"(",
"address",
"addr",
")",
"{",
"return",
"map",
"id",
"bits",
"|",
"(",
"(",
"long",
")",
"get",
"base",
"address",
"index",
"(",
"addr",
")",
"<",
"<",
"addr",
"offset",
"size",
")",
"|",
"(",
"addr",
"get",
"offset",
"(",
")",
"&",
"addr",
"offset",
"mask",
")",
";",
"}"
]
|
[
"set",
"'",
"numpass",
"'",
"field",
"value",
"within",
"emulation",
"memory",
"state"
]
| [
"void",
"set",
"number",
"passed",
"(",
"emulator",
"test",
"runner",
"emu",
"test",
"runner",
",",
"int",
"value",
")",
"{",
"address",
"addr",
"=",
"get",
"mirrored",
"data",
"address",
"(",
"emu",
"test",
"runner",
",",
"info",
"struct",
"addr",
"add",
"(",
"num",
"pass",
"offset",
")",
")",
";",
"emu",
"write",
"(",
"emu",
"test",
"runner",
"get",
"emulator",
"helper",
"(",
")",
",",
"addr",
",",
"sizeof",
"u4",
",",
"value",
")",
";",
"}"
]
|
[
"get",
"enum",
"integer"
]
| [
"public",
"enum",
"integer",
"enum",
"get",
"enum",
"integer",
"(",
")",
"{",
"return",
"enum",
"integer",
";",
"}"
]
|
[
"write",
"out",
"attributes",
"for",
"the",
"base",
"xml",
"tag"
]
| [
"protected",
"void",
"save",
"x",
"m",
"l",
"header",
"(",
"string",
"builder",
"buf",
")",
"{",
"if",
"(",
"(",
"id",
">",
">",
"56",
")",
"!",
"=",
"(",
"id",
"base",
">",
">",
"56",
")",
")",
"{",
"/",
"/",
"don",
"'",
"t",
"send",
"down",
"internal",
"ids",
"spec",
"xml",
"utils",
"encode",
"unsigned",
"integer",
"attribute",
"(",
"buf",
",",
"\"",
"id",
"\"",
",",
"id",
")",
";",
"}",
"spec",
"xml",
"utils",
"xml",
"escape",
"attribute",
"(",
"buf",
",",
"\"",
"name",
"\"",
",",
"name",
")",
";",
"spec",
"xml",
"utils",
"encode",
"boolean",
"attribute",
"(",
"buf",
",",
"\"",
"typelock",
"\"",
",",
"typelock",
")",
";",
"spec",
"xml",
"utils",
"encode",
"boolean",
"attribute",
"(",
"buf",
",",
"\"",
"namelock",
"\"",
",",
"namelock",
")",
";",
"spec",
"xml",
"utils",
"encode",
"boolean",
"attribute",
"(",
"buf",
",",
"\"",
"readonly",
"\"",
",",
"is",
"read",
"only",
"(",
")",
")",
";",
"boolean",
"is",
"volatile",
"=",
"entry",
"list",
"[",
"0",
"]",
"is",
"volatile",
"(",
")",
";",
"if",
"(",
"is",
"volatile",
")",
"{",
"spec",
"xml",
"utils",
"encode",
"boolean",
"attribute",
"(",
"buf",
",",
"\"",
"volatile",
"\"",
",",
"true",
")",
";",
"}",
"if",
"(",
"is",
"isolated",
"(",
")",
")",
"{",
"spec",
"xml",
"utils",
"encode",
"boolean",
"attribute",
"(",
"buf",
",",
"\"",
"merge",
"\"",
",",
"false",
")",
";",
"}",
"if",
"(",
"is",
"this",
")",
"{",
"spec",
"xml",
"utils",
"encode",
"boolean",
"attribute",
"(",
"buf",
",",
"\"",
"thisptr",
"\"",
",",
"true",
")",
";",
"}",
"if",
"(",
"is",
"hidden",
")",
"{",
"spec",
"xml",
"utils",
"encode",
"boolean",
"attribute",
"(",
"buf",
",",
"\"",
"hiddenretparm",
"\"",
",",
"true",
")",
";",
"}",
"spec",
"xml",
"utils",
"encode",
"signed",
"integer",
"attribute",
"(",
"buf",
",",
"\"",
"cat",
"\"",
",",
"category",
")",
";",
"if",
"(",
"category",
"index",
">",
"=",
"0",
")",
"{",
"spec",
"xml",
"utils",
"encode",
"signed",
"integer",
"attribute",
"(",
"buf",
",",
"\"",
"index",
"\"",
",",
"category",
"index",
")",
";",
"}",
"}"
]
|
[
"close",
"the",
"split",
"fetcher",
"manager"
]
| [
"public",
"synchronized",
"void",
"close",
"(",
"long",
"timeout",
"ms",
")",
"throws",
"exception",
"{",
"closed",
"=",
"true",
";",
"fetchers",
"values",
"(",
")",
"for",
"each",
"(",
"split",
"fetcher",
":",
":",
"shutdown",
")",
";",
"executors",
"shutdown",
"(",
")",
";",
"if",
"(",
"!",
"executors",
"await",
"termination",
"(",
"timeout",
"ms",
",",
"time",
"unit",
"milliseconds",
")",
")",
"{",
"log",
"warn",
"(",
"\"",
"failed",
"to",
"close",
"the",
"source",
"reader",
"in",
"{",
"}",
"ms",
"there",
"are",
"still",
"{",
"}",
"split",
"fetchers",
"running",
"\"",
",",
"timeout",
"ms",
",",
"fetchers",
"size",
"(",
")",
")",
";",
"}",
"}"
]
|
[
"find",
"a",
"unique",
"argument",
"matching",
"the",
"given",
"type"
]
| [
"public",
"method",
"parameter",
"arg",
"(",
"resolvable",
"type",
"type",
")",
"{",
"return",
"new",
"arg",
"resolver",
"(",
")",
"arg",
"(",
"type",
")",
";",
"}"
]
|
[
"hashes",
"according",
"to",
"{",
"@",
"link",
"#",
"to",
"u",
"r",
"i",
"}",
"{",
"@",
"inherit",
"doc",
"}"
]
| [
"@",
"override",
"public",
"final",
"int",
"hash",
"code",
"(",
")",
"{",
"return",
"to",
"u",
"r",
"i",
"(",
")",
"hash",
"code",
"(",
")",
";",
"}"
]
|
[
"gets",
"the",
"number",
"of",
"milliseconds",
"that",
"a",
"opening",
"a",
"stream",
"may",
"wait",
"for",
"availability",
"in",
"the",
"connection",
"pool"
]
| [
"public",
"long",
"get",
"stream",
"open",
"timeout",
"(",
")",
"{",
"return",
"stream",
"open",
"timeout",
"nanos",
"/",
"1",
"000",
"000",
";",
"}"
]
|
[
"the",
"log",
"sync",
"(",
")",
"method",
"in",
"f",
"s",
"edit",
"log",
"is",
"unsynchronized",
"whiel",
"syncing",
"so",
"that",
"other",
"threads",
"can",
"concurrently",
"enqueue",
"edits",
"while",
"the",
"prior",
"sync",
"is",
"ongoing",
"this",
"test",
"checks",
"that",
"the",
"log",
"is",
"saved",
"correctly",
"if",
"the",
"save",
"image",
"occurs",
"while",
"the",
"syncing",
"thread",
"is",
"in",
"the",
"unsynchronized",
"middle",
"section",
"this",
"replicates",
"the",
"following",
"manual",
"test",
"proposed",
"by",
"konstantin",
":",
"i",
"start",
"the",
"name",
"-",
"node",
"in",
"debugger",
"i",
"do",
"-",
"mkdir",
"and",
"stop",
"the",
"debugger",
"in",
"log",
"sync",
"(",
")",
"just",
"before",
"it",
"does",
"flush",
"then",
"i",
"enter",
"safe",
"mode",
"with",
"another",
"client",
"i",
"start",
"save",
"namepsace",
"and",
"stop",
"the",
"debugger",
"in",
"f",
"s",
"image",
"save",
"f",
"s",
"image",
"(",
")",
"-",
">",
"f",
"s",
"edit",
"log",
"create",
"edit",
"log",
"file",
"(",
")",
"-",
">",
"edit",
"log",
"file",
"output",
"stream",
"create",
"(",
")",
"-",
">",
"after",
"truncating",
"the",
"file",
"but",
"before",
"writing",
"layout",
"version",
"into",
"it",
"then",
"i",
"let",
"log",
"sync",
"(",
")",
"run",
"then",
"i",
"terminate",
"the",
"name",
"-",
"node",
"after",
"that",
"the",
"name",
"-",
"node",
"wont",
"start",
",",
"since",
"the",
"edits",
"file",
"is",
"broken"
]
| [
"public",
"void",
"test",
"save",
"image",
"while",
"sync",
"in",
"progress",
"(",
")",
"throws",
"exception",
"{",
"configuration",
"conf",
"=",
"get",
"conf",
"(",
")",
";",
"name",
"node",
"init",
"metrics",
"(",
"conf",
",",
"namenode",
"role",
"namenode",
")",
";",
"d",
"f",
"s",
"test",
"util",
"format",
"name",
"node",
"(",
"conf",
")",
";",
"final",
"f",
"s",
"namesystem",
"namesystem",
"=",
"f",
"s",
"namesystem",
"load",
"from",
"disk",
"(",
"conf",
")",
";",
"try",
"{",
"f",
"s",
"image",
"fsimage",
"=",
"namesystem",
"get",
"f",
"s",
"image",
"(",
")",
";",
"f",
"s",
"edit",
"log",
"edit",
"log",
"=",
"fsimage",
"get",
"edit",
"log",
"(",
")",
";",
"journal",
"and",
"stream",
"jas",
"=",
"edit",
"log",
"get",
"journals",
"(",
")",
"get",
"(",
"0",
")",
";",
"edit",
"log",
"file",
"output",
"stream",
"spy",
"elos",
"=",
"spy",
"(",
"(",
"edit",
"log",
"file",
"output",
"stream",
")",
"jas",
"get",
"current",
"stream",
"(",
")",
")",
";",
"jas",
"set",
"current",
"stream",
"for",
"tests",
"(",
"spy",
"elos",
")",
";",
"final",
"atomic",
"reference",
"<",
"throwable",
">",
"deferred",
"exception",
"=",
"new",
"atomic",
"reference",
"<",
"throwable",
">",
"(",
")",
";",
"final",
"count",
"down",
"latch",
"wait",
"to",
"enter",
"flush",
"=",
"new",
"count",
"down",
"latch",
"(",
"1",
")",
";",
"final",
"thread",
"do",
"an",
"edit",
"thread",
"=",
"new",
"thread",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"run",
"(",
")",
"{",
"try",
"{",
"log",
"info",
"(",
"\"",
"starting",
"mkdirs",
"\"",
")",
";",
"namesystem",
"mkdirs",
"(",
"\"",
"/",
"test",
"\"",
",",
"new",
"permission",
"status",
"(",
"\"",
"test",
"\"",
",",
"\"",
"test",
"\"",
",",
"new",
"fs",
"permission",
"(",
"(",
"short",
")",
"00755",
")",
")",
",",
"true",
")",
";",
"log",
"info",
"(",
"\"",
"mkdirs",
"complete",
"\"",
")",
";",
"}",
"catch",
"(",
"throwable",
"ioe",
")",
"{",
"log",
"error",
"(",
"\"",
"got",
"exception",
"\"",
",",
"ioe",
")",
";",
"deferred",
"exception",
"set",
"(",
"ioe",
")",
";",
"wait",
"to",
"enter",
"flush",
"count",
"down",
"(",
")",
";",
"}",
"}",
"}",
";",
"answer",
"<",
"void",
">",
"blocking",
"flush",
"=",
"new",
"answer",
"<",
"void",
">",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"answer",
"(",
"invocation",
"on",
"mock",
"invocation",
")",
"throws",
"throwable",
"{",
"log",
"info",
"(",
"\"",
"flush",
"called",
"\"",
")",
";",
"if",
"(",
"use",
"async",
"edit",
"log",
"|",
"|",
"thread",
"current",
"thread",
"(",
")",
"=",
"=",
"do",
"an",
"edit",
"thread",
")",
"{",
"log",
"info",
"(",
"\"",
"edit",
"thread",
":",
"telling",
"main",
"thread",
"we",
"made",
"it",
"to",
"flush",
"section",
"\"",
")",
";",
"/",
"/",
"signal",
"to",
"main",
"thread",
"that",
"the",
"edit",
"thread",
"is",
"in",
"the",
"racy",
"section",
"wait",
"to",
"enter",
"flush",
"count",
"down",
"(",
")",
";",
"log",
"info",
"(",
"\"",
"edit",
"thread",
":",
"sleeping",
"for",
"\"",
"+",
"block",
"time",
"+",
"\"",
"secs",
"\"",
")",
";",
"thread",
"sleep",
"(",
"block",
"time",
"*",
"1000",
")",
";",
"log",
"info",
"(",
"\"",
"going",
"through",
"to",
"flush",
"this",
"will",
"allow",
"the",
"main",
"thread",
"to",
"continue",
"\"",
")",
";",
"}",
"invocation",
"call",
"real",
"method",
"(",
")",
";",
"log",
"info",
"(",
"\"",
"flush",
"complete",
"\"",
")",
";",
"return",
"null",
";",
"}",
"}",
";",
"do",
"answer",
"(",
"blocking",
"flush",
")",
"when",
"(",
"spy",
"elos",
")",
"flush",
"(",
")",
";",
"do",
"an",
"edit",
"thread",
"start",
"(",
")",
";",
"/",
"/",
"wait",
"for",
"the",
"edit",
"thread",
"to",
"get",
"to",
"the",
"logsync",
"unsynchronized",
"section",
"log",
"info",
"(",
"\"",
"main",
"thread",
":",
"waiting",
"to",
"enter",
"flush",
"\"",
")",
";",
"wait",
"to",
"enter",
"flush",
"await",
"(",
")",
";",
"assert",
"null",
"(",
"deferred",
"exception",
"get",
"(",
")",
")",
";",
"log",
"info",
"(",
"\"",
"main",
"thread",
":",
"detected",
"that",
"log",
"sync",
"is",
"in",
"unsynchronized",
"section",
"\"",
")",
";",
"log",
"info",
"(",
"\"",
"trying",
"to",
"enter",
"safe",
"mode",
"\"",
")",
";",
"log",
"info",
"(",
"\"",
"this",
"should",
"block",
"for",
"\"",
"+",
"block",
"time",
"+",
"\"",
"sec",
",",
"since",
"flush",
"will",
"sleep",
"that",
"long",
"\"",
")",
";",
"long",
"st",
"=",
"time",
"now",
"(",
")",
";",
"namesystem",
"set",
"safe",
"mode",
"(",
"safe",
"mode",
"action",
"safemode",
"enter",
")",
";",
"long",
"et",
"=",
"time",
"now",
"(",
")",
";",
"log",
"info",
"(",
"\"",
"entered",
"safe",
"mode",
"\"",
")",
";",
"/",
"/",
"make",
"sure",
"we",
"really",
"waited",
"for",
"the",
"flush",
"to",
"complete",
"!",
"assert",
"true",
"(",
"et",
"-",
"st",
">",
"(",
"block",
"time",
"-",
"1",
")",
"*",
"1000",
")",
";",
"/",
"/",
"once",
"we",
"'",
"re",
"in",
"safe",
"mode",
",",
"save",
"namespace",
"namesystem",
"save",
"namespace",
"(",
"0",
",",
"0",
")",
";",
"log",
"info",
"(",
"\"",
"joining",
"on",
"edit",
"thread",
"\"",
")",
";",
"do",
"an",
"edit",
"thread",
"join",
"(",
")",
";",
"assert",
"null",
"(",
"deferred",
"exception",
"get",
"(",
")",
")",
";",
"/",
"/",
"we",
"did",
"3",
"edits",
":",
"begin",
",",
"txn",
",",
"and",
"end",
"assert",
"equals",
"(",
"3",
",",
"verify",
"edit",
"logs",
"(",
"namesystem",
",",
"fsimage",
",",
"n",
"n",
"storage",
"get",
"finalized",
"edits",
"file",
"name",
"(",
"1",
",",
"3",
")",
",",
"1",
")",
")",
";",
"/",
"/",
"after",
"the",
"save",
",",
"just",
"the",
"one",
"\"",
"begin",
"\"",
"assert",
"equals",
"(",
"1",
",",
"verify",
"edit",
"logs",
"(",
"namesystem",
",",
"fsimage",
",",
"n",
"n",
"storage",
"get",
"in",
"progress",
"edits",
"file",
"name",
"(",
"4",
")",
",",
"4",
")",
")",
";",
"}",
"finally",
"{",
"log",
"info",
"(",
"\"",
"closing",
"nn",
"\"",
")",
";",
"if",
"(",
"namesystem",
"!",
"=",
"null",
")",
"namesystem",
"close",
"(",
")",
";",
"}",
"}"
]
|
[
"you",
"can",
"call",
"this",
"for",
"non",
"-",
"groups",
"and",
"not",
"have",
"to",
"handle",
"any",
"network",
"errors"
]
| [
"public",
"static",
"void",
"block",
"non",
"group",
"(",
"@",
"non",
"null",
"context",
"context",
",",
"@",
"non",
"null",
"recipient",
"recipient",
")",
"{",
"if",
"(",
"recipient",
"is",
"group",
"(",
")",
")",
"{",
"throw",
"new",
"assertion",
"error",
"(",
")",
";",
"}",
"try",
"{",
"block",
"(",
"context",
",",
"recipient",
")",
";",
"}",
"catch",
"(",
"group",
"change",
"exception",
"|",
"i",
"o",
"exception",
"e",
")",
"{",
"throw",
"new",
"assertion",
"error",
"(",
"e",
")",
";",
"}",
"}"
]
|
[
"returns",
"a",
"reference",
"to",
"the",
"type",
"of",
"a",
"formal",
"parameter",
"of",
"a",
"method"
]
| [
"public",
"static",
"type",
"reference",
"new",
"formal",
"parameter",
"reference",
"(",
"final",
"int",
"param",
"index",
")",
"{",
"return",
"new",
"type",
"reference",
"(",
"(",
"method",
"formal",
"parameter",
"<",
"<",
"24",
")",
"|",
"(",
"param",
"index",
"<",
"<",
"16",
")",
")",
";",
"}"
]
|
[
"creates",
"list",
"of",
"users",
"with",
"given",
"input",
"array"
]
| [
"public",
"void",
"create",
"users",
"with",
"list",
"input",
"(",
"@",
"valid",
"list",
"<",
"user",
">",
"body",
")",
";"
]
|
[
"test",
"the",
"property",
"'",
"namespace",
"array",
"'"
]
| [
"public",
"void",
"namespace",
"array",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"namespace",
"array",
"}"
]
|
[
"is",
"timeout",
"boolean"
]
| [
"public",
"boolean",
"is",
"timeout",
"(",
")",
"{",
"return",
"(",
"system",
"current",
"time",
"millis",
"(",
")",
"-",
"begin",
"time",
")",
">",
"timeout",
";",
"}"
]
|
[
"called",
"after",
"the",
"indexing",
"operation",
"occurred",
"note",
"that",
"this",
"is",
"also",
"called",
"when",
"indexing",
"a",
"document",
"did",
"not",
"succeed",
"due",
"to",
"document",
"related",
"failures",
"see",
"{",
"@",
"link",
"#",
"post",
"index",
"(",
"shard",
"id",
",",
"engine",
"index",
",",
"exception",
")",
"}",
"for",
"engine",
"level",
"failures"
]
| [
"default",
"void",
"post",
"index",
"(",
"shard",
"id",
"shard",
"id",
",",
"engine",
"index",
"index",
",",
"engine",
"index",
"result",
"result",
")",
"{",
"}"
]
|
[
"sets",
"the",
"color",
"components",
"using",
"the",
"specified",
"integer",
"value",
"in",
"the",
"format",
"rgba4444",
"this",
"is",
"inverse",
"to",
"the",
"rgba",
"4",
"4",
"4",
"4",
"(",
"r",
",",
"g",
",",
"b",
",",
"a",
")",
"method"
]
| [
"public",
"static",
"void",
"rgba",
"4",
"4",
"4",
"4",
"to",
"color",
"(",
"color",
"color",
",",
"int",
"value",
")",
"{",
"color",
"r",
"=",
"(",
"(",
"value",
"&",
"0x",
"0",
"0",
"0",
"0f",
"0",
"0",
"0",
")",
">",
">",
">",
"12",
")",
"/",
"1",
"5f",
";",
"color",
"g",
"=",
"(",
"(",
"value",
"&",
"0x",
"0",
"0",
"0",
"0",
"0f",
"0",
"0",
")",
">",
">",
">",
"8",
")",
"/",
"1",
"5f",
";",
"color",
"b",
"=",
"(",
"(",
"value",
"&",
"0x",
"0",
"0",
"0",
"0",
"0",
"0f",
"0",
")",
">",
">",
">",
"4",
")",
"/",
"1",
"5f",
";",
"color",
"a",
"=",
"(",
"(",
"value",
"&",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"0f",
")",
")",
"/",
"1",
"5f",
";",
"}"
]
|
[
"returns",
"whether",
"the",
"given",
"instruction",
"may",
"throw",
"exceptions"
]
| [
"public",
"boolean",
"may",
"throw",
"exceptions",
"(",
"clazz",
"clazz",
",",
"method",
"method",
",",
"code",
"attribute",
"code",
"attribute",
",",
"int",
"offset",
",",
"instruction",
"instruction",
")",
"{",
"return",
"instruction",
"may",
"throw",
"exceptions",
"(",
")",
";",
"/",
"/",
"may",
"throw",
"exceptions",
"=",
"false",
";",
"/",
"/",
"/",
"/",
"instruction",
"accept",
"(",
"clazz",
",",
"method",
",",
"code",
"attribute",
",",
"offset",
",",
"this",
")",
";",
"/",
"/",
"/",
"/",
"return",
"may",
"throw",
"exceptions",
";",
"}"
]
|
[
"finalize",
"the",
"upgrade",
"if",
"not",
"already",
"finalized"
]
| [
"public",
"void",
"finalize",
"(",
"long",
"finalize",
"time",
")",
"{",
"if",
"(",
"finalize",
"time",
"!",
"=",
"0",
")",
"{",
"this",
"finalize",
"time",
"=",
"finalize",
"time",
";",
"created",
"rollback",
"images",
"=",
"false",
";",
"}",
"}"
]
|
[
"test",
"for",
"flink",
"-",
"2135"
]
| [
"public",
"void",
"test",
"faulty",
"cast",
"(",
")",
"throws",
"exception",
"{",
"execution",
"environment",
"ee",
"=",
"execution",
"environment",
"get",
"execution",
"environment",
"(",
")",
";",
"data",
"set",
"<",
"string",
">",
"b",
"=",
"ee",
"from",
"elements",
"(",
"\"",
"a",
"\"",
",",
"\"",
"b",
"\"",
")",
";",
"group",
"reduce",
"operator",
"<",
"string",
",",
"string",
">",
"a",
"=",
"b",
"group",
"by",
"(",
"new",
"key",
"selector",
"<",
"string",
",",
"long",
">",
"(",
")",
"{",
"@",
"override",
"public",
"long",
"get",
"key",
"(",
"string",
"value",
")",
"throws",
"exception",
"{",
"return",
"1l",
";",
"}",
"}",
")",
"sort",
"group",
"(",
"new",
"key",
"selector",
"<",
"string",
",",
"double",
">",
"(",
")",
"{",
"@",
"override",
"public",
"double",
"get",
"key",
"(",
"string",
"value",
")",
"throws",
"exception",
"{",
"return",
"1",
"0",
";",
"}",
"}",
",",
"order",
"descending",
")",
"first",
"(",
"1",
")",
";",
"list",
"<",
"string",
">",
"result",
"=",
"b",
"collect",
"(",
")",
";",
"string",
"expected",
"=",
"\"",
"a",
"\\",
"nb",
"\"",
";",
"compare",
"result",
"as",
"text",
"(",
"result",
",",
"expected",
")",
";",
"}"
]
|
[
"builds",
"the",
"action",
"as",
"configured"
]
| [
"public",
"void",
"build",
"(",
")",
"throws",
"interrupted",
"exception",
"{",
"immutable",
"list",
"<",
"artifact",
">",
"classpath",
"resources",
"=",
"attributes",
"get",
"class",
"path",
"resources",
"(",
")",
";",
"set",
"<",
"string",
">",
"class",
"path",
"resource",
"names",
"=",
"new",
"hash",
"set",
"<",
">",
"(",
")",
";",
"for",
"(",
"artifact",
"artifact",
":",
"classpath",
"resources",
")",
"{",
"string",
"name",
"=",
"artifact",
"get",
"exec",
"path",
"(",
")",
"get",
"base",
"name",
"(",
")",
";",
"if",
"(",
"!",
"class",
"path",
"resource",
"names",
"add",
"(",
"name",
")",
")",
"{",
"rule",
"context",
"attribute",
"error",
"(",
"\"",
"classpath",
"resources",
"\"",
",",
"\"",
"entries",
"must",
"have",
"different",
"file",
"names",
"(",
"duplicate",
":",
"\"",
"+",
"name",
"+",
"\"",
")",
"\"",
")",
";",
"return",
";",
"}",
"}",
"nested",
"set",
"<",
"artifact",
">",
"runtime",
"jars",
"=",
"runtime",
"jars",
"builder",
"build",
"(",
")",
";",
"nested",
"set",
"<",
"artifact",
">",
"runtime",
"classpath",
"for",
"archive",
"=",
"attributes",
"get",
"runtime",
"class",
"path",
"for",
"archive",
"(",
")",
";",
"/",
"/",
"todo",
"(",
"kmb",
")",
":",
"consider",
"not",
"using",
"get",
"archive",
"inputs",
",",
"specifically",
"because",
"we",
"don",
"'",
"t",
"want",
"/",
"need",
"to",
"/",
"/",
"transform",
"anything",
"but",
"the",
"runtime",
"classpath",
"and",
"b",
"/",
"c",
"we",
"currently",
"do",
"it",
"twice",
"here",
"and",
"below",
"nested",
"set",
"builder",
"<",
"artifact",
">",
"inputs",
"=",
"nested",
"set",
"builder",
"stable",
"order",
"(",
")",
";",
"inputs",
"add",
"transitive",
"(",
"get",
"archive",
"inputs",
"(",
"attributes",
",",
"runtime",
"classpath",
"for",
"archive",
",",
"derived",
"jars",
")",
")",
";",
"if",
"(",
"derived",
"jars",
"!",
"=",
"null",
")",
"{",
"inputs",
"add",
"all",
"(",
"iterables",
"transform",
"(",
"runtime",
"jars",
"to",
"list",
"(",
")",
",",
"derived",
"jars",
")",
")",
";",
"}",
"else",
"{",
"inputs",
"add",
"transitive",
"(",
"runtime",
"jars",
")",
";",
"}",
"if",
"(",
"runfiles",
"middleman",
"!",
"=",
"null",
")",
"{",
"inputs",
"add",
"(",
"runfiles",
"middleman",
")",
";",
"}",
"immutable",
"list",
"<",
"artifact",
">",
"build",
"info",
"artifacts",
"=",
"rule",
"context",
"get",
"build",
"info",
"(",
"java",
"build",
"info",
"factory",
"key",
")",
";",
"inputs",
"add",
"all",
"(",
"build",
"info",
"artifacts",
")",
";",
"nested",
"set",
"builder",
"<",
"artifact",
">",
"runtime",
"classpath",
"=",
"nested",
"set",
"builder",
"stable",
"order",
"(",
")",
";",
"if",
"(",
"derived",
"jars",
"!",
"=",
"null",
")",
"{",
"runtime",
"classpath",
"add",
"all",
"(",
"iterables",
"transform",
"(",
"runtime",
"jars",
"to",
"list",
"(",
")",
",",
"derived",
"jars",
")",
")",
";",
"runtime",
"classpath",
"add",
"all",
"(",
"iterables",
"transform",
"(",
"runtime",
"classpath",
"for",
"archive",
"to",
"list",
"(",
")",
",",
"derived",
"jars",
")",
")",
";",
"}",
"else",
"{",
"runtime",
"classpath",
"add",
"transitive",
"(",
"runtime",
"jars",
")",
";",
"runtime",
"classpath",
"add",
"transitive",
"(",
"runtime",
"classpath",
"for",
"archive",
")",
";",
"}",
"if",
"(",
"launcher",
"!",
"=",
"null",
")",
"{",
"inputs",
"add",
"(",
"launcher",
")",
";",
"}",
"if",
"(",
"one",
"version",
"enforcement",
"level",
"!",
"=",
"one",
"version",
"enforcement",
"level",
"off",
")",
"{",
"if",
"(",
"one",
"version",
"allowlist",
"artifact",
"=",
"=",
"null",
")",
"{",
"one",
"version",
"check",
"action",
"builder",
"add",
"rule",
"error",
"for",
"missing",
"artifacts",
"(",
"rule",
"context",
",",
"java",
"toolchain",
"provider",
"from",
"(",
"rule",
"context",
")",
")",
";",
"return",
";",
"}",
"inputs",
"add",
"(",
"one",
"version",
"allowlist",
"artifact",
")",
";",
"}",
"if",
"(",
"shared",
"archive",
"!",
"=",
"null",
")",
"{",
"inputs",
"add",
"(",
"shared",
"archive",
")",
";",
"}",
"/",
"/",
"if",
"singlejar",
"'",
"s",
"name",
"ends",
"with",
"jar",
",",
"it",
"is",
"java",
"application",
",",
"otherwise",
"it",
"is",
"native",
"/",
"/",
"todo",
"(",
"asmundak",
")",
":",
"once",
"https",
":",
"/",
"/",
"github",
"com",
"/",
"bazelbuild",
"/",
"bazel",
"/",
"issues",
"/",
"2241",
"is",
"fixed",
"(",
"that",
"is",
",",
"/",
"/",
"the",
"native",
"singlejar",
"is",
"used",
"on",
"windows",
")",
"remove",
"support",
"for",
"the",
"java",
"implementation",
"artifact",
"singlejar",
"=",
"java",
"toolchain",
"provider",
"from",
"(",
"rule",
"context",
")",
"get",
"single",
"jar",
"(",
")",
";",
"boolean",
"using",
"native",
"singlejar",
"=",
"!",
"singlejar",
"get",
"filename",
"(",
")",
"ends",
"with",
"(",
"\"",
"jar",
"\"",
")",
";",
"command",
"line",
"command",
"line",
"=",
"semantics",
"build",
"single",
"jar",
"command",
"line",
"(",
"cpp",
"helper",
"get",
"toolchain",
"using",
"default",
"cc",
"toolchain",
"attribute",
"(",
"rule",
"context",
")",
"get",
"toolchain",
"identifier",
"(",
")",
",",
"output",
"jar",
",",
"java",
"start",
"class",
",",
"deploy",
"manifest",
"lines",
",",
"build",
"info",
"artifacts",
",",
"classpath",
"resources",
",",
"runtime",
"classpath",
"build",
"(",
")",
",",
"include",
"build",
"data",
",",
"compression",
",",
"launcher",
",",
"using",
"native",
"singlejar",
",",
"one",
"version",
"enforcement",
"level",
",",
"one",
"version",
"allowlist",
"artifact",
",",
"shared",
"archive",
")",
";",
"if",
"(",
"check",
"desugar",
"deps",
")",
"{",
"command",
"line",
"=",
"command",
"line",
"concat",
"(",
"command",
"line",
",",
"immutable",
"list",
"of",
"(",
"\"",
"-",
"-",
"check",
"desugar",
"deps",
"\"",
")",
")",
";",
"}",
"list",
"<",
"string",
">",
"jvm",
"args",
"=",
"immutable",
"list",
"of",
"(",
"singlejar",
"max",
"memory",
")",
";",
"if",
"(",
"!",
"using",
"native",
"singlejar",
")",
"{",
"rule",
"context",
"register",
"action",
"(",
"new",
"spawn",
"action",
"builder",
"(",
")",
"use",
"default",
"shell",
"environment",
"(",
")",
"add",
"transitive",
"inputs",
"(",
"inputs",
"build",
"(",
")",
")",
"add",
"transitive",
"inputs",
"(",
"java",
"runtime",
"info",
"for",
"host",
"(",
"rule",
"context",
")",
"java",
"base",
"inputs",
"middleman",
"(",
")",
")",
"add",
"output",
"(",
"output",
"jar",
")",
"set",
"resources",
"(",
"deploy",
"action",
"resource",
"set",
")",
"set",
"jar",
"executable",
"(",
"java",
"common",
"get",
"host",
"java",
"executable",
"(",
"rule",
"context",
")",
",",
"singlejar",
",",
"jvm",
"args",
")",
"add",
"command",
"line",
"(",
"command",
"line",
",",
"param",
"file",
"info",
"builder",
"(",
"parameter",
"file",
"type",
"shell",
"quoted",
")",
"set",
"use",
"always",
"(",
"true",
")",
"build",
"(",
")",
")",
"set",
"progress",
"message",
"(",
"\"",
"building",
"deploy",
"jar",
"%",
"s",
"\"",
",",
"output",
"jar",
"pretty",
"print",
"(",
")",
")",
"set",
"mnemonic",
"(",
"\"",
"java",
"deploy",
"jar",
"\"",
")",
"set",
"execution",
"info",
"(",
"execution",
"requirements",
"worker",
"mode",
"enabled",
")",
"build",
"(",
"rule",
"context",
")",
")",
";",
"}",
"else",
"{",
"rule",
"context",
"register",
"action",
"(",
"new",
"spawn",
"action",
"builder",
"(",
")",
"use",
"default",
"shell",
"environment",
"(",
")",
"add",
"transitive",
"inputs",
"(",
"inputs",
"build",
"(",
")",
")",
"add",
"output",
"(",
"output",
"jar",
")",
"set",
"resources",
"(",
"deploy",
"action",
"resource",
"set",
")",
"set",
"executable",
"(",
"singlejar",
")",
"add",
"command",
"line",
"(",
"command",
"line",
",",
"param",
"file",
"info",
"builder",
"(",
"parameter",
"file",
"type",
"shell",
"quoted",
")",
"set",
"use",
"always",
"(",
"true",
")",
"build",
"(",
")",
")",
"set",
"progress",
"message",
"(",
"\"",
"building",
"deploy",
"jar",
"%",
"s",
"\"",
",",
"output",
"jar",
"pretty",
"print",
"(",
")",
")",
"set",
"mnemonic",
"(",
"\"",
"java",
"deploy",
"jar",
"\"",
")",
"build",
"(",
"rule",
"context",
")",
")",
";",
"}",
"}"
]
|
[
"postgre",
"s",
"q",
"l",
"can",
"return",
"null",
"sap",
"db",
"can",
"apparently",
"return",
"empty",
"sql",
"code",
"bug",
"729170"
]
| [
"public",
"void",
"malformed",
"sql",
"state",
"codes",
"(",
")",
"{",
"s",
"q",
"l",
"exception",
"sex",
"=",
"new",
"s",
"q",
"l",
"exception",
"(",
"\"",
"message",
"\"",
",",
"null",
",",
"1",
")",
";",
"assert",
"that",
"(",
"this",
"trans",
"translate",
"(",
"\"",
"task",
"\"",
",",
"sql",
",",
"sex",
")",
")",
"is",
"null",
"(",
")",
";",
"sex",
"=",
"new",
"s",
"q",
"l",
"exception",
"(",
"\"",
"message",
"\"",
",",
"\"",
"\"",
",",
"1",
")",
";",
"assert",
"that",
"(",
"this",
"trans",
"translate",
"(",
"\"",
"task",
"\"",
",",
"sql",
",",
"sex",
")",
")",
"is",
"null",
"(",
")",
";",
"/",
"/",
"one",
"char",
"'",
"s",
"not",
"allowed",
"sex",
"=",
"new",
"s",
"q",
"l",
"exception",
"(",
"\"",
"message",
"\"",
",",
"\"",
"i",
"\"",
",",
"1",
")",
";",
"assert",
"that",
"(",
"this",
"trans",
"translate",
"(",
"\"",
"task",
"\"",
",",
"sql",
",",
"sex",
")",
")",
"is",
"null",
"(",
")",
";",
"}"
]
|
[
"returns",
"the",
"last",
"error",
"raised",
"during",
"the",
"update",
"sites",
"checking"
]
| [
"public",
"string",
"get",
"last",
"error",
"check",
"update",
"centers",
"(",
")",
"{",
"return",
"last",
"error",
"check",
"update",
"centers",
";",
"}"
]
|
[
"used",
"by",
"metrics"
]
| [
"public",
"long",
"get",
"missing",
"replication",
"one",
"blocks",
"(",
")",
"{",
"return",
"needed",
"reconstruction",
"get",
"corrupt",
"replication",
"one",
"blocks",
"(",
")",
";",
"}"
]
|
[
"called",
"when",
"a",
"position",
"discontinuity",
"occurs",
"without",
"a",
"change",
"to",
"the",
"timeline",
"a",
"position",
"discontinuity",
"occurs",
"when",
"the",
"current",
"window",
"or",
"period",
"index",
"changes",
"(",
"as",
"a",
"result",
"of",
"playback",
"transitioning",
"from",
"one",
"period",
"in",
"the",
"timeline",
"to",
"the",
"next",
")",
",",
"or",
"when",
"the",
"playback",
"position",
"jumps",
"within",
"the",
"period",
"currently",
"being",
"played",
"(",
"as",
"a",
"result",
"of",
"a",
"seek",
"being",
"performed",
",",
"or",
"when",
"the",
"source",
"introduces",
"a",
"discontinuity",
"internally",
")",
"when",
"a",
"position",
"discontinuity",
"occurs",
"as",
"a",
"result",
"of",
"a",
"change",
"to",
"the",
"timeline",
"this",
"method",
"is",
"not",
"called",
"{",
"@",
"link",
"#",
"on",
"timeline",
"changed",
"(",
"timeline",
",",
"int",
")",
"}",
"is",
"called",
"in",
"this",
"case"
]
| [
"default",
"void",
"on",
"position",
"discontinuity",
"(",
"@",
"discontinuity",
"reason",
"int",
"reason",
")",
"{",
"}"
]
|
[
"test",
"the",
"property",
"'",
"prefix",
"namespace",
"boolean",
"'"
]
| [
"public",
"void",
"prefix",
"namespace",
"boolean",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"prefix",
"namespace",
"boolean",
"}"
]
|
[
"get",
"sc",
"a",
"e",
"t",
"h",
"flow",
"points"
]
| [
"public",
"string",
"get",
"sc",
"a",
"e",
"t",
"h",
"flow",
"points",
"(",
")",
"{",
"return",
"sc",
"a",
"e",
"t",
"h",
"flow",
"points",
";",
"}"
]
|
[
"returns",
"the",
"directory",
"entries",
"for",
"this",
"directory",
",",
"in",
"a",
"stable",
"order",
"symlinks",
"are",
"not",
"expanded"
]
| [
"public",
"dirents",
"get",
"dirents",
"(",
")",
"{",
"return",
"compact",
"sorted",
"dirents",
";",
"}"
]
|
[
"this",
"implementation",
"always",
"returns",
"{",
"@",
"code",
"null",
"}",
",",
"assuming",
"that",
"this",
"resource",
"type",
"does",
"not",
"have",
"a",
"filename"
]
| [
"public",
"string",
"get",
"filename",
"(",
")",
"{",
"return",
"null",
"=",
"=",
"this",
"filename",
"?",
"this",
"get",
"description",
"(",
")",
":",
"this",
"filename",
";",
"}"
]
|
[
"get",
"int",
"6",
"4"
]
| [
"public",
"long",
"get",
"int",
"6",
"4",
"(",
")",
"{",
"return",
"int",
"6",
"4",
";",
"}"
]
|
[
"verify",
"if",
"{",
"@",
"link",
"mammoth",
"#",
"to",
"string",
"(",
")",
"}",
"gives",
"the",
"expected",
"value"
]
| [
"public",
"void",
"test",
"to",
"string",
"(",
")",
"{",
"final",
"var",
"to",
"string",
"=",
"new",
"mammoth",
"(",
")",
"to",
"string",
"(",
")",
";",
"assert",
"not",
"null",
"(",
"to",
"string",
")",
";",
"assert",
"equals",
"(",
"\"",
"the",
"mammoth",
"\"",
",",
"to",
"string",
")",
";",
"}"
]
|
[
"create",
"an",
"empty",
"dir",
"marker",
"which",
",",
"when",
"passed",
"to",
"the",
"ddb",
"metastore",
",",
"is",
"considered",
"authoritative"
]
| [
"static",
"path",
"metadata",
"authoritative",
"empty",
"directory",
"marker",
"(",
"final",
"s",
"3",
"a",
"file",
"status",
"status",
")",
"{",
"return",
"new",
"d",
"d",
"b",
"path",
"metadata",
"(",
"status",
",",
"tristate",
"true",
",",
"false",
",",
"true",
",",
"0",
")",
";",
"}"
]
|
[
"gets",
"interface",
"class",
"name"
]
| [
"public",
"string",
"get",
"interface",
"class",
"name",
"(",
")",
"{",
"return",
"interface",
"class",
"name",
";",
"}"
]
|
[
"return",
"the",
"{",
"@",
"link",
"#",
"set",
"media",
"types",
"(",
"map",
")",
"configured",
"}",
"media",
"type",
"mappings"
]
| [
"public",
"map",
"<",
"string",
",",
"media",
"type",
">",
"get",
"media",
"types",
"(",
")",
"{",
"return",
"(",
"this",
"media",
"types",
"!",
"=",
"null",
"?",
"this",
"media",
"types",
":",
"collections",
"empty",
"map",
"(",
")",
")",
";",
"}"
]
|
[
"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",
"\"",
")",
";",
"}"
]
|
[
"allow",
"change",
"into",
"input",
"buffers",
"or",
"not",
"while",
"perform",
"encodingdecoding"
]
| [
"public",
"boolean",
"allow",
"change",
"inputs",
"(",
")",
"{",
"return",
"coder",
"options",
"allow",
"change",
"inputs",
"(",
")",
";",
"}"
]
|
[
"returns",
"the",
"compression",
"factor",
"of",
"the",
"t",
"-",
"digest",
"sketches",
"used"
]
| [
"public",
"double",
"compression",
"(",
")",
"{",
"return",
"compression",
";",
"}"
]
|
[
"gets",
"transaction",
"service",
"group"
]
| [
"public",
"string",
"get",
"transaction",
"service",
"group",
"(",
")",
"{",
"return",
"transaction",
"service",
"group",
";",
"}"
]
|
[
"variant",
"of",
"{",
"@",
"link",
"#",
"join",
"(",
"publisher",
")",
"}",
"that",
"behaves",
"the",
"same",
"way",
"up",
"until",
"the",
"specified",
"max",
"number",
"of",
"bytes",
"to",
"buffer",
"once",
"the",
"limit",
"is",
"exceeded",
",",
"{",
"@",
"link",
"data",
"buffer",
"limit",
"exception",
"}",
"is",
"raised"
]
| [
"public",
"static",
"mono",
"<",
"data",
"buffer",
">",
"join",
"(",
"publisher",
"<",
"?",
"extends",
"data",
"buffer",
">",
"buffers",
",",
"int",
"max",
"byte",
"count",
")",
"{",
"assert",
"not",
"null",
"(",
"buffers",
",",
"\"",
"'",
"data",
"buffers",
"'",
"must",
"not",
"be",
"null",
"\"",
")",
";",
"if",
"(",
"buffers",
"instanceof",
"mono",
")",
"{",
"return",
"(",
"mono",
"<",
"data",
"buffer",
">",
")",
"buffers",
";",
"}",
"return",
"flux",
"from",
"(",
"buffers",
")",
"collect",
"(",
"(",
")",
"-",
">",
"new",
"limited",
"data",
"buffer",
"list",
"(",
"max",
"byte",
"count",
")",
",",
"limited",
"data",
"buffer",
"list",
":",
":",
"add",
")",
"filter",
"(",
"list",
"-",
">",
"!",
"list",
"is",
"empty",
"(",
")",
")",
"map",
"(",
"list",
"-",
">",
"list",
"get",
"(",
"0",
")",
"factory",
"(",
")",
"join",
"(",
"list",
")",
")",
"do",
"on",
"discard",
"(",
"pooled",
"data",
"buffer",
"class",
",",
"data",
"buffer",
"utils",
":",
":",
"release",
")",
";",
"}"
]
|
[
"get",
"namespace",
"string"
]
| [
"public",
"string",
"get",
"namespace",
"string",
"(",
")",
"{",
"return",
"namespace",
"string",
";",
"}"
]
|
[
"for",
"a",
"given",
"identifier",
",",
"add",
"a",
"mapping",
"to",
"the",
"nodetype",
"for",
"the",
"parse",
"tree",
"and",
"to",
"the",
"composable",
"record",
"reader",
"to",
"be",
"created",
",",
"including",
"the",
"formals",
"required",
"to",
"invoke",
"the",
"constructor",
"the",
"nodetype",
"and",
"constructor",
"signature",
"should",
"be",
"filled",
"in",
"from",
"the",
"child",
"node"
]
| [
"protected",
"static",
"void",
"add",
"identifier",
"(",
"string",
"ident",
",",
"class",
"<",
"?",
">",
"[",
"]",
"mcstr",
"sig",
",",
"class",
"<",
"?",
"extends",
"node",
">",
"nodetype",
",",
"class",
"<",
"?",
"extends",
"composable",
"record",
"reader",
">",
"cl",
")",
"throws",
"no",
"such",
"method",
"exception",
"{",
"constructor",
"<",
"?",
"extends",
"node",
">",
"ncstr",
"=",
"nodetype",
"get",
"declared",
"constructor",
"(",
"ncstr",
"sig",
")",
";",
"ncstr",
"set",
"accessible",
"(",
"true",
")",
";",
"node",
"cstr",
"map",
"put",
"(",
"ident",
",",
"ncstr",
")",
";",
"constructor",
"<",
"?",
"extends",
"composable",
"record",
"reader",
">",
"mcstr",
"=",
"cl",
"get",
"declared",
"constructor",
"(",
"mcstr",
"sig",
")",
";",
"mcstr",
"set",
"accessible",
"(",
"true",
")",
";",
"rr",
"cstr",
"map",
"put",
"(",
"ident",
",",
"mcstr",
")",
";",
"}"
]
|
[
"log",
"a",
"message",
"with",
"trace",
"log",
"level"
]
| [
"public",
"void",
"trace",
"(",
"char",
"sequence",
"message",
")",
"{",
"this",
"log",
"trace",
"(",
"message",
")",
";",
"}"
]
|
[
"create",
"a",
"new",
"{",
"@",
"link",
"mock",
"http",
"servlet",
"request",
"}",
"based",
"on",
"the",
"supplied",
"{",
"@",
"code",
"servlet",
"context",
"}",
"can",
"be",
"overridden",
"in",
"subclasses"
]
| [
"protected",
"mock",
"http",
"servlet",
"request",
"create",
"servlet",
"request",
"(",
"servlet",
"context",
"servlet",
"context",
")",
"{",
"return",
"new",
"mock",
"http",
"servlet",
"request",
"(",
"servlet",
"context",
")",
";",
"}"
]
|
[
"decodes",
"a",
"given",
"base",
"6",
"4",
"string",
"into",
"its",
"corresponding",
"byte",
"array"
]
| [
"public",
"static",
"byte",
"[",
"]",
"decode",
"as",
"byte",
"object",
"array",
"(",
"final",
"string",
"data",
")",
"{",
"int",
"byte",
"array",
"length",
"=",
"3",
"*",
"data",
"length",
"(",
")",
"/",
"4",
";",
"if",
"(",
"data",
"ends",
"with",
"(",
"\"",
"=",
"=",
"\"",
")",
")",
"{",
"byte",
"array",
"length",
"-",
"=",
"2",
";",
"}",
"else",
"if",
"(",
"data",
"ends",
"with",
"(",
"\"",
"=",
"\"",
")",
")",
"{",
"byte",
"array",
"length",
"-",
"=",
"1",
";",
"}",
"final",
"byte",
"[",
"]",
"ret",
"array",
"=",
"new",
"byte",
"[",
"byte",
"array",
"length",
"]",
";",
"int",
"byte",
"dex",
"=",
"0",
";",
"int",
"char",
"dex",
"=",
"0",
";",
"for",
"(",
";",
"char",
"dex",
"<",
"data",
"length",
"(",
")",
";",
"char",
"dex",
"+",
"=",
"4",
")",
"{",
"/",
"/",
"get",
"4",
"chars",
",",
"convert",
"to",
"3",
"bytes",
"final",
"int",
"char",
"1",
"=",
"decode",
"64",
"[",
"(",
"byte",
")",
"data",
"char",
"at",
"(",
"char",
"dex",
")",
"]",
";",
"final",
"int",
"char",
"2",
"=",
"decode",
"64",
"[",
"(",
"byte",
")",
"data",
"char",
"at",
"(",
"char",
"dex",
"+",
"1",
")",
"]",
";",
"final",
"int",
"char",
"3",
"=",
"decode",
"64",
"[",
"(",
"byte",
")",
"data",
"char",
"at",
"(",
"char",
"dex",
"+",
"2",
")",
"]",
";",
"final",
"int",
"char",
"4",
"=",
"decode",
"64",
"[",
"(",
"byte",
")",
"data",
"char",
"at",
"(",
"char",
"dex",
"+",
"3",
")",
"]",
";",
"if",
"(",
"char",
"1",
"<",
"0",
"|",
"|",
"char",
"2",
"<",
"0",
"|",
"|",
"char",
"3",
"=",
"=",
"-",
"1",
"|",
"|",
"char",
"4",
"=",
"=",
"-",
"1",
")",
"{",
"/",
"/",
"invalid",
"character",
"(",
"-",
"1",
")",
",",
"or",
"bad",
"padding",
"(",
"-",
"2",
")",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"the",
"data",
"parameter",
"is",
"not",
"a",
"valid",
"base",
"6",
"4",
"-",
"encoded",
"string",
"\"",
")",
";",
"}",
"int",
"t",
"val",
"=",
"char",
"1",
"<",
"<",
"18",
";",
"t",
"val",
"+",
"=",
"char",
"2",
"<",
"<",
"12",
";",
"t",
"val",
"+",
"=",
"(",
"char",
"3",
"&",
"0xff",
")",
"<",
"<",
"6",
";",
"t",
"val",
"+",
"=",
"char",
"4",
"&",
"0xff",
";",
"if",
"(",
"char",
"3",
"=",
"=",
"-",
"2",
")",
"{",
"/",
"/",
"two",
"\"",
"=",
"=",
"\"",
"pad",
"chars",
",",
"check",
"bits",
"12",
"-",
"24",
"t",
"val",
"&",
"=",
"0x",
"0",
"0",
"f",
"f",
"f",
"0",
"0",
"0",
";",
"ret",
"array",
"[",
"byte",
"dex",
"+",
"+",
"]",
"=",
"(",
"byte",
")",
"(",
"t",
"val",
">",
">",
"16",
"&",
"0x",
"f",
"f",
")",
";",
"}",
"else",
"if",
"(",
"char",
"4",
"=",
"=",
"-",
"2",
")",
"{",
"/",
"/",
"one",
"pad",
"char",
"\"",
"=",
"\"",
",",
"check",
"bits",
"6",
"-",
"24",
"t",
"val",
"&",
"=",
"0x",
"0",
"0",
"f",
"f",
"f",
"f",
"c",
"0",
";",
"ret",
"array",
"[",
"byte",
"dex",
"+",
"+",
"]",
"=",
"(",
"byte",
")",
"(",
"t",
"val",
">",
">",
"16",
"&",
"0x",
"f",
"f",
")",
";",
"ret",
"array",
"[",
"byte",
"dex",
"+",
"+",
"]",
"=",
"(",
"byte",
")",
"(",
"t",
"val",
">",
">",
"8",
"&",
"0x",
"f",
"f",
")",
";",
"}",
"else",
"{",
"/",
"/",
"no",
"pads",
"take",
"all",
"3",
"bytes",
",",
"bits",
"0",
"-",
"24",
"ret",
"array",
"[",
"byte",
"dex",
"+",
"+",
"]",
"=",
"(",
"byte",
")",
"(",
"t",
"val",
">",
">",
"16",
"&",
"0x",
"f",
"f",
")",
";",
"ret",
"array",
"[",
"byte",
"dex",
"+",
"+",
"]",
"=",
"(",
"byte",
")",
"(",
"t",
"val",
">",
">",
"8",
"&",
"0x",
"f",
"f",
")",
";",
"ret",
"array",
"[",
"byte",
"dex",
"+",
"+",
"]",
"=",
"(",
"byte",
")",
"(",
"t",
"val",
"&",
"0x",
"f",
"f",
")",
";",
"}",
"}",
"return",
"ret",
"array",
";",
"}"
]
|
[
"build",
"the",
"{",
"@",
"link",
"deferring",
"bucket",
"collector",
"}",
"the",
"default",
"implementation",
"replays",
"all",
"hits",
"against",
"the",
"buckets",
"selected",
"by",
"{",
"#",
"link",
"{",
"@",
"link",
"deferring",
"bucket",
"collector",
"#",
"prepare",
"selected",
"buckets",
"(",
"long",
")",
"}"
]
| [
"protected",
"deferring",
"bucket",
"collector",
"build",
"deferring",
"collector",
"(",
")",
"{",
"return",
"new",
"best",
"buckets",
"deferring",
"collector",
"(",
"top",
"level",
"query",
"(",
")",
",",
"searcher",
"(",
")",
",",
"descends",
"from",
"global",
"aggregator",
"(",
"parent",
"(",
")",
")",
")",
";",
"}"
]
|
[
"create",
"an",
"input",
"stream",
"from",
"the",
"{",
"@",
"link",
"hdfs",
"path",
"handle",
"}",
"if",
"the",
"constraints",
"encoded",
"from",
"{",
"@",
"link",
"distributed",
"file",
"system",
"#",
"create",
"path",
"handle",
"(",
"file",
"status",
",",
"options",
"handle",
"opt",
")",
"}",
"are",
"satisfied",
"note",
"that",
"hdfs",
"does",
"not",
"ensure",
"that",
"these",
"constraints",
"remain",
"invariant",
"for",
"the",
"life",
"of",
"the",
"stream",
"it",
"only",
"checks",
"that",
"they",
"still",
"held",
"when",
"the",
"stream",
"was",
"opened"
]
| [
"public",
"d",
"f",
"s",
"input",
"stream",
"open",
"(",
"hdfs",
"path",
"handle",
"fd",
",",
"int",
"buffersize",
",",
"boolean",
"verify",
"checksum",
")",
"throws",
"i",
"o",
"exception",
"{",
"check",
"open",
"(",
")",
";",
"string",
"src",
"=",
"fd",
"get",
"path",
"(",
")",
";",
"try",
"(",
"trace",
"scope",
"ignored",
"=",
"new",
"path",
"trace",
"scope",
"(",
"\"",
"new",
"d",
"f",
"s",
"input",
"stream",
"\"",
",",
"src",
")",
")",
"{",
"hdfs",
"located",
"file",
"status",
"s",
"=",
"get",
"located",
"file",
"info",
"(",
"src",
",",
"true",
")",
";",
"fd",
"verify",
"(",
"s",
")",
";",
"/",
"/",
"check",
"invariants",
"in",
"path",
"handle",
"located",
"blocks",
"located",
"blocks",
"=",
"s",
"get",
"located",
"blocks",
"(",
")",
";",
"return",
"open",
"internal",
"(",
"located",
"blocks",
",",
"src",
",",
"verify",
"checksum",
")",
";",
"}",
"}"
]
|
[
"set",
"the",
"maximum",
"nested",
"depth",
"of",
"bool",
"queries",
"default",
"value",
"is",
"20"
]
| [
"public",
"static",
"void",
"set",
"max",
"nested",
"depth",
"(",
"int",
"max",
"nested",
"depth",
")",
"{",
"if",
"(",
"max",
"nested",
"depth",
"<",
"1",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"max",
"nested",
"depth",
"must",
"be",
">",
"=",
"1",
"\"",
")",
";",
"}",
"bool",
"query",
"builder",
"max",
"nested",
"depth",
"=",
"max",
"nested",
"depth",
";",
"}"
]
|
[
"bi",
"-",
"directional",
"example",
",",
"which",
"can",
"only",
"be",
"asynchronous",
"send",
"some",
"chat",
"messages",
",",
"and",
"print",
"any",
"chat",
"messages",
"that",
"are",
"sent",
"from",
"the",
"server"
]
| [
"public",
"count",
"down",
"latch",
"route",
"chat",
"(",
")",
"{",
"info",
"(",
"\"",
"*",
"*",
"*",
"route",
"chat",
"\"",
")",
";",
"final",
"count",
"down",
"latch",
"finish",
"latch",
"=",
"new",
"count",
"down",
"latch",
"(",
"1",
")",
";",
"stream",
"observer",
"<",
"route",
"note",
">",
"request",
"observer",
"=",
"async",
"stub",
"route",
"chat",
"(",
"new",
"stream",
"observer",
"<",
"route",
"note",
">",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"on",
"next",
"(",
"route",
"note",
"note",
")",
"{",
"info",
"(",
"\"",
"got",
"message",
"\\",
"\"",
"{",
"0",
"}",
"\\",
"\"",
"at",
"{",
"1",
"}",
",",
"{",
"2",
"}",
"\"",
",",
"note",
"get",
"message",
"(",
")",
",",
"note",
"get",
"location",
"(",
")",
"get",
"latitude",
"(",
")",
",",
"note",
"get",
"location",
"(",
")",
"get",
"longitude",
"(",
")",
")",
";",
"if",
"(",
"test",
"helper",
"!",
"=",
"null",
")",
"{",
"test",
"helper",
"on",
"message",
"(",
"note",
")",
";",
"}",
"}",
"@",
"override",
"public",
"void",
"on",
"error",
"(",
"throwable",
"t",
")",
"{",
"warning",
"(",
"\"",
"route",
"chat",
"failed",
":",
"{",
"0",
"}",
"\"",
",",
"status",
"from",
"throwable",
"(",
"t",
")",
")",
";",
"if",
"(",
"test",
"helper",
"!",
"=",
"null",
")",
"{",
"test",
"helper",
"on",
"rpc",
"error",
"(",
"t",
")",
";",
"}",
"finish",
"latch",
"count",
"down",
"(",
")",
";",
"}",
"@",
"override",
"public",
"void",
"on",
"completed",
"(",
")",
"{",
"info",
"(",
"\"",
"finished",
"route",
"chat",
"\"",
")",
";",
"finish",
"latch",
"count",
"down",
"(",
")",
";",
"}",
"}",
")",
";",
"try",
"{",
"route",
"note",
"[",
"]",
"requests",
"=",
"{",
"new",
"note",
"(",
"\"",
"first",
"message",
"\"",
",",
"0",
",",
"0",
")",
",",
"new",
"note",
"(",
"\"",
"second",
"message",
"\"",
",",
"0",
",",
"10",
"000",
"000",
")",
",",
"new",
"note",
"(",
"\"",
"third",
"message",
"\"",
",",
"10",
"000",
"000",
",",
"0",
")",
",",
"new",
"note",
"(",
"\"",
"fourth",
"message",
"\"",
",",
"10",
"000",
"000",
",",
"10",
"000",
"000",
")",
"}",
";",
"for",
"(",
"route",
"note",
"request",
":",
"requests",
")",
"{",
"info",
"(",
"\"",
"sending",
"message",
"\\",
"\"",
"{",
"0",
"}",
"\\",
"\"",
"at",
"{",
"1",
"}",
",",
"{",
"2",
"}",
"\"",
",",
"request",
"get",
"message",
"(",
")",
",",
"request",
"get",
"location",
"(",
")",
"get",
"latitude",
"(",
")",
",",
"request",
"get",
"location",
"(",
")",
"get",
"longitude",
"(",
")",
")",
";",
"request",
"observer",
"on",
"next",
"(",
"request",
")",
";",
"}",
"}",
"catch",
"(",
"runtime",
"exception",
"e",
")",
"{",
"/",
"/",
"cancel",
"rpc",
"request",
"observer",
"on",
"error",
"(",
"e",
")",
";",
"throw",
"e",
";",
"}",
"/",
"/",
"mark",
"the",
"end",
"of",
"requests",
"request",
"observer",
"on",
"completed",
"(",
")",
";",
"/",
"/",
"return",
"the",
"latch",
"while",
"receiving",
"happens",
"asynchronously",
"return",
"finish",
"latch",
";",
"}"
]
|
[
"sets",
"all",
"flags",
"to",
"return",
"all",
"stats"
]
| [
"public",
"indices",
"stats",
"request",
"all",
"(",
")",
"{",
"flags",
"all",
"(",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"tests",
"that",
"we",
"can",
"write",
"more",
"than",
"64",
"values"
]
| [
"public",
"void",
"test",
"wide",
"tuple",
"boundary",
"(",
")",
"throws",
"exception",
"{",
"text",
"empty",
"text",
"=",
"new",
"text",
"(",
"\"",
"should",
"not",
"be",
"set",
"written",
"\"",
")",
";",
"writable",
"[",
"]",
"values",
"=",
"new",
"writable",
"[",
"65",
"]",
";",
"arrays",
"fill",
"(",
"values",
",",
"empty",
"text",
")",
";",
"values",
"[",
"64",
"]",
"=",
"new",
"text",
"(",
"\"",
"should",
"be",
"the",
"only",
"value",
"set",
"written",
"\"",
")",
";",
"tuple",
"writable",
"tuple",
"=",
"new",
"tuple",
"writable",
"(",
"values",
")",
";",
"tuple",
"set",
"written",
"(",
"64",
")",
";",
"for",
"(",
"int",
"pos",
"=",
"0",
";",
"pos",
"<",
"tuple",
"size",
"(",
")",
";",
"pos",
"+",
"+",
")",
"{",
"boolean",
"has",
"=",
"tuple",
"has",
"(",
"pos",
")",
";",
"if",
"(",
"pos",
"=",
"=",
"64",
")",
"{",
"assert",
"true",
"(",
"has",
")",
";",
"}",
"else",
"{",
"assert",
"false",
"(",
"\"",
"tuple",
"position",
"is",
"incorrectly",
"labelled",
"as",
"set",
":",
"\"",
"+",
"pos",
",",
"has",
")",
";",
"}",
"}",
"}"
]
|
[
"returns",
"the",
"placeholder",
"object",
"associated",
"with",
"this",
"dockable",
"component"
]
| [
"public",
"component",
"placeholder",
"get",
"component",
"windowing",
"placeholder",
"(",
")",
"{",
"return",
"placeholder",
";",
"}"
]
|
[
"gets",
"the",
"element",
"at",
"the",
"given",
"index",
"it",
"is",
"an",
"error",
"to",
"call",
"this",
"with",
"the",
"index",
"for",
"an",
"element",
"which",
"was",
"never",
"set",
";",
"if",
"you",
"do",
"that",
",",
"this",
"will",
"throw",
"{",
"@",
"code",
"null",
"pointer",
"exception",
"}"
]
| [
"public",
"basic",
"block",
"get",
"(",
"int",
"n",
")",
"{",
"return",
"(",
"basic",
"block",
")",
"get",
"0",
"(",
"n",
")",
";",
"}"
]
|
[
"compares",
"the",
"remaining",
"bytes",
"of",
"this",
"buffer",
"to",
"another",
"byte",
"buffer",
"'",
"s",
"remaining",
"bytes"
]
| [
"public",
"int",
"compare",
"to",
"(",
"byte",
"buffer",
"other",
"buffer",
")",
"{",
"int",
"compare",
"remaining",
"=",
"(",
"remaining",
"(",
")",
"<",
"other",
"buffer",
"remaining",
"(",
")",
")",
"?",
"remaining",
"(",
")",
":",
"other",
"buffer",
"remaining",
"(",
")",
";",
"int",
"this",
"pos",
"=",
"position",
";",
"int",
"other",
"pos",
"=",
"other",
"buffer",
"position",
";",
"byte",
"this",
"byte",
",",
"other",
"byte",
";",
"while",
"(",
"compare",
"remaining",
">",
"0",
")",
"{",
"this",
"byte",
"=",
"get",
"(",
"this",
"pos",
")",
";",
"other",
"byte",
"=",
"other",
"buffer",
"get",
"(",
"other",
"pos",
")",
";",
"if",
"(",
"this",
"byte",
"!",
"=",
"other",
"byte",
")",
"{",
"return",
"this",
"byte",
"<",
"other",
"byte",
"?",
"-",
"1",
":",
"1",
";",
"}",
"this",
"pos",
"+",
"+",
";",
"other",
"pos",
"+",
"+",
";",
"compare",
"remaining",
"-",
"-",
";",
"}",
"return",
"remaining",
"(",
")",
"-",
"other",
"buffer",
"remaining",
"(",
")",
";",
"}"
]
|
[
"get",
"maximum",
"allocatable",
"{",
"@",
"link",
"resource",
"}",
"at",
"the",
"cluster",
"level"
]
| [
"public",
"resource",
"get",
"maximum",
"resource",
"capability",
"(",
")",
";"
]
|
[
"get",
"enum",
"number"
]
| [
"public",
"enum",
"number",
"enum",
"get",
"enum",
"number",
"(",
")",
"{",
"return",
"enum",
"number",
";",
"}"
]
|
[
"defines",
"a",
"helper",
"method",
"for",
"performing",
"a",
"request",
"and",
"then",
"parsing",
"the",
"returned",
"entity",
"using",
"the",
"provided",
"entity",
"parser"
]
| [
"protected",
"final",
"<",
"req",
"extends",
"validatable",
",",
"resp",
">",
"resp",
"perform",
"request",
"and",
"parse",
"entity",
"(",
"req",
"request",
",",
"checked",
"function",
"<",
"req",
",",
"request",
",",
"i",
"o",
"exception",
">",
"request",
"converter",
",",
"request",
"options",
"options",
",",
"checked",
"function",
"<",
"x",
"content",
"parser",
",",
"resp",
",",
"i",
"o",
"exception",
">",
"entity",
"parser",
",",
"set",
"<",
"integer",
">",
"ignores",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"perform",
"request",
"(",
"request",
",",
"request",
"converter",
",",
"options",
",",
"response",
"-",
">",
"parse",
"entity",
"(",
"response",
"get",
"entity",
"(",
")",
",",
"entity",
"parser",
")",
",",
"ignores",
")",
";",
"}"
]
|
[
"get",
"number",
"of",
"requested",
"g",
"p",
"us",
"from",
"resource"
]
| [
"public",
"static",
"int",
"get",
"requested",
"gpus",
"(",
"resource",
"requested",
"resource",
")",
"{",
"try",
"{",
"return",
"long",
"value",
"of",
"(",
"requested",
"resource",
"get",
"resource",
"value",
"(",
"gpu",
"uri",
")",
")",
"int",
"value",
"(",
")",
";",
"}",
"catch",
"(",
"resource",
"not",
"found",
"exception",
"e",
")",
"{",
"return",
"0",
";",
"}",
"}"
]
|
[
"customize",
"response",
"specification"
]
| [
"public",
"find",
"pets",
"by",
"status",
"oper",
"resp",
"spec",
"(",
"consumer",
"<",
"response",
"spec",
"builder",
">",
"resp",
"spec",
"customizer",
")",
"{",
"resp",
"spec",
"customizer",
"accept",
"(",
"resp",
"spec",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"verifies",
"the",
"plan",
"execution",
"has",
"been",
"done"
]
| [
"public",
"void",
"verify",
"plan",
"exection",
"done",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"node",
"=",
"cluster",
"get",
"data",
"nodes",
"(",
")",
"get",
"(",
"data",
"node",
"index",
")",
";",
"assert",
"equals",
"(",
"node",
"query",
"disk",
"balancer",
"plan",
"(",
")",
"get",
"result",
"(",
")",
",",
"disk",
"balancer",
"work",
"status",
"result",
"plan",
"done",
")",
";",
"}"
]
|
[
"pop",
"up",
"the",
"edit",
"plugin",
"path",
"dialog"
]
| [
"private",
"void",
"edit",
"plugin",
"path",
"(",
")",
"{",
"if",
"(",
"plugin",
"path",
"dialog",
"=",
"=",
"null",
")",
"{",
"plugin",
"path",
"dialog",
"=",
"new",
"edit",
"plugin",
"path",
"dialog",
"(",
")",
";",
"}",
"plugin",
"path",
"dialog",
"show",
"(",
"tool",
")",
";",
"}"
]
|
[
"returns",
"the",
"idl",
"preprocessed",
"defined",
"on",
"the",
"given",
"rule"
]
| [
"private",
"static",
"collection",
"<",
"artifact",
">",
"get",
"idl",
"preprocessed",
"(",
"rule",
"context",
"rule",
"context",
")",
"{",
"return",
"rule",
"context",
"is",
"attr",
"defined",
"(",
"\"",
"idl",
"preprocessed",
"\"",
",",
"build",
"type",
"label",
"list",
")",
"?",
"rule",
"context",
"get",
"prerequisite",
"artifacts",
"(",
"\"",
"idl",
"preprocessed",
"\"",
")",
"filter",
"(",
"android",
"rule",
"classes",
"android",
"idl",
")",
"list",
"(",
")",
":",
"immutable",
"list",
"<",
"artifact",
">",
"of",
"(",
")",
";",
"}"
]
|
[
"true",
"iff",
"there",
"are",
"no",
"defined",
"bits"
]
| [
"public",
"boolean",
"is",
"fully",
"undefined",
"(",
")",
"{",
"return",
"msk",
"=",
"=",
"0l",
";",
"}",
"/",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"operators",
"*",
"/"
]
|
[
"gets",
"the",
"d",
"register",
"number",
",",
"as",
"a",
"nibble",
"this",
"will",
"throw",
"if",
"the",
"value",
"is",
"out",
"of",
"the",
"range",
"of",
"an",
"unsigned",
"nibble"
]
| [
"public",
"final",
"short",
"get",
"d",
"nibble",
"(",
")",
"{",
"int",
"d",
"=",
"get",
"d",
"(",
")",
";",
"if",
"(",
"(",
"d",
"&",
"~",
"0xf",
")",
"!",
"=",
"0",
")",
"{",
"throw",
"new",
"dex",
"exception",
"2",
"(",
"\"",
"register",
"d",
"out",
"of",
"range",
":",
"\"",
"+",
"hex",
"u",
"8",
"(",
"d",
")",
")",
";",
"}",
"return",
"(",
"short",
")",
"d",
";",
"}"
]
|
[
"called",
"to",
"determine",
"whether",
"the",
"view",
"can",
"be",
"dismissed"
]
| [
"boolean",
"can",
"dismiss",
"(",
"object",
"token",
")",
";"
]
|
[
"works",
"like",
"{",
"@",
"link",
"#",
"encode",
"to",
"(",
"writer",
")",
"}",
"but",
"obtain",
"the",
"result",
"as",
"a",
"string"
]
| [
"public",
"string",
"encode",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"encode",
"to",
"bytes",
"(",
")",
"to",
"string",
"(",
")",
";",
"}"
]
|
[
"returns",
"a",
"descriptive",
"method",
"about",
"the",
"error",
"which",
"occurred"
]
| [
"public",
"string",
"get",
"message",
"(",
")",
"{",
"return",
"message",
";",
"}"
]
|
[
"sets",
"the",
"transform",
"matrix",
"to",
"be",
"used",
"by",
"this",
"batch",
"even",
"if",
"this",
"is",
"called",
"inside",
"a",
"{",
"@",
"link",
"#",
"begin",
"(",
")",
"}",
"{",
"@",
"link",
"#",
"end",
"(",
")",
"}",
"block",
",",
"the",
"current",
"batch",
"is",
"not",
"flushed",
"to",
"the",
"gpu",
"instead",
",",
"for",
"every",
"subsequent",
"draw",
"(",
")",
"the",
"vertices",
"will",
"be",
"transformed",
"on",
"the",
"cpu",
"to",
"match",
"the",
"original",
"batch",
"matrix",
"this",
"adjustment",
"must",
"be",
"performed",
"until",
"the",
"matrices",
"are",
"realigned",
"by",
"restoring",
"the",
"original",
"matrix",
",",
"or",
"by",
"calling",
"{",
"@",
"link",
"#",
"flush",
"and",
"sync",
"transform",
"matrix",
"(",
")",
"}",
"or",
"{",
"@",
"link",
"#",
"end",
"(",
")",
"}"
]
| [
"public",
"void",
"set",
"transform",
"matrix",
"(",
"affine",
"2",
"transform",
")",
"{",
"matrix",
"4",
"real",
"matrix",
"=",
"super",
"get",
"transform",
"matrix",
"(",
")",
";",
"if",
"(",
"check",
"equal",
"(",
"real",
"matrix",
",",
"transform",
")",
")",
"{",
"adjust",
"needed",
"=",
"false",
";",
"}",
"else",
"{",
"virtual",
"matrix",
"set",
"as",
"affine",
"(",
"transform",
")",
";",
"if",
"(",
"is",
"drawing",
"(",
")",
")",
"{",
"adjust",
"needed",
"=",
"true",
";",
"/",
"/",
"adjust",
"=",
"inverse",
"(",
"real",
")",
"x",
"virtual",
"/",
"/",
"real",
"x",
"adjust",
"x",
"vertex",
"=",
"virtual",
"x",
"vertex",
"if",
"(",
"have",
"identity",
"real",
"matrix",
")",
"{",
"adjust",
"affine",
"set",
"(",
"transform",
")",
";",
"}",
"else",
"{",
"adjust",
"affine",
"set",
"(",
"real",
"matrix",
")",
"inv",
"(",
")",
"mul",
"(",
"transform",
")",
";",
"}",
"}",
"else",
"{",
"real",
"matrix",
"set",
"as",
"affine",
"(",
"transform",
")",
";",
"have",
"identity",
"real",
"matrix",
"=",
"check",
"idt",
"(",
"real",
"matrix",
")",
";",
"}",
"}",
"}"
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.