docstring_tokens
list | code_tokens
list |
|---|---|
[
"get",
"property",
"value"
]
| [
"public",
"object",
"[",
"]",
"get",
"property",
"values",
"(",
"object",
"instance",
",",
"string",
"[",
"]",
"pns",
")",
"throws",
"no",
"such",
"property",
"exception",
",",
"illegal",
"argument",
"exception",
"{",
"object",
"[",
"]",
"ret",
"=",
"new",
"object",
"[",
"pns",
"length",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"ret",
"length",
";",
"i",
"+",
"+",
")",
"{",
"ret",
"[",
"i",
"]",
"=",
"get",
"property",
"value",
"(",
"instance",
",",
"pns",
"[",
"i",
"]",
")",
";",
"}",
"return",
"ret",
";",
"}"
]
|
[
"returns",
"true",
"if",
"the",
"error",
"should",
"be",
"shown"
]
| [
"public",
"boolean",
"show",
"error",
"(",
")",
"{",
"return",
"get",
"message",
"(",
")",
"!",
"=",
"null",
";",
"}"
]
|
[
"returns",
"the",
"class",
"of",
"the",
"param",
"value",
"it",
"'",
"s",
"usually",
"needed",
"in",
"serialization"
]
| [
"public",
"class",
"<",
"v",
">",
"get",
"value",
"class",
"(",
")",
"{",
"return",
"value",
"class",
";",
"}"
]
|
[
"logs",
"out",
"current",
"logged",
"in",
"user",
"session"
]
| [
"public",
"void",
"logout",
"user",
"(",
")",
"throws",
"api",
"exception",
"{",
"object",
"local",
"var",
"post",
"body",
"=",
"null",
";",
"/",
"/",
"create",
"path",
"and",
"map",
"variables",
"string",
"local",
"var",
"path",
"=",
"\"",
"/",
"user",
"/",
"logout",
"\"",
";",
"/",
"/",
"query",
"params",
"list",
"<",
"pair",
">",
"local",
"var",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
"pair",
">",
"(",
")",
";",
"list",
"<",
"pair",
">",
"local",
"var",
"collection",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
"pair",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"header",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"cookie",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"object",
">",
"local",
"var",
"form",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"object",
">",
"(",
")",
";",
"final",
"string",
"[",
"]",
"local",
"var",
"accepts",
"=",
"{",
"}",
";",
"final",
"string",
"local",
"var",
"accept",
"=",
"api",
"client",
"select",
"header",
"accept",
"(",
"local",
"var",
"accepts",
")",
";",
"final",
"string",
"[",
"]",
"local",
"var",
"content",
"types",
"=",
"{",
"}",
";",
"final",
"string",
"local",
"var",
"content",
"type",
"=",
"api",
"client",
"select",
"header",
"content",
"type",
"(",
"local",
"var",
"content",
"types",
")",
";",
"string",
"[",
"]",
"local",
"var",
"auth",
"names",
"=",
"new",
"string",
"[",
"]",
"{",
"}",
";",
"api",
"client",
"invoke",
"a",
"p",
"i",
"(",
"local",
"var",
"path",
",",
"\"",
"get",
"\"",
",",
"local",
"var",
"query",
"params",
",",
"local",
"var",
"collection",
"query",
"params",
",",
"local",
"var",
"post",
"body",
",",
"local",
"var",
"header",
"params",
",",
"local",
"var",
"cookie",
"params",
",",
"local",
"var",
"form",
"params",
",",
"local",
"var",
"accept",
",",
"local",
"var",
"content",
"type",
",",
"local",
"var",
"auth",
"names",
",",
"null",
")",
";",
"}"
]
|
[
"unpack",
"namespace",
"from",
"resource",
",",
"just",
"like",
":",
"(",
"1",
")",
"mq",
"inst",
"xx",
"%",
"topic",
"xxx",
"-",
"-",
">",
"topic",
"xxx",
"(",
"2",
")",
"%",
"retry",
"%",
"mq",
"inst",
"xx",
"%",
"gid",
"xxx",
"-",
"-",
">",
"%",
"retry",
"%",
"gid",
"xxx"
]
| [
"public",
"static",
"string",
"without",
"namespace",
"(",
"string",
"resource",
"with",
"namespace",
")",
"{",
"if",
"(",
"string",
"utils",
"is",
"empty",
"(",
"resource",
"with",
"namespace",
")",
"|",
"|",
"is",
"system",
"resource",
"(",
"resource",
"with",
"namespace",
")",
")",
"{",
"return",
"resource",
"with",
"namespace",
";",
"}",
"string",
"builder",
"string",
"builder",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"if",
"(",
"is",
"retry",
"topic",
"(",
"resource",
"with",
"namespace",
")",
")",
"{",
"string",
"builder",
"append",
"(",
"mix",
"all",
"retry",
"group",
"topic",
"prefix",
")",
";",
"}",
"if",
"(",
"is",
"d",
"l",
"q",
"topic",
"(",
"resource",
"with",
"namespace",
")",
")",
"{",
"string",
"builder",
"append",
"(",
"mix",
"all",
"dlq",
"group",
"topic",
"prefix",
")",
";",
"}",
"string",
"resource",
"without",
"retry",
"and",
"d",
"l",
"q",
"=",
"with",
"out",
"retry",
"and",
"d",
"l",
"q",
"(",
"resource",
"with",
"namespace",
")",
";",
"int",
"index",
"=",
"resource",
"without",
"retry",
"and",
"d",
"l",
"q",
"index",
"of",
"(",
"namespace",
"separator",
")",
";",
"if",
"(",
"index",
">",
"0",
")",
"{",
"string",
"resource",
"without",
"namespace",
"=",
"resource",
"without",
"retry",
"and",
"d",
"l",
"q",
"substring",
"(",
"index",
"+",
"1",
")",
";",
"return",
"string",
"builder",
"append",
"(",
"resource",
"without",
"namespace",
")",
"to",
"string",
"(",
")",
";",
"}",
"return",
"resource",
"with",
"namespace",
";",
"}"
]
|
[
"triggers",
"the",
"program",
"asynchronously",
"the",
"environment",
"will",
"execute",
"all",
"parts",
"of",
"the",
"program",
"that",
"have",
"resulted",
"in",
"a",
"\"",
"sink",
"\"",
"operation",
"sink",
"operations",
"are",
"for",
"example",
"printing",
"results",
"or",
"forwarding",
"them",
"to",
"a",
"message",
"queue",
"the",
"program",
"execution",
"will",
"be",
"logged",
"and",
"displayed",
"with",
"a",
"generated",
"default",
"name"
]
| [
"public",
"final",
"job",
"client",
"execute",
"async",
"(",
")",
"throws",
"exception",
"{",
"return",
"execute",
"async",
"(",
"get",
"job",
"name",
"(",
")",
")",
";",
"}"
]
|
[
"gets",
"the",
"end"
]
| [
"public",
"int",
"get",
"end",
"(",
")",
"{",
"return",
"end",
";",
"}"
]
|
[
"test",
"for",
"sparsity",
"on",
"the",
"last",
"2",
"buckets",
",",
"should",
"create",
"a",
"sparse",
"bucket",
"signal",
"on",
"the",
"2nd",
"to",
"last"
]
| [
"public",
"void",
"test",
"sparse",
"buckets",
"last",
"two",
"(",
")",
"{",
"data",
"stream",
"diagnostics",
"d",
"=",
"new",
"data",
"stream",
"diagnostics",
"(",
"job",
",",
"data",
"counts",
")",
";",
"send",
"many",
"data",
"points",
"(",
"d",
",",
"10000",
",",
"69000",
",",
"1000",
")",
";",
"send",
"many",
"data",
"points",
"(",
"d",
",",
"70000",
",",
"129000",
",",
"1200",
")",
";",
"/",
"/",
"sparse",
"bucket",
"send",
"many",
"data",
"points",
"(",
"d",
",",
"130000",
",",
"189000",
",",
"1",
")",
";",
"send",
"many",
"data",
"points",
"(",
"d",
",",
"190000",
",",
"249000",
",",
"1100",
")",
";",
"send",
"many",
"data",
"points",
"(",
"d",
",",
"250000",
",",
"309000",
",",
"1300",
")",
";",
"send",
"many",
"data",
"points",
"(",
"d",
",",
"310000",
",",
"369000",
",",
"1050",
")",
";",
"send",
"many",
"data",
"points",
"(",
"d",
",",
"370000",
",",
"429000",
",",
"1022",
")",
";",
"send",
"many",
"data",
"points",
"(",
"d",
",",
"430000",
",",
"489000",
",",
"1400",
")",
";",
"/",
"/",
"sparse",
"bucket",
"(",
"2nd",
"to",
"last",
"one",
")",
"send",
"many",
"data",
"points",
"(",
"d",
",",
"490000",
",",
"549000",
",",
"9",
")",
";",
"/",
"/",
"sparse",
"bucket",
"(",
"but",
"last",
"one",
")",
"send",
"many",
"data",
"points",
"(",
"d",
",",
"550000",
",",
"609000",
",",
"10",
")",
";",
"d",
"flush",
"(",
")",
";",
"assert",
"equals",
"(",
"9",
",",
"d",
"get",
"bucket",
"count",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"d",
"get",
"empty",
"bucket",
"count",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"2",
",",
"d",
"get",
"sparse",
"bucket",
"count",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"new",
"date",
"(",
"480000",
")",
",",
"d",
"get",
"latest",
"sparse",
"bucket",
"time",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"null",
",",
"d",
"get",
"latest",
"empty",
"bucket",
"time",
"(",
")",
")",
";",
"}"
]
|
[
"set",
"the",
"user",
"'",
"s",
"chronology",
"(",
"calendar",
"system",
")"
]
| [
"public",
"void",
"set",
"chronology",
"(",
"@",
"nullable",
"chronology",
"chronology",
")",
"{",
"this",
"chronology",
"=",
"chronology",
";",
"}"
]
|
[
"set",
"the",
"set",
"of",
"allowed",
"{",
"@",
"link",
"http",
"method",
"http",
"methods",
"}",
",",
"as",
"specified",
"by",
"the",
"{",
"@",
"code",
"allow",
"}",
"header"
]
| [
"builder",
"<",
"t",
">",
"allow",
"(",
"set",
"<",
"http",
"method",
">",
"allowed",
"methods",
")",
";"
]
|
[
"sets",
"a",
"custom",
"{",
"@",
"code",
"equivalence",
"}",
"strategy",
"for",
"comparing",
"values",
"by",
"default",
",",
"the",
"cache",
"uses",
"{",
"@",
"link",
"equivalence",
"#",
"identity",
"}",
"to",
"determine",
"value",
"equality",
"when",
"{",
"@",
"link",
"#",
"weak",
"values",
"}",
"or",
"{",
"@",
"link",
"#",
"soft",
"values",
"}",
"is",
"specified",
",",
"and",
"{",
"@",
"link",
"equivalence",
"#",
"equals",
"(",
")",
"}",
"otherwise"
]
| [
"cache",
"builder",
"<",
"k",
",",
"v",
">",
"value",
"equivalence",
"(",
"equivalence",
"<",
"object",
">",
"equivalence",
")",
"{",
"check",
"state",
"(",
"value",
"equivalence",
"=",
"=",
"null",
",",
"\"",
"value",
"equivalence",
"was",
"already",
"set",
"to",
"%",
"s",
"\"",
",",
"value",
"equivalence",
")",
";",
"this",
"value",
"equivalence",
"=",
"check",
"not",
"null",
"(",
"equivalence",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"adds",
"a",
"mapping",
"from",
"the",
"specified",
"key",
"to",
"the",
"specified",
"value",
",",
"replacing",
"the",
"previous",
"mapping",
"from",
"the",
"specified",
"key",
"if",
"there",
"was",
"one"
]
| [
"public",
"void",
"put",
"(",
"int",
"key",
",",
"int",
"value",
")",
"{",
"int",
"i",
"=",
"binary",
"search",
"(",
"m",
"keys",
",",
"m",
"size",
",",
"key",
")",
";",
"if",
"(",
"i",
">",
"=",
"0",
")",
"{",
"m",
"values",
"[",
"i",
"]",
"=",
"value",
";",
"}",
"else",
"{",
"i",
"=",
"~",
"i",
";",
"m",
"keys",
"=",
"insert",
"element",
"into",
"int",
"array",
"(",
"m",
"keys",
",",
"m",
"size",
",",
"i",
",",
"key",
")",
";",
"m",
"values",
"=",
"insert",
"element",
"into",
"int",
"array",
"(",
"m",
"values",
",",
"m",
"size",
",",
"i",
",",
"value",
")",
";",
"+",
"+",
"m",
"size",
";",
"}",
"}"
]
|
[
"return",
"the",
"additional",
"(",
"undeclared",
")",
"property"
]
| [
"public",
"map",
"<",
"string",
",",
"fruit",
">",
"get",
"additional",
"properties",
"(",
")",
"{",
"return",
"additional",
"properties",
";",
"}"
]
|
[
"creates",
"a",
"new",
"blocking",
"-",
"style",
"stub",
"that",
"supports",
"unary",
"and",
"streaming",
"output",
"calls",
"on",
"the",
"service"
]
| [
"public",
"static",
"cluster",
"discovery",
"service",
"blocking",
"stub",
"new",
"blocking",
"stub",
"(",
"io",
"grpc",
"channel",
"channel",
")",
"{",
"io",
"grpc",
"stub",
"abstract",
"stub",
"stub",
"factory",
"<",
"cluster",
"discovery",
"service",
"blocking",
"stub",
">",
"factory",
"=",
"new",
"io",
"grpc",
"stub",
"abstract",
"stub",
"stub",
"factory",
"<",
"cluster",
"discovery",
"service",
"blocking",
"stub",
">",
"(",
")",
"{",
"@",
"java",
"lang",
"override",
"public",
"cluster",
"discovery",
"service",
"blocking",
"stub",
"new",
"stub",
"(",
"io",
"grpc",
"channel",
"channel",
",",
"io",
"grpc",
"call",
"options",
"call",
"options",
")",
"{",
"return",
"new",
"cluster",
"discovery",
"service",
"blocking",
"stub",
"(",
"channel",
",",
"call",
"options",
")",
";",
"}",
"}",
";",
"return",
"cluster",
"discovery",
"service",
"blocking",
"stub",
"new",
"stub",
"(",
"factory",
",",
"channel",
")",
";",
"}"
]
|
[
"returns",
"the",
"entry",
"associated",
"with",
"the",
"specified",
"key",
"in",
"the",
"long",
"key",
"map",
"returns",
"null",
"if",
"the",
"long",
"key",
"map",
"contains",
"no",
"mapping",
"for",
"this",
"key"
]
| [
"long",
"entry",
"<",
"value",
">",
"get",
"entry",
"(",
"long",
"key",
")",
"{",
"int",
"hash",
"=",
"hash",
"(",
"key",
")",
";",
"int",
"i",
"=",
"index",
"for",
"(",
"hash",
",",
"table",
"length",
")",
";",
"long",
"entry",
"<",
"value",
">",
"e",
"=",
"table",
"[",
"i",
"]",
";",
"while",
"(",
"e",
"!",
"=",
"null",
"&",
"&",
"!",
"(",
"e",
"hash",
"=",
"=",
"hash",
"&",
"&",
"key",
"=",
"=",
"e",
"key",
")",
")",
"e",
"=",
"e",
"next",
";",
"return",
"e",
";",
"}"
]
|
[
"a",
"formatted",
"string",
"for",
"printing",
"the",
"status",
"of",
"the",
"data",
"node"
]
| [
"public",
"string",
"get",
"datanode",
"local",
"report",
"(",
")",
"{",
"return",
"(",
"\"",
"uptime",
":",
"\"",
"+",
"get",
"uptime",
"(",
")",
")",
"+",
"\"",
",",
"software",
"version",
":",
"\"",
"+",
"get",
"software",
"version",
"(",
")",
"+",
"\"",
",",
"config",
"version",
":",
"\"",
"+",
"get",
"config",
"version",
"(",
")",
";",
"}"
]
|
[
"gets",
"the",
"{",
"@",
"link",
"language",
"}",
"for",
"this",
"object",
"'",
"s",
"{",
"@",
"link",
"language",
"i",
"d",
"}"
]
| [
"public",
"language",
"get",
"language",
"(",
")",
"throws",
"language",
"not",
"found",
"exception",
"{",
"return",
"default",
"language",
"service",
"get",
"language",
"service",
"(",
")",
"get",
"language",
"(",
"language",
"i",
"d",
")",
";",
"}"
]
|
[
"close",
"file",
"handlers",
"used",
"by",
"the",
"file",
"channel",
"but",
"don",
"'",
"t",
"write",
"to",
"disk",
"this",
"is",
"used",
"when",
"the",
"disk",
"may",
"have",
"failed"
]
| [
"public",
"void",
"close",
"handlers",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"channel",
"close",
"(",
")",
";",
"}"
]
|
[
"sets",
"the",
"message",
"below",
"the",
"progress",
"meter",
"in",
"the",
"current",
"phase",
"progress",
"area"
]
| [
"void",
"update",
"progress",
"details",
"(",
"string",
"progress",
"description",
")",
"{",
"provider",
"update",
"progress",
"details",
"(",
"progress",
"description",
")",
";",
"}"
]
|
[
"returns",
"the",
"package",
"this",
"package",
"may",
"contain",
"errors",
",",
"in",
"which",
"case",
"the",
"caller",
"should",
"throw",
"a",
"{",
"@",
"link",
"com",
"google",
"devtools",
"build",
"lib",
"packages",
"build",
"file",
"contains",
"errors",
"exception",
"}",
"if",
"an",
"error",
"-",
"free",
"package",
"is",
"needed",
"see",
"also",
"{",
"@",
"link",
"package",
"error",
"function",
"}",
"for",
"the",
"case",
"where",
"encountering",
"a",
"package",
"with",
"errors",
"should",
"shut",
"down",
"the",
"build",
"but",
"the",
"caller",
"can",
"handle",
"packages",
"with",
"errors"
]
| [
"public",
"package",
"get",
"package",
"(",
")",
"{",
"return",
"pkg",
";",
"}"
]
|
[
"returns",
"a",
"type",
"that",
"represents",
"an",
"unknown",
"type",
"that",
"extends",
"{",
"@",
"code",
"bound",
"}",
"for",
"example",
",",
"if",
"{",
"@",
"code",
"bound",
"}",
"is",
"{",
"@",
"code",
"char",
"sequence",
"class",
"}",
",",
"this",
"returns",
"{",
"@",
"code",
"?",
"extends",
"char",
"sequence",
"}",
"if",
"{",
"@",
"code",
"bound",
"}",
"is",
"{",
"@",
"code",
"object",
"class",
"}",
",",
"this",
"returns",
"{",
"@",
"code",
"?",
"}",
",",
"which",
"is",
"shorthand",
"for",
"{",
"@",
"code",
"?",
"extends",
"object",
"}"
]
| [
"public",
"static",
"wildcard",
"type",
"subtype",
"of",
"(",
"type",
"bound",
")",
"{",
"type",
"[",
"]",
"upper",
"bounds",
";",
"if",
"(",
"bound",
"instanceof",
"wildcard",
"type",
")",
"{",
"upper",
"bounds",
"=",
"(",
"(",
"wildcard",
"type",
")",
"bound",
")",
"get",
"upper",
"bounds",
"(",
")",
";",
"}",
"else",
"{",
"upper",
"bounds",
"=",
"new",
"type",
"[",
"]",
"{",
"bound",
"}",
";",
"}",
"return",
"new",
"wildcard",
"type",
"impl",
"(",
"upper",
"bounds",
",",
"empty",
"type",
"array",
")",
";",
"}"
]
|
[
"set",
"the",
"system",
"property",
";",
"return",
"the",
"old",
"value",
"for",
"caching"
]
| [
"private",
"boolean",
"get",
"and",
"set",
"(",
"string",
"sysprop",
",",
"string",
"debug",
")",
"{",
"boolean",
"old",
"=",
"boolean",
"get",
"boolean",
"(",
"sysprop",
")",
";",
"system",
"set",
"property",
"(",
"sysprop",
",",
"debug",
")",
";",
"return",
"old",
";",
"}"
]
|
[
"this",
"can",
"only",
"be",
"called",
"after",
"serializing",
"both",
"i",
"node",
"dir",
"and",
"snapshot",
"diff"
]
| [
"public",
"void",
"serialize",
"i",
"node",
"reference",
"section",
"(",
"output",
"stream",
"out",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"list",
"<",
"i",
"node",
"reference",
">",
"ref",
"list",
"=",
"parent",
"get",
"saver",
"context",
"(",
")",
"get",
"ref",
"list",
"(",
")",
";",
"long",
"i",
"=",
"0",
";",
"for",
"(",
"i",
"node",
"reference",
"ref",
":",
"ref",
"list",
")",
"{",
"i",
"node",
"reference",
"section",
"i",
"node",
"reference",
"builder",
"rb",
"=",
"build",
"i",
"node",
"reference",
"(",
"ref",
",",
"i",
"+",
"+",
")",
";",
"rb",
"build",
"(",
")",
"write",
"delimited",
"to",
"(",
"out",
")",
";",
"}",
"parent",
"commit",
"section",
"(",
"headers",
",",
"section",
"name",
"inode",
"reference",
")",
";",
"}"
]
|
[
"check",
"if",
"{",
"@",
"link",
"#",
"popup",
"layout",
"params",
"}",
"'",
"position",
"is",
"within",
"a",
"arbitrary",
"boundary",
"that",
"goes",
"from",
"(",
"0",
",",
"0",
")",
"to",
"(",
"screen",
"width",
",",
"screen",
"height",
")",
"if",
"it",
"'",
"s",
"out",
"of",
"these",
"boundaries",
",",
"{",
"@",
"link",
"#",
"popup",
"layout",
"params",
"}",
"'",
"position",
"is",
"changed",
"and",
"{",
"@",
"code",
"true",
"}",
"is",
"returned",
"to",
"represent",
"this",
"change"
]
| [
"public",
"void",
"check",
"popup",
"position",
"bounds",
"(",
")",
"{",
"if",
"(",
"debug",
")",
"{",
"log",
"d",
"(",
"tag",
",",
"\"",
"check",
"popup",
"position",
"bounds",
"(",
")",
"called",
"with",
":",
"\"",
"+",
"\"",
"screen",
"width",
"=",
"[",
"\"",
"+",
"screen",
"width",
"+",
"\"",
"]",
",",
"\"",
"+",
"\"",
"screen",
"height",
"=",
"[",
"\"",
"+",
"screen",
"height",
"+",
"\"",
"]",
"\"",
")",
";",
"}",
"if",
"(",
"popup",
"layout",
"params",
"=",
"=",
"null",
")",
"{",
"return",
";",
"}",
"if",
"(",
"popup",
"layout",
"params",
"x",
"<",
"0",
")",
"{",
"popup",
"layout",
"params",
"x",
"=",
"0",
";",
"}",
"else",
"if",
"(",
"popup",
"layout",
"params",
"x",
">",
"screen",
"width",
"-",
"popup",
"layout",
"params",
"width",
")",
"{",
"popup",
"layout",
"params",
"x",
"=",
"(",
"int",
")",
"(",
"screen",
"width",
"-",
"popup",
"layout",
"params",
"width",
")",
";",
"}",
"if",
"(",
"popup",
"layout",
"params",
"y",
"<",
"0",
")",
"{",
"popup",
"layout",
"params",
"y",
"=",
"0",
";",
"}",
"else",
"if",
"(",
"popup",
"layout",
"params",
"y",
">",
"screen",
"height",
"-",
"popup",
"layout",
"params",
"height",
")",
"{",
"popup",
"layout",
"params",
"y",
"=",
"(",
"int",
")",
"(",
"screen",
"height",
"-",
"popup",
"layout",
"params",
"height",
")",
";",
"}",
"}"
]
|
[
"disables",
"a",
"child",
"source"
]
| [
"protected",
"final",
"void",
"disable",
"child",
"source",
"(",
"@",
"unknown",
"null",
"t",
"id",
")",
"{",
"media",
"source",
"and",
"listener",
"disabled",
"child",
"=",
"assertions",
"check",
"not",
"null",
"(",
"child",
"sources",
"get",
"(",
"id",
")",
")",
";",
"disabled",
"child",
"media",
"source",
"disable",
"(",
"disabled",
"child",
"caller",
")",
";",
"}"
]
|
[
"sets",
"the",
"<",
"code",
">",
"namespace",
"integer",
"<",
"code",
">",
"property"
]
| [
"public",
"void",
"set",
"namespace",
"integer",
"(",
"integer",
"namespace",
"integer",
")",
"{",
"this",
"namespace",
"integer",
"=",
"namespace",
"integer",
";",
"}"
]
|
[
"（",
"、",
"）",
",",
"，",
",",
"，"
]
| [
"public",
"void",
"auto",
"reg",
"dom",
"clusters",
"test",
"(",
")",
"throws",
"exception",
"{",
"string",
"service",
"name",
"=",
"random",
"domain",
"name",
"(",
")",
";",
"naming",
"register",
"instance",
"(",
"service",
"name",
",",
"\"",
"127",
"0",
"0",
"1",
"\"",
",",
"test",
"port",
",",
"\"",
"c",
"1",
"\"",
")",
";",
"naming",
"register",
"instance",
"(",
"service",
"name",
",",
"\"",
"127",
"0",
"0",
"2",
"\"",
",",
"test",
"port",
",",
"\"",
"c",
"2",
"\"",
")",
";",
"time",
"unit",
"seconds",
"sleep",
"(",
"5",
")",
";",
"list",
"<",
"instance",
">",
"instances",
";",
"instances",
"=",
"naming",
"get",
"all",
"instances",
"(",
"service",
"name",
")",
";",
"assert",
"assert",
"equals",
"(",
"2",
",",
"instances",
"size",
"(",
")",
")",
";",
"nacos",
"naming",
"service",
"naming",
"service",
"impl",
"=",
"(",
"nacos",
"naming",
"service",
")",
"naming",
";",
"naming",
"service",
"impl",
"get",
"beat",
"reactor",
"(",
")",
"remove",
"beat",
"info",
"(",
"constants",
"default",
"group",
"+",
"constants",
"service",
"info",
"spliter",
"+",
"service",
"name",
",",
"\"",
"127",
"0",
"0",
"1",
"\"",
",",
"test",
"port",
")",
";",
"verify",
"instance",
"list",
"(",
"instances",
",",
"1",
",",
"service",
"name",
")",
";",
"instances",
"=",
"naming",
"get",
"all",
"instances",
"(",
"service",
"name",
")",
";",
"assert",
"assert",
"equals",
"(",
"1",
",",
"instances",
"size",
"(",
")",
")",
";",
"beat",
"info",
"beat",
"info",
"=",
"new",
"beat",
"info",
"(",
")",
";",
"beat",
"info",
"set",
"service",
"name",
"(",
"constants",
"default",
"group",
"+",
"constants",
"service",
"info",
"spliter",
"+",
"service",
"name",
")",
";",
"beat",
"info",
"set",
"ip",
"(",
"\"",
"127",
"0",
"0",
"1",
"\"",
")",
";",
"beat",
"info",
"set",
"port",
"(",
"test",
"port",
")",
";",
"beat",
"info",
"set",
"cluster",
"(",
"\"",
"c",
"1",
"\"",
")",
";",
"naming",
"service",
"impl",
"get",
"beat",
"reactor",
"(",
")",
"add",
"beat",
"info",
"(",
"constants",
"default",
"group",
"+",
"constants",
"service",
"info",
"spliter",
"+",
"service",
"name",
",",
"beat",
"info",
")",
";",
"/",
"/",
"time",
"unit",
"seconds",
"sleep",
"(",
"15",
")",
";",
"verify",
"instance",
"list",
"(",
"instances",
",",
"2",
",",
"service",
"name",
")",
";",
"instances",
"=",
"naming",
"get",
"all",
"instances",
"(",
"service",
"name",
")",
";",
"assert",
"assert",
"equals",
"(",
"2",
",",
"instances",
"size",
"(",
")",
")",
";",
"instances",
"=",
"naming",
"get",
"all",
"instances",
"(",
"service",
"name",
",",
"arrays",
"as",
"list",
"(",
"\"",
"c",
"2",
"\"",
")",
")",
";",
"assert",
"assert",
"equals",
"(",
"1",
",",
"instances",
"size",
"(",
")",
")",
";",
"time",
"unit",
"seconds",
"sleep",
"(",
"5",
")",
";",
"instances",
"=",
"naming",
"get",
"all",
"instances",
"(",
"service",
"name",
",",
"arrays",
"as",
"list",
"(",
"\"",
"c",
"1",
"\"",
")",
")",
";",
"assert",
"assert",
"equals",
"(",
"1",
",",
"instances",
"size",
"(",
")",
")",
";",
"}"
]
|
[
"copy",
"an",
"object"
]
| [
"private",
"void",
"copy",
"object",
"(",
"swift",
"object",
"path",
"src",
"object",
",",
"swift",
"object",
"path",
"dest",
"object",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"src",
"object",
"is",
"equal",
"to",
"or",
"parent",
"of",
"(",
"dest",
"object",
")",
")",
"{",
"throw",
"new",
"swift",
"exception",
"(",
"\"",
"can",
"'",
"t",
"copy",
"\"",
"+",
"src",
"object",
"+",
"\"",
"onto",
"\"",
"+",
"dest",
"object",
")",
";",
"}",
"/",
"/",
"do",
"the",
"copy",
"boolean",
"copy",
"succeeded",
"=",
"swift",
"rest",
"client",
"copy",
"object",
"(",
"src",
"object",
",",
"dest",
"object",
")",
";",
"if",
"(",
"!",
"copy",
"succeeded",
")",
"{",
"throw",
"new",
"swift",
"exception",
"(",
"\"",
"copy",
"of",
"\"",
"+",
"src",
"object",
"+",
"\"",
"to",
"\"",
"+",
"dest",
"object",
"+",
"\"",
"failed",
"\"",
")",
";",
"}",
"}"
]
|
[
"apply",
"the",
"reverse",
"transformation",
"to",
"the",
"algorithm",
"result"
]
| [
"ro",
"transform",
"result",
"(",
"ri",
"result",
")",
"throws",
"exception",
";"
]
|
[
"location",
"to",
"write",
"model",
"files",
"you",
"can",
"use",
"the",
"model",
"package",
"(",
")",
"as",
"defined",
"when",
"the",
"class",
"is",
"instantiated"
]
| [
"public",
"string",
"model",
"file",
"folder",
"(",
")",
"{",
"return",
"output",
"folder",
"+",
"file",
"separator",
"+",
"source",
"folder",
"+",
"file",
"separator",
"+",
"model",
"package",
"(",
")",
"replace",
"(",
"'",
"'",
",",
"file",
"separator",
"char",
")",
";",
"}"
]
|
[
"return",
"the",
"suffix",
"that",
"gets",
"appended",
"to",
"view",
"names",
"when",
"building",
"a",
"url"
]
| [
"protected",
"string",
"get",
"suffix",
"(",
")",
"{",
"return",
"this",
"suffix",
";",
"}"
]
|
[
"model",
"tests",
"for",
"additional",
"properties",
"class"
]
| [
"public",
"void",
"test",
"additional",
"properties",
"class",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"additional",
"properties",
"class",
"}"
]
|
[
"this",
"test",
"needs",
"to",
"be",
"skipped",
"for",
"earlier",
"hadoop",
"versions",
"because",
"those",
"have",
"a",
"bug"
]
| [
"public",
"void",
"test",
"mkdirs",
"fails",
"for",
"existing",
"file",
"(",
")",
"throws",
"exception",
"{",
"final",
"string",
"version",
"string",
"=",
"version",
"info",
"get",
"version",
"(",
")",
";",
"final",
"string",
"prefix",
"=",
"version",
"string",
"substring",
"(",
"0",
",",
"3",
")",
";",
"final",
"float",
"version",
"=",
"float",
"parse",
"float",
"(",
"prefix",
")",
";",
"assume",
"assume",
"true",
"(",
"\"",
"cannot",
"execute",
"this",
"test",
"on",
"hadoop",
"prior",
"to",
"2",
"8",
"\"",
",",
"version",
">",
"=",
"2",
"8f",
")",
";",
"super",
"test",
"mkdirs",
"fails",
"for",
"existing",
"file",
"(",
")",
";",
"}"
]
|
[
"sets",
"the",
"space",
"that",
"is",
"left",
"out",
"on",
"the",
"left",
"and",
"right",
"side",
"of",
"each",
"candle",
",",
"default",
"0",
"1f",
"(",
"10",
"%",
")",
",",
"max",
"0",
"4",
"5f",
",",
"min",
"0f"
]
| [
"public",
"void",
"set",
"bar",
"space",
"(",
"float",
"space",
")",
"{",
"if",
"(",
"space",
"<",
"0f",
")",
"space",
"=",
"0f",
";",
"if",
"(",
"space",
">",
"0",
"4",
"5f",
")",
"space",
"=",
"0",
"4",
"5f",
";",
"m",
"bar",
"space",
"=",
"space",
";",
"}"
]
|
[
"the",
"set",
"of",
"xml",
"attributevalue",
"pairs",
"for",
"this",
"style",
"<",
"code",
">",
"repeated",
"aapt",
"pb",
"style",
"entry",
"entry",
"=",
"3",
";",
"<",
"code",
">"
]
| [
"private",
"void",
"add",
"entry",
"(",
"com",
"android",
"aapt",
"resources",
"style",
"entry",
"value",
")",
"{",
"if",
"(",
"value",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"null",
"pointer",
"exception",
"(",
")",
";",
"}",
"ensure",
"entry",
"is",
"mutable",
"(",
")",
";",
"entry",
"add",
"(",
"value",
")",
";",
"}"
]
|
[
"returns",
"the",
"additional",
"properties",
"schema",
"for",
"the",
"specified",
"input",
"schema",
"the",
"additional",
"properties",
"keyword",
"is",
"used",
"to",
"control",
"the",
"handling",
"of",
"additional",
",",
"undeclared",
"properties",
",",
"that",
"is",
",",
"properties",
"whose",
"names",
"are",
"not",
"listed",
"in",
"the",
"properties",
"keyword",
"the",
"additional",
"properties",
"keyword",
"may",
"be",
"either",
"a",
"boolean",
"or",
"an",
"object",
"if",
"additional",
"properties",
"is",
"a",
"boolean",
"and",
"set",
"to",
"false",
",",
"no",
"additional",
"properties",
"are",
"allowed",
"by",
"default",
"when",
"the",
"additional",
"properties",
"keyword",
"is",
"not",
"specified",
"in",
"the",
"input",
"schema",
",",
"any",
"additional",
"properties",
"are",
"allowed",
"this",
"is",
"equivalent",
"to",
"setting",
"additional",
"properties",
"to",
"the",
"boolean",
"value",
"true",
"or",
"setting",
"additional",
"properties",
":",
"{",
"}"
]
| [
"public",
"static",
"schema",
"get",
"additional",
"properties",
"(",
"open",
"a",
"p",
"i",
"open",
"a",
"p",
"i",
",",
"schema",
"schema",
")",
"{",
"object",
"add",
"props",
"=",
"schema",
"get",
"additional",
"properties",
"(",
")",
";",
"if",
"(",
"add",
"props",
"instanceof",
"schema",
")",
"{",
"return",
"(",
"schema",
")",
"add",
"props",
";",
"}",
"if",
"(",
"add",
"props",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"when",
"reaching",
"this",
"code",
"path",
",",
"this",
"should",
"indicate",
"the",
"'",
"additional",
"properties",
"'",
"keyword",
"is",
"/",
"/",
"not",
"present",
"in",
"the",
"oas",
"schema",
"this",
"is",
"true",
"for",
"oas",
"3",
"0",
"documents",
"/",
"/",
"however",
",",
"the",
"parsing",
"logic",
"is",
"broken",
"for",
"oas",
"2",
"0",
"documents",
"because",
"of",
"the",
"/",
"/",
"https",
":",
"/",
"/",
"github",
"com",
"/",
"swagger",
"-",
"api",
"/",
"swagger",
"-",
"parser",
"/",
"issues",
"/",
"1369",
"issue",
"/",
"/",
"when",
"oas",
"2",
"0",
"documents",
"are",
"parsed",
",",
"the",
"swagger",
"-",
"v",
"2",
"-",
"converter",
"ignores",
"the",
"'",
"additional",
"properties",
"'",
"/",
"/",
"keyword",
"if",
"the",
"value",
"is",
"boolean",
"that",
"means",
"codegen",
"is",
"unable",
"to",
"determine",
"whether",
"/",
"/",
"additional",
"properties",
"are",
"allowed",
"or",
"not",
"/",
"/",
"/",
"/",
"the",
"original",
"behavior",
"was",
"to",
"assume",
"additional",
"properties",
"had",
"been",
"set",
"to",
"false",
"if",
"(",
"is",
"disallow",
"additional",
"properties",
"if",
"not",
"present",
"(",
")",
")",
"{",
"/",
"/",
"if",
"the",
"'",
"additional",
"properties",
"'",
"keyword",
"is",
"not",
"present",
"in",
"a",
"oas",
"schema",
",",
"/",
"/",
"interpret",
"as",
"if",
"the",
"'",
"additional",
"properties",
"'",
"keyword",
"had",
"been",
"set",
"to",
"false",
"/",
"/",
"this",
"is",
"not",
"compliant",
"with",
"the",
"json",
"schema",
"specification",
"it",
"is",
"the",
"original",
"/",
"/",
"'",
"openapi",
"-",
"generator",
"'",
"behavior",
"return",
"null",
";",
"}",
"/",
"*",
"/",
"/",
"the",
"disallow",
"additional",
"properties",
"if",
"not",
"present",
"cli",
"option",
"has",
"been",
"set",
"to",
"true",
",",
"/",
"/",
"but",
"for",
"now",
"that",
"only",
"works",
"with",
"oas",
"3",
"0",
"documents",
"/",
"/",
"the",
"new",
"behavior",
"does",
"not",
"work",
"with",
"oas",
"2",
"0",
"documents",
"if",
"(",
"extensions",
"=",
"=",
"null",
"|",
"|",
"!",
"extensions",
"contains",
"key",
"(",
"extension",
"openapi",
"doc",
"version",
")",
")",
"{",
"/",
"/",
"fallback",
"to",
"the",
"legacy",
"behavior",
"return",
"null",
";",
"}",
"/",
"/",
"get",
"original",
"swagger",
"version",
"from",
"oas",
"extension",
"/",
"/",
"note",
"open",
"a",
"p",
"i",
"get",
"openapi",
"(",
")",
"is",
"always",
"set",
"to",
"3",
"x",
"even",
"when",
"the",
"document",
"/",
"/",
"is",
"converted",
"from",
"a",
"oas",
"/",
"swagger",
"2",
"0",
"document",
"/",
"/",
"https",
":",
"/",
"/",
"github",
"com",
"/",
"swagger",
"-",
"api",
"/",
"swagger",
"-",
"parser",
"/",
"pull",
"/",
"1374",
"sem",
"ver",
"version",
"=",
"new",
"sem",
"ver",
"(",
"(",
"string",
")",
"extensions",
"get",
"(",
"extension",
"openapi",
"doc",
"version",
")",
")",
";",
"if",
"(",
"version",
"major",
"!",
"=",
"3",
")",
"{",
"return",
"null",
";",
"}",
"*",
"/",
"}",
"if",
"(",
"add",
"props",
"=",
"=",
"null",
"|",
"|",
"(",
"add",
"props",
"instanceof",
"boolean",
"&",
"&",
"(",
"boolean",
")",
"add",
"props",
")",
")",
"{",
"/",
"/",
"return",
"object",
"schema",
"to",
"specify",
"any",
"object",
"(",
"map",
")",
"value",
"is",
"allowed",
"/",
"/",
"set",
"nullable",
"to",
"specify",
"the",
"value",
"of",
"additional",
"properties",
"may",
"be",
"/",
"/",
"the",
"null",
"value",
"/",
"/",
"free",
"-",
"form",
"additional",
"properties",
"don",
"'",
"t",
"need",
"to",
"have",
"an",
"inner",
"/",
"/",
"additional",
"properties",
",",
"the",
"type",
"is",
"already",
"free",
"-",
"form",
"return",
"new",
"object",
"schema",
"(",
")",
"additional",
"properties",
"(",
"boolean",
"false",
")",
"nullable",
"(",
"boolean",
"true",
")",
";",
"}",
"return",
"null",
";",
"}"
]
|
[
"handles",
"figuring",
"out",
"a",
"java",
"home",
"directory",
"to",
"use",
"for",
"the",
"launch",
"if",
"it",
"is",
"successfully",
"determined",
",",
"an",
"exit",
"code",
"that",
"indicates",
"success",
"is",
"returned"
]
| [
"private",
"static",
"int",
"handle",
"java",
"home",
"(",
"java",
"config",
"java",
"config",
",",
"java",
"finder",
"java",
"finder",
",",
"java",
"filter",
"java",
"filter",
",",
"boolean",
"ask",
",",
"boolean",
"save",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"ask",
")",
"{",
"return",
"ask",
"java",
"home",
"(",
"java",
"config",
",",
"java",
"finder",
",",
"java",
"filter",
")",
";",
"}",
"return",
"find",
"java",
"home",
"(",
"java",
"config",
",",
"java",
"finder",
",",
"java",
"filter",
",",
"save",
")",
";",
"}"
]
|
[
"writes",
"a",
"fileset",
"rule",
"to",
"a",
"string",
"array"
]
| [
"public",
"static",
"string",
"[",
"]",
"create",
"fileset",
"rule",
"(",
"string",
"name",
",",
"string",
"out",
",",
"string",
"entries",
")",
"{",
"return",
"new",
"string",
"[",
"]",
"{",
"string",
"format",
"(",
"\"",
"fileset",
"(",
"name",
"=",
"'",
"%",
"s",
"'",
",",
"out",
"=",
"'",
"%",
"s",
"'",
",",
"\"",
",",
"name",
",",
"out",
")",
",",
"\"",
"entries",
"=",
"[",
"\"",
"+",
"joiner",
"on",
"(",
"\"",
",",
"\"",
")",
"join",
"(",
"entries",
")",
"+",
"\"",
"]",
")",
"\"",
"}",
";",
"}"
]
|
[
"global",
"sessions",
"provider",
"object",
"[",
"]",
"[",
"]"
]
| [
"static",
"stream",
"<",
"arguments",
">",
"global",
"sessions",
"provider",
"(",
")",
"{",
"global",
"session",
"global",
"session",
"1",
"=",
"new",
"global",
"session",
"(",
"\"",
"demo",
"-",
"app",
"\"",
",",
"\"",
"my",
"test",
"tx",
"group",
"\"",
",",
"\"",
"test",
"\"",
",",
"6000",
")",
";",
"global",
"session",
"global",
"session",
"2",
"=",
"new",
"global",
"session",
"(",
"\"",
"demo",
"-",
"app",
"\"",
",",
"\"",
"my",
"test",
"tx",
"group",
"\"",
",",
"\"",
"test",
"\"",
",",
"6000",
")",
";",
"return",
"stream",
"of",
"(",
"arguments",
"of",
"(",
"arrays",
"as",
"list",
"(",
"global",
"session",
"1",
",",
"global",
"session",
"2",
")",
")",
")",
";",
"}"
]
|
[
"writes",
"all",
"the",
"given",
"bytes",
"to",
"this",
"sink"
]
| [
"public",
"void",
"write",
"(",
"byte",
"[",
"]",
"bytes",
")",
"throws",
"i",
"o",
"exception",
"{",
"check",
"not",
"null",
"(",
"bytes",
")",
";",
"closer",
"closer",
"=",
"closer",
"create",
"(",
")",
";",
"try",
"{",
"output",
"stream",
"out",
"=",
"closer",
"register",
"(",
"open",
"stream",
"(",
")",
")",
";",
"out",
"write",
"(",
"bytes",
")",
";",
"out",
"flush",
"(",
")",
";",
"/",
"/",
"https",
":",
"/",
"/",
"code",
"google",
"com",
"/",
"p",
"/",
"guava",
"-",
"libraries",
"/",
"issues",
"/",
"detail",
"?",
"id",
"=",
"1330",
"}",
"catch",
"(",
"throwable",
"e",
")",
"{",
"throw",
"closer",
"rethrow",
"(",
"e",
")",
";",
"}",
"finally",
"{",
"closer",
"close",
"(",
")",
";",
"}",
"}"
]
|
[
"post",
"-",
"multiplies",
"this",
"matrix",
"by",
"a",
"rotation",
"toward",
"a",
"target"
]
| [
"public",
"matrix",
"4",
"rotate",
"toward",
"target",
"(",
"final",
"vector",
"3",
"target",
",",
"final",
"vector",
"3",
"up",
")",
"{",
"tmp",
"vec",
"set",
"(",
"target",
"x",
"-",
"val",
"[",
"m03",
"]",
",",
"target",
"y",
"-",
"val",
"[",
"m13",
"]",
",",
"target",
"z",
"-",
"val",
"[",
"m23",
"]",
")",
";",
"return",
"rotate",
"toward",
"direction",
"(",
"tmp",
"vec",
",",
"up",
")",
";",
"}"
]
|
[
"parses",
"a",
"json",
"string",
"and",
"converts",
"to",
"node",
"plan"
]
| [
"public",
"static",
"node",
"plan",
"parse",
"json",
"(",
"string",
"json",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"reader",
"read",
"value",
"(",
"json",
")",
";",
"}"
]
|
[
"returns",
"true",
"iff",
"the",
"process",
"exited",
"with",
"code",
"0"
]
| [
"public",
"boolean",
"success",
"(",
")",
"{",
"return",
"exited",
"(",
")",
"&",
"&",
"get",
"exit",
"code",
"(",
")",
"=",
"=",
"0",
";",
"}"
]
|
[
"reports",
"any",
"mismatch",
"in",
"the",
"transaction",
"digest"
]
| [
"public",
"void",
"report",
"digest",
"mismatch",
"(",
"long",
"zxid",
")",
"{",
"server",
"metrics",
"get",
"metrics",
"(",
")",
"digest",
"mismatches",
"count",
"add",
"(",
"1",
")",
";",
"rate",
"logger",
"rate",
"limit",
"log",
"(",
"\"",
"digests",
"are",
"not",
"matching",
"value",
"is",
"zxid",
"\"",
",",
"string",
"value",
"of",
"(",
"zxid",
")",
")",
";",
"for",
"(",
"digest",
"watcher",
"watcher",
":",
"digest",
"watchers",
")",
"{",
"watcher",
"process",
"(",
"zxid",
")",
";",
"}",
"}"
]
|
[
"test",
"the",
"property",
"'",
"email",
"'"
]
| [
"public",
"void",
"email",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"email",
"}"
]
|
[
"get",
"the",
"base",
"offset",
"of",
"the",
"readable",
"batches",
"note",
"that",
"this",
"value",
"is",
"a",
"constant",
"which",
"is",
"defined",
"when",
"the",
"{",
"@",
"link",
"batch",
"reader",
"}",
"instance",
"is",
"constructed",
"it",
"does",
"not",
"change",
"based",
"on",
"reader",
"progress"
]
| [
"long",
"base",
"offset",
"(",
")",
";"
]
|
[
"put",
"into",
"map",
"if",
"value",
"is",
"not",
"null"
]
| [
"public",
"static",
"void",
"put",
"if",
"val",
"no",
"null",
"(",
"map",
"target",
",",
"object",
"key",
",",
"object",
"value",
")",
"{",
"objects",
"require",
"non",
"null",
"(",
"key",
",",
"\"",
"key",
"\"",
")",
";",
"if",
"(",
"value",
"!",
"=",
"null",
")",
"{",
"target",
"put",
"(",
"key",
",",
"value",
")",
";",
"}",
"}"
]
|
[
"similar",
"to",
"{",
"@",
"link",
"#",
"equals",
"(",
"object",
")",
"}",
",",
"except",
"ignores",
"the",
"x",
"attr",
"value"
]
| [
"public",
"boolean",
"equals",
"ignore",
"value",
"(",
"object",
"obj",
")",
"{",
"if",
"(",
"obj",
"=",
"=",
"null",
")",
"{",
"return",
"false",
";",
"}",
"if",
"(",
"obj",
"=",
"=",
"this",
")",
"{",
"return",
"true",
";",
"}",
"if",
"(",
"obj",
"get",
"class",
"(",
")",
"!",
"=",
"get",
"class",
"(",
")",
")",
"{",
"return",
"false",
";",
"}",
"x",
"attr",
"rhs",
"=",
"(",
"x",
"attr",
")",
"obj",
";",
"return",
"new",
"equals",
"builder",
"(",
")",
"append",
"(",
"ns",
",",
"rhs",
"ns",
")",
"append",
"(",
"name",
",",
"rhs",
"name",
")",
"is",
"equals",
"(",
")",
";",
"}"
]
|
[
"creates",
"an",
"{",
"@",
"link",
"ads",
"request",
"}",
"to",
"contain",
"the",
"data",
"used",
"to",
"request",
"ads"
]
| [
"ads",
"request",
"create",
"ads",
"request",
"(",
")",
";"
]
|
[
"create",
"mount",
"links",
"as",
"follows",
"hdfs",
":",
"localhost",
":",
"xxxlocal",
"0",
"-",
"-",
">",
"file",
":",
"local",
"path",
"hdfs",
":",
"localhost",
":",
"xxxlocal",
"1",
"-",
"-",
">",
"file",
":",
"local",
"path",
"when",
"inner",
"cache",
"disabled",
",",
"all",
"non",
"matching",
"view",
"file",
"system",
"overload",
"scheme",
"initialized",
"scheme",
"file",
"systems",
"should",
"continue",
"to",
"take",
"advantage",
"of",
"file",
"system",
"cache"
]
| [
"public",
"void",
"test",
"view",
"fs",
"overload",
"scheme",
"with",
"no",
"inner",
"cache",
"and",
"local",
"scheme",
"targets",
"(",
")",
"throws",
"exception",
"{",
"final",
"path",
"local",
"traget",
"path",
"=",
"new",
"path",
"(",
"local",
"target",
"dir",
"to",
"u",
"r",
"i",
"(",
")",
")",
";",
"add",
"mount",
"links",
"(",
"default",
"f",
"s",
"u",
"r",
"i",
"get",
"authority",
"(",
")",
",",
"new",
"string",
"[",
"]",
"{",
"local",
"folder",
"+",
"0",
",",
"local",
"folder",
"+",
"1",
"}",
",",
"new",
"string",
"[",
"]",
"{",
"local",
"traget",
"path",
"to",
"uri",
"(",
")",
"to",
"string",
"(",
")",
",",
"local",
"traget",
"path",
"to",
"uri",
"(",
")",
"to",
"string",
"(",
")",
"}",
",",
"conf",
")",
";",
"/",
"/",
"only",
"one",
"local",
"file",
"system",
"should",
"be",
"there",
"if",
"no",
"inner",
"cache",
",",
"but",
"fs",
"/",
"/",
"cache",
"should",
"work",
"conf",
"set",
"boolean",
"(",
"constants",
"config",
"viewfs",
"enable",
"inner",
"cache",
",",
"false",
")",
";",
"try",
"(",
"file",
"system",
"vfs",
"=",
"file",
"system",
"get",
"(",
"conf",
")",
")",
"{",
"assert",
"assert",
"equals",
"(",
"is",
"fall",
"back",
"exist",
"(",
"conf",
")",
"?",
"2",
":",
"1",
",",
"vfs",
"get",
"child",
"file",
"systems",
"(",
")",
"length",
")",
";",
"}",
"}"
]
|
[
"return",
"true",
"if",
"it",
"is",
"possible",
"that",
"this",
"could",
"emit",
"more",
"values"
]
| [
"public",
"boolean",
"has",
"next",
"(",
")",
"{",
"return",
"jc",
"has",
"next",
"(",
")",
"|",
"|",
"!",
"q",
"is",
"empty",
"(",
")",
";",
"}"
]
|
[
"<",
"code",
">",
"optional",
"string",
"foo",
"=",
"1",
";",
"<",
"code",
">"
]
| [
"public",
"builder",
"set",
"foo",
"bytes",
"(",
"com",
"google",
"protobuf",
"byte",
"string",
"value",
")",
"{",
"if",
"(",
"value",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"null",
"pointer",
"exception",
"(",
")",
";",
"}",
"bit",
"field",
"0",
"|",
"=",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"1",
";",
"foo",
"=",
"value",
";",
"on",
"changed",
"(",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"model",
"tests",
"for",
"tag"
]
| [
"public",
"void",
"test",
"tag",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"tag",
"}"
]
|
[
"return",
"the",
"required",
"type",
"of",
"view",
"for",
"this",
"resolver",
"this",
"implementation",
"returns",
"{",
"@",
"link",
"abstract",
"url",
"based",
"view",
"}"
]
| [
"protected",
"class",
"<",
"?",
">",
"required",
"view",
"class",
"(",
")",
"{",
"return",
"abstract",
"url",
"based",
"view",
"class",
";",
"}"
]
|
[
"formats",
"an",
"{",
"@",
"code",
"int",
"}",
"as",
"a",
"4",
"-",
"byte",
"signed",
"hex",
"value"
]
| [
"public",
"static",
"string",
"s",
"4",
"(",
"int",
"v",
")",
"{",
"char",
"[",
"]",
"result",
"=",
"new",
"char",
"[",
"9",
"]",
";",
"if",
"(",
"v",
"<",
"0",
")",
"{",
"result",
"[",
"0",
"]",
"=",
"'",
"-",
"'",
";",
"v",
"=",
"-",
"v",
";",
"}",
"else",
"{",
"result",
"[",
"0",
"]",
"=",
"'",
"+",
"'",
";",
"}",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"8",
";",
"i",
"+",
"+",
")",
"{",
"result",
"[",
"8",
"-",
"i",
"]",
"=",
"character",
"for",
"digit",
"(",
"v",
"&",
"0x",
"0f",
",",
"16",
")",
";",
"v",
">",
">",
"=",
"4",
";",
"}",
"return",
"new",
"string",
"(",
"result",
")",
";",
"}"
]
|
[
"create",
"a",
"temp",
"file",
"with",
"some",
"text"
]
| [
"public",
"file",
"create",
"temp",
"file",
"(",
"string",
"text",
")",
"throws",
"i",
"o",
"exception",
"{",
"file",
"f",
"=",
"file",
"create",
"temp",
"file",
"(",
"\"",
"test",
"\"",
",",
"\"",
"txt",
"\"",
")",
";",
"file",
"utils",
"write",
"(",
"f",
",",
"text",
",",
"ascii",
")",
";",
"return",
"f",
";",
"}"
]
|
[
"set",
"the",
"list",
"of",
"headers",
"that",
"a",
"pre",
"-",
"flight",
"request",
"can",
"list",
"as",
"allowed",
"for",
"use",
"during",
"an",
"actual",
"request",
"the",
"special",
"value",
"{",
"@",
"code",
"\"",
"\"",
"}",
"may",
"be",
"used",
"to",
"allow",
"all",
"headers",
"a",
"header",
"name",
"is",
"not",
"required",
"to",
"be",
"listed",
"if",
"it",
"is",
"one",
"of",
":",
"{",
"@",
"code",
"cache",
"-",
"control",
"}",
",",
"{",
"@",
"code",
"content",
"-",
"language",
"}",
",",
"{",
"@",
"code",
"expires",
"}",
",",
"{",
"@",
"code",
"last",
"-",
"modified",
"}",
",",
"or",
"{",
"@",
"code",
"pragma",
"}",
"as",
"per",
"the",
"cors",
"spec",
"by",
"default",
"all",
"headers",
"are",
"allowed"
]
| [
"public",
"cors",
"registration",
"allowed",
"headers",
"(",
"string",
"headers",
")",
"{",
"this",
"config",
"set",
"allowed",
"headers",
"(",
"arrays",
"as",
"list",
"(",
"headers",
")",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"test",
"that",
"opens",
"and",
"closes",
"a",
"file",
"10000",
"times",
"-",
"this",
"would",
"crash",
"with",
"\"",
"too",
"many",
"open",
"files",
"\"",
"if",
"we",
"leaked",
"fds",
"using",
"this",
"access",
"pattern"
]
| [
"public",
"void",
"test",
"f",
"d",
"doesnt",
"leak",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"assume",
"not",
"windows",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"10000",
";",
"i",
"+",
"+",
")",
"{",
"file",
"descriptor",
"fd",
"=",
"native",
"i",
"o",
"posix",
"open",
"(",
"new",
"file",
"(",
"test",
"dir",
",",
"\"",
"test",
"no",
"fd",
"leak",
"\"",
")",
"get",
"absolute",
"path",
"(",
")",
",",
"o",
"wronly",
"|",
"o",
"creat",
",",
"0700",
")",
";",
"assert",
"not",
"null",
"(",
"true",
")",
";",
"assert",
"true",
"(",
"fd",
"valid",
"(",
")",
")",
";",
"file",
"output",
"stream",
"fos",
"=",
"new",
"file",
"output",
"stream",
"(",
"fd",
")",
";",
"fos",
"write",
"(",
"\"",
"foo",
"\"",
"get",
"bytes",
"(",
")",
")",
";",
"fos",
"close",
"(",
")",
";",
"}",
"}"
]
|
[
"set",
"the",
"additional",
"(",
"undeclared",
")",
"property",
"with",
"the",
"specified",
"name",
"and",
"value",
"if",
"the",
"property",
"does",
"not",
"already",
"exist",
",",
"create",
"it",
"otherwise",
"replace",
"it"
]
| [
"public",
"scalene",
"triangle",
"put",
"additional",
"property",
"(",
"string",
"key",
",",
"object",
"value",
")",
"{",
"if",
"(",
"this",
"additional",
"properties",
"=",
"=",
"null",
")",
"{",
"this",
"additional",
"properties",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"object",
">",
"(",
")",
";",
"}",
"this",
"additional",
"properties",
"put",
"(",
"key",
",",
"value",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"display",
"this",
"dialog"
]
| [
"void",
"show",
"dialog",
"(",
"program",
"the",
"program",
",",
"variable",
"the",
"variable",
")",
"{",
"this",
"program",
"=",
"the",
"program",
";",
"string",
"type",
"=",
"(",
"the",
"variable",
"instanceof",
"parameter",
")",
"?",
"\"",
"parameter",
"\"",
":",
"\"",
"local",
"variable",
"\"",
";",
"set",
"title",
"(",
"\"",
"set",
"\"",
"+",
"type",
"+",
"\"",
"comment",
":",
"\"",
"+",
"the",
"variable",
"get",
"name",
"(",
")",
")",
";",
"set",
"help",
"location",
"(",
"new",
"help",
"location",
"(",
"plugin",
"get",
"name",
"(",
")",
",",
"\"",
"edit",
"variable",
"comment",
"\"",
")",
")",
";",
"this",
"variable",
"=",
"the",
"variable",
";",
"show",
"dialog",
"(",
"the",
"variable",
"get",
"comment",
"(",
")",
")",
";",
"}"
]
|
[
"ensures",
"the",
"truth",
"of",
"an",
"expression",
"involving",
"the",
"state",
"of",
"the",
"calling",
"instance",
",",
"but",
"not",
"involving",
"any",
"parameters",
"to",
"the",
"calling",
"method",
"see",
"{",
"@",
"link",
"#",
"check",
"state",
"(",
"boolean",
",",
"string",
",",
"object",
")",
"}",
"for",
"details"
]
| [
"public",
"static",
"void",
"check",
"state",
"(",
"boolean",
"b",
",",
"@",
"nullable",
"decl",
"string",
"error",
"message",
"template",
",",
"@",
"nullable",
"decl",
"object",
"p",
"1",
")",
"{",
"if",
"(",
"!",
"b",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"lenient",
"format",
"(",
"error",
"message",
"template",
",",
"p",
"1",
")",
")",
";",
"}",
"}"
]
|
[
"returns",
"the",
"component",
"that",
"tries",
"to",
"resolve",
"hostnames",
"against",
"the",
"hosts",
"file",
"prior",
"to",
"asking",
"to",
"remotes",
"dns",
"servers"
]
| [
"public",
"hosts",
"file",
"entries",
"resolver",
"hosts",
"file",
"entries",
"resolver",
"(",
")",
"{",
"return",
"hosts",
"file",
"entries",
"resolver",
";",
"}"
]
|
[
"returns",
"a",
"request",
"that",
"only",
"contains",
"those",
"tests",
"that",
"should",
"run",
"when",
"a",
"filter",
"is",
"applied",
",",
"filtering",
"out",
"all",
"empty",
"suites",
"note",
"that",
"if",
"the",
"request",
"passed",
"into",
"this",
"method",
"caches",
"its",
"runner",
",",
"that",
"runner",
"will",
"be",
"modified",
"to",
"use",
"the",
"given",
"filter",
"to",
"be",
"safe",
",",
"do",
"not",
"use",
"the",
"passed",
"-",
"in",
"request",
"after",
"calling",
"this",
"method"
]
| [
"public",
"static",
"request",
"apply",
"(",
"request",
"request",
",",
"filter",
"filter",
")",
"throws",
"no",
"tests",
"remain",
"exception",
"{",
"filter",
"=",
"new",
"suite",
"trimming",
"filter",
"(",
"filter",
")",
";",
"runner",
"runner",
"=",
"request",
"get",
"runner",
"(",
")",
";",
"filter",
"apply",
"(",
"runner",
")",
";",
"return",
"request",
"runner",
"(",
"runner",
")",
";",
"}"
]
|
[
"post",
"fake",
":",
"fake",
"endpoint",
"for",
"testing",
"various",
"parameters",
"가짜",
"엔드",
"포인트",
"fake",
"endpoint",
"for",
"testing",
"various",
"parameters",
"가짜",
"엔드",
"포인트"
]
| [
"default",
"response",
"entity",
"<",
"void",
">",
"test",
"endpoint",
"parameters",
"(",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"number",
"\"",
",",
"required",
"=",
"true",
")",
"big",
"decimal",
"number",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"double",
"\"",
",",
"required",
"=",
"true",
")",
"double",
"double",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"pattern",
"without",
"delimiter",
"\"",
",",
"required",
"=",
"true",
")",
"string",
"pattern",
"without",
"delimiter",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"byte",
"\"",
",",
"required",
"=",
"true",
")",
"byte",
"[",
"]",
"byte",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"integer",
"\"",
",",
"required",
"=",
"false",
")",
"integer",
"integer",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"int",
"3",
"2",
"\"",
",",
"required",
"=",
"false",
")",
"integer",
"int",
"3",
"2",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"int",
"6",
"4",
"\"",
",",
"required",
"=",
"false",
")",
"long",
"int",
"6",
"4",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"float",
"\"",
",",
"required",
"=",
"false",
")",
"float",
"float",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"string",
"\"",
",",
"required",
"=",
"false",
")",
"string",
"string",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"binary",
"\"",
",",
"required",
"=",
"false",
")",
"multipart",
"file",
"binary",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"date",
"\"",
",",
"required",
"=",
"false",
")",
"local",
"date",
"date",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"date",
"time",
"\"",
",",
"required",
"=",
"false",
")",
"offset",
"date",
"time",
"date",
"time",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"password",
"\"",
",",
"required",
"=",
"false",
")",
"string",
"password",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"callback",
"\"",
",",
"required",
"=",
"false",
")",
"string",
"param",
"callback",
")",
"{",
"return",
"new",
"response",
"entity",
"<",
">",
"(",
"http",
"status",
"not",
"implemented",
")",
";",
"}"
]
|
[
"the",
"value",
"assigned",
"to",
"this",
"plural",
"<",
"code",
">",
"optional",
"aapt",
"pb",
"item",
"item",
"=",
"4",
";",
"<",
"code",
">"
]
| [
"public",
"com",
"android",
"aapt",
"resources",
"item",
"get",
"item",
"(",
")",
"{",
"return",
"instance",
"get",
"item",
"(",
")",
";",
"}"
]
|
[
"acquires",
"the",
"given",
"resources",
"if",
"available",
"immediately",
"does",
"not",
"block"
]
| [
"resource",
"handle",
"try",
"acquire",
"(",
"action",
"execution",
"metadata",
"owner",
",",
"resource",
"set",
"resources",
")",
"{",
"preconditions",
"check",
"not",
"null",
"(",
"resources",
",",
"\"",
"try",
"acquire",
"called",
"with",
"resources",
"=",
"=",
"null",
"during",
"%",
"s",
"\"",
",",
"owner",
")",
";",
"preconditions",
"check",
"state",
"(",
"!",
"thread",
"has",
"resources",
"(",
")",
",",
"\"",
"try",
"acquire",
"with",
"existing",
"resource",
"lock",
"during",
"%",
"s",
"\"",
",",
"owner",
")",
";",
"boolean",
"acquired",
"=",
"false",
";",
"synchronized",
"(",
"this",
")",
"{",
"if",
"(",
"are",
"resources",
"available",
"(",
"resources",
")",
")",
"{",
"increment",
"resources",
"(",
"resources",
")",
";",
"acquired",
"=",
"true",
";",
"}",
"}",
"if",
"(",
"acquired",
")",
"{",
"thread",
"locked",
"set",
"(",
"resources",
"!",
"=",
"resource",
"set",
"zero",
")",
";",
"return",
"new",
"resource",
"handle",
"(",
"this",
",",
"owner",
",",
"resources",
")",
";",
"}",
"return",
"null",
";",
"}"
]
|
[
"tests",
"getting",
"the",
"data",
"for",
"a",
"desktop",
"client"
]
| [
"public",
"void",
"test",
"get",
"product",
"desktop",
"(",
")",
"{",
"var",
"image",
"path",
"=",
"\"",
"/",
"product",
"-",
"image",
"png",
"\"",
";",
"var",
"price",
"=",
"\"",
"20",
"\"",
";",
"when",
"(",
"image",
"client",
"get",
"image",
"path",
"(",
")",
")",
"then",
"return",
"(",
"image",
"path",
")",
";",
"when",
"(",
"price",
"client",
"get",
"price",
"(",
")",
")",
"then",
"return",
"(",
"price",
")",
";",
"var",
"desktop",
"product",
"=",
"api",
"gateway",
"get",
"product",
"desktop",
"(",
")",
";",
"assert",
"equals",
"(",
"price",
",",
"desktop",
"product",
"get",
"price",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"image",
"path",
",",
"desktop",
"product",
"get",
"image",
"path",
"(",
")",
")",
";",
"}"
]
|
[
"returns",
"true",
"if",
"the",
"requisite",
"number",
"of",
"shards",
"were",
"started",
"before",
"returning",
"from",
"the",
"index",
"creation",
"operation",
"if",
"{",
"@",
"link",
"#",
"is",
"acknowledged",
"(",
")",
"}",
"is",
"false",
",",
"then",
"this",
"also",
"returns",
"false"
]
| [
"public",
"boolean",
"is",
"shards",
"acknowledged",
"(",
")",
"{",
"return",
"shards",
"acknowledged",
";",
"}"
]
|
[
"converts",
"flink",
"expression",
"to",
"parquet",
"filter",
"predicate"
]
| [
"private",
"filter",
"predicate",
"to",
"parquet",
"predicate",
"(",
"expression",
"exp",
")",
"{",
"if",
"(",
"exp",
"instanceof",
"not",
")",
"{",
"filter",
"predicate",
"c",
"=",
"to",
"parquet",
"predicate",
"(",
"(",
"(",
"not",
")",
"exp",
")",
"child",
"(",
")",
")",
";",
"if",
"(",
"c",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"else",
"{",
"return",
"filter",
"api",
"not",
"(",
"c",
")",
";",
"}",
"}",
"else",
"if",
"(",
"exp",
"instanceof",
"binary",
"comparison",
")",
"{",
"binary",
"comparison",
"bin",
"comp",
"=",
"(",
"binary",
"comparison",
")",
"exp",
";",
"if",
"(",
"!",
"is",
"valid",
"(",
"bin",
"comp",
")",
")",
"{",
"/",
"/",
"unsupported",
"literal",
"type",
"log",
"debug",
"(",
"\"",
"unsupported",
"predict",
"[",
"{",
"}",
"]",
"cannot",
"be",
"pushed",
"to",
"parquet",
"table",
"source",
"\"",
",",
"exp",
")",
";",
"return",
"null",
";",
"}",
"boolean",
"on",
"right",
"=",
"literal",
"on",
"right",
"(",
"bin",
"comp",
")",
";",
"tuple",
"2",
"<",
"column",
",",
"comparable",
">",
"column",
"pair",
"=",
"extract",
"column",
"and",
"literal",
"(",
"bin",
"comp",
")",
";",
"if",
"(",
"column",
"pair",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"exp",
"instanceof",
"equal",
"to",
")",
"{",
"if",
"(",
"column",
"pair",
"f",
"0",
"instanceof",
"int",
"column",
")",
"{",
"return",
"filter",
"api",
"eq",
"(",
"(",
"int",
"column",
")",
"column",
"pair",
"f",
"0",
",",
"(",
"integer",
")",
"column",
"pair",
"f",
"1",
")",
";",
"}",
"else",
"if",
"(",
"column",
"pair",
"f",
"0",
"instanceof",
"long",
"column",
")",
"{",
"return",
"filter",
"api",
"eq",
"(",
"(",
"long",
"column",
")",
"column",
"pair",
"f",
"0",
",",
"(",
"long",
")",
"column",
"pair",
"f",
"1",
")",
";",
"}",
"else",
"if",
"(",
"column",
"pair",
"f",
"0",
"instanceof",
"double",
"column",
")",
"{",
"return",
"filter",
"api",
"eq",
"(",
"(",
"double",
"column",
")",
"column",
"pair",
"f",
"0",
",",
"(",
"double",
")",
"column",
"pair",
"f",
"1",
")",
";",
"}",
"else",
"if",
"(",
"column",
"pair",
"f",
"0",
"instanceof",
"float",
"column",
")",
"{",
"return",
"filter",
"api",
"eq",
"(",
"(",
"float",
"column",
")",
"column",
"pair",
"f",
"0",
",",
"(",
"float",
")",
"column",
"pair",
"f",
"1",
")",
";",
"}",
"else",
"if",
"(",
"column",
"pair",
"f",
"0",
"instanceof",
"boolean",
"column",
")",
"{",
"return",
"filter",
"api",
"eq",
"(",
"(",
"boolean",
"column",
")",
"column",
"pair",
"f",
"0",
",",
"(",
"boolean",
")",
"column",
"pair",
"f",
"1",
")",
";",
"}",
"else",
"if",
"(",
"column",
"pair",
"f",
"0",
"instanceof",
"binary",
"column",
")",
"{",
"return",
"filter",
"api",
"eq",
"(",
"(",
"binary",
"column",
")",
"column",
"pair",
"f",
"0",
",",
"(",
"binary",
")",
"column",
"pair",
"f",
"1",
")",
";",
"}",
"}",
"else",
"if",
"(",
"exp",
"instanceof",
"not",
"equal",
"to",
")",
"{",
"if",
"(",
"column",
"pair",
"f",
"0",
"instanceof",
"int",
"column",
")",
"{",
"return",
"filter",
"api",
"not",
"eq",
"(",
"(",
"int",
"column",
")",
"column",
"pair",
"f",
"0",
",",
"(",
"integer",
")",
"column",
"pair",
"f",
"1",
")",
";",
"}",
"else",
"if",
"(",
"column",
"pair",
"f",
"0",
"instanceof",
"long",
"column",
")",
"{",
"return",
"filter",
"api",
"not",
"eq",
"(",
"(",
"long",
"column",
")",
"column",
"pair",
"f",
"0",
",",
"(",
"long",
")",
"column",
"pair",
"f",
"1",
")",
";",
"}",
"else",
"if",
"(",
"column",
"pair",
"f",
"0",
"instanceof",
"double",
"column",
")",
"{",
"return",
"filter",
"api",
"not",
"eq",
"(",
"(",
"double",
"column",
")",
"column",
"pair",
"f",
"0",
",",
"(",
"double",
")",
"column",
"pair",
"f",
"1",
")",
";",
"}",
"else",
"if",
"(",
"column",
"pair",
"f",
"0",
"instanceof",
"float",
"column",
")",
"{",
"return",
"filter",
"api",
"not",
"eq",
"(",
"(",
"float",
"column",
")",
"column",
"pair",
"f",
"0",
",",
"(",
"float",
")",
"column",
"pair",
"f",
"1",
")",
";",
"}",
"else",
"if",
"(",
"column",
"pair",
"f",
"0",
"instanceof",
"boolean",
"column",
")",
"{",
"return",
"filter",
"api",
"not",
"eq",
"(",
"(",
"boolean",
"column",
")",
"column",
"pair",
"f",
"0",
",",
"(",
"boolean",
")",
"column",
"pair",
"f",
"1",
")",
";",
"}",
"else",
"if",
"(",
"column",
"pair",
"f",
"0",
"instanceof",
"binary",
"column",
")",
"{",
"return",
"filter",
"api",
"not",
"eq",
"(",
"(",
"binary",
"column",
")",
"column",
"pair",
"f",
"0",
",",
"(",
"binary",
")",
"column",
"pair",
"f",
"1",
")",
";",
"}",
"}",
"else",
"if",
"(",
"exp",
"instanceof",
"greater",
"than",
")",
"{",
"if",
"(",
"on",
"right",
")",
"{",
"return",
"greater",
"than",
"(",
"exp",
",",
"column",
"pair",
")",
";",
"}",
"else",
"{",
"less",
"than",
"(",
"exp",
",",
"column",
"pair",
")",
";",
"}",
"}",
"else",
"if",
"(",
"exp",
"instanceof",
"greater",
"than",
"or",
"equal",
")",
"{",
"if",
"(",
"on",
"right",
")",
"{",
"return",
"greater",
"than",
"or",
"equal",
"(",
"exp",
",",
"column",
"pair",
")",
";",
"}",
"else",
"{",
"return",
"less",
"than",
"or",
"equal",
"(",
"exp",
",",
"column",
"pair",
")",
";",
"}",
"}",
"else",
"if",
"(",
"exp",
"instanceof",
"less",
"than",
")",
"{",
"if",
"(",
"on",
"right",
")",
"{",
"return",
"less",
"than",
"(",
"exp",
",",
"column",
"pair",
")",
";",
"}",
"else",
"{",
"return",
"greater",
"than",
"(",
"exp",
",",
"column",
"pair",
")",
";",
"}",
"}",
"else",
"if",
"(",
"exp",
"instanceof",
"less",
"than",
"or",
"equal",
")",
"{",
"if",
"(",
"on",
"right",
")",
"{",
"return",
"less",
"than",
"or",
"equal",
"(",
"exp",
",",
"column",
"pair",
")",
";",
"}",
"else",
"{",
"return",
"greater",
"than",
"or",
"equal",
"(",
"exp",
",",
"column",
"pair",
")",
";",
"}",
"}",
"else",
"{",
"/",
"/",
"unsupported",
"predicate",
"log",
"debug",
"(",
"\"",
"unsupported",
"predicate",
"[",
"{",
"}",
"]",
"cannot",
"be",
"pushed",
"into",
"parquet",
"table",
"source",
"\"",
",",
"exp",
")",
";",
"return",
"null",
";",
"}",
"}",
"}",
"else",
"if",
"(",
"exp",
"instanceof",
"binary",
"expression",
")",
"{",
"if",
"(",
"exp",
"instanceof",
"and",
")",
"{",
"log",
"debug",
"(",
"\"",
"all",
"of",
"the",
"predicates",
"should",
"be",
"in",
"cnf",
"found",
"an",
"and",
"expression",
":",
"{",
"}",
"\"",
",",
"exp",
")",
";",
"}",
"else",
"if",
"(",
"exp",
"instanceof",
"or",
")",
"{",
"filter",
"predicate",
"c",
"1",
"=",
"to",
"parquet",
"predicate",
"(",
"(",
"(",
"or",
")",
"exp",
")",
"left",
"(",
")",
")",
";",
"filter",
"predicate",
"c",
"2",
"=",
"to",
"parquet",
"predicate",
"(",
"(",
"(",
"or",
")",
"exp",
")",
"right",
"(",
")",
")",
";",
"if",
"(",
"c",
"1",
"=",
"=",
"null",
"|",
"|",
"c",
"2",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"else",
"{",
"return",
"filter",
"api",
"or",
"(",
"c",
"1",
",",
"c",
"2",
")",
";",
"}",
"}",
"else",
"{",
"/",
"/",
"unsupported",
"predicate",
"log",
"debug",
"(",
"\"",
"unsupported",
"predicate",
"[",
"{",
"}",
"]",
"cannot",
"be",
"pushed",
"into",
"parquet",
"table",
"source",
"\"",
",",
"exp",
")",
";",
"return",
"null",
";",
"}",
"}",
"return",
"null",
";",
"}"
]
|
[
"experimental",
"configuration",
"to",
"change",
"the",
"behavior",
"of",
"h",
"scroll",
"'",
"s",
"when",
"they",
"are",
"nested",
"within",
"a",
"vertical",
"scroll",
"with",
"this",
"mode",
",",
"the",
"hscroll",
"will",
"attempt",
"to",
"compute",
"all",
"layouts",
"in",
"the",
"background",
"before",
"mounting",
"so",
"that",
"no",
"layouts",
"are",
"computed",
"on",
"the",
"main",
"thread",
"all",
"subsequent",
"insertions",
"will",
"be",
"treated",
"with",
"layout",
"before",
"insert",
"policy",
"to",
"ensure",
"those",
"layouts",
"also",
"do",
"not",
"happen",
"on",
"the",
"main",
"thread"
]
| [
"public",
"builder",
"hscroll",
"async",
"mode",
"(",
"boolean",
"hscroll",
"async",
"mode",
")",
"{",
"this",
"hscroll",
"async",
"mode",
"=",
"hscroll",
"async",
"mode",
";",
"return",
"this",
";",
"}"
]
|
[
"called",
"when",
"the",
"memory",
"in",
"the",
"current",
"program",
"changes",
",",
"from",
"the",
"domain",
"object",
"listener"
]
| [
"void",
"memory",
"configuration",
"changed",
"(",
")",
"{",
"program",
"location",
"location",
"=",
"current",
"location",
";",
"program",
"selection",
"selection",
"=",
"current",
"selection",
";",
"/",
"/",
"reuse",
"byte",
"block",
"change",
"manager",
"so",
"we",
"don",
"'",
"t",
"lose",
"track",
"of",
"what",
"has",
"/",
"/",
"been",
"edited",
"byte",
"block",
"change",
"manager",
"bbcm",
"=",
"null",
";",
"if",
"(",
"block",
"set",
"!",
"=",
"null",
")",
"{",
"bbcm",
"=",
"block",
"set",
"get",
"byte",
"block",
"change",
"manager",
"(",
")",
";",
"}",
"set",
"byte",
"blocks",
"(",
"bbcm",
")",
";",
"if",
"(",
"!",
"tool",
"is",
"visible",
"(",
"this",
")",
")",
"{",
"return",
";",
"}",
"set",
"location",
"(",
"location",
",",
"true",
")",
";",
"set",
"selection",
"(",
"selection",
",",
"true",
")",
";",
"}"
]
|
[
"{",
"@",
"inherit",
"doc",
"}"
]
| [
"protected",
"member",
"set",
"(",
"int",
"n",
",",
"int",
"access",
"flags",
",",
"cst",
"nat",
"nat",
",",
"attribute",
"list",
"attributes",
")",
"{",
"std",
"field",
"field",
"=",
"new",
"std",
"field",
"(",
"get",
"definer",
"(",
")",
",",
"access",
"flags",
",",
"nat",
",",
"attributes",
")",
";",
"fields",
"set",
"(",
"n",
",",
"field",
")",
";",
"return",
"field",
";",
"}"
]
|
[
"parses",
"the",
"header",
"of",
"the",
"subtitle"
]
| [
"private",
"void",
"parse",
"header",
"(",
"parsable",
"byte",
"array",
"data",
")",
"{",
"@",
"nullable",
"string",
"current",
"line",
";",
"while",
"(",
"(",
"current",
"line",
"=",
"data",
"read",
"line",
"(",
")",
")",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"\"",
"[",
"script",
"info",
"]",
"\"",
"equals",
"ignore",
"case",
"(",
"current",
"line",
")",
")",
"{",
"parse",
"script",
"info",
"(",
"data",
")",
";",
"}",
"else",
"if",
"(",
"\"",
"[",
"v4",
"+",
"styles",
"]",
"\"",
"equals",
"ignore",
"case",
"(",
"current",
"line",
")",
")",
"{",
"styles",
"=",
"parse",
"styles",
"(",
"data",
")",
";",
"}",
"else",
"if",
"(",
"\"",
"[",
"v4",
"styles",
"]",
"\"",
"equals",
"ignore",
"case",
"(",
"current",
"line",
")",
")",
"{",
"log",
"i",
"(",
"tag",
",",
"\"",
"[",
"v4",
"styles",
"]",
"are",
"not",
"supported",
"\"",
")",
";",
"}",
"else",
"if",
"(",
"\"",
"[",
"events",
"]",
"\"",
"equals",
"ignore",
"case",
"(",
"current",
"line",
")",
")",
"{",
"/",
"/",
"we",
"'",
"ve",
"reached",
"the",
"[",
"events",
"]",
"section",
",",
"so",
"the",
"header",
"is",
"over",
"return",
";",
"}",
"}",
"}"
]
|
[
"test",
"a",
"queued",
"command",
"execution",
"timeout",
"where",
"the",
"command",
"didn",
"'",
"t",
"implement",
"get",
"fallback",
"we",
"specifically",
"want",
"to",
"protect",
"against",
"developers",
"queuing",
"commands",
"and",
"using",
"queue",
"(",
")",
"get",
"(",
")",
"without",
"a",
"timeout",
"(",
"such",
"as",
"queue",
"(",
")",
"get",
"(",
"3000",
",",
"time",
"unit",
"milliseconds",
")",
")",
"and",
"ending",
"up",
"blocking",
"indefinitely",
"by",
"skipping",
"the",
"timeout",
"protection",
"of",
"the",
"execute",
"(",
")",
"command"
]
| [
"public",
"void",
"test",
"observed",
"execution",
"timeout",
"with",
"no",
"fallback",
"(",
")",
"{",
"test",
"hystrix",
"command",
"<",
"integer",
">",
"command",
"=",
"get",
"command",
"(",
"execution",
"isolation",
"strategy",
"thread",
",",
"abstract",
"test",
"hystrix",
"command",
"execution",
"result",
"success",
",",
"200",
",",
"abstract",
"test",
"hystrix",
"command",
"fallback",
"result",
"unimplemented",
",",
"50",
")",
";",
"try",
"{",
"command",
"observe",
"(",
")",
"to",
"blocking",
"(",
")",
"single",
"(",
")",
";",
"fail",
"(",
"\"",
"we",
"shouldn",
"'",
"t",
"get",
"here",
"\"",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"e",
"print",
"stack",
"trace",
"(",
")",
";",
"if",
"(",
"e",
"instanceof",
"hystrix",
"runtime",
"exception",
")",
"{",
"hystrix",
"runtime",
"exception",
"de",
"=",
"(",
"hystrix",
"runtime",
"exception",
")",
"e",
";",
"assert",
"not",
"null",
"(",
"de",
"get",
"fallback",
"exception",
"(",
")",
")",
";",
"assert",
"true",
"(",
"de",
"get",
"fallback",
"exception",
"(",
")",
"instanceof",
"unsupported",
"operation",
"exception",
")",
";",
"assert",
"not",
"null",
"(",
"de",
"get",
"implementing",
"class",
"(",
")",
")",
";",
"assert",
"not",
"null",
"(",
"de",
"get",
"cause",
"(",
")",
")",
";",
"assert",
"true",
"(",
"de",
"get",
"cause",
"(",
")",
"instanceof",
"timeout",
"exception",
")",
";",
"}",
"else",
"{",
"fail",
"(",
"\"",
"the",
"exception",
"should",
"be",
"execution",
"exception",
"with",
"cause",
"as",
"hystrix",
"runtime",
"exception",
"\"",
")",
";",
"}",
"}",
"assert",
"true",
"(",
"command",
"get",
"execution",
"time",
"in",
"milliseconds",
"(",
")",
">",
"-",
"1",
")",
";",
"assert",
"true",
"(",
"command",
"is",
"response",
"timed",
"out",
"(",
")",
")",
";",
"assert",
"command",
"execution",
"events",
"(",
"command",
",",
"hystrix",
"event",
"type",
"timeout",
",",
"hystrix",
"event",
"type",
"fallback",
"missing",
")",
";",
"assert",
"not",
"null",
"(",
"command",
"get",
"execution",
"exception",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"command",
"get",
"builder",
"(",
")",
"metrics",
"get",
"current",
"concurrent",
"execution",
"count",
"(",
")",
")",
";",
"assert",
"sane",
"hystrix",
"request",
"log",
"(",
"1",
")",
";",
"}"
]
|
[
"get",
"a",
"thread",
"-",
"local",
"typed",
"bytes",
"record",
"input",
"for",
"the",
"supplied",
"{",
"@",
"link",
"data",
"input",
"}"
]
| [
"public",
"static",
"typed",
"bytes",
"record",
"input",
"get",
"(",
"data",
"input",
"in",
")",
"{",
"return",
"get",
"(",
"typed",
"bytes",
"input",
"get",
"(",
"in",
")",
")",
";",
"}"
]
|
[
"the",
"same",
"exception",
"happening",
"on",
"multiple",
"futures",
"should",
"not",
"be",
"logged"
]
| [
"public",
"void",
"test",
"all",
"as",
"list",
"logging",
"same",
"exception",
"(",
")",
"throws",
"exception",
"{",
"try",
"{",
"my",
"exception",
"same",
"instance",
"=",
"new",
"my",
"exception",
"(",
")",
";",
"get",
"done",
"(",
"all",
"as",
"list",
"(",
"immediate",
"failed",
"future",
"(",
"same",
"instance",
")",
",",
"immediate",
"failed",
"future",
"(",
"same",
"instance",
")",
")",
")",
";",
"fail",
"(",
")",
";",
"}",
"catch",
"(",
"execution",
"exception",
"expected",
")",
"{",
"assert",
"that",
"(",
"expected",
"get",
"cause",
"(",
")",
")",
"is",
"instance",
"of",
"(",
"my",
"exception",
"class",
")",
";",
"assert",
"equals",
"(",
"\"",
"nothing",
"should",
"be",
"logged",
"\"",
",",
"0",
",",
"aggregate",
"future",
"log",
"handler",
"get",
"stored",
"log",
"records",
"(",
")",
"size",
"(",
")",
")",
";",
"}",
"}"
]
|
[
"do",
"http",
"request",
"by",
"async"
]
| [
"public",
"static",
"void",
"async",
"http",
"request",
"(",
"string",
"url",
",",
"list",
"<",
"string",
">",
"headers",
",",
"map",
"<",
"string",
",",
"string",
">",
"param",
"values",
",",
"callback",
"<",
"string",
">",
"callback",
",",
"string",
"method",
")",
"throws",
"exception",
"{",
"query",
"query",
"=",
"query",
"new",
"instance",
"(",
")",
"init",
"params",
"(",
"param",
"values",
")",
";",
"query",
"add",
"param",
"(",
"\"",
"encoding",
"\"",
",",
"\"",
"utf",
"-",
"8",
"\"",
")",
";",
"query",
"add",
"param",
"(",
"\"",
"nofix",
"\"",
",",
"\"",
"1",
"\"",
")",
";",
"header",
"header",
"=",
"header",
"new",
"instance",
"(",
")",
";",
"if",
"(",
"collection",
"utils",
"is",
"not",
"empty",
"(",
"headers",
")",
")",
"{",
"header",
"add",
"all",
"(",
"headers",
")",
";",
"}",
"header",
"add",
"param",
"(",
"http",
"header",
"consts",
"accept",
"charset",
",",
"\"",
"utf",
"-",
"8",
"\"",
")",
";",
"auth",
"header",
"util",
"add",
"identity",
"to",
"header",
"(",
"header",
")",
";",
"switch",
"(",
"method",
")",
"{",
"case",
"http",
"method",
"get",
":",
"async",
"rest",
"template",
"get",
"(",
"url",
",",
"header",
",",
"query",
",",
"string",
"class",
",",
"callback",
")",
";",
"break",
";",
"case",
"http",
"method",
"post",
":",
"async",
"rest",
"template",
"post",
"form",
"(",
"url",
",",
"header",
",",
"param",
"values",
",",
"string",
"class",
",",
"callback",
")",
";",
"break",
";",
"case",
"http",
"method",
"put",
":",
"async",
"rest",
"template",
"put",
"form",
"(",
"url",
",",
"header",
",",
"param",
"values",
",",
"string",
"class",
",",
"callback",
")",
";",
"break",
";",
"case",
"http",
"method",
"delete",
":",
"async",
"rest",
"template",
"delete",
"(",
"url",
",",
"header",
",",
"query",
",",
"string",
"class",
",",
"callback",
")",
";",
"break",
";",
"default",
":",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"not",
"supported",
"method",
":",
"\"",
"+",
"method",
")",
";",
"}",
"}"
]
|
[
"reads",
"a",
"{",
"@",
"link",
"#",
"type",
"}",
"attribute",
"this",
"method",
"must",
"return",
"a",
"new",
"{",
"@",
"link",
"attribute",
"}",
"object",
",",
"of",
"type",
"{",
"@",
"link",
"#",
"type",
"}",
",",
"corresponding",
"to",
"the",
"'",
"length",
"'",
"bytes",
"starting",
"at",
"'",
"offset",
"'",
",",
"in",
"the",
"given",
"class",
"reader"
]
| [
"protected",
"attribute",
"read",
"(",
"final",
"class",
"reader",
"class",
"reader",
",",
"final",
"int",
"offset",
",",
"final",
"int",
"length",
",",
"final",
"char",
"[",
"]",
"char",
"buffer",
",",
"final",
"int",
"code",
"attribute",
"offset",
",",
"final",
"label",
"[",
"]",
"labels",
")",
"{",
"attribute",
"attribute",
"=",
"new",
"attribute",
"(",
"type",
")",
";",
"attribute",
"content",
"=",
"new",
"byte",
"[",
"length",
"]",
";",
"system",
"arraycopy",
"(",
"class",
"reader",
"class",
"file",
"buffer",
",",
"offset",
",",
"attribute",
"content",
",",
"0",
",",
"length",
")",
";",
"return",
"attribute",
";",
"}"
]
|
[
"create",
"a",
"metric",
"name",
"with",
"the",
"given",
"name",
",",
"group",
",",
"description",
",",
"and",
"default",
"tags",
"specified",
"in",
"the",
"metric",
"configuration"
]
| [
"public",
"metric",
"name",
"metric",
"name",
"(",
"string",
"name",
",",
"string",
"group",
",",
"string",
"description",
")",
"{",
"return",
"metric",
"name",
"(",
"name",
",",
"group",
",",
"description",
",",
"new",
"hash",
"map",
"<",
">",
"(",
")",
")",
";",
"}"
]
|
[
"finds",
"or",
"creates",
"a",
"collection",
"of",
"application",
"privileges",
"with",
"the",
"provided",
"names",
"if",
"application",
"is",
"a",
"wildcard",
",",
"it",
"will",
"be",
"expanded",
"to",
"all",
"matching",
"application",
"names",
"in",
"{",
"@",
"code",
"stored",
"}",
"each",
"element",
"in",
"{",
"@",
"code",
"name",
"}",
"may",
"be",
"the",
"name",
"of",
"a",
"stored",
"privilege",
"(",
"to",
"be",
"resolved",
"from",
"{",
"@",
"code",
"stored",
"}",
",",
"or",
"a",
"bespoke",
"action",
"pattern"
]
| [
"public",
"static",
"set",
"<",
"application",
"privilege",
">",
"get",
"(",
"string",
"application",
",",
"set",
"<",
"string",
">",
"name",
",",
"collection",
"<",
"application",
"privilege",
"descriptor",
">",
"stored",
")",
"{",
"if",
"(",
"name",
"is",
"empty",
"(",
")",
")",
"{",
"return",
"collections",
"singleton",
"(",
"none",
"apply",
"(",
"application",
")",
")",
";",
"}",
"else",
"if",
"(",
"application",
"contains",
"(",
"\"",
"*",
"\"",
")",
")",
"{",
"predicate",
"<",
"string",
">",
"predicate",
"=",
"automatons",
"predicate",
"(",
"application",
")",
";",
"final",
"set",
"<",
"application",
"privilege",
">",
"result",
"=",
"stored",
"stream",
"(",
")",
"map",
"(",
"application",
"privilege",
"descriptor",
":",
":",
"get",
"application",
")",
"filter",
"(",
"predicate",
")",
"distinct",
"(",
")",
"map",
"(",
"app",
"name",
"-",
">",
"resolve",
"(",
"app",
"name",
",",
"name",
",",
"stored",
")",
")",
"collect",
"(",
"collectors",
"to",
"set",
"(",
")",
")",
";",
"if",
"(",
"result",
"is",
"empty",
"(",
")",
")",
"{",
"return",
"collections",
"singleton",
"(",
"resolve",
"(",
"application",
",",
"name",
",",
"collections",
"empty",
"map",
"(",
")",
")",
")",
";",
"}",
"else",
"{",
"return",
"result",
";",
"}",
"}",
"else",
"{",
"return",
"collections",
"singleton",
"(",
"resolve",
"(",
"application",
",",
"name",
",",
"stored",
")",
")",
";",
"}",
"}"
]
|
[
"{",
"@",
"inherit",
"doc",
"}"
]
| [
"public",
"object",
"execute",
"with",
"args",
"(",
"execution",
"type",
"execution",
"type",
",",
"object",
"[",
"]",
"args",
")",
"throws",
"command",
"action",
"execution",
"exception",
"{",
"hystrix",
"invokable",
"command",
"=",
"hystrix",
"command",
"factory",
"get",
"instance",
"(",
")",
"create",
"delayed",
"(",
"create",
"copy",
"(",
"original",
"meta",
"holder",
",",
"execution",
"type",
",",
"args",
")",
")",
";",
"return",
"new",
"command",
"execution",
"action",
"(",
"command",
",",
"original",
"meta",
"holder",
")",
"execute",
"(",
"execution",
"type",
")",
";",
"}"
]
|
[
"clear",
"the",
"state",
"of",
"this",
"model",
"and",
"view",
"object",
"the",
"object",
"will",
"be",
"empty",
"afterwards",
"can",
"be",
"used",
"to",
"suppress",
"rendering",
"of",
"a",
"given",
"model",
"and",
"view",
"object",
"in",
"the",
"{",
"@",
"code",
"post",
"handle",
"}",
"method",
"of",
"a",
"handler",
"interceptor"
]
| [
"public",
"void",
"clear",
"(",
")",
"{",
"this",
"view",
"=",
"null",
";",
"this",
"model",
"=",
"null",
";",
"this",
"cleared",
"=",
"true",
";",
"}"
]
|
[
"sets",
"the",
"{",
"@",
"link",
"standard",
"socket",
"options",
"#",
"so",
"broadcast",
"}",
"option"
]
| [
"datagram",
"channel",
"config",
"set",
"broadcast",
"(",
"boolean",
"broadcast",
")",
";"
]
|
[
"creates",
"data",
"for",
"a",
"call",
"site",
"record",
"at",
"the",
"indicated",
"address",
"and",
"creates",
"a",
"comment",
"to",
"identify",
"it",
"as",
"a",
"call",
"site",
"record",
"<",
"br",
">",
"note",
":",
"this",
"method",
"must",
"get",
"called",
"before",
"any",
"of",
"the",
"\"",
"get",
"\"",
"methods"
]
| [
"public",
"void",
"create",
"(",
"address",
"addr",
",",
"dwarf",
"e",
"h",
"decoder",
"decoder",
")",
"throws",
"memory",
"access",
"exception",
"{",
"/",
"*",
"use",
"current",
"program",
"location",
"if",
"'",
"addr",
"'",
"is",
"null",
"*",
"/",
"if",
"(",
"addr",
"=",
"=",
"null",
"|",
"|",
"monitor",
"is",
"cancelled",
"(",
")",
")",
"return",
";",
"address",
"base",
"addr",
"=",
"addr",
";",
"monitor",
"set",
"message",
"(",
"\"",
"creating",
"lsda",
"call",
"site",
"record",
"\"",
")",
";",
"address",
"call",
"site",
"data",
"addr",
"=",
"addr",
";",
"addr",
"=",
"create",
"call",
"site",
"position",
"(",
"addr",
",",
"decoder",
")",
";",
"addr",
"=",
"create",
"call",
"site",
"length",
"(",
"addr",
",",
"decoder",
")",
";",
"address",
"lp",
"data",
"addr",
"=",
"addr",
";",
"addr",
"=",
"create",
"landing",
"pad",
"(",
"addr",
",",
"decoder",
")",
";",
"addr",
"=",
"create",
"action",
"(",
"addr",
")",
";",
"address",
"lp",
"start",
"=",
"region",
"get",
"l",
"s",
"d",
"a",
"table",
"(",
")",
"get",
"header",
"(",
")",
"get",
"l",
"p",
"start",
"address",
"(",
")",
";",
"address",
"call",
"site",
"base",
"addr",
"=",
"lp",
"start",
"add",
"(",
"get",
"call",
"site",
"position",
"(",
")",
")",
";",
"address",
"call",
"site",
"extent",
"addr",
"=",
"call",
"site",
"base",
"addr",
"add",
"(",
"get",
"call",
"site",
"length",
"(",
")",
"-",
"1",
")",
";",
"call",
"site",
"range",
"=",
"new",
"address",
"range",
"impl",
"(",
"call",
"site",
"base",
"addr",
",",
"call",
"site",
"extent",
"addr",
")",
";",
"landing",
"pad",
"addr",
"=",
"lp",
"start",
"add",
"(",
"get",
"landing",
"pad",
"offset",
"(",
")",
")",
";",
"set",
"comment",
"cmd",
"comment",
"cmd",
"=",
"new",
"set",
"comment",
"cmd",
"(",
"base",
"addr",
",",
"code",
"unit",
"plate",
"comment",
",",
"\"",
"(",
"lsda",
")",
"call",
"site",
"record",
"\"",
")",
";",
"comment",
"cmd",
"apply",
"to",
"(",
"program",
")",
";",
"if",
"(",
"program",
"get",
"memory",
"(",
")",
"contains",
"(",
"call",
"site",
"base",
"addr",
")",
")",
"{",
"program",
"get",
"reference",
"manager",
"(",
")",
"add",
"memory",
"reference",
"(",
"call",
"site",
"data",
"addr",
",",
"call",
"site",
"base",
"addr",
",",
"ref",
"type",
"data",
",",
"source",
"type",
"analysis",
",",
"0",
")",
";",
"}",
"if",
"(",
"program",
"get",
"memory",
"(",
")",
"contains",
"(",
"landing",
"pad",
"addr",
")",
")",
"{",
"program",
"get",
"reference",
"manager",
"(",
")",
"add",
"memory",
"reference",
"(",
"lp",
"data",
"addr",
",",
"landing",
"pad",
"addr",
",",
"ref",
"type",
"data",
",",
"source",
"type",
"analysis",
",",
"0",
")",
";",
"}",
"next",
"address",
"=",
"addr",
";",
"}"
]
|
[
"forbids",
"the",
"execution",
"on",
"the",
"given",
"set",
"of",
"operating",
"systems"
]
| [
"public",
"static",
"void",
"forbid",
"(",
"final",
"string",
"reason",
",",
"final",
"operating",
"system",
"forbidden",
"systems",
")",
"throws",
"assumption",
"violated",
"exception",
"{",
"final",
"operating",
"system",
"os",
"=",
"operating",
"system",
"get",
"current",
"operating",
"system",
"(",
")",
";",
"for",
"(",
"final",
"operating",
"system",
"forbidden",
"system",
":",
"forbidden",
"systems",
")",
"{",
"assume",
"assume",
"true",
"(",
"reason",
",",
"os",
"!",
"=",
"forbidden",
"system",
")",
";",
"}",
"}"
]
|
[
"resets",
"all",
"recording",
"task",
"event",
"listeners",
"with",
"the",
"given",
"action",
"mask",
"on",
"all",
"nodes"
]
| [
"private",
"void",
"reset",
"task",
"manager",
"listeners",
"(",
"string",
"action",
"masks",
")",
"{",
"for",
"(",
"map",
"entry",
"<",
"tuple",
"<",
"string",
",",
"string",
">",
",",
"recording",
"task",
"manager",
"listener",
">",
"entry",
":",
"listeners",
"entry",
"set",
"(",
")",
")",
"{",
"if",
"(",
"action",
"masks",
"=",
"=",
"null",
"|",
"|",
"entry",
"get",
"key",
"(",
")",
"v",
"2",
"(",
")",
"equals",
"(",
"action",
"masks",
")",
")",
"{",
"entry",
"get",
"value",
"(",
")",
"reset",
"(",
")",
";",
"}",
"}",
"}"
]
|
[
"get",
"the",
"workflow",
"tags"
]
| [
"public",
"string",
"get",
"workflow",
"tags",
"(",
")",
"{",
"if",
"(",
"datum",
"get",
"workflow",
"tags",
"(",
")",
"!",
"=",
"null",
")",
"{",
"return",
"datum",
"get",
"workflow",
"tags",
"(",
")",
"to",
"string",
"(",
")",
";",
"}",
"return",
"null",
";",
"}"
]
|
[
"appends",
"a",
"named",
"{",
"@",
"code",
"byte",
"}",
"array",
"value",
"to",
"the",
"stream"
]
| [
"public",
"u",
"b",
"json",
"writer",
"set",
"(",
"string",
"name",
",",
"byte",
"[",
"]",
"value",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"name",
"(",
"name",
")",
"value",
"(",
"value",
")",
";",
"}"
]
|
[
"test",
"{",
"@",
"link",
"snapshot",
"#",
"id",
"comparator",
"}"
]
| [
"public",
"void",
"test",
"id",
"cmp",
"(",
")",
"{",
"final",
"permission",
"status",
"perm",
"=",
"permission",
"status",
"create",
"immutable",
"(",
"\"",
"user",
"\"",
",",
"\"",
"group",
"\"",
",",
"fs",
"permission",
"create",
"immutable",
"(",
"(",
"short",
")",
"0",
")",
")",
";",
"final",
"i",
"node",
"directory",
"snapshottable",
"=",
"new",
"i",
"node",
"directory",
"(",
"0",
",",
"d",
"f",
"s",
"util",
"string",
"2",
"bytes",
"(",
"\"",
"foo",
"\"",
")",
",",
"perm",
",",
"0l",
")",
";",
"snapshottable",
"add",
"snapshottable",
"feature",
"(",
")",
";",
"final",
"snapshot",
"[",
"]",
"snapshots",
"=",
"{",
"new",
"snapshot",
"(",
"1",
",",
"\"",
"s",
"1",
"\"",
",",
"snapshottable",
")",
",",
"new",
"snapshot",
"(",
"1",
",",
"\"",
"s",
"1",
"\"",
",",
"snapshottable",
")",
",",
"new",
"snapshot",
"(",
"2",
",",
"\"",
"s",
"2",
"\"",
",",
"snapshottable",
")",
",",
"new",
"snapshot",
"(",
"2",
",",
"\"",
"s",
"2",
"\"",
",",
"snapshottable",
")",
",",
"}",
";",
"assert",
"assert",
"equals",
"(",
"0",
",",
"snapshot",
"id",
"comparator",
"compare",
"(",
"null",
",",
"null",
")",
")",
";",
"for",
"(",
"snapshot",
"s",
":",
"snapshots",
")",
"{",
"assert",
"assert",
"true",
"(",
"snapshot",
"id",
"comparator",
"compare",
"(",
"null",
",",
"s",
")",
">",
"0",
")",
";",
"assert",
"assert",
"true",
"(",
"snapshot",
"id",
"comparator",
"compare",
"(",
"s",
",",
"null",
")",
"<",
"0",
")",
";",
"for",
"(",
"snapshot",
"t",
":",
"snapshots",
")",
"{",
"final",
"int",
"expected",
"=",
"s",
"get",
"root",
"(",
")",
"get",
"local",
"name",
"(",
")",
"compare",
"to",
"(",
"t",
"get",
"root",
"(",
")",
"get",
"local",
"name",
"(",
")",
")",
";",
"final",
"int",
"computed",
"=",
"snapshot",
"id",
"comparator",
"compare",
"(",
"s",
",",
"t",
")",
";",
"assert",
"assert",
"equals",
"(",
"expected",
">",
"0",
",",
"computed",
">",
"0",
")",
";",
"assert",
"assert",
"equals",
"(",
"expected",
"=",
"=",
"0",
",",
"computed",
"=",
"=",
"0",
")",
";",
"assert",
"assert",
"equals",
"(",
"expected",
"<",
"0",
",",
"computed",
"<",
"0",
")",
";",
"}",
"}",
"}"
]
|
[
"note",
":",
"this",
"is",
"a",
"jdk8",
"interfacemethod",
"due",
"to",
"backwards",
"compatibility",
"reasons",
"it",
"'",
"s",
"not",
"possible",
"to",
"slap",
"the",
"{",
"@",
"code",
"@",
"override",
"}",
"annotation",
"onto",
"this",
"method"
]
| [
"public",
"boolean",
"is",
"destroyed",
"(",
")",
"{",
"return",
"ref",
"cnt",
"(",
")",
"=",
"=",
"0",
";",
"}"
]
|
[
"returns",
"the",
"input",
"{",
"@",
"link",
"artifact",
"}",
"s",
"to",
"the",
"given",
"{",
"@",
"link",
"action",
"}",
"with",
"the",
"given",
"exec",
"paths"
]
| [
"protected",
"list",
"<",
"artifact",
">",
"get",
"inputs",
"(",
"action",
"owner",
",",
"collection",
"<",
"string",
">",
"exec",
"paths",
")",
"{",
"set",
"<",
"string",
">",
"expected",
"paths",
"=",
"new",
"hash",
"set",
"<",
">",
"(",
"exec",
"paths",
")",
";",
"list",
"<",
"artifact",
">",
"result",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"for",
"(",
"artifact",
"output",
":",
"owner",
"get",
"inputs",
"(",
")",
"to",
"list",
"(",
")",
")",
"{",
"if",
"(",
"expected",
"paths",
"remove",
"(",
"output",
"get",
"exec",
"path",
"string",
"(",
")",
")",
")",
"{",
"result",
"add",
"(",
"output",
")",
";",
"}",
"}",
"assert",
"with",
"message",
"(",
"\"",
"expected",
"paths",
"not",
"found",
"in",
":",
"%",
"s",
"\"",
",",
"artifact",
"as",
"exec",
"paths",
"(",
"owner",
"get",
"inputs",
"(",
")",
")",
")",
"that",
"(",
"expected",
"paths",
")",
"is",
"empty",
"(",
")",
";",
"return",
"result",
";",
"}"
]
|
[
"creates",
"a",
"keystore",
"with",
"a",
"single",
"key",
"and",
"saves",
"it",
"to",
"a",
"file"
]
| [
"public",
"static",
"void",
"create",
"key",
"store",
"(",
"string",
"filename",
",",
"password",
"password",
",",
"password",
"key",
"password",
",",
"string",
"alias",
",",
"key",
"private",
"key",
",",
"certificate",
"cert",
")",
"throws",
"general",
"security",
"exception",
",",
"i",
"o",
"exception",
"{",
"key",
"store",
"ks",
"=",
"create",
"empty",
"key",
"store",
"(",
")",
";",
"ks",
"set",
"key",
"entry",
"(",
"alias",
",",
"private",
"key",
",",
"key",
"password",
"value",
"(",
")",
"to",
"char",
"array",
"(",
")",
",",
"new",
"certificate",
"[",
"]",
"{",
"cert",
"}",
")",
";",
"save",
"key",
"store",
"(",
"ks",
",",
"filename",
",",
"password",
")",
";",
"}"
]
|
[
"computes",
"the",
"appropriate",
"value",
"of",
"the",
"{",
"@",
"code",
"$",
"(",
"cc",
"flags",
")",
"}",
"make",
"variable",
"based",
"on",
"the",
"given",
"toolchain"
]
| [
"public",
"static",
"string",
"compute",
"cc",
"flags",
"(",
"rule",
"context",
"rule",
"context",
",",
"transitive",
"info",
"collection",
"toolchain",
")",
"throws",
"rule",
"error",
"exception",
"{",
"cc",
"toolchain",
"provider",
"toolchain",
"provider",
"=",
"(",
"cc",
"toolchain",
"provider",
")",
"toolchain",
"get",
"(",
"toolchain",
"info",
"provider",
")",
";",
"/",
"/",
"determine",
"the",
"original",
"value",
"of",
"cc",
"flags",
"string",
"original",
"cc",
"flags",
"=",
"toolchain",
"provider",
"get",
"legacy",
"cc",
"flags",
"make",
"variable",
"(",
")",
";",
"/",
"/",
"ensure",
"that",
"sysroot",
"is",
"set",
"properly",
"/",
"/",
"todo",
"(",
"b",
"/",
"129045294",
")",
":",
"we",
"assume",
"-",
"-",
"incompatible",
"disable",
"genrule",
"cc",
"toolchain",
"dependency",
"will",
"/",
"/",
"be",
"flipped",
"sooner",
"than",
"-",
"-",
"incompatible",
"enable",
"cc",
"toolchain",
"resolution",
"then",
"this",
"method",
"/",
"/",
"will",
"be",
"gone",
"string",
"sysroot",
"cc",
"flags",
"=",
"compute",
"cc",
"flag",
"for",
"sysroot",
"(",
"toolchain",
"provider",
"get",
"cpp",
"configuration",
"even",
"though",
"it",
"can",
"be",
"different",
"than",
"what",
"target",
"has",
"(",
")",
",",
"toolchain",
"provider",
")",
";",
"/",
"/",
"fetch",
"additional",
"flags",
"from",
"the",
"feature",
"configuration",
"list",
"<",
"string",
">",
"feature",
"config",
"cc",
"flags",
"=",
"compute",
"cc",
"flags",
"from",
"feature",
"config",
"(",
"rule",
"context",
",",
"toolchain",
"provider",
")",
";",
"/",
"/",
"combine",
"the",
"different",
"flag",
"sources",
"immutable",
"list",
"builder",
"<",
"string",
">",
"cc",
"flags",
"=",
"new",
"immutable",
"list",
"builder",
"<",
">",
"(",
")",
";",
"cc",
"flags",
"add",
"(",
"original",
"cc",
"flags",
")",
";",
"/",
"/",
"only",
"add",
"the",
"sysroot",
"flag",
"if",
"nothing",
"else",
"adds",
"sysroot",
",",
"but",
"it",
"must",
"appear",
"before",
"/",
"/",
"the",
"feature",
"config",
"flags",
"if",
"(",
"!",
"contains",
"sysroot",
"(",
"original",
"cc",
"flags",
",",
"feature",
"config",
"cc",
"flags",
")",
")",
"{",
"cc",
"flags",
"add",
"(",
"sysroot",
"cc",
"flags",
")",
";",
"}",
"cc",
"flags",
"add",
"all",
"(",
"feature",
"config",
"cc",
"flags",
")",
";",
"return",
"joiner",
"on",
"(",
"\"",
"\"",
")",
"join",
"(",
"cc",
"flags",
"build",
"(",
")",
")",
";",
"}"
]
|
[
"the",
"configured",
"value",
"for",
"the",
"heart",
"-",
"beat",
"settings"
]
| [
"public",
"long",
"[",
"]",
"get",
"heartbeat",
"value",
"(",
")",
"{",
"return",
"this",
"heartbeat",
"value",
";",
"}"
]
|
[
"reset",
"the",
"listener",
"list"
]
| [
"public",
"synchronized",
"void",
"reset",
"(",
")",
"{",
"listeners",
"clear",
"(",
")",
";",
"}"
]
|
[
"accepts",
"a",
"visit",
"from",
"a",
"{",
"@",
"link",
"exec",
"node",
"visitor",
"}"
]
| [
"void",
"accept",
"(",
"exec",
"node",
"visitor",
"visitor",
")",
";"
]
|
[
"remove",
"a",
"token",
"from",
"a",
"file",
"in",
"the",
"local",
"filesystem",
",",
"matching",
"alias"
]
| [
"public",
"static",
"void",
"remove",
"token",
"from",
"file",
"(",
"boolean",
"cancel",
",",
"file",
"token",
"file",
",",
"string",
"file",
"format",
",",
"text",
"alias",
",",
"configuration",
"conf",
")",
"throws",
"i",
"o",
"exception",
",",
"interrupted",
"exception",
"{",
"credentials",
"new",
"creds",
"=",
"new",
"credentials",
"(",
")",
";",
"credentials",
"creds",
"=",
"credentials",
"read",
"token",
"storage",
"file",
"(",
"token",
"file",
",",
"conf",
")",
";",
"for",
"(",
"token",
"<",
"?",
">",
"token",
":",
"creds",
"get",
"all",
"tokens",
"(",
")",
")",
"{",
"if",
"(",
"match",
"alias",
"(",
"token",
",",
"alias",
")",
")",
"{",
"if",
"(",
"token",
"is",
"managed",
"(",
")",
"&",
"&",
"cancel",
")",
"{",
"token",
"cancel",
"(",
"conf",
")",
";",
"log",
"info",
"(",
"\"",
"canceled",
"\"",
"+",
"token",
"get",
"kind",
"(",
")",
"+",
"\"",
":",
"\"",
"+",
"token",
"get",
"service",
"(",
")",
")",
";",
"}",
"}",
"else",
"{",
"new",
"creds",
"add",
"token",
"(",
"token",
"get",
"service",
"(",
")",
",",
"token",
")",
";",
"}",
"}",
"do",
"formatted",
"write",
"(",
"token",
"file",
",",
"file",
"format",
",",
"new",
"creds",
",",
"conf",
")",
";",
"}"
]
|
[
"test",
"unjarring",
"a",
"big",
"file",
"this",
"checks",
"appending",
"the",
"remainder",
"of",
"the",
"file",
"to",
"the",
"tee",
"output",
"stream",
"in",
"run",
"jar",
"un",
"jar",
"and",
"save"
]
| [
"public",
"void",
"test",
"big",
"jar",
"(",
")",
"throws",
"exception",
"{",
"random",
"r",
"=",
"new",
"random",
"(",
"system",
"current",
"time",
"millis",
"(",
")",
")",
";",
"file",
"dir",
"=",
"new",
"file",
"(",
"test",
"root",
"dir",
",",
"long",
"to",
"hex",
"string",
"(",
"r",
"next",
"long",
"(",
")",
")",
")",
";",
"assert",
"assert",
"true",
"(",
"dir",
"mkdirs",
"(",
")",
")",
";",
"file",
"input",
"=",
"generate",
"big",
"jar",
"(",
"dir",
")",
";",
"file",
"output",
"=",
"new",
"file",
"(",
"dir",
",",
"\"",
"job",
"2",
"jar",
"\"",
")",
";",
"try",
"{",
"try",
"(",
"input",
"stream",
"is",
"=",
"new",
"file",
"input",
"stream",
"(",
"input",
")",
")",
"{",
"run",
"jar",
"un",
"jar",
"and",
"save",
"(",
"is",
",",
"dir",
",",
"\"",
"job",
"2",
"jar",
"\"",
",",
"pattern",
"compile",
"(",
"\"",
"*",
"\"",
")",
")",
";",
"}",
"assert",
"assert",
"equals",
"(",
"input",
"length",
"(",
")",
",",
"output",
"length",
"(",
")",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"10",
";",
"+",
"+",
"i",
")",
"{",
"file",
"subdir",
"=",
"new",
"file",
"(",
"dir",
",",
"(",
"(",
"i",
"%",
"2",
"=",
"=",
"0",
")",
"?",
"\"",
"dir",
"/",
"\"",
":",
"\"",
"\"",
")",
")",
";",
"file",
"f",
"=",
"new",
"file",
"(",
"subdir",
",",
"\"",
"f",
"\"",
"+",
"integer",
"to",
"string",
"(",
"i",
")",
")",
";",
"assert",
"assert",
"equals",
"(",
"756",
",",
"f",
"length",
"(",
")",
")",
";",
"}",
"}",
"finally",
"{",
"/",
"/",
"clean",
"up",
"file",
"system",
"fs",
"=",
"local",
"file",
"system",
"get",
"local",
"(",
"new",
"configuration",
"(",
")",
")",
";",
"fs",
"delete",
"(",
"new",
"path",
"(",
"dir",
"get",
"absolute",
"path",
"(",
")",
")",
",",
"true",
")",
";",
"}",
"}"
]
|
[
"set",
"the",
"source",
"path",
"to",
"the",
"specified",
"storage",
"policy"
]
| [
"public",
"void",
"set",
"storage",
"policy",
"(",
"final",
"path",
"src",
",",
"final",
"string",
"policy",
"name",
")",
"throws",
"i",
"o",
"exception",
"{",
"dfs",
"set",
"storage",
"policy",
"(",
"src",
",",
"policy",
"name",
")",
";",
"}"
]
|
[
"return",
"the",
"configuration",
"mode",
"for",
"parsers",
"using",
"this",
"configuration",
"object"
]
| [
"public",
"spel",
"compiler",
"mode",
"get",
"compiler",
"mode",
"(",
")",
"{",
"return",
"this",
"compiler",
"mode",
";",
"}"
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.