docstring_tokens
list | code_tokens
list |
|---|---|
[
"checks",
",",
"if",
"this",
"set",
"of",
"interesting",
"properties",
",",
"is",
"met",
"by",
"the",
"given",
"produced",
"properties"
]
| [
"public",
"boolean",
"is",
"met",
"by",
"(",
"global",
"properties",
"props",
")",
"{",
"if",
"(",
"this",
"partitioning",
"=",
"=",
"partitioning",
"property",
"any",
"distribution",
")",
"{",
"return",
"true",
";",
"}",
"else",
"if",
"(",
"this",
"partitioning",
"=",
"=",
"partitioning",
"property",
"full",
"replication",
")",
"{",
"return",
"props",
"is",
"fully",
"replicated",
"(",
")",
";",
"}",
"else",
"if",
"(",
"props",
"is",
"fully",
"replicated",
"(",
")",
")",
"{",
"return",
"false",
";",
"}",
"else",
"if",
"(",
"this",
"partitioning",
"=",
"=",
"partitioning",
"property",
"random",
"partitioned",
")",
"{",
"return",
"true",
";",
"}",
"else",
"if",
"(",
"this",
"partitioning",
"=",
"=",
"partitioning",
"property",
"any",
"partitioning",
")",
"{",
"return",
"check",
"compatible",
"partitioning",
"fields",
"(",
"props",
")",
";",
"}",
"else",
"if",
"(",
"this",
"partitioning",
"=",
"=",
"partitioning",
"property",
"hash",
"partitioned",
")",
"{",
"return",
"props",
"get",
"partitioning",
"(",
")",
"=",
"=",
"partitioning",
"property",
"hash",
"partitioned",
"&",
"&",
"check",
"compatible",
"partitioning",
"fields",
"(",
"props",
")",
";",
"}",
"else",
"if",
"(",
"this",
"partitioning",
"=",
"=",
"partitioning",
"property",
"range",
"partitioned",
")",
"{",
"return",
"props",
"get",
"partitioning",
"(",
")",
"=",
"=",
"partitioning",
"property",
"range",
"partitioned",
"&",
"&",
"props",
"matches",
"ordered",
"partitioning",
"(",
"this",
"ordering",
")",
";",
"}",
"else",
"if",
"(",
"this",
"partitioning",
"=",
"=",
"partitioning",
"property",
"forced",
"rebalanced",
")",
"{",
"return",
"props",
"get",
"partitioning",
"(",
")",
"=",
"=",
"partitioning",
"property",
"forced",
"rebalanced",
";",
"}",
"else",
"if",
"(",
"this",
"partitioning",
"=",
"=",
"partitioning",
"property",
"custom",
"partitioning",
")",
"{",
"return",
"props",
"get",
"partitioning",
"(",
")",
"=",
"=",
"partitioning",
"property",
"custom",
"partitioning",
"&",
"&",
"check",
"compatible",
"partitioning",
"fields",
"(",
"props",
")",
"&",
"&",
"props",
"get",
"custom",
"partitioner",
"(",
")",
"equals",
"(",
"this",
"custom",
"partitioner",
")",
";",
"}",
"else",
"{",
"throw",
"new",
"compiler",
"exception",
"(",
"\"",
"properties",
"matching",
"logic",
"leaves",
"open",
"cases",
"\"",
")",
";",
"}",
"}"
]
|
[
"interns",
"a",
"{",
"@",
"link",
"tree",
"string",
"}",
"created",
"elsewhere"
]
| [
"public",
"tree",
"string",
"intern",
"(",
"final",
"tree",
"string",
"s",
")",
"{",
"if",
"(",
"s",
"=",
"=",
"null",
")",
"return",
"null",
";",
"return",
"root",
"intern",
"(",
"s",
"to",
"string",
"(",
")",
")",
"node",
";",
"}"
]
|
[
"test",
"load",
"by",
"class",
"and",
"class",
"loader",
"and",
"activate",
"name"
]
| [
"public",
"void",
"test",
"load",
"by",
"class",
"and",
"class",
"loader",
"and",
"activate",
"name",
"(",
")",
"{",
"hello",
"english",
"hello",
"=",
"enhanced",
"service",
"loader",
"load",
"(",
"hello",
"class",
",",
"\"",
"english",
"hello",
"\"",
",",
"enhanced",
"service",
"loader",
"test",
"class",
"get",
"class",
"loader",
"(",
")",
")",
";",
"assert",
"that",
"(",
"english",
"hello",
"say",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"\"",
"hello",
"!",
"\"",
")",
";",
"}"
]
|
[
"convert",
"a",
"located",
"block",
"to",
"a",
"json",
"map"
]
| [
"private",
"static",
"map",
"<",
"string",
",",
"object",
">",
"to",
"json",
"map",
"(",
"final",
"located",
"block",
"locatedblock",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"locatedblock",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"final",
"map",
"<",
"string",
",",
"object",
">",
"m",
"=",
"new",
"tree",
"map",
"<",
"string",
",",
"object",
">",
"(",
")",
";",
"m",
"put",
"(",
"\"",
"block",
"token",
"\"",
",",
"to",
"json",
"map",
"(",
"locatedblock",
"get",
"block",
"token",
"(",
")",
")",
")",
";",
"m",
"put",
"(",
"\"",
"is",
"corrupt",
"\"",
",",
"locatedblock",
"is",
"corrupt",
"(",
")",
")",
";",
"m",
"put",
"(",
"\"",
"start",
"offset",
"\"",
",",
"locatedblock",
"get",
"start",
"offset",
"(",
")",
")",
";",
"m",
"put",
"(",
"\"",
"block",
"\"",
",",
"to",
"json",
"map",
"(",
"locatedblock",
"get",
"block",
"(",
")",
")",
")",
";",
"m",
"put",
"(",
"\"",
"storage",
"types",
"\"",
",",
"to",
"json",
"array",
"(",
"locatedblock",
"get",
"storage",
"types",
"(",
")",
")",
")",
";",
"m",
"put",
"(",
"\"",
"locations",
"\"",
",",
"to",
"json",
"array",
"(",
"locatedblock",
"get",
"locations",
"(",
")",
")",
")",
";",
"m",
"put",
"(",
"\"",
"cached",
"locations",
"\"",
",",
"to",
"json",
"array",
"(",
"locatedblock",
"get",
"cached",
"locations",
"(",
")",
")",
")",
";",
"return",
"m",
";",
"}"
]
|
[
"set",
"the",
"working",
"directory"
]
| [
"protected",
"void",
"set",
"working",
"directory",
"(",
"file",
"dir",
")",
"{",
"this",
"dir",
"=",
"dir",
";",
"}"
]
|
[
"get",
"branch",
"type"
]
| [
"public",
"static",
"branch",
"type",
"get",
"(",
"byte",
"ordinal",
")",
"{",
"return",
"get",
"(",
"(",
"int",
")",
"ordinal",
")",
";",
"}"
]
|
[
"add",
"a",
"{",
"@",
"link",
"bt",
"indexed",
"mesh",
"}",
"to",
"this",
"array"
]
| [
"public",
"bt",
"triangle",
"index",
"vertex",
"array",
"add",
"indexed",
"mesh",
"(",
"final",
"bt",
"indexed",
"mesh",
"mesh",
",",
"int",
"index",
"type",
")",
"{",
"mesh",
"obtain",
"(",
")",
";",
"internal",
"add",
"indexed",
"mesh",
"(",
"mesh",
",",
"index",
"type",
")",
";",
"meshes",
"add",
"(",
"mesh",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"creates",
"a",
"builder",
"to",
"build",
"{",
"@",
"link",
"message",
"subscription",
"impl",
"}",
"and",
"initialize",
"it",
"with",
"the",
"given",
"object"
]
| [
"public",
"static",
"builder",
"builder",
"from",
"(",
"message",
"subscription",
"impl",
"message",
"event",
"subscription",
"impl",
")",
"{",
"return",
"new",
"builder",
"(",
"message",
"event",
"subscription",
"impl",
")",
";",
"}"
]
|
[
"returns",
"an",
"unmodifiable",
"view",
"of",
"the",
"union",
"of",
"two",
"multisets",
"in",
"the",
"returned",
"multiset",
",",
"the",
"count",
"of",
"each",
"element",
"is",
"the",
"maximum",
"of",
"its",
"counts",
"in",
"the",
"two",
"backing",
"multisets",
"the",
"iteration",
"order",
"of",
"the",
"returned",
"multiset",
"matches",
"that",
"of",
"the",
"element",
"set",
"of",
"{",
"@",
"code",
"multiset",
"1",
"}",
"followed",
"by",
"the",
"members",
"of",
"the",
"element",
"set",
"of",
"{",
"@",
"code",
"multiset",
"2",
"}",
"that",
"are",
"not",
"contained",
"in",
"{",
"@",
"code",
"multiset",
"1",
"}",
",",
"with",
"repeated",
"occurrences",
"of",
"the",
"same",
"element",
"appearing",
"consecutively",
"results",
"are",
"undefined",
"if",
"{",
"@",
"code",
"multiset",
"1",
"}",
"and",
"{",
"@",
"code",
"multiset",
"2",
"}",
"are",
"based",
"on",
"different",
"equivalence",
"relations",
"(",
"as",
"{",
"@",
"code",
"hash",
"multiset",
"}",
"and",
"{",
"@",
"code",
"tree",
"multiset",
"}",
"are",
")"
]
| [
"public",
"static",
"<",
"e",
">",
"multiset",
"<",
"e",
">",
"union",
"(",
"final",
"multiset",
"<",
"?",
"extends",
"e",
">",
"multiset",
"1",
",",
"final",
"multiset",
"<",
"?",
"extends",
"e",
">",
"multiset",
"2",
")",
"{",
"check",
"not",
"null",
"(",
"multiset",
"1",
")",
";",
"check",
"not",
"null",
"(",
"multiset",
"2",
")",
";",
"return",
"new",
"view",
"multiset",
"<",
"e",
">",
"(",
")",
"{",
"@",
"override",
"public",
"boolean",
"contains",
"(",
"@",
"nullable",
"object",
"element",
")",
"{",
"return",
"multiset",
"1",
"contains",
"(",
"element",
")",
"|",
"|",
"multiset",
"2",
"contains",
"(",
"element",
")",
";",
"}",
"@",
"override",
"public",
"boolean",
"is",
"empty",
"(",
")",
"{",
"return",
"multiset",
"1",
"is",
"empty",
"(",
")",
"&",
"&",
"multiset",
"2",
"is",
"empty",
"(",
")",
";",
"}",
"@",
"override",
"public",
"int",
"count",
"(",
"object",
"element",
")",
"{",
"return",
"math",
"max",
"(",
"multiset",
"1",
"count",
"(",
"element",
")",
",",
"multiset",
"2",
"count",
"(",
"element",
")",
")",
";",
"}",
"@",
"override",
"set",
"<",
"e",
">",
"create",
"element",
"set",
"(",
")",
"{",
"return",
"sets",
"union",
"(",
"multiset",
"1",
"element",
"set",
"(",
")",
",",
"multiset",
"2",
"element",
"set",
"(",
")",
")",
";",
"}",
"@",
"override",
"iterator",
"<",
"e",
">",
"element",
"iterator",
"(",
")",
"{",
"throw",
"new",
"assertion",
"error",
"(",
"\"",
"should",
"never",
"be",
"called",
"\"",
")",
";",
"}",
"@",
"override",
"iterator",
"<",
"entry",
"<",
"e",
">",
">",
"entry",
"iterator",
"(",
")",
"{",
"final",
"iterator",
"<",
"?",
"extends",
"entry",
"<",
"?",
"extends",
"e",
">",
">",
"iterator",
"1",
"=",
"multiset",
"1",
"entry",
"set",
"(",
")",
"iterator",
"(",
")",
";",
"final",
"iterator",
"<",
"?",
"extends",
"entry",
"<",
"?",
"extends",
"e",
">",
">",
"iterator",
"2",
"=",
"multiset",
"2",
"entry",
"set",
"(",
")",
"iterator",
"(",
")",
";",
"/",
"/",
"todo",
"(",
"lowasser",
")",
":",
"consider",
"making",
"the",
"entries",
"live",
"views",
"return",
"new",
"abstract",
"iterator",
"<",
"entry",
"<",
"e",
">",
">",
"(",
")",
"{",
"@",
"override",
"protected",
"entry",
"<",
"e",
">",
"compute",
"next",
"(",
")",
"{",
"if",
"(",
"iterator",
"1",
"has",
"next",
"(",
")",
")",
"{",
"entry",
"<",
"?",
"extends",
"e",
">",
"entry",
"1",
"=",
"iterator",
"1",
"next",
"(",
")",
";",
"e",
"element",
"=",
"entry",
"1",
"get",
"element",
"(",
")",
";",
"int",
"count",
"=",
"math",
"max",
"(",
"entry",
"1",
"get",
"count",
"(",
")",
",",
"multiset",
"2",
"count",
"(",
"element",
")",
")",
";",
"return",
"immutable",
"entry",
"(",
"element",
",",
"count",
")",
";",
"}",
"while",
"(",
"iterator",
"2",
"has",
"next",
"(",
")",
")",
"{",
"entry",
"<",
"?",
"extends",
"e",
">",
"entry",
"2",
"=",
"iterator",
"2",
"next",
"(",
")",
";",
"e",
"element",
"=",
"entry",
"2",
"get",
"element",
"(",
")",
";",
"if",
"(",
"!",
"multiset",
"1",
"contains",
"(",
"element",
")",
")",
"{",
"return",
"immutable",
"entry",
"(",
"element",
",",
"entry",
"2",
"get",
"count",
"(",
")",
")",
";",
"}",
"}",
"return",
"end",
"of",
"data",
"(",
")",
";",
"}",
"}",
";",
"}",
"}",
";",
"}"
]
|
[
"{",
"@",
"inherit",
"doc",
"}"
]
| [
"public",
"void",
"add",
"contents",
"(",
"dex",
"file",
"file",
")",
"{",
"mixed",
"item",
"section",
"word",
"data",
"=",
"file",
"get",
"word",
"data",
"(",
")",
";",
"annotations",
"=",
"word",
"data",
"intern",
"(",
"annotations",
")",
";",
"}"
]
|
[
"returns",
"whether",
"this",
"target",
"uses",
"annotation",
"processing"
]
| [
"public",
"boolean",
"uses",
"annotation",
"processing",
"(",
")",
"{",
"java",
"target",
"attributes",
"attributes",
"=",
"get",
"attributes",
"(",
")",
";",
"return",
"get",
"javac",
"opts",
"(",
")",
"contains",
"(",
"\"",
"-",
"processor",
"\"",
")",
"|",
"|",
"attributes",
"plugins",
"(",
")",
"has",
"processors",
"(",
")",
";",
"}"
]
|
[
"provide",
"resolvers",
"for",
"custom",
"argument",
"types",
"custom",
"resolvers",
"are",
"ordered",
"after",
"built",
"-",
"in",
"ones",
"to",
"override",
"the",
"built",
"-",
"in",
"support",
"for",
"argument",
"resolution",
"use",
"{",
"@",
"link",
"#",
"set",
"argument",
"resolvers",
"}",
"instead"
]
| [
"public",
"void",
"set",
"custom",
"argument",
"resolvers",
"(",
"@",
"nullable",
"list",
"<",
"handler",
"method",
"argument",
"resolver",
">",
"argument",
"resolvers",
")",
"{",
"this",
"custom",
"argument",
"resolvers",
"=",
"argument",
"resolvers",
";",
"}"
]
|
[
"computes",
"an",
"average",
"estimated",
"module",
"size",
"based",
"on",
"estimated",
"derived",
"from",
"the",
"positions",
"of",
"the",
"three",
"finder",
"patterns"
]
| [
"protected",
"final",
"float",
"calculate",
"module",
"size",
"(",
"result",
"point",
"top",
"left",
",",
"result",
"point",
"top",
"right",
",",
"result",
"point",
"bottom",
"left",
")",
"{",
"/",
"/",
"take",
"the",
"average",
"return",
"(",
"calculate",
"module",
"size",
"one",
"way",
"(",
"top",
"left",
",",
"top",
"right",
")",
"+",
"calculate",
"module",
"size",
"one",
"way",
"(",
"top",
"left",
",",
"bottom",
"left",
")",
")",
"/",
"2",
"0f",
";",
"}"
]
|
[
"populates",
"a",
"multimap",
"by",
"reading",
"an",
"input",
"stream",
",",
"as",
"part",
"of",
"deserialization",
"see",
"{",
"@",
"link",
"#",
"write",
"multimap",
"}",
"for",
"the",
"data",
"format"
]
| [
"static",
"<",
"k",
",",
"v",
">",
"void",
"populate",
"multimap",
"(",
"multimap",
"<",
"k",
",",
"v",
">",
"multimap",
",",
"object",
"input",
"stream",
"stream",
")",
"throws",
"i",
"o",
"exception",
",",
"class",
"not",
"found",
"exception",
"{",
"int",
"distinct",
"keys",
"=",
"stream",
"read",
"int",
"(",
")",
";",
"populate",
"multimap",
"(",
"multimap",
",",
"stream",
",",
"distinct",
"keys",
")",
";",
"}"
]
|
[
"returns",
"an",
"address",
"range",
"iterator",
"that",
"will",
"return",
"address",
"ranges",
"everywhere",
"that",
"register",
"values",
"have",
"been",
"set"
]
| [
"public",
"address",
"range",
"iterator",
"get",
"address",
"range",
"iterator",
"(",
")",
"{",
"/",
"/",
"assume",
"we",
"must",
"be",
"in",
"open",
"transaction",
"if",
"range",
"cache",
"is",
"active",
"flush",
"write",
"cache",
"(",
")",
";",
"return",
"range",
"map",
"get",
"address",
"range",
"iterator",
"(",
")",
";",
"}"
]
|
[
"check",
"to",
"see",
"if",
"the",
"view",
"name",
"in",
"the",
"model",
"and",
"view",
"matches",
"the",
"given",
"{",
"@",
"code",
"expected",
"name",
"}"
]
| [
"public",
"static",
"void",
"assert",
"view",
"name",
"(",
"model",
"and",
"view",
"mav",
",",
"string",
"expected",
"name",
")",
"{",
"assert",
"true",
"(",
"\"",
"view",
"name",
"is",
"not",
"equal",
"to",
"'",
"\"",
"+",
"expected",
"name",
"+",
"\"",
"'",
"but",
"was",
"'",
"\"",
"+",
"mav",
"get",
"view",
"name",
"(",
")",
"+",
"\"",
"'",
"\"",
",",
"object",
"utils",
"null",
"safe",
"equals",
"(",
"expected",
"name",
",",
"mav",
"get",
"view",
"name",
"(",
")",
")",
")",
";",
"}"
]
|
[
"returns",
"the",
"current",
"sum",
"the",
"returned",
"value",
"is",
"not",
"an",
"atomic",
"snapshot",
";",
"invocation",
"in",
"the",
"absence",
"of",
"concurrent",
"updates",
"returns",
"an",
"accurate",
"result",
",",
"but",
"concurrent",
"updates",
"that",
"occur",
"while",
"the",
"sum",
"is",
"being",
"calculated",
"might",
"not",
"be",
"incorporated"
]
| [
"public",
"long",
"sum",
"(",
")",
"{",
"long",
"sum",
"=",
"base",
";",
"cell",
"[",
"]",
"as",
"=",
"cells",
";",
"if",
"(",
"as",
"!",
"=",
"null",
")",
"{",
"int",
"n",
"=",
"as",
"length",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"n",
";",
"+",
"+",
"i",
")",
"{",
"cell",
"a",
"=",
"as",
"[",
"i",
"]",
";",
"if",
"(",
"a",
"!",
"=",
"null",
")",
"sum",
"+",
"=",
"a",
"value",
";",
"}",
"}",
"return",
"sum",
";",
"}"
]
|
[
"sets",
"the",
"current",
"gauge",
"value",
"for",
"how",
"many",
"bytes",
"were",
"written",
"in",
"the",
"last",
"second"
]
| [
"public",
"void",
"update",
"bytes",
"written",
"in",
"last",
"second",
"(",
"long",
"current",
"bytes",
"written",
")",
"{",
"bytes",
"written",
"in",
"last",
"second",
"set",
"(",
"current",
"bytes",
"written",
")",
";",
"}"
]
|
[
"array",
"of",
"geohashes",
"one",
"level",
"below",
"the",
"base",
"geohash",
"sorted"
]
| [
"public",
"static",
"string",
"[",
"]",
"get",
"sub",
"geohashes",
"(",
"string",
"base",
"geohash",
")",
"{",
"string",
"[",
"]",
"hashes",
"=",
"new",
"string",
"[",
"base",
"32",
"length",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"base",
"32",
"length",
";",
"i",
"+",
"+",
")",
"{",
"/",
"/",
"note",
":",
"already",
"sorted",
"char",
"c",
"=",
"base",
"32",
"[",
"i",
"]",
";",
"hashes",
"[",
"i",
"]",
"=",
"base",
"geohash",
"+",
"c",
";",
"}",
"return",
"hashes",
";",
"}"
]
|
[
"returns",
"a",
"new",
"builder",
",",
"expecting",
"the",
"specified",
"number",
"of",
"entries",
"to",
"be",
"added",
"if",
"{",
"@",
"code",
"expected",
"size",
"}",
"is",
"exactly",
"the",
"number",
"of",
"entries",
"added",
"to",
"the",
"builder",
"before",
"{",
"@",
"link",
"builder",
"#",
"build",
"}",
"is",
"called",
",",
"the",
"builder",
"is",
"likely",
"to",
"perform",
"better",
"than",
"an",
"unsized",
"{",
"@",
"link",
"#",
"builder",
"(",
")",
"}",
"would",
"have",
"it",
"is",
"not",
"specified",
"if",
"any",
"performance",
"benefits",
"apply",
"if",
"{",
"@",
"code",
"expected",
"size",
"}",
"is",
"close",
"to",
",",
"but",
"not",
"exactly",
",",
"the",
"number",
"of",
"entries",
"added",
"to",
"the",
"builder"
]
| [
"public",
"static",
"<",
"k",
",",
"v",
">",
"builder",
"<",
"k",
",",
"v",
">",
"builder",
"with",
"expected",
"size",
"(",
"int",
"expected",
"size",
")",
"{",
"check",
"nonnegative",
"(",
"expected",
"size",
",",
"\"",
"expected",
"size",
"\"",
")",
";",
"return",
"new",
"builder",
"<",
">",
"(",
"expected",
"size",
")",
";",
"}"
]
|
[
"get",
"the",
"{",
"@",
"link",
"metrics",
"kafka",
"metrics",
"}",
"that",
"are",
"managed",
"by",
"this",
"object",
"and",
"that",
"should",
"be",
"used",
"to",
"add",
"sensors",
"and",
"individual",
"metrics"
]
| [
"public",
"metrics",
"metrics",
"(",
")",
"{",
"return",
"metrics",
";",
"}"
]
|
[
"returns",
"an",
"instance",
"for",
"a",
"state",
"that",
"is",
"not",
"{",
"@",
"code",
"transient",
"failure",
"}"
]
| [
"public",
"static",
"connectivity",
"state",
"info",
"for",
"non",
"error",
"(",
"connectivity",
"state",
"state",
")",
"{",
"preconditions",
"check",
"argument",
"(",
"state",
"!",
"=",
"transient",
"failure",
",",
"\"",
"state",
"is",
"transient",
"error",
"use",
"for",
"error",
"(",
")",
"instead",
"\"",
")",
";",
"return",
"new",
"connectivity",
"state",
"info",
"(",
"state",
",",
"status",
"ok",
")",
";",
"}"
]
|
[
"stop",
"this",
"container"
]
| [
"public",
"void",
"stop",
"(",
")",
"throws",
"jms",
"exception",
"{",
"try",
"{",
"do",
"stop",
"(",
")",
";",
"}",
"catch",
"(",
"j",
"m",
"s",
"exception",
"ex",
")",
"{",
"throw",
"convert",
"jms",
"access",
"exception",
"(",
"ex",
")",
";",
"}",
"}"
]
|
[
"see",
"{",
"@",
"link",
"socket",
"#",
"is",
"connected",
"(",
")",
"}",
"calling",
"this",
"method",
"does",
"not",
"trigger",
"mode",
"detection"
]
| [
"public",
"boolean",
"is",
"connected",
"(",
")",
"{",
"return",
"get",
"socket",
"allow",
"unknown",
"mode",
"(",
")",
"is",
"connected",
"(",
")",
";",
"}"
]
|
[
"return",
"a",
"string",
"to",
"be",
"used",
"at",
"the",
"end",
"of",
"an",
"error",
"message",
"it",
"is",
"either",
"an",
"empty",
"string",
",",
"or",
"a",
"spelling",
"suggestion",
",",
"e",
"g",
"\"",
"(",
"did",
"you",
"mean",
"'",
"x",
"'",
"?",
")",
"\""
]
| [
"public",
"static",
"string",
"did",
"you",
"mean",
"(",
"string",
"input",
",",
"iterable",
"<",
"string",
">",
"words",
")",
"{",
"string",
"suggestion",
"=",
"suggest",
"(",
"input",
",",
"words",
")",
";",
"if",
"(",
"suggestion",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"\"",
";",
"}",
"else",
"{",
"return",
"\"",
"(",
"did",
"you",
"mean",
"'",
"\"",
"+",
"suggestion",
"+",
"\"",
"'",
"?",
")",
"\"",
";",
"}",
"}"
]
|
[
"returns",
"the",
"schema",
"model",
"associated",
"with",
"the",
"editor"
]
| [
"public",
"entity",
"diagram",
"get",
"diagram",
"(",
")",
"{",
"return",
"get",
"diagram",
"part",
"(",
")",
"get",
"diagram",
"(",
")",
";",
"}"
]
|
[
"to",
"test",
"class",
"name",
"in",
"snake",
"case",
"to",
"test",
"class",
"name",
"in",
"snake",
"case"
]
| [
"public",
"single",
"<",
"client",
">",
"rx",
"test",
"classname",
"(",
"client",
"body",
",",
"api",
"client",
"auth",
"info",
"auth",
"info",
")",
"{",
"return",
"single",
"create",
"(",
"new",
"io",
"vertx",
"rx",
"java",
"single",
"on",
"subscribe",
"adapter",
"<",
">",
"(",
"fut",
"-",
">",
"delegate",
"test",
"classname",
"(",
"body",
",",
"auth",
"info",
",",
"fut",
")",
")",
")",
";",
"}"
]
|
[
"returns",
"asin",
"in",
"radians",
";",
"less",
"accurate",
"than",
"math",
"asin",
"but",
"may",
"be",
"faster",
"average",
"error",
"of",
"0",
"000028447",
"radians",
"(",
"0",
"0016298931",
"degrees",
")",
",",
"largest",
"error",
"of",
"0",
"000067592",
"radians",
"(",
"0",
"0038727364",
"degrees",
")",
"this",
"implementation",
"does",
"not",
"return",
"na",
"n",
"if",
"given",
"an",
"out",
"-",
"of",
"-",
"range",
"input",
"(",
"math",
"asin",
"does",
"return",
"na",
"n",
")",
",",
"unless",
"the",
"input",
"is",
"na",
"n"
]
| [
"static",
"public",
"float",
"asin",
"(",
"float",
"a",
")",
"{",
"float",
"a",
"2",
"=",
"a",
"*",
"a",
";",
"/",
"/",
"a",
"squared",
"float",
"a",
"3",
"=",
"a",
"*",
"a",
"2",
";",
"/",
"/",
"a",
"cubed",
"if",
"(",
"a",
">",
"=",
"0f",
")",
"{",
"return",
"1",
"5",
"7",
"0",
"7",
"9",
"6",
"3",
"2",
"6",
"7",
"9",
"4",
"8",
"9",
"6",
"6f",
"-",
"(",
"float",
")",
"math",
"sqrt",
"(",
"1f",
"-",
"a",
")",
"*",
"(",
"1",
"5",
"7",
"0",
"7",
"2",
"8",
"8f",
"-",
"0",
"2",
"1",
"2",
"1",
"1",
"4",
"4f",
"*",
"a",
"+",
"0",
"0",
"7",
"4",
"2",
"6",
"1",
"0f",
"*",
"a",
"2",
"-",
"0",
"0",
"1",
"8",
"7",
"2",
"9",
"3f",
"*",
"a",
"3",
")",
";",
"}",
"else",
"{",
"return",
"-",
"1",
"5",
"7",
"0",
"7",
"9",
"6",
"3",
"2",
"6",
"7",
"9",
"4",
"8",
"9",
"6",
"6f",
"+",
"(",
"float",
")",
"math",
"sqrt",
"(",
"1f",
"+",
"a",
")",
"*",
"(",
"1",
"5",
"7",
"0",
"7",
"2",
"8",
"8f",
"+",
"0",
"2",
"1",
"2",
"1",
"1",
"4",
"4f",
"*",
"a",
"+",
"0",
"0",
"7",
"4",
"2",
"6",
"1",
"0f",
"*",
"a",
"2",
"+",
"0",
"0",
"1",
"8",
"7",
"2",
"9",
"3f",
"*",
"a",
"3",
")",
";",
"}",
"}"
]
|
[
"get",
"a",
"thread",
"-",
"local",
"typed",
"bytes",
"output",
"for",
"the",
"supplied",
"{",
"@",
"link",
"data",
"output",
"}"
]
| [
"public",
"static",
"typed",
"bytes",
"output",
"get",
"(",
"data",
"output",
"out",
")",
"{",
"typed",
"bytes",
"output",
"bout",
"=",
"tb",
"out",
"get",
"(",
")",
";",
"bout",
"set",
"data",
"output",
"(",
"out",
")",
";",
"return",
"bout",
";",
"}"
]
|
[
"return",
"a",
"control",
"that",
"allows",
"putting",
"the",
"request",
"in",
"asynchronous",
"mode",
"so",
"the",
"response",
"remains",
"open",
"until",
"closed",
"explicitly",
"from",
"the",
"current",
"or",
"another",
"thread"
]
| [
"server",
"http",
"async",
"request",
"control",
"get",
"async",
"request",
"control",
"(",
"server",
"http",
"response",
"response",
")",
";"
]
|
[
"returns",
"a",
"^",
"p",
"mod",
"m"
]
| [
"private",
"long",
"pow",
"mod",
"(",
"long",
"a",
",",
"long",
"p",
",",
"long",
"m",
")",
"{",
"long",
"res",
"=",
"1",
";",
"for",
"(",
";",
"p",
"!",
"=",
"0",
";",
"p",
">",
">",
"=",
"1",
")",
"{",
"if",
"(",
"(",
"p",
"&",
"1",
")",
"!",
"=",
"0",
")",
"{",
"res",
"=",
"mul",
"mod",
"(",
"res",
",",
"a",
",",
"m",
")",
";",
"}",
"a",
"=",
"square",
"mod",
"(",
"a",
",",
"m",
")",
";",
"}",
"return",
"res",
";",
"}"
]
|
[
"returns",
"the",
"list",
"of",
"{",
"@",
"link",
"file",
"fragment",
"}",
"-",
"fragments",
"on",
"the",
"bounds",
"of",
"the",
"current",
"fragment",
",",
"which",
"should",
"be",
"potentially",
"merged",
"with",
"neighbor",
"fragments",
"combined",
"list",
"of",
"{",
"@",
"link",
"file",
"fragment",
"}",
"is",
"passed",
"to",
"{",
"@",
"link",
"declaration",
"assembler",
"}",
"for",
"merging"
]
| [
"public",
"list",
"<",
"file",
"fragment",
">",
"call",
"(",
")",
"throws",
"exception",
"{",
"list",
"<",
"file",
"fragment",
">",
"fragments",
"=",
"lists",
"new",
"array",
"list",
"(",
")",
";",
"int",
"start",
"=",
"0",
";",
"while",
"(",
"true",
")",
"{",
"int",
"end",
"=",
"ninja",
"separator",
"finder",
"find",
"next",
"separator",
"(",
"file",
"fragment",
",",
"start",
",",
"-",
"1",
")",
";",
"if",
"(",
"end",
"<",
"0",
")",
"{",
"break",
";",
"}",
"file",
"fragment",
"fragment",
"=",
"file",
"fragment",
"sub",
"fragment",
"(",
"start",
",",
"end",
"+",
"1",
")",
";",
"if",
"(",
"start",
">",
"0",
")",
"{",
"consumer",
"declaration",
"(",
"fragment",
")",
";",
"}",
"else",
"{",
"fragments",
"add",
"(",
"fragment",
")",
";",
"}",
"start",
"=",
"end",
"+",
"1",
";",
"}",
"/",
"/",
"there",
"is",
"always",
"at",
"least",
"one",
"byte",
"at",
"the",
"bounds",
"of",
"the",
"fragment",
"file",
"fragment",
"last",
"fragment",
"=",
"file",
"fragment",
"sub",
"fragment",
"(",
"start",
",",
"file",
"fragment",
"length",
"(",
")",
")",
";",
"fragments",
"add",
"(",
"last",
"fragment",
")",
";",
"return",
"fragments",
";",
"}"
]
|
[
"when",
"the",
"request",
"resources",
"is",
"the",
"first",
"in",
"a",
"stream",
",",
"the",
"initial",
"resource",
"versions",
"must",
"be",
"populated",
"otherwise",
",",
"initial",
"resource",
"versions",
"must",
"be",
"omitted",
"the",
"keys",
"are",
"the",
"resources",
"names",
"of",
"the",
"mcp",
"resources",
"known",
"to",
"the",
"mcp",
"client",
"the",
"values",
"in",
"the",
"map",
"are",
"the",
"associated",
"resource",
"level",
"version",
"info",
"<",
"code",
">",
"map",
"&",
"lt",
";",
"string",
",",
"string",
"&",
"gt",
";",
"initial",
"resource",
"versions",
"=",
"3",
";",
"<",
"code",
">"
]
| [
"public",
"java",
"lang",
"string",
"get",
"initial",
"resource",
"versions",
"or",
"throw",
"(",
"java",
"lang",
"string",
"key",
")",
"{",
"if",
"(",
"key",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"java",
"lang",
"null",
"pointer",
"exception",
"(",
")",
";",
"}",
"java",
"util",
"map",
"<",
"java",
"lang",
"string",
",",
"java",
"lang",
"string",
">",
"map",
"=",
"internal",
"get",
"initial",
"resource",
"versions",
"(",
")",
"get",
"map",
"(",
")",
";",
"if",
"(",
"!",
"map",
"contains",
"key",
"(",
"key",
")",
")",
"{",
"throw",
"new",
"java",
"lang",
"illegal",
"argument",
"exception",
"(",
")",
";",
"}",
"return",
"map",
"get",
"(",
"key",
")",
";",
"}"
]
|
[
"insert",
"the",
"{",
"@",
"link",
"timer",
"job",
"entity",
"}",
",",
"similar",
"to",
"{",
"@",
"link",
"#",
"insert",
"(",
"timer",
"job",
"entity",
")",
"}",
",",
"but",
"returns",
"a",
"boolean",
"in",
"case",
"the",
"insert",
"did",
"not",
"go",
"through",
"this",
"could",
"happen",
"if",
"the",
"execution",
"related",
"to",
"the",
"{",
"@",
"link",
"timer",
"job",
"entity",
"}",
"has",
"been",
"removed",
"(",
"for",
"example",
"due",
"to",
"a",
"task",
"complete",
"for",
"a",
"timer",
"boundary",
"on",
"that",
"task",
")"
]
| [
"boolean",
"insert",
"timer",
"job",
"entity",
"(",
"timer",
"job",
"entity",
"timer",
"job",
"entity",
")",
";"
]
|
[
"multiplies",
"the",
"current",
"transformation",
"matrix",
"by",
"a",
"scale",
"matrix"
]
| [
"public",
"void",
"scale",
"(",
"float",
"scale",
"x",
",",
"float",
"scale",
"y",
",",
"float",
"scale",
"z",
")",
"{",
"transform",
"matrix",
"scale",
"(",
"scale",
"x",
",",
"scale",
"y",
",",
"scale",
"z",
")",
";",
"matrix",
"dirty",
"=",
"true",
";",
"}"
]
|
[
"returns",
"a",
"specialized",
"view",
"of",
"the",
"keys",
"of",
"this",
"associated",
"container",
"the",
"view",
"additionally",
"implements",
"{",
"@",
"link",
"object",
"lookup",
"container",
"}"
]
| [
"public",
"object",
"lookup",
"container",
"<",
"k",
"type",
">",
"keys",
"(",
")",
"{",
"return",
"map",
"keys",
"(",
")",
";",
"}"
]
|
[
"delegates",
"to",
"the",
"{",
"@",
"link",
"log",
"#",
"debug",
"(",
"object",
")",
"}",
"method",
"of",
"the",
"underlying",
"{",
"@",
"link",
"log",
"}",
"instance",
"however",
",",
"this",
"form",
"avoids",
"superfluous",
"object",
"creation",
"when",
"the",
"logger",
"is",
"disabled",
"for",
"level",
"debug"
]
| [
"public",
"void",
"debug",
"(",
"string",
"format",
",",
"object",
"arguments",
")",
"{",
"if",
"(",
"logger",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"formatting",
"tuple",
"ft",
"=",
"message",
"formatter",
"array",
"format",
"(",
"format",
",",
"arguments",
")",
";",
"logger",
"debug",
"(",
"ft",
"get",
"message",
"(",
")",
",",
"ft",
"get",
"throwable",
"(",
")",
")",
";",
"}",
"}"
]
|
[
"customize",
"request",
"specification"
]
| [
"public",
"test",
"json",
"form",
"data",
"oper",
"req",
"spec",
"(",
"consumer",
"<",
"request",
"spec",
"builder",
">",
"req",
"spec",
"customizer",
")",
"{",
"req",
"spec",
"customizer",
"accept",
"(",
"req",
"spec",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"get",
"user",
"by",
"user",
"name"
]
| [
"public",
"void",
"get",
"user",
"by",
"name",
"test",
"(",
")",
"throws",
"api",
"exception",
"{",
"string",
"username",
"=",
"null",
";",
"user",
"response",
"=",
"api",
"get",
"user",
"by",
"name",
"(",
"username",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
]
|
[
"when",
"referent",
"is",
"freed",
"by",
"the",
"garbage",
"collector",
",",
"run",
"cleanup",
"note",
":",
"cleanup",
"must",
"not",
"contain",
"a",
"reference",
"to",
"the",
"referent",
"object"
]
| [
"public",
"void",
"add",
"finalizer",
"(",
"object",
"referent",
",",
"runnable",
"cleanup",
")",
"{",
"require",
"non",
"null",
"(",
"referent",
",",
"\"",
"referent",
"is",
"null",
"\"",
")",
";",
"require",
"non",
"null",
"(",
"cleanup",
",",
"\"",
"cleanup",
"is",
"null",
"\"",
")",
";",
"finalizers",
"add",
"(",
"new",
"finalizer",
"reference",
"(",
"referent",
",",
"finalizer",
"queue",
",",
"cleanup",
")",
")",
";",
"}"
]
|
[
"create",
"a",
"progress",
"message",
"for",
"the",
"ninja",
"action",
"if",
"the",
"target",
"has",
"a",
"\"",
"description",
"\"",
"variable",
",",
"use",
"that",
"it",
"has",
"been",
"expanded",
"at",
"parse",
"time",
"with",
"file",
"variables",
"if",
"the",
"rule",
"for",
"the",
"target",
"has",
"a",
"description",
",",
"use",
"that",
"it",
"has",
"been",
"expanded",
"with",
"rule",
",",
"build",
"and",
"file",
"variables",
"else",
",",
"generate",
"a",
"pretty",
"-",
"printed",
"progress",
"message",
"at",
"runtime",
",",
"using",
"the",
"rule",
"name",
"and",
"output",
"filenames",
"for",
"a",
"general",
"idea",
"on",
"what",
"the",
"action",
"is",
"doing",
",",
"without",
"printing",
"the",
"full",
"command",
"line",
"(",
"which",
"can",
"be",
"surfaced",
"with",
"-",
"-",
"subcommands",
",",
"anyway",
")"
]
| [
"private",
"static",
"string",
"create",
"progress",
"message",
"(",
"ninja",
"target",
"target",
",",
"immutable",
"sorted",
"map",
"<",
"ninja",
"rule",
"variable",
",",
"string",
">",
"rule",
"variables",
",",
"list",
"<",
"artifact",
">",
"outputs",
")",
"{",
"string",
"rule",
"description",
"=",
"rule",
"variables",
"get",
"(",
"ninja",
"rule",
"variable",
"description",
")",
";",
"if",
"(",
"rule",
"description",
"!",
"=",
"null",
")",
"{",
"return",
"rule",
"description",
";",
"}",
"string",
"rule",
"name",
"=",
"target",
"get",
"rule",
"name",
"(",
")",
";",
"string",
"builder",
"message",
"builder",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"if",
"(",
"!",
"rule",
"name",
"is",
"empty",
"(",
")",
")",
"{",
"message",
"builder",
"append",
"(",
"\"",
"[",
"rule",
"\"",
")",
"append",
"(",
"rule",
"name",
")",
"append",
"(",
"\"",
"]",
"\"",
")",
";",
"}",
"message",
"builder",
"append",
"(",
"\"",
"outputs",
":",
"\"",
")",
";",
"message",
"builder",
"append",
"(",
"outputs",
"stream",
"(",
")",
"map",
"(",
"artifact",
":",
":",
"get",
"filename",
")",
"collect",
"(",
"joining",
"(",
"\"",
",",
"\"",
")",
")",
")",
";",
"return",
"message",
"builder",
"to",
"string",
"(",
")",
";",
"}"
]
|
[
"get",
"prefix",
"wrapped",
"array"
]
| [
"public",
"list",
"<",
"integer",
">",
"get",
"prefix",
"wrapped",
"array",
"(",
")",
"{",
"return",
"prefix",
"wrapped",
"array",
";",
"}"
]
|
[
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"a",
"scheduled",
"task",
"is",
"ready",
"for",
"processing"
]
| [
"protected",
"final",
"boolean",
"has",
"scheduled",
"tasks",
"(",
")",
"{",
"scheduled",
"future",
"task",
"<",
"?",
">",
"scheduled",
"task",
"=",
"peek",
"scheduled",
"task",
"(",
")",
";",
"return",
"scheduled",
"task",
"!",
"=",
"null",
"&",
"&",
"scheduled",
"task",
"deadline",
"nanos",
"(",
")",
"<",
"=",
"nano",
"time",
"(",
")",
";",
"}"
]
|
[
"set",
"the",
"quartz",
"{",
"@",
"link",
"scheduler",
"factory",
"}",
"implementation",
"to",
"use",
"default",
"is",
"the",
"{",
"@",
"link",
"std",
"scheduler",
"factory",
"}",
"class",
",",
"reading",
"in",
"the",
"standard",
"{",
"@",
"code",
"quartz",
"properties",
"}",
"from",
"{",
"@",
"code",
"quartz",
"jar",
"}",
"for",
"applying",
"custom",
"quartz",
"properties",
",",
"specify",
"{",
"@",
"link",
"#",
"set",
"config",
"location",
"\"",
"config",
"location",
"\"",
"}",
"andor",
"{",
"@",
"link",
"#",
"set",
"quartz",
"properties",
"\"",
"quartz",
"properties",
"\"",
"}",
"etc",
"on",
"this",
"local",
"{",
"@",
"code",
"scheduler",
"factory",
"bean",
"}",
"instance"
]
| [
"public",
"void",
"set",
"scheduler",
"factory",
"class",
"(",
"class",
"<",
"?",
"extends",
"scheduler",
"factory",
">",
"scheduler",
"factory",
"class",
")",
"{",
"this",
"scheduler",
"factory",
"class",
"=",
"scheduler",
"factory",
"class",
";",
"}"
]
|
[
"tests",
"that",
"a",
"blocking",
"request",
"fails",
"properly",
"if",
"the",
"buffer",
"pool",
"is",
"destroyed",
"starts",
"a",
"thread",
",",
"which",
"triggers",
"an",
"unsatisfiable",
"blocking",
"buffer",
"request",
"after",
"making",
"sure",
"that",
"the",
"thread",
"is",
"actually",
"waiting",
"in",
"the",
"blocking",
"call",
",",
"the",
"buffer",
"pool",
"is",
"destroyed",
"and",
"we",
"check",
"whether",
"the",
"request",
"thread",
"threw",
"the",
"expected",
"exception"
]
| [
"public",
"void",
"test",
"destroy",
"while",
"blocking",
"request",
"(",
")",
"throws",
"interrupted",
"exception",
"{",
"atomic",
"reference",
"<",
"exception",
">",
"async",
"exception",
"=",
"new",
"atomic",
"reference",
"<",
">",
"(",
")",
";",
"network",
"buffer",
"pool",
"network",
"buffer",
"pool",
"=",
"null",
";",
"local",
"buffer",
"pool",
"local",
"buffer",
"pool",
"=",
"null",
";",
"try",
"{",
"network",
"buffer",
"pool",
"=",
"new",
"network",
"buffer",
"pool",
"(",
"1",
",",
"4096",
")",
";",
"local",
"buffer",
"pool",
"=",
"new",
"local",
"buffer",
"pool",
"(",
"network",
"buffer",
"pool",
",",
"1",
")",
";",
"/",
"/",
"drain",
"buffer",
"pool",
"assert",
"not",
"null",
"(",
"local",
"buffer",
"pool",
"request",
"buffer",
"(",
")",
")",
";",
"assert",
"null",
"(",
"local",
"buffer",
"pool",
"request",
"buffer",
"(",
")",
")",
";",
"/",
"/",
"start",
"request",
"thread",
"thread",
"thread",
"=",
"new",
"thread",
"(",
"new",
"buffer",
"request",
"task",
"(",
"local",
"buffer",
"pool",
",",
"async",
"exception",
")",
")",
";",
"thread",
"start",
"(",
")",
";",
"/",
"/",
"wait",
"for",
"request",
"boolean",
"success",
"=",
"false",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"50",
";",
"i",
"+",
"+",
")",
"{",
"stack",
"trace",
"element",
"[",
"]",
"stack",
"trace",
"=",
"thread",
"get",
"stack",
"trace",
"(",
")",
";",
"success",
"=",
"is",
"in",
"blocking",
"buffer",
"request",
"(",
"stack",
"trace",
")",
";",
"if",
"(",
"success",
")",
"{",
"break",
";",
"}",
"else",
"{",
"/",
"/",
"retry",
"thread",
"sleep",
"(",
"500",
")",
";",
"}",
"}",
"/",
"/",
"verify",
"that",
"thread",
"was",
"in",
"blocking",
"request",
"assert",
"true",
"(",
"\"",
"did",
"not",
"trigger",
"blocking",
"buffer",
"request",
"\"",
",",
"success",
")",
";",
"/",
"/",
"destroy",
"the",
"buffer",
"pool",
"local",
"buffer",
"pool",
"lazy",
"destroy",
"(",
")",
";",
"/",
"/",
"wait",
"for",
"thread",
"to",
"finish",
"thread",
"join",
"(",
")",
";",
"/",
"/",
"verify",
"expected",
"exception",
"assert",
"not",
"null",
"(",
"\"",
"did",
"not",
"throw",
"expected",
"exception",
"\"",
",",
"async",
"exception",
"get",
"(",
")",
")",
";",
"assert",
"true",
"(",
"async",
"exception",
"get",
"(",
")",
"instanceof",
"illegal",
"state",
"exception",
")",
";",
"}",
"finally",
"{",
"if",
"(",
"local",
"buffer",
"pool",
"!",
"=",
"null",
")",
"{",
"local",
"buffer",
"pool",
"lazy",
"destroy",
"(",
")",
";",
"}",
"if",
"(",
"network",
"buffer",
"pool",
"!",
"=",
"null",
")",
"{",
"network",
"buffer",
"pool",
"destroy",
"all",
"buffer",
"pools",
"(",
")",
";",
"network",
"buffer",
"pool",
"destroy",
"(",
")",
";",
"}",
"}",
"}"
]
|
[
"add",
"a",
"\"",
"no",
"-",
"cache",
"\"",
"directive",
"this",
"directive",
"is",
"well",
"suited",
"for",
"telling",
"caches",
"that",
"the",
"response",
"can",
"be",
"reused",
"only",
"if",
"the",
"client",
"revalidates",
"it",
"with",
"the",
"server",
"this",
"directive",
"won",
"'",
"t",
"disable",
"cache",
"altogether",
"and",
"may",
"result",
"with",
"clients",
"sending",
"conditional",
"requests",
"(",
"with",
"\"",
"e",
"tag",
"\"",
",",
"\"",
"if",
"-",
"modified",
"-",
"since",
"\"",
"headers",
")",
"and",
"the",
"server",
"responding",
"with",
"\"",
"304",
"-",
"not",
"modified",
"\"",
"status",
"in",
"order",
"to",
"disable",
"caching",
"and",
"minimize",
"requestsresponses",
"exchanges",
",",
"the",
"{",
"@",
"link",
"#",
"no",
"store",
"(",
")",
"}",
"directive",
"should",
"be",
"used",
"instead",
"of",
"{",
"@",
"code",
"#",
"no",
"cache",
"(",
")",
"}"
]
| [
"public",
"static",
"cache",
"control",
"no",
"cache",
"(",
")",
"{",
"cache",
"control",
"cc",
"=",
"new",
"cache",
"control",
"(",
")",
";",
"cc",
"no",
"cache",
"=",
"true",
";",
"return",
"cc",
";",
"}"
]
|
[
"when",
"the",
"channel",
"goes",
"inactive",
",",
"release",
"all",
"frames",
"to",
"prevent",
"data",
"leaks"
]
| [
"public",
"void",
"channel",
"inactive",
"(",
"channel",
"handler",
"context",
"ctx",
")",
"throws",
"exception",
"{",
"super",
"channel",
"inactive",
"(",
"ctx",
")",
";",
"reset",
"decoder",
"(",
")",
";",
"}"
]
|
[
"gets",
"the",
"file",
"status",
"for",
"the",
"given",
"uri",
"if",
"the",
"uri",
"is",
"in",
"the",
"cache",
",",
"returns",
"it",
"otherwise",
",",
"fetches",
"it",
"and",
"adds",
"it",
"to",
"the",
"cache"
]
| [
"private",
"static",
"file",
"status",
"get",
"file",
"status",
"(",
"configuration",
"job",
",",
"uri",
"uri",
",",
"map",
"<",
"uri",
",",
"file",
"status",
">",
"stat",
"cache",
")",
"throws",
"i",
"o",
"exception",
"{",
"file",
"system",
"file",
"system",
"=",
"file",
"system",
"get",
"(",
"uri",
",",
"job",
")",
";",
"return",
"get",
"file",
"status",
"(",
"file",
"system",
",",
"uri",
",",
"stat",
"cache",
")",
";",
"}"
]
|
[
"validate",
"the",
"final",
"resulting",
"path",
"listing",
"checks",
"if",
"there",
"are",
"duplicate",
"entries",
"if",
"preserving",
"a",
"c",
"ls",
",",
"checks",
"that",
"file",
"system",
"can",
"support",
"a",
"c",
"ls",
"if",
"preserving",
"x",
"attrs",
",",
"checks",
"that",
"file",
"system",
"can",
"support",
"x",
"attrs"
]
| [
"private",
"void",
"validate",
"final",
"listing",
"(",
"path",
"path",
"to",
"list",
"file",
",",
"dist",
"cp",
"context",
"context",
")",
"throws",
"duplicate",
"file",
"exception",
",",
"i",
"o",
"exception",
"{",
"configuration",
"config",
"=",
"get",
"conf",
"(",
")",
";",
"final",
"boolean",
"split",
"large",
"file",
"=",
"context",
"split",
"large",
"file",
"(",
")",
";",
"/",
"/",
"when",
"split",
"large",
"file",
"is",
"enabled",
",",
"we",
"don",
"'",
"t",
"randomize",
"the",
"copylist",
"/",
"/",
"earlier",
",",
"so",
"we",
"don",
"'",
"t",
"do",
"the",
"sorting",
"here",
"for",
"a",
"file",
"that",
"has",
"/",
"/",
"multiple",
"entries",
"due",
"to",
"split",
",",
"we",
"check",
"here",
"that",
"their",
"/",
"/",
"<",
"chunk",
"offset",
",",
"chunk",
"length",
">",
"is",
"continuous",
"/",
"/",
"path",
"check",
"path",
"=",
"split",
"large",
"file",
"?",
"path",
"to",
"list",
"file",
":",
"dist",
"cp",
"utils",
"sort",
"listing",
"(",
"config",
",",
"path",
"to",
"list",
"file",
")",
";",
"sequence",
"file",
"reader",
"reader",
"=",
"new",
"sequence",
"file",
"reader",
"(",
"config",
",",
"sequence",
"file",
"reader",
"file",
"(",
"check",
"path",
")",
")",
";",
"try",
"{",
"text",
"last",
"key",
"=",
"new",
"text",
"(",
"\"",
"*",
"\"",
")",
";",
"/",
"/",
"source",
"relative",
"path",
"can",
"never",
"hold",
"*",
"long",
"last",
"chunk",
"offset",
"=",
"-",
"1",
";",
"long",
"last",
"chunk",
"length",
"=",
"-",
"1",
";",
"copy",
"listing",
"file",
"status",
"last",
"file",
"status",
"=",
"new",
"copy",
"listing",
"file",
"status",
"(",
")",
";",
"text",
"current",
"key",
"=",
"new",
"text",
"(",
")",
";",
"set",
"<",
"uri",
">",
"acl",
"support",
"check",
"fs",
"set",
"=",
"sets",
"new",
"hash",
"set",
"(",
")",
";",
"set",
"<",
"uri",
">",
"x",
"attr",
"support",
"check",
"fs",
"set",
"=",
"sets",
"new",
"hash",
"set",
"(",
")",
";",
"long",
"idx",
"=",
"0",
";",
"while",
"(",
"reader",
"next",
"(",
"current",
"key",
")",
")",
"{",
"if",
"(",
"current",
"key",
"equals",
"(",
"last",
"key",
")",
")",
"{",
"copy",
"listing",
"file",
"status",
"current",
"file",
"status",
"=",
"new",
"copy",
"listing",
"file",
"status",
"(",
")",
";",
"reader",
"get",
"current",
"value",
"(",
"current",
"file",
"status",
")",
";",
"if",
"(",
"!",
"split",
"large",
"file",
")",
"{",
"throw",
"new",
"duplicate",
"file",
"exception",
"(",
"\"",
"file",
"\"",
"+",
"last",
"file",
"status",
"get",
"path",
"(",
")",
"+",
"\"",
"and",
"\"",
"+",
"current",
"file",
"status",
"get",
"path",
"(",
")",
"+",
"\"",
"would",
"cause",
"duplicates",
"aborting",
"\"",
")",
";",
"}",
"else",
"{",
"if",
"(",
"last",
"chunk",
"offset",
"+",
"last",
"chunk",
"length",
"!",
"=",
"current",
"file",
"status",
"get",
"chunk",
"offset",
"(",
")",
")",
"{",
"throw",
"new",
"invalid",
"input",
"exception",
"(",
"\"",
"file",
"\"",
"+",
"last",
"file",
"status",
"get",
"path",
"(",
")",
"+",
"\"",
"\"",
"+",
"last",
"chunk",
"offset",
"+",
"\"",
",",
"\"",
"+",
"last",
"chunk",
"length",
"+",
"\"",
"and",
"\"",
"+",
"current",
"file",
"status",
"get",
"path",
"(",
")",
"+",
"\"",
"\"",
"+",
"current",
"file",
"status",
"get",
"chunk",
"offset",
"(",
")",
"+",
"\"",
",",
"\"",
"+",
"current",
"file",
"status",
"get",
"chunk",
"length",
"(",
")",
"+",
"\"",
"are",
"not",
"continuous",
"aborting",
"\"",
")",
";",
"}",
"}",
"}",
"reader",
"get",
"current",
"value",
"(",
"last",
"file",
"status",
")",
";",
"if",
"(",
"context",
"should",
"preserve",
"(",
"dist",
"cp",
"options",
"file",
"attribute",
"acl",
")",
")",
"{",
"file",
"system",
"last",
"fs",
"=",
"last",
"file",
"status",
"get",
"path",
"(",
")",
"get",
"file",
"system",
"(",
"config",
")",
";",
"uri",
"last",
"fs",
"uri",
"=",
"last",
"fs",
"get",
"uri",
"(",
")",
";",
"if",
"(",
"!",
"acl",
"support",
"check",
"fs",
"set",
"contains",
"(",
"last",
"fs",
"uri",
")",
")",
"{",
"dist",
"cp",
"utils",
"check",
"file",
"system",
"acl",
"support",
"(",
"last",
"fs",
")",
";",
"acl",
"support",
"check",
"fs",
"set",
"add",
"(",
"last",
"fs",
"uri",
")",
";",
"}",
"}",
"if",
"(",
"context",
"should",
"preserve",
"(",
"dist",
"cp",
"options",
"file",
"attribute",
"xattr",
")",
")",
"{",
"file",
"system",
"last",
"fs",
"=",
"last",
"file",
"status",
"get",
"path",
"(",
")",
"get",
"file",
"system",
"(",
"config",
")",
";",
"uri",
"last",
"fs",
"uri",
"=",
"last",
"fs",
"get",
"uri",
"(",
")",
";",
"if",
"(",
"!",
"x",
"attr",
"support",
"check",
"fs",
"set",
"contains",
"(",
"last",
"fs",
"uri",
")",
")",
"{",
"dist",
"cp",
"utils",
"check",
"file",
"system",
"x",
"attr",
"support",
"(",
"last",
"fs",
")",
";",
"x",
"attr",
"support",
"check",
"fs",
"set",
"add",
"(",
"last",
"fs",
"uri",
")",
";",
"}",
"}",
"last",
"key",
"set",
"(",
"current",
"key",
")",
";",
"if",
"(",
"split",
"large",
"file",
")",
"{",
"last",
"chunk",
"offset",
"=",
"last",
"file",
"status",
"get",
"chunk",
"offset",
"(",
")",
";",
"last",
"chunk",
"length",
"=",
"last",
"file",
"status",
"get",
"chunk",
"length",
"(",
")",
";",
"}",
"if",
"(",
"context",
"should",
"use",
"diff",
"(",
")",
"&",
"&",
"log",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"log",
"debug",
"(",
"\"",
"copy",
"list",
"entry",
"\"",
"+",
"idx",
"+",
"\"",
":",
"\"",
"+",
"last",
"file",
"status",
"get",
"path",
"(",
")",
"to",
"uri",
"(",
")",
"get",
"path",
"(",
")",
")",
";",
"idx",
"+",
"+",
";",
"}",
"}",
"}",
"finally",
"{",
"i",
"o",
"utils",
"close",
"stream",
"(",
"reader",
")",
";",
"}",
"}"
]
|
[
"emits",
"the",
"resulting",
"entities",
"one",
"by",
"one",
",",
"producing",
"them",
"on",
"the",
"fly",
"(",
"\"",
"streaming",
"\"",
"entities",
")",
"unlike",
"{",
"@",
"link",
"#",
"list",
"(",
")",
"}",
",",
"it",
"does",
"not",
"wait",
"for",
"the",
"query",
"to",
"gather",
"all",
"results",
"thus",
",",
"the",
"first",
"entities",
"are",
"immediately",
"available",
"as",
"soon",
"the",
"underlying",
"database",
"cursor",
"has",
"data",
"this",
"approach",
"may",
"be",
"more",
"memory",
"efficient",
"for",
"large",
"number",
"of",
"entities",
"(",
"or",
"large",
"entities",
")",
"at",
"the",
"cost",
"of",
"additional",
"overhead",
"caused",
"by",
"a",
"per",
"-",
"entity",
"delivery",
"through",
"rx"
]
| [
"public",
"observable",
"<",
"t",
">",
"one",
"by",
"one",
"(",
")",
"{",
"observable",
"<",
"t",
">",
"observable",
"=",
"observable",
"create",
"(",
"new",
"on",
"subscribe",
"<",
"t",
">",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"call",
"(",
"subscriber",
"<",
"?",
"super",
"t",
">",
"subscriber",
")",
"{",
"try",
"{",
"lazy",
"list",
"<",
"t",
">",
"lazy",
"list",
"=",
"query",
"for",
"current",
"thread",
"(",
")",
"list",
"lazy",
"uncached",
"(",
")",
";",
"try",
"{",
"for",
"(",
"t",
"entity",
":",
"lazy",
"list",
")",
"{",
"if",
"(",
"subscriber",
"is",
"unsubscribed",
"(",
")",
")",
"{",
"break",
";",
"}",
"subscriber",
"on",
"next",
"(",
"entity",
")",
";",
"}",
"}",
"finally",
"{",
"lazy",
"list",
"close",
"(",
")",
";",
"}",
"if",
"(",
"!",
"subscriber",
"is",
"unsubscribed",
"(",
")",
")",
"{",
"subscriber",
"on",
"completed",
"(",
")",
";",
"}",
"}",
"catch",
"(",
"throwable",
"e",
")",
"{",
"exceptions",
"throw",
"if",
"fatal",
"(",
"e",
")",
";",
"subscriber",
"on",
"error",
"(",
"e",
")",
";",
"}",
"}",
"}",
")",
";",
"return",
"wrap",
"(",
"observable",
")",
";",
"}",
"/",
"/",
"@",
"experimental",
"/",
"/",
"public",
"query",
"<",
"t",
">",
"get",
"query",
"(",
")",
"{",
"/",
"/",
"return",
"query",
";",
"/",
"/",
"}"
]
|
[
"get",
"attribute",
"number"
]
| [
"public",
"big",
"decimal",
"get",
"attribute",
"number",
"(",
")",
"{",
"return",
"attribute",
"number",
";",
"}"
]
|
[
"used",
"in",
"the",
"op",
"code",
"check",
"watches",
",",
"which",
"is",
"a",
"read",
"operation",
",",
"since",
"read",
"and",
"write",
"requests",
"are",
"exclusively",
"processed",
",",
"we",
"don",
"'",
"t",
"need",
"to",
"hold",
"lock",
"here",
"different",
"from",
"add",
"watch",
"this",
"method",
"doesn",
"'",
"t",
"mutate",
"any",
"state",
",",
"so",
"we",
"don",
"'",
"t",
"need",
"to",
"hold",
"read",
"lock",
"to",
"avoid",
"dead",
"watcher",
"(",
"cnxn",
"closed",
")",
"being",
"added",
"to",
"the",
"watcher",
"manager",
"it",
"'",
"s",
"possible",
"that",
"before",
"we",
"lazily",
"clean",
"up",
"the",
"dead",
"watcher",
",",
"this",
"will",
"return",
"true",
",",
"but",
"since",
"the",
"cnxn",
"is",
"closed",
",",
"the",
"response",
"will",
"dropped",
"as",
"well",
",",
"so",
"it",
"doesn",
"'",
"t",
"matter"
]
| [
"public",
"boolean",
"contains",
"watcher",
"(",
"string",
"path",
",",
"watcher",
"watcher",
")",
"{",
"bit",
"hash",
"set",
"watchers",
"=",
"path",
"watches",
"get",
"(",
"path",
")",
";",
"return",
"watchers",
"!",
"=",
"null",
"&",
"&",
"watchers",
"contains",
"(",
"watcher",
"bit",
"id",
"map",
"get",
"bit",
"(",
"watcher",
")",
")",
";",
"}"
]
|
[
"asserts",
"that",
"a",
"zero",
"byte",
"file",
"has",
"a",
"status",
"of",
"file",
"and",
"not",
"directory",
"or",
"symlink"
]
| [
"public",
"void",
"test",
"multi",
"byte",
"files",
"are",
"files",
"(",
")",
"throws",
"exception",
"{",
"path",
"src",
"=",
"path",
"(",
"\"",
"test",
"multi",
"byte",
"files",
"are",
"files",
"\"",
")",
";",
"f",
"s",
"data",
"output",
"stream",
"out",
"=",
"fs",
"create",
"(",
"src",
")",
";",
"out",
"write",
"u",
"t",
"f",
"(",
"\"",
"test",
"multi",
"byte",
"files",
"are",
"files",
"\"",
")",
";",
"out",
"close",
"(",
")",
";",
"assert",
"is",
"file",
"(",
"src",
")",
";",
"}"
]
|
[
"returns",
"a",
"clear",
"{",
"@",
"link",
"format",
"holder",
"}"
]
| [
"protected",
"final",
"format",
"holder",
"get",
"format",
"holder",
"(",
")",
"{",
"format",
"holder",
"clear",
"(",
")",
";",
"return",
"format",
"holder",
";",
"}"
]
|
[
"get",
"namespace",
"number"
]
| [
"public",
"big",
"decimal",
"get",
"namespace",
"number",
"(",
")",
"{",
"return",
"namespace",
"number",
";",
"}"
]
|
[
"returns",
"true",
"if",
"the",
"file",
"is",
"a",
"directory",
"or",
"a",
"symlink",
"to",
"an",
"existing",
"directory",
"if",
"so",
",",
"its",
"parent",
"directory",
"is",
"guaranteed",
"to",
"exist"
]
| [
"public",
"boolean",
"is",
"directory",
"(",
")",
"{",
"return",
"real",
"file",
"state",
"value",
"(",
")",
"get",
"type",
"(",
")",
"=",
"=",
"file",
"state",
"type",
"directory",
";",
"}"
]
|
[
"get",
"small",
"snake"
]
| [
"public",
"string",
"get",
"small",
"snake",
"(",
")",
"{",
"return",
"small",
"snake",
";",
"}"
]
|
[
"when",
"looking",
"at",
"a",
"result",
"set",
"that",
"consists",
"of",
"a",
"map",
"hash",
"table",
"we",
"cannot",
"rely",
"on",
"the",
"output",
"order",
",",
"as",
"the",
"hashing",
"algorithm",
"or",
"other",
"aspects",
"of",
"the",
"implementation",
"may",
"be",
"different",
"on",
"differnt",
"j",
"d",
"ks",
"or",
"platforms",
"hence",
"we",
"take",
"the",
"map",
",",
"convert",
"the",
"keys",
"to",
"a",
"list",
",",
"sort",
"them",
"and",
"stringify",
"the",
"map",
",",
"which",
"is",
"a",
"bit",
"of",
"a",
"hack",
",",
"but",
"guarantees",
"that",
"we",
"get",
"the",
"same",
"order",
"on",
"all",
"systems",
"we",
"assume",
"that",
"the",
"keys",
"are",
"strings"
]
| [
"public",
"<",
"k",
",",
"v",
">",
"string",
"sort",
"map",
"to",
"string",
"(",
"map",
"<",
"k",
",",
"v",
">",
"m",
")",
"{",
"/",
"/",
"pass",
"in",
"crap",
",",
"and",
"get",
"nothing",
"back",
"/",
"/",
"if",
"(",
"m",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"system",
"out",
"println",
"(",
"\"",
"map",
"to",
"string",
"looks",
"like",
":",
"\"",
"+",
"m",
"to",
"string",
"(",
")",
")",
";",
"/",
"/",
"sort",
"the",
"keys",
"in",
"the",
"map",
"/",
"/",
"tree",
"map",
"<",
"k",
",",
"v",
">",
"nset",
"=",
"new",
"tree",
"map",
"<",
"k",
",",
"v",
">",
"(",
"m",
")",
";",
"system",
"out",
"println",
"(",
"\"",
"tree",
"map",
"looks",
"like",
":",
"\"",
"+",
"nset",
"to",
"string",
"(",
")",
")",
";",
"return",
"nset",
"to",
"string",
"(",
")",
";",
"}"
]
|
[
"clears",
"all",
"fields",
"of",
"this",
"row"
]
| [
"public",
"void",
"clear",
"(",
")",
"{",
"if",
"(",
"field",
"by",
"position",
"!",
"=",
"null",
")",
"{",
"arrays",
"fill",
"(",
"field",
"by",
"position",
",",
"null",
")",
";",
"}",
"else",
"{",
"assert",
"field",
"by",
"name",
"!",
"=",
"null",
";",
"field",
"by",
"name",
"clear",
"(",
")",
";",
"}",
"}"
]
|
[
"sets",
"the",
"{",
"@",
"code",
"ignore",
"file",
"override",
"}",
"and",
"returns",
"a",
"reference",
"to",
"this",
"builder",
"so",
"that",
"the",
"methods",
"can",
"be",
"chained",
"together"
]
| [
"public",
"builder",
"with",
"ignore",
"file",
"override",
"(",
"string",
"ignore",
"file",
"override",
")",
"{",
"this",
"ignore",
"file",
"override",
"=",
"ignore",
"file",
"override",
";",
"return",
"this",
";",
"}"
]
|
[
"specify",
"headers",
"to",
"add",
"to",
"the",
"response"
]
| [
"b",
"headers",
"(",
"http",
"headers",
"headers",
")",
";"
]
|
[
"returns",
"the",
"parent",
"pointer"
]
| [
"public",
"long",
"get",
"parent",
"pointer",
"(",
")",
"{",
"return",
"parent",
"pointer",
";",
"}"
]
|
[
"performs",
"the",
"selective",
"clearing",
"for",
"a",
"given",
"key"
]
| [
"public",
"void",
"selective",
"clearing",
"(",
"key",
"k",
",",
"short",
"scheme",
")",
"{",
"if",
"(",
"k",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"null",
"pointer",
"exception",
"(",
"\"",
"key",
"can",
"not",
"be",
"null",
"\"",
")",
";",
"}",
"if",
"(",
"!",
"membership",
"test",
"(",
"k",
")",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"key",
"is",
"not",
"a",
"member",
"\"",
")",
";",
"}",
"int",
"index",
"=",
"0",
";",
"int",
"[",
"]",
"h",
"=",
"hash",
"hash",
"(",
"k",
")",
";",
"switch",
"(",
"scheme",
")",
"{",
"case",
"random",
":",
"index",
"=",
"random",
"remove",
"(",
")",
";",
"break",
";",
"case",
"minimum",
"fn",
":",
"index",
"=",
"minimum",
"fn",
"remove",
"(",
"h",
")",
";",
"break",
";",
"case",
"maximum",
"fp",
":",
"index",
"=",
"maximum",
"fp",
"remove",
"(",
"h",
")",
";",
"break",
";",
"case",
"ratio",
":",
"index",
"=",
"ratio",
"remove",
"(",
"h",
")",
";",
"break",
";",
"default",
":",
"throw",
"new",
"assertion",
"error",
"(",
"\"",
"undefined",
"selective",
"clearing",
"scheme",
"\"",
")",
";",
"}",
"clear",
"bit",
"(",
"index",
")",
";",
"}"
]
|
[
"invalidates",
"the",
"index",
"buffer",
"object",
"so",
"a",
"new",
"open",
"g",
"l",
"buffer",
"handle",
"is",
"created",
"use",
"this",
"in",
"case",
"of",
"a",
"context",
"loss"
]
| [
"public",
"void",
"invalidate",
"(",
")",
"{",
"buffer",
"handle",
"=",
"gdx",
"gl",
"2",
"0",
"gl",
"gen",
"buffer",
"(",
")",
";",
"is",
"dirty",
"=",
"true",
";",
"}"
]
|
[
"get",
"argument",
"value",
"for",
"the",
"given",
"index",
"in",
"the",
"constructor",
"argument",
"list"
]
| [
"public",
"value",
"holder",
"get",
"indexed",
"argument",
"value",
"(",
"int",
"index",
",",
"@",
"nullable",
"class",
"<",
"?",
">",
"required",
"type",
",",
"@",
"nullable",
"string",
"required",
"name",
")",
"{",
"assert",
"is",
"true",
"(",
"index",
">",
"=",
"0",
",",
"\"",
"index",
"must",
"not",
"be",
"negative",
"\"",
")",
";",
"value",
"holder",
"value",
"holder",
"=",
"this",
"indexed",
"argument",
"values",
"get",
"(",
"index",
")",
";",
"if",
"(",
"value",
"holder",
"!",
"=",
"null",
"&",
"&",
"(",
"value",
"holder",
"get",
"type",
"(",
")",
"=",
"=",
"null",
"|",
"|",
"(",
"required",
"type",
"!",
"=",
"null",
"&",
"&",
"class",
"utils",
"matches",
"type",
"name",
"(",
"required",
"type",
",",
"value",
"holder",
"get",
"type",
"(",
")",
")",
")",
")",
"&",
"&",
"(",
"value",
"holder",
"get",
"name",
"(",
")",
"=",
"=",
"null",
"|",
"|",
"(",
"required",
"name",
"!",
"=",
"null",
"&",
"&",
"(",
"required",
"name",
"is",
"empty",
"(",
")",
"|",
"|",
"required",
"name",
"equals",
"(",
"value",
"holder",
"get",
"name",
"(",
")",
")",
")",
")",
")",
")",
"{",
"return",
"value",
"holder",
";",
"}",
"return",
"null",
";",
"}"
]
|
[
"prepare",
"a",
"builder",
"by",
"copying",
"the",
"scheme",
",",
"host",
",",
"port",
",",
"path",
",",
"and",
"query",
"string",
"of",
"an",
"http",
"servlet",
"request"
]
| [
"public",
"static",
"servlet",
"uri",
"components",
"builder",
"from",
"request",
"(",
"http",
"servlet",
"request",
"request",
")",
"{",
"servlet",
"uri",
"components",
"builder",
"builder",
"=",
"init",
"from",
"request",
"(",
"request",
")",
";",
"builder",
"init",
"path",
"(",
"request",
"get",
"request",
"u",
"r",
"i",
"(",
")",
")",
";",
"builder",
"query",
"(",
"request",
"get",
"query",
"string",
"(",
")",
")",
";",
"return",
"builder",
";",
"}"
]
|
[
"flushes",
"any",
"outstanding",
"writes",
"and",
"then",
"reads",
"to",
"the",
"current",
"end",
"of",
"the",
"log",
"and",
"invokes",
"the",
"specified",
"callback",
"note",
"that",
"this",
"checks",
"the",
"current",
",",
"offsets",
",",
"reads",
"to",
"them",
",",
"and",
"invokes",
"the",
"callback",
"regardless",
"of",
"whether",
"additional",
"records",
"have",
"been",
"written",
"to",
"the",
"log",
"if",
"the",
"caller",
"needs",
"to",
"ensure",
"they",
"have",
"truly",
"reached",
"the",
"end",
"of",
"the",
"log",
",",
"they",
"must",
"ensure",
"there",
"are",
"no",
"other",
"writers",
"during",
"this",
"period",
"this",
"waits",
"until",
"the",
"end",
"of",
"all",
"partitions",
"has",
"been",
"reached",
"this",
"method",
"is",
"asynchronous",
"if",
"you",
"need",
"a",
"synchronous",
"version",
",",
"pass",
"an",
"instance",
"of",
"{",
"@",
"link",
"org",
"apache",
"kafka",
"connect",
"util",
"future",
"callback",
"}",
"as",
"the",
"{"
]
| [
"public",
"void",
"read",
"to",
"end",
"(",
"callback",
"<",
"void",
">",
"callback",
")",
"{",
"log",
"trace",
"(",
"\"",
"starting",
"read",
"to",
"end",
"log",
"for",
"topic",
"{",
"}",
"\"",
",",
"topic",
")",
";",
"producer",
"flush",
"(",
")",
";",
"synchronized",
"(",
"this",
")",
"{",
"read",
"log",
"end",
"offset",
"callbacks",
"add",
"(",
"callback",
")",
";",
"}",
"consumer",
"wakeup",
"(",
")",
";",
"}"
]
|
[
"this",
"ignores",
"the",
"reserved",
"span",
"name",
"\"",
"all",
"\""
]
| [
"public",
"builder",
"span",
"name",
"(",
"@",
"nullable",
"string",
"span",
"name",
")",
"{",
"this",
"span",
"name",
"=",
"span",
"name",
";",
"return",
"this",
";",
"}"
]
|
[
"test",
"for",
"the",
"case",
"when",
"the",
"following",
"submit",
"application",
"and",
"administer",
"queue",
"a",
"c",
"ls",
"are",
"defined",
":",
"root",
":",
"(",
"none",
")",
"d",
":",
"(",
"none",
")",
"d1",
":",
"(",
"all",
")",
"expected",
"result",
":",
"only",
"queue",
"d1",
"can",
"be",
"accessed"
]
| [
"public",
"void",
"test",
"queue",
"acl",
"restricted",
"root",
"and",
"d",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"update",
"config",
"with",
"d",
"and",
"d",
"1",
"queues",
"(",
"none",
"acl",
",",
"none",
"acl",
",",
"all",
"acl",
")",
";",
"check",
"access",
"(",
"false",
",",
"false",
",",
"true",
")",
";",
"}"
]
|
[
"returns",
"true",
"if",
"the",
"only",
"{",
"@",
"link",
"file",
"system",
"ref",
"}",
"pinning",
"this",
"filesystem",
"is",
"the",
"caller",
"'",
"s",
"ref"
]
| [
"public",
"synchronized",
"boolean",
"can",
"close",
"(",
"file",
"system",
"ref",
"callers",
"ref",
")",
"{",
"return",
"refs",
"size",
"(",
")",
"=",
"=",
"1",
"&",
"&",
"refs",
"get",
"(",
"0",
")",
"=",
"=",
"callers",
"ref",
";",
"}"
]
|
[
"returns",
"an",
"{",
"@",
"link",
"escaper",
"}",
"instance",
"that",
"escapes",
"special",
"characters",
"in",
"a",
"string",
"so",
"it",
"can",
"safely",
"be",
"included",
"in",
"an",
"xml",
"document",
"as",
"element",
"content",
"see",
"section",
"<",
"a",
"href",
"=",
"\"",
"http",
":",
"www",
"w",
"3",
"org",
"t",
"r",
"2",
"0",
"0",
"8",
"r",
"e",
"c",
"-",
"xml",
"-",
"20081126",
"#",
"syntax",
"\"",
">",
"2",
"4",
"of",
"the",
"xml",
"specification",
"<",
"b",
">",
"note",
":",
"<",
"b",
">",
"double",
"and",
"single",
"quotes",
"are",
"not",
"escaped",
",",
"so",
"it",
"is",
"<",
"b",
">",
"not",
"safe",
"<",
"b",
">",
"to",
"use",
"this",
"escaper",
"to",
"escape",
"attribute",
"values",
"use",
"{",
"@",
"link",
"#",
"xml",
"content",
"escaper",
"}",
"if",
"the",
"output",
"can",
"appear",
"in",
"element",
"content",
"or",
"{",
"@",
"link",
"#",
"xml",
"attribute",
"escaper",
"}",
"in",
"attribute",
"values",
"this",
"escaper",
"substitutes",
"{",
"@",
"code",
"0x",
"f",
"f",
"f",
"d",
"}",
"for",
"non",
"-",
"whitespace",
"control",
"characters",
"and",
"the",
"character",
"values",
"{",
"@",
"code",
"0x",
"f",
"f",
"f",
"e",
"}",
"and",
"{",
"@",
"code",
"0x",
"f",
"f",
"f",
"f",
"}",
"which",
"are",
"not",
"permitted",
"in",
"xml",
"for",
"more",
"detail",
"see",
"section",
"<",
"a",
"href",
"=",
"\"",
"http",
":",
"www",
"w",
"3",
"org",
"t",
"r",
"2",
"0",
"0",
"8",
"r",
"e",
"c",
"-",
"xml",
"-",
"20081126",
"#",
"charsets",
"\"",
">",
"2",
"2",
"of",
"the",
"xml",
"specification",
"this",
"escaper",
"does",
"not",
"escape",
"non",
"-",
"ascii",
"characters",
"to",
"their",
"numeric",
"character",
"references",
"(",
"ncr",
")",
"any",
"non",
"-",
"ascii",
"characters",
"appearing",
"in",
"the",
"input",
"will",
"be",
"preserved",
"in",
"the",
"output",
"specifically",
"\"",
"\\",
"r",
"\"",
"(",
"carriage",
"return",
")",
"is",
"preserved",
"in",
"the",
"output",
",",
"which",
"may",
"result",
"in",
"it",
"being",
"silently",
"converted",
"to",
"\"",
"\\",
"n",
"\"",
"when",
"the",
"xml",
"is",
"parsed",
"this",
"escaper",
"does",
"not",
"treat",
"surrogate",
"pairs",
"specially",
"and",
"does",
"not",
"perform",
"unicode",
"validation",
"on",
"its",
"input"
]
| [
"public",
"static",
"escaper",
"xml",
"content",
"escaper",
"(",
")",
"{",
"return",
"xml",
"content",
"escaper",
";",
"}"
]
|
[
"set",
"the",
"current",
"group",
"subscription",
"this",
"is",
"used",
"by",
"the",
"group",
"leader",
"to",
"ensure",
"that",
"it",
"receives",
"metadata",
"updates",
"for",
"all",
"topics",
"that",
"the",
"group",
"is",
"interested",
"in"
]
| [
"synchronized",
"boolean",
"group",
"subscribe",
"(",
"collection",
"<",
"string",
">",
"topics",
")",
"{",
"if",
"(",
"!",
"has",
"auto",
"assigned",
"partitions",
"(",
")",
")",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"subscription",
"exception",
"message",
")",
";",
"group",
"subscription",
"=",
"new",
"hash",
"set",
"<",
">",
"(",
"topics",
")",
";",
"return",
"!",
"subscription",
"contains",
"all",
"(",
"group",
"subscription",
")",
";",
"}"
]
|
[
"return",
"the",
"list",
"of",
"all",
"schemas",
"in",
"the",
"'",
"componentsschemas",
"'",
"section",
"of",
"an",
"open",
"a",
"p",
"i",
"specification",
",",
"including",
"inlined",
"schemas",
"and",
"children",
"of",
"composed",
"schemas"
]
| [
"public",
"static",
"list",
"<",
"schema",
">",
"get",
"all",
"schemas",
"(",
"open",
"a",
"p",
"i",
"open",
"a",
"p",
"i",
")",
"{",
"list",
"<",
"schema",
">",
"all",
"schemas",
"=",
"new",
"array",
"list",
"<",
"schema",
">",
"(",
")",
";",
"list",
"<",
"string",
">",
"ref",
"schemas",
"=",
"new",
"array",
"list",
"<",
"string",
">",
"(",
")",
";",
"get",
"schemas",
"(",
"open",
"a",
"p",
"i",
")",
"for",
"each",
"(",
"(",
"key",
",",
"schema",
")",
"-",
">",
"{",
"/",
"/",
"invoke",
"visit",
"schema",
"to",
"recursively",
"visit",
"all",
"schema",
"objects",
",",
"included",
"inlined",
"and",
"composed",
"schemas",
"/",
"/",
"use",
"the",
"open",
"a",
"p",
"i",
"schema",
"visitor",
"visitor",
"function",
"visit",
"schema",
"(",
"open",
"a",
"p",
"i",
",",
"schema",
",",
"null",
",",
"ref",
"schemas",
",",
"(",
"s",
",",
"mimetype",
")",
"-",
">",
"{",
"all",
"schemas",
"add",
"(",
"s",
")",
";",
"}",
")",
";",
"}",
")",
";",
"return",
"all",
"schemas",
";",
"}"
]
|
[
"sets",
"the",
"width",
"of",
"the",
"line",
"when",
"selected"
]
| [
"public",
"void",
"set",
"selected",
"(",
"int",
"value",
")",
"{",
"super",
"set",
"selected",
"(",
"value",
")",
";",
"editable",
"label",
"column",
"label",
"=",
"get",
"figure",
"(",
")",
"get",
"label",
"(",
")",
";",
"if",
"(",
"value",
"!",
"=",
"edit",
"part",
"selected",
"none",
")",
"column",
"label",
"set",
"selected",
"(",
"true",
")",
";",
"else",
"column",
"label",
"set",
"selected",
"(",
"false",
")",
";",
"column",
"label",
"repaint",
"(",
")",
";",
"}"
]
|
[
"create",
"a",
"{",
"@",
"link",
"consumer",
"record",
"}",
"with",
"default",
"topic",
"name",
"and",
"given",
"key",
",",
"value",
",",
"headers",
",",
"and",
"timestamp",
"does",
"not",
"auto",
"advance",
"internally",
"tracked",
"time"
]
| [
"public",
"consumer",
"record",
"<",
"byte",
"[",
"]",
",",
"byte",
"[",
"]",
">",
"create",
"(",
"final",
"k",
"key",
",",
"final",
"v",
"value",
",",
"final",
"headers",
"headers",
",",
"final",
"long",
"timestamp",
"ms",
")",
"{",
"if",
"(",
"topic",
"name",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"consumer",
"record",
"factory",
"was",
"created",
"without",
"default",
"topic",
"name",
"\"",
"+",
"\"",
"use",
"#",
"create",
"(",
"string",
"topic",
"name",
",",
"k",
"key",
",",
"v",
"value",
",",
"long",
"timestamp",
"ms",
")",
"instead",
"\"",
")",
";",
"}",
"return",
"create",
"(",
"topic",
"name",
",",
"key",
",",
"value",
",",
"headers",
",",
"timestamp",
"ms",
")",
";",
"}"
]
|
[
"process",
"server",
"response",
":",
"http1",
"1",
"101",
"web",
"socket",
"protocol",
"handshake",
"upgrade",
":",
"web",
"socket",
"connection",
":",
"upgrade",
"sec",
"-",
"web",
"socket",
"-",
"origin",
":",
"http",
":",
"example",
"com",
"sec",
"-",
"web",
"socket",
"-",
"location",
":",
"ws",
":",
"example",
"comdemo",
"sec",
"-",
"web",
"socket",
"-",
"protocol",
":",
"sample",
"8j",
"k",
"s",
"'",
"y",
":",
"g",
"co",
",",
"wxa",
"-"
]
| [
"protected",
"void",
"verify",
"(",
"full",
"http",
"response",
"response",
")",
"{",
"http",
"response",
"status",
"status",
"=",
"response",
"status",
"(",
")",
";",
"if",
"(",
"!",
"http",
"response",
"status",
"switching",
"protocols",
"equals",
"(",
"status",
")",
")",
"{",
"throw",
"new",
"web",
"socket",
"client",
"handshake",
"exception",
"(",
"\"",
"invalid",
"handshake",
"response",
"get",
"status",
":",
"\"",
"+",
"status",
",",
"response",
")",
";",
"}",
"http",
"headers",
"headers",
"=",
"response",
"headers",
"(",
")",
";",
"char",
"sequence",
"upgrade",
"=",
"headers",
"get",
"(",
"http",
"header",
"names",
"upgrade",
")",
";",
"if",
"(",
"!",
"http",
"header",
"values",
"websocket",
"content",
"equals",
"ignore",
"case",
"(",
"upgrade",
")",
")",
"{",
"throw",
"new",
"web",
"socket",
"client",
"handshake",
"exception",
"(",
"\"",
"invalid",
"handshake",
"response",
"upgrade",
":",
"\"",
"+",
"upgrade",
",",
"response",
")",
";",
"}",
"if",
"(",
"!",
"headers",
"contains",
"value",
"(",
"http",
"header",
"names",
"connection",
",",
"http",
"header",
"values",
"upgrade",
",",
"true",
")",
")",
"{",
"throw",
"new",
"web",
"socket",
"client",
"handshake",
"exception",
"(",
"\"",
"invalid",
"handshake",
"response",
"connection",
":",
"\"",
"+",
"headers",
"get",
"(",
"http",
"header",
"names",
"connection",
")",
",",
"response",
")",
";",
"}",
"byte",
"buf",
"challenge",
"=",
"response",
"content",
"(",
")",
";",
"if",
"(",
"!",
"challenge",
"equals",
"(",
"expected",
"challenge",
"response",
"bytes",
")",
")",
"{",
"throw",
"new",
"web",
"socket",
"client",
"handshake",
"exception",
"(",
"\"",
"invalid",
"challenge",
"\"",
",",
"response",
")",
";",
"}",
"}"
]
|
[
"return",
"the",
"bytes",
"of",
"file",
"'",
"s",
"md5",
"encryption"
]
| [
"public",
"static",
"byte",
"[",
"]",
"encrypt",
"m",
"d",
"5",
"file",
"(",
"final",
"string",
"file",
"path",
")",
"{",
"file",
"file",
"=",
"utils",
"bridge",
"is",
"space",
"(",
"file",
"path",
")",
"?",
"null",
":",
"new",
"file",
"(",
"file",
"path",
")",
";",
"return",
"encrypt",
"m",
"d",
"5",
"file",
"(",
"file",
")",
";",
"}"
]
|
[
"tests",
"that",
"in",
"case",
"of",
"a",
"failing",
"async",
"checkpoint",
"runnable",
"all",
"operator",
"snapshot",
"results",
"are",
"cancelled",
"and",
"all",
"non",
"partitioned",
"state",
"handles",
"are",
"discarded"
]
| [
"public",
"void",
"test",
"failing",
"async",
"checkpoint",
"runnable",
"(",
")",
"throws",
"exception",
"{",
"/",
"/",
"mock",
"the",
"new",
"state",
"operator",
"snapshots",
"operator",
"snapshot",
"futures",
"operator",
"snapshot",
"result",
"1",
"=",
"mock",
"(",
"operator",
"snapshot",
"futures",
"class",
")",
";",
"operator",
"snapshot",
"futures",
"operator",
"snapshot",
"result",
"2",
"=",
"mock",
"(",
"operator",
"snapshot",
"futures",
"class",
")",
";",
"operator",
"snapshot",
"futures",
"operator",
"snapshot",
"result",
"3",
"=",
"mock",
"(",
"operator",
"snapshot",
"futures",
"class",
")",
";",
"runnable",
"future",
"<",
"snapshot",
"result",
"<",
"operator",
"state",
"handle",
">",
">",
"failing",
"future",
"=",
"mock",
"(",
"runnable",
"future",
"class",
")",
";",
"when",
"(",
"failing",
"future",
"get",
"(",
")",
")",
"then",
"throw",
"(",
"new",
"execution",
"exception",
"(",
"new",
"exception",
"(",
"\"",
"test",
"exception",
"\"",
")",
")",
")",
";",
"when",
"(",
"operator",
"snapshot",
"result",
"3",
"get",
"operator",
"state",
"raw",
"future",
"(",
")",
")",
"then",
"return",
"(",
"failing",
"future",
")",
";",
"try",
"(",
"mock",
"environment",
"mock",
"environment",
"=",
"new",
"mock",
"environment",
"builder",
"(",
")",
"build",
"(",
")",
")",
"{",
"running",
"task",
"<",
"mock",
"stream",
"task",
">",
"task",
"=",
"run",
"task",
"(",
"(",
")",
"-",
">",
"create",
"mock",
"stream",
"task",
"(",
"mock",
"environment",
",",
"operator",
"chain",
"(",
"stream",
"operator",
"with",
"snapshot",
"(",
"operator",
"snapshot",
"result",
"1",
")",
",",
"stream",
"operator",
"with",
"snapshot",
"(",
"operator",
"snapshot",
"result",
"2",
")",
",",
"stream",
"operator",
"with",
"snapshot",
"(",
"operator",
"snapshot",
"result",
"3",
")",
")",
")",
")",
";",
"mock",
"stream",
"task",
"stream",
"task",
"=",
"task",
"stream",
"task",
";",
"wait",
"task",
"is",
"running",
"(",
"stream",
"task",
",",
"task",
"invocation",
"future",
")",
";",
"mock",
"environment",
"set",
"expected",
"external",
"failure",
"cause",
"(",
"throwable",
"class",
")",
";",
"stream",
"task",
"trigger",
"checkpoint",
"async",
"(",
"new",
"checkpoint",
"meta",
"data",
"(",
"42l",
",",
"1l",
")",
",",
"checkpoint",
"options",
"for",
"checkpoint",
"with",
"default",
"location",
"(",
")",
",",
"false",
")",
"get",
"(",
")",
";",
"/",
"/",
"wait",
"for",
"the",
"completion",
"of",
"the",
"async",
"task",
"executor",
"service",
"executor",
"=",
"stream",
"task",
"get",
"async",
"operations",
"thread",
"pool",
"(",
")",
";",
"executor",
"shutdown",
"(",
")",
";",
"if",
"(",
"!",
"executor",
"await",
"termination",
"(",
"10000l",
",",
"time",
"unit",
"milliseconds",
")",
")",
"{",
"fail",
"(",
"\"",
"executor",
"did",
"not",
"shut",
"down",
"within",
"the",
"given",
"timeout",
"this",
"indicates",
"that",
"the",
"\"",
"+",
"\"",
"checkpointing",
"did",
"not",
"resume",
"\"",
")",
";",
"}",
"assert",
"true",
"(",
"mock",
"environment",
"get",
"actual",
"external",
"failure",
"cause",
"(",
")",
"is",
"present",
"(",
")",
")",
";",
"verify",
"(",
"operator",
"snapshot",
"result",
"1",
")",
"cancel",
"(",
")",
";",
"verify",
"(",
"operator",
"snapshot",
"result",
"2",
")",
"cancel",
"(",
")",
";",
"verify",
"(",
"operator",
"snapshot",
"result",
"3",
")",
"cancel",
"(",
")",
";",
"stream",
"task",
"finish",
"input",
"(",
")",
";",
"task",
"wait",
"for",
"task",
"completion",
"(",
"false",
")",
";",
"}",
"}"
]
|
[
"this",
"will",
"be",
"called",
"once",
"the",
"view",
"visible",
"part",
"changes",
"on",
"model",
"visibility",
"changed",
"listener",
"should",
"be",
"used",
"with",
"particular",
"care",
"since",
"they",
"will",
"be",
"dispatched",
"on",
"every",
"frame",
"while",
"scrolling",
"no",
"heavy",
"work",
"should",
"be",
"done",
"inside",
"the",
"implementation",
"using",
"{",
"@",
"link",
"on",
"model",
"visibility",
"state",
"changed",
"listener",
"}",
"is",
"recommended",
"whenever",
"possible"
]
| [
"void",
"on",
"visibility",
"changed",
"(",
"t",
"model",
",",
"v",
"view",
",",
"@",
"float",
"range",
"(",
"from",
"=",
"0",
",",
"to",
"=",
"100",
")",
"float",
"percent",
"visible",
"height",
",",
"@",
"float",
"range",
"(",
"from",
"=",
"0",
",",
"to",
"=",
"100",
")",
"float",
"percent",
"visible",
"width",
",",
"@",
"px",
"int",
"height",
"visible",
",",
"@",
"px",
"int",
"width",
"visible",
")",
";"
]
|
[
"whether",
"the",
"model",
"'",
"s",
"view",
"should",
"be",
"shown",
"on",
"screen",
"if",
"false",
"it",
"won",
"'",
"t",
"be",
"inflated",
"and",
"drawn",
",",
"and",
"will",
"be",
"like",
"it",
"was",
"never",
"added",
"to",
"the",
"recycler",
"view"
]
| [
"public",
"boolean",
"is",
"shown",
"(",
")",
"{",
"return",
"shown",
";",
"}"
]
|
[
"verify",
"each",
"component",
"name",
"of",
"a",
"destination",
"path",
"for",
"fs",
"limit"
]
| [
"void",
"verify",
"max",
"component",
"length",
"(",
"string",
"dest",
"path",
")",
"throws",
"path",
"component",
"too",
"long",
"exception",
"{",
"if",
"(",
"max",
"component",
"length",
"<",
"=",
"0",
")",
"{",
"return",
";",
"}",
"if",
"(",
"dest",
"path",
"=",
"=",
"null",
")",
"{",
"return",
";",
"}",
"string",
"[",
"]",
"components",
"=",
"dest",
"path",
"split",
"(",
"path",
"separator",
")",
";",
"for",
"(",
"string",
"component",
":",
"components",
")",
"{",
"int",
"length",
"=",
"component",
"length",
"(",
")",
";",
"if",
"(",
"length",
">",
"max",
"component",
"length",
")",
"{",
"path",
"component",
"too",
"long",
"exception",
"e",
"=",
"new",
"path",
"component",
"too",
"long",
"exception",
"(",
"max",
"component",
"length",
",",
"length",
",",
"dest",
"path",
",",
"component",
")",
";",
"throw",
"e",
";",
"}",
"}",
"}"
]
|
[
"override",
"{",
"@",
"link",
"namespace",
"handler",
"support",
"#",
"parse",
"(",
"element",
",",
"parser",
"context",
")",
"}",
"method"
]
| [
"public",
"bean",
"definition",
"parse",
"(",
"element",
"element",
",",
"parser",
"context",
"parser",
"context",
")",
"{",
"bean",
"definition",
"registry",
"registry",
"=",
"parser",
"context",
"get",
"registry",
"(",
")",
";",
"register",
"annotation",
"config",
"processors",
"(",
"registry",
")",
";",
"/",
"*",
"*",
"*",
"@",
"since",
"2",
"7",
"8",
"*",
"issue",
":",
"https",
":",
"/",
"/",
"github",
"com",
"/",
"apache",
"/",
"dubbo",
"/",
"issues",
"/",
"6275",
"*",
"/",
"register",
"common",
"beans",
"(",
"registry",
")",
";",
"bean",
"definition",
"bean",
"definition",
"=",
"super",
"parse",
"(",
"element",
",",
"parser",
"context",
")",
";",
"set",
"source",
"(",
"bean",
"definition",
")",
";",
"return",
"bean",
"definition",
";",
"}"
]
|
[
"test",
"the",
"property",
"'",
"property",
"class",
"'"
]
| [
"public",
"void",
"property",
"class",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"property",
"class",
"}"
]
|
[
"put",
"the",
"future",
"in",
"the",
"cache",
"if",
"it",
"does",
"not",
"already",
"exist",
"if",
"this",
"method",
"returns",
"a",
"non",
"-",
"null",
"value",
"then",
"another",
"thread",
"won",
"the",
"race",
"and",
"it",
"should",
"be",
"returned",
"instead",
"of",
"proceeding",
"with",
"execution",
"of",
"the",
"new",
"future"
]
| [
"/",
"*",
"package",
"*",
"/",
"<",
"t",
">",
"hystrix",
"cached",
"observable",
"<",
"t",
">",
"put",
"if",
"absent",
"(",
"string",
"cache",
"key",
",",
"hystrix",
"cached",
"observable",
"<",
"t",
">",
"f",
")",
"{",
"value",
"cache",
"key",
"key",
"=",
"get",
"request",
"cache",
"key",
"(",
"cache",
"key",
")",
";",
"if",
"(",
"key",
"!",
"=",
"null",
")",
"{",
"/",
"*",
"look",
"for",
"the",
"stored",
"value",
"*",
"/",
"concurrent",
"hash",
"map",
"<",
"value",
"cache",
"key",
",",
"hystrix",
"cached",
"observable",
"<",
"?",
">",
">",
"cache",
"instance",
"=",
"request",
"variable",
"for",
"cache",
"get",
"(",
"concurrency",
"strategy",
")",
";",
"if",
"(",
"cache",
"instance",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"request",
"caching",
"is",
"not",
"available",
"maybe",
"you",
"need",
"to",
"initialize",
"the",
"hystrix",
"request",
"context",
"?",
"\"",
")",
";",
"}",
"hystrix",
"cached",
"observable",
"<",
"t",
">",
"already",
"set",
"=",
"(",
"hystrix",
"cached",
"observable",
"<",
"t",
">",
")",
"cache",
"instance",
"put",
"if",
"absent",
"(",
"key",
",",
"f",
")",
";",
"if",
"(",
"already",
"set",
"!",
"=",
"null",
")",
"{",
"/",
"/",
"someone",
"beat",
"us",
"so",
"we",
"didn",
"'",
"t",
"cache",
"this",
"return",
"already",
"set",
";",
"}",
"}",
"/",
"/",
"we",
"either",
"set",
"it",
"in",
"the",
"cache",
"or",
"do",
"not",
"have",
"a",
"cache",
"key",
"return",
"null",
";",
"}"
]
|
[
"gets",
"the",
"{",
"@",
"link",
"local",
"cache",
"}",
"used",
"by",
"the",
"given",
"{",
"@",
"link",
"cache",
"}",
",",
"if",
"any",
",",
"or",
"throws",
"an",
"illegal",
"argument",
"exception",
"if",
"this",
"is",
"a",
"cache",
"type",
"that",
"doesn",
"'",
"t",
"have",
"a",
"local",
"cache"
]
| [
"static",
"<",
"k",
",",
"v",
">",
"local",
"cache",
"<",
"k",
",",
"v",
">",
"to",
"local",
"cache",
"(",
"cache",
"<",
"k",
",",
"v",
">",
"cache",
")",
"{",
"if",
"(",
"cache",
"instanceof",
"local",
"loading",
"cache",
")",
"{",
"return",
"(",
"(",
"local",
"loading",
"cache",
"<",
"k",
",",
"v",
">",
")",
"cache",
")",
"local",
"cache",
";",
"}",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"cache",
"of",
"type",
"\"",
"+",
"cache",
"get",
"class",
"(",
")",
"+",
"\"",
"doesn",
"'",
"t",
"have",
"a",
"local",
"cache",
"\"",
")",
";",
"}"
]
|
[
"returns",
"the",
"marker",
"that",
"is",
"set",
"as",
"a",
"marker",
"view",
"for",
"the",
"chart"
]
| [
"public",
"i",
"marker",
"get",
"marker",
"(",
")",
"{",
"return",
"m",
"marker",
";",
"}"
]
|
[
"returns",
"the",
"device",
"number",
"of",
"this",
"inode"
]
| [
"public",
"int",
"get",
"device",
"number",
"(",
")",
"{",
"return",
"st",
"dev",
";",
"}"
]
|
[
"initiate",
"a",
"bulk",
"write",
"and",
"create",
"an",
"operation",
"state",
"for",
"it",
"this",
"may",
"then",
"be",
"passed",
"into",
"put",
"operations"
]
| [
"public",
"static",
"bulk",
"operation",
"state",
"initiate",
"bulk",
"write",
"(",
"@",
"nullable",
"final",
"metadata",
"store",
"metastore",
",",
"final",
"bulk",
"operation",
"state",
"operation",
"type",
"operation",
",",
"final",
"path",
"path",
")",
"throws",
"i",
"o",
"exception",
"{",
"preconditions",
"check",
"argument",
"(",
"operation",
"!",
"=",
"bulk",
"operation",
"state",
"operation",
"type",
"rename",
",",
"\"",
"rename",
"operations",
"cannot",
"be",
"started",
"through",
"initiate",
"bulk",
"write",
"\"",
")",
";",
"if",
"(",
"metastore",
"=",
"=",
"null",
"|",
"|",
"is",
"null",
"metadata",
"store",
"(",
"metastore",
")",
")",
"{",
"return",
"null",
";",
"}",
"else",
"{",
"return",
"metastore",
"initiate",
"bulk",
"write",
"(",
"operation",
",",
"path",
")",
";",
"}",
"}"
]
|
[
"returns",
"the",
"given",
"list",
"of",
"line",
"numbers",
",",
"without",
"the",
"ones",
"that",
"have",
"empty",
"code",
"blocks",
"or",
"that",
"exceed",
"the",
"code",
"size"
]
| [
"private",
"int",
"remove",
"empty",
"line",
"numbers",
"(",
"line",
"number",
"info",
"[",
"]",
"line",
"number",
"infos",
",",
"int",
"line",
"number",
"info",
"count",
",",
"int",
"code",
"length",
")",
"{",
"/",
"/",
"overwrite",
"all",
"empty",
"line",
"number",
"entries",
"int",
"new",
"index",
"=",
"0",
";",
"for",
"(",
"int",
"index",
"=",
"0",
";",
"index",
"<",
"line",
"number",
"info",
"count",
";",
"index",
"+",
"+",
")",
"{",
"line",
"number",
"info",
"line",
"number",
"info",
"=",
"line",
"number",
"infos",
"[",
"index",
"]",
";",
"int",
"start",
"p",
"c",
"=",
"line",
"number",
"info",
"u",
"2start",
"p",
"c",
";",
"if",
"(",
"start",
"p",
"c",
"<",
"code",
"length",
"&",
"&",
"(",
"index",
"=",
"=",
"0",
"|",
"|",
"start",
"p",
"c",
">",
"line",
"number",
"infos",
"[",
"index",
"-",
"1",
"]",
"u",
"2start",
"p",
"c",
")",
")",
"{",
"line",
"number",
"infos",
"[",
"new",
"index",
"+",
"+",
"]",
"=",
"line",
"number",
"info",
";",
"}",
"}",
"/",
"/",
"clear",
"the",
"unused",
"array",
"entries",
"arrays",
"fill",
"(",
"line",
"number",
"infos",
",",
"new",
"index",
",",
"line",
"number",
"info",
"count",
",",
"null",
")",
";",
"return",
"new",
"index",
";",
"}"
]
|
[
"returns",
"an",
"iterator",
"for",
"the",
"keys",
"in",
"the",
"set",
"remove",
"is",
"supported",
"if",
"{",
"@",
"link",
"collections",
"#",
"allocate",
"iterators",
"}",
"is",
"false",
",",
"the",
"same",
"iterator",
"instance",
"is",
"returned",
"each",
"time",
"this",
"method",
"is",
"called",
"use",
"the",
"{",
"@",
"link",
"object",
"set",
"iterator",
"}",
"constructor",
"for",
"nested",
"or",
"multithreaded",
"iteration"
]
| [
"public",
"object",
"set",
"iterator",
"<",
"t",
">",
"iterator",
"(",
")",
"{",
"if",
"(",
"collections",
"allocate",
"iterators",
")",
"return",
"new",
"object",
"set",
"iterator",
"(",
"this",
")",
";",
"if",
"(",
"iterator",
"1",
"=",
"=",
"null",
")",
"{",
"iterator",
"1",
"=",
"new",
"object",
"set",
"iterator",
"(",
"this",
")",
";",
"iterator",
"2",
"=",
"new",
"object",
"set",
"iterator",
"(",
"this",
")",
";",
"}",
"if",
"(",
"!",
"iterator",
"1",
"valid",
")",
"{",
"iterator",
"1",
"reset",
"(",
")",
";",
"iterator",
"1",
"valid",
"=",
"true",
";",
"iterator",
"2",
"valid",
"=",
"false",
";",
"return",
"iterator",
"1",
";",
"}",
"iterator",
"2",
"reset",
"(",
")",
";",
"iterator",
"2",
"valid",
"=",
"true",
";",
"iterator",
"1",
"valid",
"=",
"false",
";",
"return",
"iterator",
"2",
";",
"}"
]
|
[
"adds",
"a",
"field",
"to",
"load",
"from",
"doc",
"values",
"and",
"return"
]
| [
"public",
"inner",
"hit",
"builder",
"add",
"doc",
"value",
"field",
"(",
"string",
"field",
")",
"{",
"return",
"add",
"doc",
"value",
"field",
"(",
"field",
",",
"null",
")",
";",
"}"
]
|
[
"returns",
"the",
"vertical",
"scrollbar",
"used",
"by",
"this",
"panel"
]
| [
"public",
"j",
"scroll",
"bar",
"get",
"vertical",
"scroll",
"bar",
"(",
")",
"{",
"return",
"scroller",
"get",
"vertical",
"scroll",
"bar",
"(",
")",
";",
"}"
]
|
[
"returns",
"the",
"delay",
"and",
"sets",
"the",
"next",
"fire",
"time"
]
| [
"long",
"calculate",
"schedule",
"(",
"long",
"now",
",",
"long",
"delay",
",",
"long",
"schedule",
"at",
")",
"{",
"if",
"(",
"delay",
"<",
"=",
"tolerance",
")",
"{",
"/",
"/",
"use",
"a",
"minimum",
"delay",
"if",
"close",
"to",
"now",
"next",
"fire",
"time",
"=",
"(",
"now",
"+",
"tolerance",
")",
";",
"return",
"tolerance",
";",
"}",
"next",
"fire",
"time",
"=",
"schedule",
"at",
";",
"return",
"delay",
";",
"}"
]
|
[
"update",
"the",
"highest",
"tx",
"id",
"that",
"has",
"been",
"written",
"to",
"the",
"journal",
"also",
"update",
"the",
"{",
"@",
"link",
"file",
"journal",
"manager",
"#",
"last",
"readable",
"tx",
"id",
"}",
"of",
"the",
"underlying",
"fjm"
]
| [
"private",
"void",
"update",
"highest",
"written",
"tx",
"id",
"(",
"long",
"val",
")",
"{",
"highest",
"written",
"tx",
"id",
"=",
"val",
";",
"fjm",
"set",
"last",
"readable",
"tx",
"id",
"(",
"val",
")",
";",
"}"
]
|
[
"updates",
"a",
"slot",
"with",
"the",
"given",
"allocation",
"id"
]
| [
"private",
"boolean",
"update",
"slot",
"(",
"slot",
"i",
"d",
"slot",
"id",
",",
"allocation",
"i",
"d",
"allocation",
"id",
",",
"job",
"i",
"d",
"job",
"id",
")",
"{",
"final",
"task",
"manager",
"slot",
"slot",
"=",
"slots",
"get",
"(",
"slot",
"id",
")",
";",
"if",
"(",
"slot",
"!",
"=",
"null",
")",
"{",
"final",
"task",
"manager",
"registration",
"task",
"manager",
"registration",
"=",
"task",
"manager",
"registrations",
"get",
"(",
"slot",
"get",
"instance",
"id",
"(",
")",
")",
";",
"if",
"(",
"task",
"manager",
"registration",
"!",
"=",
"null",
")",
"{",
"update",
"slot",
"state",
"(",
"slot",
",",
"task",
"manager",
"registration",
",",
"allocation",
"id",
",",
"job",
"id",
")",
";",
"return",
"true",
";",
"}",
"else",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"trying",
"to",
"update",
"a",
"slot",
"from",
"a",
"task",
"manager",
"\"",
"+",
"slot",
"get",
"instance",
"id",
"(",
")",
"+",
"\"",
"which",
"has",
"not",
"been",
"registered",
"\"",
")",
";",
"}",
"}",
"else",
"{",
"log",
"debug",
"(",
"\"",
"trying",
"to",
"update",
"unknown",
"slot",
"with",
"slot",
"id",
"{",
"}",
"\"",
",",
"slot",
"id",
")",
";",
"return",
"false",
";",
"}",
"}"
]
|
[
"get",
"map",
"string"
]
| [
"public",
"map",
"<",
"string",
",",
"string",
">",
"get",
"map",
"string",
"(",
")",
"{",
"return",
"map",
"string",
";",
"}"
]
|
[
"capture",
"the",
"screenshot",
"and",
"store",
"it",
"in",
"the",
"specified",
"location",
"for",
"a",
"w3c",
"-",
"conformant",
"web",
"driver",
"or",
"web",
"element",
",",
"this",
"behaves",
"as",
"stated",
"in",
"<",
"a",
"href",
"=",
"\"",
"https",
":",
"w",
"3c",
"github",
"iowebdriver",
"#",
"screen",
"-",
"capture",
"\"",
">",
"w3c",
"web",
"driver",
"specification",
"for",
"a",
"non",
"-",
"w3c",
"-",
"conformant",
"web",
"driver",
",",
"this",
"makes",
"a",
"best",
"effort",
"depending",
"on",
"the",
"browser",
"to",
"return",
"the",
"following",
"in",
"order",
"of",
"preference",
":",
"entire",
"page",
"current",
"window",
"visible",
"portion",
"of",
"the",
"current",
"frame",
"the",
"screenshot",
"of",
"the",
"entire",
"display",
"containing",
"the",
"browser",
"for",
"a",
"non",
"-",
"w3c",
"-",
"conformant",
"web",
"element",
"extending",
"takes",
"screenshot",
",",
"this",
"makes",
"a",
"best",
"effort",
"depending",
"on",
"the",
"browser",
"to",
"return",
"the",
"following",
"in",
"order",
"of",
"preference",
":",
"the",
"entire",
"content",
"of",
"the",
"html",
"element",
"the",
"visible",
"portion",
"of",
"the",
"html",
"element"
]
| [
"<",
"x",
">",
"x",
"get",
"screenshot",
"as",
"(",
"output",
"type",
"<",
"x",
">",
"target",
")",
"throws",
"web",
"driver",
"exception",
";"
]
|
[
"{",
"@",
"inherit",
"doc",
"}",
"the",
"default",
"implementation",
"returns",
"the",
"result",
"of",
"calling",
"{",
"@",
"link",
"#",
"visit",
"children",
"}",
"on",
"{",
"@",
"code",
"ctx",
"}"
]
| [
"@",
"override",
"public",
"t",
"visit",
"refcast",
"(",
"painless",
"parser",
"refcast",
"context",
"ctx",
")",
"{",
"return",
"visit",
"children",
"(",
"ctx",
")",
";",
"}"
]
|
[
"set",
"the",
"deferred",
"collectors"
]
| [
"public",
"void",
"set",
"deferred",
"collector",
"(",
"iterable",
"<",
"bucket",
"collector",
">",
"deferred",
"collectors",
")",
"{",
"this",
"deferred",
"=",
"multi",
"bucket",
"collector",
"wrap",
"(",
"deferred",
"collectors",
")",
";",
"}"
]
|
[
"set",
"the",
"status",
"of",
"the",
"node"
]
| [
"public",
"abstract",
"void",
"set",
"node",
"status",
"(",
"node",
"status",
"node",
"status",
")",
";"
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.